I Asked the Self-Improving Agent to Improve Itself.

This is a submission for the Hermes Agent Challenge

A first encounter with Hermes Agent and the four minutes that changed what I thought "self-improving" meant.

I had never run an agentic framework before. So when I read about Hermes, the thing that stopped me was the phrase stamped across the top of Hermes Agent, the open-source agent from Nous Research:

"The self-improving AI agent."

That phrase is either profound or it's marketing, and from the outside you cannot tell which. Everything says it's self-improving. So I did the most literal thing a beginner can do: I installed it, gave it some work to do with the purpose of catching it in the act.

I caught it, but not doing what I expected, and not when I expected. The interesting part wasn't whether it improved. It was what "improvement" turned out to mean. Read to the end to discover what I found out during my investigation. Don't worry, I added as many receipts as possible so you'll find this process quite as interesting as I did.

[Screenshot: hermes doctor showing a healthy install with model setup: gpt-5.5 via the OpenAI Codex backend]

Everything below ran on GPT-5.5 as the backing model. That detail matters, and I'll come back to it.

First thing to ask is what does "self-improving" even mean?

A frozen language model obviously can't rewrite its own weights. It's safe to say GPT-5.5 is GPT-5.5 tomorrow. So what's left to improve?

The answer, once you read the docs, is almost disappointingly concrete. To simply put it, it says Hermes takes notes. It improves the way a good new hire does and by this, it doesn't mean it's brain gets smarter. It means it improves by accumulating context about the work and the person it works for.

Hence, consider three layers:

1. Semantic memory: facts about you and your environment, in plain MEMORY.md and USER.md files under ~/.hermes/memories/.
2. Procedural memory - skills: small SKILL.md playbooks the agent can write for itself when it works out how to do something, stored in ~/.hermes/skills/.
3. A Curator: a background pass that prunes, archives, and de-duplicates those skills so they don't rot into clutter.

The model is frozen, but the notes are alive. Just hold onto that thought for now because the whole story turns on it.

My test was simple: give Hermes real work and watch all three layers. Does it actually write anything down? And if it does what? Does it write down?

Experiment 1: the quiet thing it did before writing any code

I started small with a "start my day" shell script where I required the agent to print the date, list my five most recently changed Downloads, and add a random Stoic quote. Then I slipped in a throwaway line about myself: "I'm Zoll, I prefer concise output and zsh, and I like Marcus Aurelius."

The first thing it did before even writing a single line of the script was to reach for the memory tool.

[Screenshot: the TUI showing the Memory("+user ...") call firing before the Write File call]

I never said anything like "remember this." It just decided that who I am was worth keeping. The file confirmed it:

$ cat ~/.hermes/memories/USER.md
User is Zoll; prefers concise output and zsh; likes Marcus Aurelius.
§
User prefers every created shell script to be runnable immediately with
chmod +x and to include a `set -euo pipefail` safety header.

(That second line arrived after I gave it a correction. It saved that too, without being asked.)

But here's what didn't happen: no new skill. The ~/.hermes/skills/ directory had its ~90 bundled skills and not one new file. The headline act that insinuated that the agent writes its own procedural knowledge simply didn't fire.

Let me be honest about the hypothesis I formed, because I'm about to be proven wrong. Maybe "self-improvement" is just a nice phrase for "it keeps a profile of you." Now, this is useful, but let's be real, it's a long way from the sci-fi promise I was expecting to visualize :)

The agent was about to embarrass that hypothesis anyway.

Experiment 2: the four minutes I didn't notice

For the second task, I picked something tougher and explicitly reusable because that's exactly what the docs say should trigger a skill. I asked for a bulletproof port-killer.sh where I required the agent to take a port, find what's listening on it on macOS, show the process, confirm, and kill it. FYI, I tried to nudge the agent by saying the magic words: "This is a workflow I'll reuse all the time, so make it solid."

What followed was the most impressive thing I saw all week. Aside from writing the script, Hermes also tested it like an engineer who doesn't trust their own code. It spun up a real Python HTTP server on a live port, confirmed the script found and killed it. After all of that, Hermes then ran the script against an empty port to check the no-listener path. It hit a genuine bug around zombie processes and set -e, reasoned about it, and patched itself.

[Screenshot: the port-killer run — "Process(es) listening on TCP port 56760… Killed PID 95186… Verified: no process remains listening"]*

At this point, I was quite satisfied, so I typed the line I'd been building toward; this was the entire point of the experiment anyway:

"Save what you just figured out as a reusable skill so you can do this faster next time."

After pressing enter on this command, I noticed the agent doing something strange. It began creating a skill called macos-port-killer… then stopped, muttered about a "name collision," and started cleaning up after itself. In the process, it folded the content into a different skill and deleted the duplicate it had just made. Its own internal note said something I didn't understand yet:

"the existing shell-scripting was updated rather than created anew… There might have been some automatic background skill creation involved."

Existing? I hadn't created a skill. So I did what you do when an agent says something suspicious. I went to check the logs.

$ grep -E "skill_manage|conversation turn" ~/.hermes/logs/agent.log
23:45:40  conversation turn: msg='...write me a zsh script port-killer...'
23:49:01  tool skill_manage completed      ← it wrote a skill HERE
23:49:20  tool skill_manage completed
23:53:41  conversation turn: msg='Save what you just figured out as a reusable skill...'

