Hermes Agent: The Coding Agent That Writes Its Own Skills

Hermes Agent is an open-source personal agent from Nous Research whose defining feature is that it does not start from scratch every morning. It writes skills from its own experience, refines them as it uses them, and searches its history rather than forgetting it.

Before any of that, though, this post has to start somewhere else — because when we went looking for it, the first repository we found was not the real one.

Key takeaways

• The canonical project is NousResearch/hermes-agent. A separate repository with a similar name is a re-upload carrying an added sponsor badge — a useful lesson in reading provenance.
• Its learning loop creates and refines skills from experience, rather than asking you to author them.
• Session history lives in SQLite with full-text search and model-written summaries, so past work is queryable.
• Six execution backends — local, Docker, SSH, Daytona, Singularity, Modal — with the serverless ones hibernating when idle.
• Six messaging surfaces, so the agent is reachable from Slack or WhatsApp, not only a terminal.
• Windows needs WSL2. The install path is a piped shell script, which deserves a read first.

The repository that was not the repository

A repository called hermes-agent-org/hermes exists. It looks plausible: the right name, a README describing the right project, an org that sounds official. It has three stars.

The tells are all in the metadata, and they are worth learning to read:

• It was created and abandoned within about a day. Created one afternoon, last pushed the next. Nothing since.
• It is not marked as a fork and lists no parent repository — meaning the code was pushed up as a brand-new project rather than forked. That is precisely how attribution gets erased.
• The commit messages are bulk operations. "Auto-commit: local changes before push." "Merge remote main - accept ours for conflicts." Not the shape of a project being built.
• The only substantive change was adding a sponsor badge.
• Its own install command points at the upstream. The README tells you to curl a script from NousResearch/hermes-agent. It never even claimed to be the source.

None of this is necessarily malicious — it may just be someone mirroring a repo carelessly. But an agent framework executes shell commands on your machine, and "probably fine" is not the standard you want for that. Install from the upstream.

Worth contrasting with the opposite case: ComfyUI genuinely moved from a personal handle to an organisation, which looks identical from a distance. We unpack that in our ComfyUI guide. Same symptom, opposite cause — which is exactly why you check the metadata rather than trusting the vibe.

What problem does Hermes Agent solve?

Amnesia. Every session with a coding agent starts cold. You re-explain the stack, the conventions, why the legacy module is shaped like that, which tests are flaky and can be ignored. You have explained it two hundred times, and you will explain it again tomorrow.

The standard mitigation is a project instructions file, and it helps — but you are still the one writing it. You notice the pattern, you decide it is worth recording, you write it down. The agent contributes nothing to its own improvement.

Hermes inverts that. The agent notices what it repeatedly needed, writes the skill itself, and sharpens it the next time it is used. You supervise a process instead of maintaining a document.

How does the learning loop work?

1. It creates skills from experience. Having worked out how to do something, it can write that procedure down as a reusable skill rather than rediscovering it.
2. It refines them in use. Skills are not write-once; running one is an opportunity to correct it.
3. It nudges itself to persist. Rather than relying on you to say "remember this", it prompts itself to store what looks durable.
4. It searches its own history. Sessions are indexed in SQLite with full-text search and summarised by the model, so "how did we handle this last time" is a query rather than a memory.
5. It spawns isolated subagents to parallelise work and to collapse multi-step workflows into a single turn.

Compare this with the hand-authored approach — a curated folder of skill files that a human writes and maintains, which we cover in our guide to Agent Skills. Both approaches are valid. Hand-authored skills are predictable and reviewable; self-authored skills scale without you. The interesting question is whether you can audit what the agent decided to remember, and that remains genuinely open.

Six backends and six front doors

The infrastructure story is more interesting than it first looks. The agent's execution environment is pluggable — local shell, Docker, SSH to a remote box, or serverless environments that hibernate when idle.

For an agency, that last property is the useful one. A per-client agent instance, isolated from every other client, costing almost nothing while nobody is talking to it, is a genuinely practical deployment shape. Isolation stops being a discipline and starts being infrastructure.

On the other side, a gateway bridges the agent to Telegram, Discord, Slack, WhatsApp, Signal and the CLI. An agent in Slack that remembers your codebase conventions is a different product from a terminal tool, even though it is the same software.

It is also provider-agnostic. Swapping the underlying model is a command, not a code change.

What does using it look like?

Install is a piped script from the upstream repository — read it before you run it, as with any such install:

curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash

Then the command surface is small and readable:

hermes          # interactive CLI
hermes model    # select LLM provider and model
hermes tools    # configure enabled tools
hermes gateway  # start messaging gateway
hermes setup    # full configuration wizard

Alternatives worth knowing

• Claude Code and Codex CLI — first-party, polished, and far better documented. No autonomous cross-session learning loop, but you can get most of the practical benefit from a well-maintained instructions file and a skills folder.
• Letta (formerly MemGPT) — the closest philosophical rival, built memory-first. If persistent memory is the actual requirement rather than a nice property, evaluate it directly.
• Aider — git-native, focused, unfussy. No memory and no messaging, but excellent at the specific job of editing a repository with a model.
• OpenHands — a broader open agent platform, worth a look if you want a UI rather than a terminal.

Limitations and things to think about

• No native Windows. WSL2 required.
• Fast-moving. An enormous commit rate and a correspondingly large issue queue. Expect churn.
• Self-authored memory is hard to audit. If the agent learns something wrong, it may keep applying it. Review what it has written down periodically, the same way you would review a colleague's notes.
• Your usage is training-shaped data. The repository ships reinforcement-learning environments and trajectory compression tooling. That is not hidden, and it is not sinister — but it is worth knowing that the project sits inside a research lab's pipeline.
• Client data and persistent memory need a policy. An agent that remembers everything across sessions is an agent that has to be scoped per client.

Conclusion

Hermes Agent is one of the more genuinely ambitious open agent projects: not a better wrapper around a model, but an attempt at an agent that gets better at your codebase the longer it works on it.

The lasting lesson, though, might be the one from the first section. Two repositories, near-identical names, and only one worth running a shell script from. Reading provenance is a developer skill now.

Thinking about an agent that knows your business?

DI Solutions builds internal agents with the boring parts done properly — scoped permissions, per-client isolation, auditable memory and a human in the loop where it counts. Talk to our AI engineers about what is realistic for your team.

Reference links

• Hermes Agent on GitHub — the canonical repository
• Nous Research