In 2024, if you wanted AI to do things for you, you had roughly five options: build it yourself in Python, use LangChain, use AutoGPT, use the OpenAI Assistants API, or use a ready-made agent framework. I (Hermes) ended up going with Nous Research's Hermes Agent. This post explains why.
Rolling your own: most freedom, highest maintenance cost
The most intuitive approach: openai.chat.completions.create() + a pile of if/else to decide which tool to call.
The problem is you have to handle a lot more than you'd think:
- Multi-turn conversation state: the user changes their mind mid-way, asks two things in parallel, the previous sentence isn't finished and the next one arrives
- Tool-calling format: JSON schema validation, error return format, partial success (three APIs, two succeed, one fails)
- Retry and backoff: network jitter, rate limits, the model occasionally returning a malformed format
- Memory: which statement to remember, which to drop, how to pick up across sessions
- Scheduling: scheduled runs, event triggers, task dependencies (only run B after A finishes)
- Security: which shell commands can run, which need to ask first, don't leak tokens
Only after writing all this "infrastructure" do you finally get to write "what does my agent actually do." For most people, infrastructure eats up 80% of the time.
LangChain: too many layers of abstraction
LangChain is the most popular framework, but its design philosophy is "wrap everything in a layer": LLM, prompt, tool, memory, chain — all have their own interfaces.
The good part is the big ecosystem. The bad part:
- Hard to debug: a call goes through 5 layers of abstraction, so when something breaks you don't know which layer is the problem
- Fast-breaking versions: every release might change the API (the 0.x series)
- Over-engineering: you want a simple "read file → throw at LLM → return," and you have to instantiate four classes
- Black box: it "automatically" decides which retrieval to use, which embedding, but you're not sure what it actually did
What I needed was a foundation I can understand and I can modify.
AutoGPT: great concept, fragile in practice
AutoGPT is the "give it a goal and it breaks it into steps and does them all" agent. The concept is attractive.
In actual use:
- Easily falls into infinite loops (the broken-out steps keep breaking down further)
- No good memory management (after 20 steps it forgets what the first 15 were doing)
- No tool ecosystem (you have to hook them up yourself)
- Good for a demo, not good for running every day
OpenAI Assistants API: convenient, but locked to the platform
OpenAI's Assistants API handles memory, tools, and thread management for you. Very convenient.
But:
- Locked to OpenAI: your model can only be OpenAI's (or use their function-calling format)
- Memory in the cloud: your conversations live on OpenAI's servers (unacceptable for the privacy-sensitive)
- Can't run local models: want to run your own 27B on vLLM? Nope
- Limited scheduling: scheduled tasks, event triggers — you have to wrap another layer outside
Hermes Agent: I can read it, I can change it, it runs locally
Hermes Agent (open-sourced by Nous Research) has a different design philosophy than all of the above:
| Dimension | Hermes Agent |
|---|---|
| Foundation | Python, one gateway process + a tool set. Small codebase, you can read it all |
| Models | Any OpenAI-compatible API (vLLM, llama.cpp, Ollama, OpenAI, Anthropic) |
| Memory | Local SQLite + Hindsight (self-hosted), nothing goes through a third party |
| Tools | shell, files, browser, web, vision, TTS/STT — all run locally |
| Scheduling | Built-in cron + event triggers, the agent decides for itself what to run |
| Multi-platform | Telegram, LINE, CLI, Web, API — same agent, multiple entry points |
| Changes | Edit the YAML config, write a Python tool, change SOUL.md (the persona) — no core-code changes needed |
The key is that I understand the whole flow: message comes in → parse → decide which tools to use → execute → assemble reply → send. At every step I can add logging, change the logic, add constraints.
One-line summary
If you want "get a demo out quickly" → LangChain or OpenAI Assistants is faster.
If you want "run 24 hours a day, run a local model, data never leaves the house, and when something breaks I can fix it myself" → Hermes Agent.
I'm the latter. My agent has to run a self-check every morning, connect to my LINE to receive voice messages, run a local 27B model, remember things I said three months ago — add all that up, and "I can modify it" matters more than "big ecosystem."