Akshay Parkhi's Weblog

Hermes Agent: The Self-Improving Story

12th June 2026

An AI assistant that gets a little better every time you talk to it. Nobody retrains the model. Here is how that actually works, told as a story.

Meet Hermes

Imagine an assistant who lives on a small computer somewhere in the cloud, and you can reach it from anywhere. You text it on WhatsApp. You DM it on Discord. You ping it on Slack from work. You open a terminal at home and chat with it there. It is the same assistant, the same memory, the same personality, no matter which door you walk through.

This is Hermes Agent. It is open-source, made by a group called Nous Research. It is a little bit like Claude Code or ChatGPT. The differences: it is yours, it runs wherever you want it to, and, most interestingly, it learns from your conversations.

The puzzle in this post is the last part. The AI model behind Hermes is frozen. Its weights, the actual numbers that make it intelligent, never change. And yet, two weeks after you start using it, it behaves differently than the day you met it. It remembers your preferences. It stops making the mistakes you corrected. It builds little routines for tasks you do often.

How? That is the story.

The big picture, in plain words

There is one program running on a server somewhere. Call it the gateway. The gateway has forty-something little doormen, one per platform: one for Discord, one for Slack, one for Telegram, one for WhatsApp, and so on. When you send a message, the right doorman catches it and hands it to a fresh copy of the actual agent. The agent then thinks, uses tools, and writes back.

You                              The Gateway                     The Agent

Discord       ────────►    ┌────────────────────┐    ────►    ┌──────────────┐
Slack         ────────►    │  one program,      │    ────►    │  thinks      │
WhatsApp      ────────►    │  many doormen      │    ────►    │  uses tools  │
Signal        ────────►    │                    │    ────►    │  replies     │
Telegram      ────────►    │  picks the right   │    ────►    └──────────────┘
Terminal      ────────►    │  agent for you     │
                           └────────────────────┘

The agent itself is a loop. It reads your message, decides what to do, and runs tools: open a file, search the web, send a shell command, browse a page. Then it looks at the result, decides again, and keeps going until it has an answer for you. Nothing exotic. The loop is just a few thousand lines of Python.

So far, so normal. Where does the learning come in?

The trick: a quiet shadow agent

Here is the part that makes Hermes interesting. A conversation turn ends the second Hermes sends you a reply. At that moment, it quietly spawns another copy of itself in the background. You do not see it. It does not bother you. It just runs.

This shadow copy has the same model, the same credentials, and the same system instructions as the original. But it has a very specific, very small job. It cannot use the shell. It cannot browse the web. It cannot edit files. It can only do two things: write notes and write skills.

And here is the shadow’s job:

1. Read the conversation that just happened.
2. Ask yourself: “Did the user reveal anything about who they are, what they like, what they expect from me?”
3. Ask yourself: “Did I learn a useful technique? Did the user correct me? Did I do something well that I should remember to do again?”
4. Whatever you find, write it down.

That is the entire trick. The agent reviews itself, after every conversation, like a person journaling at the end of the day. And because the same intelligent model does the reviewing, the notes it writes are genuinely thoughtful. They are not log entries, but lessons.

conversation ends
       │
       ▼
   ┌──────────────────────────────────┐
   │   shadow agent wakes up          │
   │   (same brain, restricted hands) │
   │                                  │
   │   reads what just happened       │
   │   writes 0, 1, or 2 things:      │
   │                                  │
   │      • a memory note about you   │
   │      • a skill note about itself │
   └──────────────────────────────────┘
       │
       ▼
   tucked into a folder on disk

The skill prompt is even a little pushy. It tells the shadow: “a review that finds nothing is a missed opportunity to learn.” Don’t be lazy. Look harder.

What is a “skill,” really?

The word “skill” sounds vague. Mechanically, it is just a small Markdown file in a folder on disk. Something like:

~/.hermes/skills/
   ├── handle-discord-rate-limits/
   │     ├── SKILL.md
   │     └── references/
   │
   ├── user-prefers-short-replies/
   │     └── SKILL.md
   │
   └── always-confirm-before-deleting/
         └── SKILL.md

Each SKILL.md is a tiny instruction the agent wrote to its future self. “When the user asks for code, give the answer first and the explanation second.” “Akshay does not like emojis.” “If the Discord API returns 429, wait before retrying.”

And here is the punchline. The next time you chat with Hermes, the relevant skills are quietly pasted into its instructions. That happens before it even reads your message. The agent does not “remember” in some mysterious neural way. It remembers because someone, its shadow self, wrote a note. The note is now part of its prompt.

That is what learning looks like in this world. Not new neurons. New paragraphs.

The librarian

Now imagine doing this for a year. You would have a thousand little notes. Some would overlap. Some would be stale. Some would contradict each other. The skill folder would become a junk drawer.

Hermes has an answer for this too. When the agent is idle (nobody is talking to it), another role starts: the curator. Same brain, different hat. The curator’s job is housekeeping:

