Hermes Agent: The Agent That Evolves Itself

I wrote about OpenClaw as a local agent architecture: inputs, gateway, queues, sessions, state, and tool execution.

Hermes Agent deserves the same treatment, but the interesting part sits one layer higher.

OpenClaw showed how an agent starts to feel alive when time, messages, hooks, and webhooks keep feeding it work. Hermes asks the next question: what happens when the agent starts maintaining the knowledge it created from prior work?

That is the real story behind the Hermes Agent v0.12.0 release. The headline is not more integrations, more platforms, or faster startup. The headline is the Curator.

Hermes now has a background process that grades, prunes, consolidates, and reports on the agent’s own skill library.

That matters.

What Hermes Agent actually is

Hermes Agent is a self-improving agent runtime from Nous Research.

It is not just a CLI. It is not just a messaging bot. It is not just another wrapper around OpenAI, Anthropic, OpenRouter, or a local model.

It has several pieces working together:

• an interactive CLI and TUI
• a gateway for messaging platforms
• a tool runtime
• a cron scheduler
• persistent sessions and memory
• a skills system
• subagents
• model provider routing
• plugins

Here is the shape:

The short version:

Hermes is an agent runtime that can live outside your laptop, talk through many channels, use tools, remember prior work, and write reusable skills from experience.

This is why the repo calls it ‘the agent that grows with you.’ The phrase is marketing, but the architecture behind it is concrete.

The agent does work. When that work teaches it something reusable, it can save the procedure as a skill. Later, it can load that skill instead of rediscovering the same approach.

That creates a new problem.

If an agent can write skills forever, the library can become a landfill.

The skill landfill problem

Skills are useful because they are procedural memory.

A good skill tells the agent:

• when to use it
• what context to gather
• which commands or tools to prefer
• which pitfalls to avoid
• how to verify the result

This is better than hoping the model remembers everything from pretraining or stuffing every workflow into AGENTS.md.

But skills have an operational cost. Every skill adds a routing surface. Every vague description competes with other vague descriptions. Every stale workflow is a future mistake waiting for a trigger.

The more an agent learns, the more easily the library becomes noisy.

This is the same problem teams already have with internal docs. The difference is speed. Humans let docs rot over months. Agents can create near-duplicate procedures in days.

Hermes v0.12.0 treats that as a first-class problem.

The Curator

The Curator is a background maintenance pass for agent-created skills.

According to the Hermes docs, it tracks how often a skill is viewed, used, and patched. It moves long-unused skills through states like active, stale, and archived. It can also run an auxiliary-model review to decide whether skills should be kept, patched, consolidated, or archived.

The important detail is that the Curator does not maintain all skills equally.

It protects bundled skills and hub-installed skills. It focuses on agent-created skills under ~/.hermes/skills/. That is the part of the library most likely to grow from daily use and drift from reality.

The default timing is conservative:

• wait 7 days between curator runs
• require idle time before running
• mark skills stale after 30 days of inactivity
• archive after 90 days
• write per-run reports
• allow pins for skills you want protected

This is not magic. It is bookkeeping plus an LLM review pass.

But that is exactly why it is interesting.

Agent improvement does not have to mean mystical self-awareness. It can mean counters, thresholds, state transitions, reports, backups, and a constrained review agent.

The new loop

The old loop for agents looked like this:

Hermes adds another loop:

That second loop matters most.

It turns agent experience into a managed asset. Not just memory. Not just a transcript search index. A library of procedures that can improve, decay, and be audited.

This is where Hermes feels different from a normal coding agent.

Most agents treat learning as one of four things:

• context in the current conversation
• memory snippets
• a local instruction file
• a user-maintained skills folder

Hermes moves toward an agent-maintained operations layer.

The user does not just ask the agent to do work. The agent also has a background responsibility: keep its procedures useful.

Why this matters for builders

The Curator release is a signal about where agent systems are going.

The next frontier is not only better prompts. It is agent hygiene.

If you build a long-running agent, you need answers to boring questions:

• Which learned procedures are still useful?
• Which skills overlap?
• Which skills are stale?
• Which skills are dangerous?
• Which skills are used often enough to deserve maintenance?
• Which skills should be pinned because a human trusts them?
• Which changes need an audit trail?

These questions sound mundane, but they decide whether an agent gets better or gets strange.

A long-running agent without hygiene becomes unpredictable. It accumulates stale notes, obsolete commands, duplicate instructions, bad assumptions, and hidden context dependencies.

A long-running agent with hygiene can compound.

That is the real promise of Hermes.

Not that it can send messages on more platforms. Not that it can use more models. Not that it bundles more creative tooling.

Those are useful features. The bigger idea is that an agent runtime needs maintenance loops for its own operating knowledge.

The gateway is still the body

Hermes also keeps expanding the body around the agent.

The v0.12.0 release adds Tencent Yuanbao as the 18th messaging platform and Microsoft Teams through the plugin system. It adds native Spotify tools and a Google Meet plugin. It promotes ComfyUI and TouchDesigner-MCP from optional to bundled-by-default. It adds more inference providers, including LM Studio, GMI Cloud, Azure AI Foundry, MiniMax OAuth, and Tencent Tokenhub.

This is the same pattern I described in OpenClaw:

• more inputs
• more tool surfaces
• more delivery channels
• more background triggers
• more places where the agent can act

The gateway is how the agent enters your life.

The Curator is how the agent keeps its learned procedures from rotting once it is there.

Both matter.

Without the gateway, the agent is trapped in a terminal.

Without maintenance, the agent becomes a pile of yesterday’s clever hacks.

The security angle

Self-improving agents increase the blast radius of bad instructions.

If an agent can write skills, update skills, load skills, and run them later, then skill provenance becomes a security boundary.

Hermes appears to understand this. The Curator docs call out bundled skills, hub-installed skills, agent-created skills, pins, archives, dry runs, backups, and rollback.

Those controls matter because the skill layer is not just documentation. It is executable operational memory. A bad skill can tell the agent to run the wrong command, trust the wrong source, leak the wrong file, or skip the wrong verification step.

The practical mitigations are straightforward:

• inspect agent-created skills
• pin workflows you rely on
• run dry-runs before mutating the library
• review curator reports
• keep dangerous tool permissions narrow
• use isolated environments for risky work
• treat skills like code, not notes

This is the tradeoff.

An agent that learns procedures can get much more useful. It can also preserve mistakes in a form that feels authoritative later.

The builder takeaway

Hermes Agent is a useful case study because it makes the self-improvement loop concrete.

It is not enough for agents to remember.

They need to maintain what they remember.

For builders, the pattern is reusable:

1. Let the agent create procedural knowledge after hard tasks.
2. Track usage, views, edits, and age.
3. Separate trusted built-ins from agent-created material.
4. Review stale or overlapping procedures on a schedule.
5. Archive instead of deleting.
6. Write reports humans can audit.
7. Let users pin important workflows.

That is how agent memory becomes infrastructure.

The big shift is this: a capable agent is no longer just a model plus tools. It is an operations system with inputs, state, skills, scheduled maintenance, and auditability.

Hermes v0.12.0 is not the final version of that idea. But the Curator release is a clear step in the right direction.

The future agent does not just do the work.

It keeps its own workshop clean.