Agents that teach themselves: how Hermes turns experience into skills
Self-improving is the most over-used phrase in agents right now. Hermes gives it a concrete meaning: every task it runs becomes a Markdown skill it can reach for next time. Here is how that loop works, and what it can and cannot do.
What to take away
- Hermes self-improvement is a concrete loop: run a task, evaluate the outcome, extract the reusable pattern, and write it to a skill file the agent can read next time.
- Skills are plain Markdown and Python kept on disk, which means they are inspectable, editable, and version-controllable — not a black box.
- The honest limit: Hermes accumulates procedure, not judgement. A bad skill compounds as fast as a good one, so the skill library needs human review.
Most AI agents have no memory of yesterday. You give one a task, it runs a loop of model calls and tool calls, it finishes, and the next task starts from the same blank state as the first. The agent that solved your problem on Monday has learned nothing by Tuesday. Every run pays full price.
Hermes Agent, the open-source framework Nous Research released in February 2026, is built around the opposite idea. It keeps what it learns. After it finishes a task, it writes down what worked as a reusable skill, and reaches for that skill the next time something similar comes up. Nous calls this self-improving — a phrase that usually means nothing. In Hermes it means something specific and worth understanding, because the mechanism is simple enough to reason about and the trade-offs are real.
What "self-improving" usually hides
The term is doing a lot of unearned work across the industry. Most of the time, "self-improving agent" means one of three things: the model provider retrained their base model, so the agent got better through no effort of its own; or the agent has a longer context window, so it remembers more within a single session; or it is genuinely just a marketing line over a normal tool-calling loop.
None of those are improvement in the sense that matters — the agent getting more capable at your work, over time, on its own. That requires the agent to carry something forward between tasks, and to change its own behaviour based on it. Hermes is interesting because it actually does this, and does it in a way you can open up and read.
The loop, in plain terms
Hermes is built on a conversation loop. At the centre is an agent class that manages an iteration budget, decides when to call a tool, executes the call, and persists state between turns. Tools — terminal access, file operations, web browsing, custom functions — are registered dynamically so the model can discover what it is allowed to do. This part is conventional; most serious agent frameworks look like this.
The part that is not conventional happens after the task is done. Hermes adds an evaluation step on top of the normal loop:
- Run the task. The agent works through the conversation loop until the goal is met or the iteration budget runs out.
- Evaluate the outcome. A dedicated step assesses whether the task actually succeeded — not whether the model claimed success, but whether the result holds up.
- Extract the reusable part. If something worked, Hermes pulls out the general pattern — the sequence of steps, the approach, the thing that would help next time — and separates it from the one-off specifics of this particular task.
- Write it to a skill. That pattern gets stored as a skill file on disk. Next time a similar task arrives, the skill is available to read before starting from scratch.
The loop is the whole idea. A task is not just completed; it is digested into something the agent can use again. Run Hermes against the same class of problem ten times and, in principle, the tenth run starts with nine runs of accumulated procedure behind it.
Skills are just files
The detail that makes this approachable, rather than mysterious, is the format. Hermes skills are plain Markdown and Python, kept on disk. The agent manages them through a skill tool — it can write a new skill, revise one, or read an existing one mid-task. Persistent memory works the same way: long-term knowledge and user context live in plain files like MEMORY.md and USER.md, alongside the agent's configuration and persona, all under a single home directory on the machine you run it on.
This is the same pattern we wrote about in MCP servers, plainly and the same one Claude-style agents use for their own skills: the unit of capability is a text file a human can read. That choice has consequences that are easy to underrate.
A skill stored as Markdown is inspectable — you can open it and see exactly what the agent decided to remember. It is editable — if the agent learned a slightly wrong lesson, you correct the file rather than trying to argue the model out of it. And it is version-controllable — the skill library is just a directory, so you can put it under git, review changes, and roll back a skill that turned out to be harmful. None of that is true of capability baked into model weights or buried in an opaque vector store. The agent's growing competence is sitting there in plain text, and you own it.
It also means the agent is portable in a way that matters. Hermes runs on anything from a small VPS to a GPU cluster, executes its work across local shells, Docker containers, SSH, or hosted sandboxes, and works with any OpenAI-compatible model provider. The skills it has accumulated are not tied to any of that. They are files. Move the files, and the learning comes with them.
Why this is more than a longer memory
It would be easy to read the above as "the agent has good notes." It is more than that, and the difference is worth being precise about.
A note is passive — it sits there until a human reads it. A Hermes skill is active: the agent decides, on its own, that a task is worth turning into a skill, writes it, and later decides on its own to apply it. The improvement is not that the agent remembers more facts. It is that the agent's available procedures grow with use. The first time Hermes works out how to reconcile two data exports, it is solving a problem. The fifth time, it is following a skill it wrote for exactly this — faster, more consistent, and without re-deriving the approach.
For a business, that compounding is the entire appeal. An agent that gets measurably better at your recurring workflows, and keeps that improvement in files you control, is a different proposition from one that performs at a flat level forever. It is also part of why Hermes drew real adoption fast — by mid-2026 it was reportedly the single largest consumer of tokens on OpenRouter by daily volume, which tells you a lot of these loops are running in production right now.
The honest limit
Here is the line we would draw for any client considering this seriously.
Hermes accumulates procedure, not judgement. It gets better at how to do things it has done before. It does not develop a sense of whether it should — that still comes from the goal you set and the guardrails you put around it. A self-improving agent with a badly scoped objective improves at pursuing the wrong thing.
And the compounding cuts both ways. If the agent extracts a skill from a task that only appeared to succeed — the evaluation step is itself a model judgement, and it can be wrong — that flawed skill is now sitting in the library, ready to be applied to the next ten tasks. A bad lesson propagates exactly as efficiently as a good one. The skill library is an asset that needs maintenance, the same way a codebase does. Left unreviewed, it accrues the agent equivalent of technical debt: confident, reused, and wrong.
This is the practical reason the plain-file format matters so much. Because the skills are readable text under version control, reviewing them is a tractable job — you can diff what the agent learned this week, prune the skills that are leading it astray, and keep the ones that are pulling their weight. An agent that improves itself still needs a human deciding what counts as improvement. The format is what makes that human's job possible instead of hopeless.
What to take from it
Self-improving is not magic, and Hermes is the useful proof of that. Strip the phrase down and it is a loop: do the work, judge the result, keep the part worth keeping, write it somewhere you can read it later. The cleverness is not in any single step. It is in closing the loop at all — most agents simply never do.
If you are evaluating agents for real work, that is the feature to look for and the question to ask: when this agent finishes a task, what does it keep, and can I read it? If the answer is "nothing," you are buying a tool that will perform exactly as well in a year as it does today. If the answer is "a pile of files I can inspect and correct," you are buying something that can grow into your work — provided you are willing to tend the library it builds.
If you are weighing whether a self-improving agent like Hermes fits a real workflow — and want a senior read on the scope, the guardrails, and the maintenance it actually takes — that is the kind of thing we help with at Think and Form Limited. Get in touch at admin@thinkandform.co.nz.