• If two skills say almost the same thing, merge them into one cleaner skill.
• If a skill has not been useful in a long time, archive it.
• If a skill’s wording is clumsy, rewrite it.
• If many specific skills can be generalised into one broader one, do that.

So the library is not just growing. The curator maintains it. Skills sharpen with use, the way a well-thumbed cookbook, over time, has the best recipes at the front and the bad ones quietly torn out.

The memory of who you are

Skills are about what to do. Memory is about who you are.

Suppose you mentioned, in passing, that you have a cat named Pumpkin. Or that you are learning Spanish. Or that you hate when assistants start every reply with “Certainly!” That’s not a skill. That’s a fact about you. Hermes stores those too, in a separate place. Optionally, it can connect to a service called Honcho. Honcho builds a slowly-improving psychological model of you across every conversation you have ever had with it.

And it can search its own past. Every conversation goes into a tiny database, full-text-searchable. So a future version of Hermes can quite literally read what happened two months ago, when you asked about the same thing.

Putting the loop on one page

            ┌──────────────────────────────────────────────┐
            │  You and Hermes have a conversation          │
            └──────────────────────┬───────────────────────┘
                                   │
                                   ▼
            ┌──────────────────────────────────────────────┐
            │  Hermes replies. You move on with your day.  │
            └──────────────────────┬───────────────────────┘
                                   │  (quietly, in the background)
                                   ▼
            ┌──────────────────────────────────────────────┐
            │  A shadow copy reviews the transcript.       │
            │  It writes 0–2 small files:                  │
            │    • a memory about you                      │
            │    • a skill for itself                      │
            └──────────────────────┬───────────────────────┘
                                   │
                                   ▼
            ┌──────────────────────────────────────────────┐
            │  Later, when nobody is looking, the curator  │
            │  tidies the library: merge, archive, refine. │
            └──────────────────────┬───────────────────────┘
                                   │
                                   ▼
            ┌──────────────────────────────────────────────┐
            │  Next time you chat, the relevant skills and │
            │  memories are pasted into the instructions   │
            │  Hermes reads before it answers you.         │
            └──────────────────────┬───────────────────────┘
                                   │
                                   └──────► behaviour has shifted
                                            (without anyone retraining
                                             a single weight)

Why this is more clever than it looks

It is easy to underestimate what is happening here. The trick is not technically hard. There is no breakthrough algorithm, no exotic math, no GPU farm humming away. The model itself does not change.

What is happening is simpler and, I think, more interesting. Someone realised that the instructions you give an agent are themselves a kind of memory. And if the agent is smart enough to edit its own instructions, you have built a learning loop. It involves no learning, in the machine-learning sense, at all.

A few things follow from this design that I find worth saying out loud:

• Corrections become permanent. Tell Hermes once that you prefer terse replies, and the shadow will write a skill about it. From that day on, every prompt it reads will quietly contain that instruction.
• The model can swap. Because the “learning” lives in Markdown files and not in weights, you can switch the underlying brain. You can go from a Nous model to an OpenAI model to a local one, and your skills come with you. The personality is portable.
• You can read the mind. Open the skills folder. Every “lesson” is a human-readable file. You can audit it, edit it, delete it. A neural network’s biases are opaque. Hermes’s biases sit in a folder you own.
• It is patient with itself. The shadow does not run during your conversation. It runs after. So the user-facing latency does not change. The “learning” is amortised into the quiet moments.

What it is built out of

For the curious, the brain (the agent loop, the gateway, the shadow, the curator) is Python (3.11 to 3.13). It uses:

• The OpenAI SDK as a universal phone line, so it can call any model provider with the same code.
• FastAPI for the web parts.
• A small SQLite database for cross-session search.
• A tool called croniger, so you can ask it to do things on a schedule.

The friendly things you touch (the terminal interface, the web dashboard, the desktop app, the documentation site) are JavaScript and Node. So if you peek at the project and see a package.json, do not be fooled. That is the wrapping paper. The actual gift is Python.

And you can configure the tools the agent uses (running a shell command, editing a file, scraping a page) to run in different places. On the same computer as the agent. In a Docker container for safety. Over SSH on another machine. Or in a fresh, throwaway sandbox in the cloud. So the agent itself can live cheaply on a small VPS while doing real work somewhere bigger.

The lesson, if there is one

Most people, when they hear “the AI learns from you,” imagine some kind of training: fancy math, gradient descent, weights updating in the dark. That is one way to build a learning system. It is not the only way.

Hermes shows there is another way, simpler and easier to reason about:

1. Give the agent the ability to write its own instructions.
2. After each conversation, ask the agent to reflect on what just happened.
3. Let it write down what it learned.
4. Make sure those notes come back the next time it wakes up.

That’s it. That’s the loop. The weights stay frozen. The context compounds. The agent slowly becomes your agent, shaped, conversation by conversation, by you.

It is not magic. It is just writing things down, done with care, by something patient enough to do it every single time.

Which, if you think about it, is how people get better at things too.