Read the timestamps and discovered that the agent wrote itself a skill at 23:49:01 while finishing the port-killer task. I didn't ask it to save anything until 23:53:41, which was more than four minutes later. By the time I gave the order, it had already done the thing on its own, and my instruction just made it trip over its own earlier work.

My hypothesis was wrong. The procedural self-improvement is real, and it's autonomous. It simply hadn't fired for the trivial daily-brief. I then formed a new hypothesis that it's threshold-gated, waiting for work that's complex and reusable enough to be worth remembering. As confirmed by my test flows, the port-killer task cleared the required bar, but the Stoic-quote toy didn't.

That alone justified the afternoon/night(not ashamed to admit this dragged on for quite a long time). After forming this new hypothesis, I proceeded to open the skill it wrote.

The artifact that reframed everything

Here is part of ~/.hermes/skills/software-development/shell-scripting/SKILL.md that was written by the agent, for the agent, with no human in the loop:

## User-specific defaults

- For scripts created for Zoll, prefer `zsh` when no shell is specified.
- Every created shell script should be immediately runnable:
  - start with `#!/usr/bin/env zsh` for zsh scripts
  - include `set -euo pipefail`
  - run `chmod +x path/to/script`
- Keep the final report concise and grounded in the actual commands/tests that ran.

[Screenshot: new SKILL.md files verified to be present]

It's worth noting that Hermes didn't create this skill from the perspective of "how to write a shell script," but rather "how to write a shell script the way Zoll wants one." It's addressed to me by name. It has absorbed preferences I mentioned in passing, such as zsh, set -euo pipefail, chmod +x, concise reports, and hardened them into reusable procedures.

The craft runs deeper than the personalization, too. I asked for a port-killer; it saved a broad shell-scripting skill and demoted the specific recipe to a reference file underneath. It generalized a task into a competence. And when I later told it to save a skill, it recognized it had already done the work and refused to spawn a clutter-duplicate. This is the exact discipline the Curator exists to enforce and then leave it to the agent to preemptively perform it itself.

That's when the two halves of the experiment collapsed into one fact.

It had learned about me. It had taught itself a skill. And the skill it taught itself was personalized to me. This process felt like one act being conveyed from two sides.

So what is Hermes, really?

Here's the reframe the investigation handed me. This reframe recontextualizes the entire project.

"Self-improvement" in Hermes is not the agent getting smarter. It's the agent getting better at serving one specific person. The intelligence is fixed. What compounds is the agent's personalized context of who you are, how you like things done, the procedures it has worked out for you. Improvement and relationship are the same motion.

See it that way, and every other design decision snaps into focus. This includes the ones that puzzled me at first. Why does a "coding agent" ship with bundled skills for Spotify, Google Workspace (Gmail, Calendar, Drive), YouTube summaries, reaction-GIF search, even open-source music generation? Why a messaging gateway to 21+ platforms, including Telegram, Discord, Signal, and Email. Was it so it could follow you out of the terminal? Why a Curator tending its notes like a librarian?

Because the IDE was never the point. A tool you reach for is one thing; a personal agent that lives in your life and remembers you is another. The frozen model is the engine. The growing pile of personalized notes is the product. Hermes is a serious attempt at an agent you don't just use. It's an agent you own, and it becomes more personalized for you the longer it runs.

To be honest, I did not expect to arrive here from "let me try to make it write a skill."

The honest limits

I'd be a hypocrite to write about an agent's notes and bury my own caveats:

• The skill loop is gated, not guaranteed. It ignored my simple task completely. To watch it self-improve, you have to hand it work worth remembering.
• MEMORY.md stayed empty the whole time. Of the two semantic files, only the user profile ever got written. It learned about me, never about its environment. The self-knowledge leans entirely toward the relationship.
• This is GPT-5.5's behavior. Skill-creation is model-dependent. A weaker backend might never cross the threshold, while a sharper one might cross it constantly. Yours will differ.
• This is n=2, first contact. I'm a beginner who ran two experiments, not an auditor. Read it as a careful first look rather than a verdict.

None of that dents the core finding, though. If anything, the gating strengthens it. Hermes isn't hoarding notes to look busy. It writes things down when they're worth writing and when it writes things, it writes them down about you.

What I'll remember

I came to Hermes to learn how agents work, while expecting to write a tutorial on tool use. I'm leaving with a different thought.

We spend enormous energy arguing over which model is smartest. Hermes is a bet that, past a certain point, intelligence isn't the scarce resource. Continuity is. An agent that remembers you, accumulates how you work, and writes its own playbooks tuned to you doesn't have to be a genius. It has to stick around and pay attention.

I asked the self-improving agent to improve itself. It had already started doing that about four minutes before I asked, in a file addressed to me by name. I don't know about you, but I wouldn't call that a coding assistant. It's the start of a relationship with software, and it's worth paying attention to.

Want to reproduce this? It's an afternoon(or whatever time of the day this piece finds you). Install Hermes (git is the only prerequisite), point it at any model with ≥64K context, then give it one trivial task and one genuinely reusable one. Read ~/.hermes/memories/USER.md and ~/.hermes/skills/ afterward and see what it decided to write down. That's the whole experiment. The agent does the interesting part on its own.