Most "AI agents" are a chat window with a tool belt. You ask, they answer, they forget, and tomorrow you re-explain the same thing. Hermes Agent, from Nous Research, takes a different swing: an open-source, MIT-licensed, self-hosted agent built around a memory-and-skills loop. Everything below is what the project claims it does. I have found the design genuinely interesting, but treat the capability claims as vendor-stated until you have run it on your own tasks, because nobody has published independent head-to-head numbers.
First, the name, because three "Hermes" things will eat your week if you conflate them. Hermes Agent is the autonomous agent, the subject here. Nous Hermes is Nous Research's open-weight model family. And Hermès is the handbag house, unrelated. The agent runs on the Nous models but is not married to them, which matters more than it sounds.
What Hermes Agent claims to be
Nous describes it as an agent with a built-in learning loop. Versions move fast, so check the project's GitHub releases page rather than trusting any number I print here. The install is one line, per the docs:
curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash
Type hermes and you are talking to it. The headline behavior Nous advertises: when the agent solves a non-trivial problem, it writes itself a SKILL.md procedure so it does not re-derive that solution from scratch, keeps a long-term memory, and can search its own past conversations to pull back context. Whether that compounding actually helps on your work is an eval question, not a marketing one.
One design point does separate it from the coding agents: Nous says it runs across Telegram, Discord, Slack, WhatsApp, Signal, email, and CLI from a single gateway process, sharing one memory store. If that holds up, the agent you talk to in Slack at 9am is the same agent, with the same memory, you ping on Telegram at midnight.
Skills and memory: the part that matters
If you have used Claude Code or Codex, you know the SKILL.md format: a folder holding a SKILL.md file with a name, a description, and instructions, optionally bundling scripts or references. Hermes Agent uses the same open standard that Anthropic originated and published. The difference the project pitches is who writes the skill.
In Claude Code and Codex, you author skills (or ask the agent to) and the agent consumes them. Nous says Hermes Agent authors them on its own, on concrete triggers: after a complex task succeeds, after it recovers from an error, after you correct it, or when it spots a reusable workflow. To keep context sane, skills are said to load with progressive disclosure: a small index first, one skill's body on request, and a bundled file only when needed. That matches how the standard is meant to work.
Because these are standard SKILL.md skills, anything Hermes writes should be portable in principle to other agents that read the format. So the skills your agent accumulates are not, in theory, a vendor jail. Verify portability on a real skill before you rely on it.
Hermes Agent vs Claude Code vs Codex
This is the comparison everyone wants, so let me be blunt: they are different categories, and pretending otherwise is how people end up disappointed.
- Claude Code is a coding agent. It reads your codebase, edits files, and runs commands across terminal, IDE, desktop, and browser. It is built to ship software, and that is the job.
- OpenAI Codex is also a coding agent, spanning CLI, an IDE extension, and a cloud runner, with subagents and skills. Same neighborhood, same primary use.
- Hermes Agent is pitched as a general-purpose agent whose headline is not editing your repo. It is authoring and refining its own skills and persistent memory across chat surfaces, open-source and self-hosted.
A note on benchmarks: nobody has published head-to-head accuracy numbers for these agents, and I will not invent any. Anyone quoting you a Hermes Agent "accuracy" figure is selling something.
Self-hosting, models, and sandboxing
Here is where the open-source angle earns attention. Nous says the agent is model-agnostic: it runs on the Nous Portal, on aggregators like OpenRouter, on other providers, or on your own endpoint. Because the agent and the models are separable, you can point it at a local model and keep everything in-house.
The project also describes subagents for parallel workstreams and several execution backends, including local, Docker, SSH, and Modal, with container hardening. So when an autonomous agent decides to run code, the design intends for that to happen in an isolated sandbox rather than on your bare metal.
Business and developer use cases
Three patterns, none requiring you to write code:
- A Slack ops assistant that gets faster. Connect it to Slack and ask for a weekly metrics summary. The claim is that the first Monday it works out the multi-step pull and writes a skill, and the next Monday it just runs it. Test whether that actually compounds for you.
- A cross-channel assistant with one memory. The same agent on Telegram at night and CLI at your desk, sharing one memory store rather than per-app silos.
- A private alternative to a hosted bot. Run it in Docker on your own box, point it at your own endpoint, and keep data in-house. MIT license, no per-seat bill.
For builders, the interesting surface is the self-authoring skill system. Treat it as a substrate: let it accumulate skills as it solves recurring tasks, then lift those portable SKILL.md files into Codex or Claude Code. Because it is MIT and self-hosted, you can read the code, fork it, and run it against your own endpoint.
Security and oversight
An agent that writes its own skills and runs code is exactly the thing that should make you cautious, and the design acknowledges it. Nous documents a write-approval setting that stages skill writes for human review before they take effect, and the sandbox backends exist so autonomous execution stays isolated. This is not "set it loose and pray." Use the staging, use the sandbox, and review what it writes, at least until you trust it.
Keep what it writes
If you run it, the payoff is the skills it accumulates. Save the ones that prove useful as portable SKILL.md files in Command Center, so the work survives beyond one agent.
Sources and further reading
- Nous Research
- Anthropic: Equipping agents for the real world with Agent Skills
- Anthropic: Claude Code documentation
- OpenAI Codex documentation
FAQ
Is Hermes Agent the same as the Nous Hermes models? No. Hermes Agent is the autonomous agent; Nous Hermes is the open-weight LLM family. The agent can run on those models but is described as model-agnostic.
Does Hermes Agent only work with Nous's models? No. Nous says it runs on many providers and your own endpoint. The Nous models are one option, not a requirement.
Are the skills it writes locked to it?
They use the open SKILL.md standard, so in principle they are reusable in other agents that read the format. Verify on a real skill before relying on it.
Is it free? The agent is MIT-licensed and self-hosted, so the software is free. You pay only for whatever model inference you point it at.
Can it run code without touching my machine? Per the docs, yes. Beyond local execution it offers Docker, SSH, and Modal backends with container hardening, so autonomous code runs in a sandbox.