Hermes Agent: how Nous Research's self-learning agent really works

Most AI assistants start every conversation from scratch. You explain how you like your reports, it goes well, and the next day you explain it again. Hermes Agent from Nous Research promises the opposite: an agent that learns from its own work and uses that the next time.

That sounds like self-learning AI, but what actually happens is more concrete and easier to check. After a hard task, Hermes writes a text file describing the approach that worked, and reads that file again next time. Once you understand that, you know what to expect from the agent and what to keep an eye on.

What is Hermes Agent?

Hermes Agent is an open-source AI agent (MIT licence) from the research lab Nous Research. You install it on your own computer or a server, connect a language model of your choice, and it carries out tasks on its own: running terminal commands, editing files, searching the web. The project calls itself "the agent that grows with you".

The model is swappable. Hermes works with Nous Portal, OpenRouter, OpenAI, your own endpoint and other providers, so it also runs on local open models if your hardware can handle them. According to the README it ships with more than forty built-in tools.

How does Hermes learn from earlier tasks?

The learning does not happen inside the model. The model's weights don't change. What changes is a folder of skills: Markdown files (SKILL.md, following the open agentskills.io standard) in ~/.hermes/skills/.

The system prompt asks the agent to record any non-trivial workflow with its skill_manage tool. According to the documentation, that happens in practice when it has worked out a multi-step workflow worth repeating, or when it hit errors and dead ends before finding the path that works. If a skill later turns out to be wrong, the agent updates it, preferably with a targeted patch rather than a full rewrite.

A hypothetical example: you ask Hermes to pull revenue figures from Stripe, compare them with HubSpot, chart them and post a summary to Slack. The first time, it has to work out which API calls it needs and may trip over a date format. Afterwards it saves the working steps as a skill. Ask for the same report a week later and it doesn't have to figure it out again.

What about GEPA?

Many articles about Hermes mention GEPA (often misspelled as GAPA). GEPA is a technique from prompt-optimisation research: a language model reads execution traces, proposes variants of a prompt and keeps the best ones. Nous Research uses it, together with the DSPy framework, in a separate project: hermes-agent-self-evolution. That project optimises skills, tool descriptions and prompts outside your day-to-day sessions. It is not the mechanism Hermes uses to create skills while you work.

What does Hermes remember, and what not?

Besides skills, Hermes keeps two small memory files in ~/.hermes/memories/:

• MEMORY.md (up to 2,200 characters): the agent's own notes, such as facts about the environment and conventions.
• USER.md (up to 1,375 characters): what it knows about you, such as preferences and communication style.

Those limits are deliberately tight. Together they hold a few dozen short lines, not a dossier. The contents are loaded into the system prompt once, at the start of a session, and stay fixed for that session. If Hermes learns something new about you halfway through, you'll only notice in the next session.

Older conversations live in a SQLite database (~/.hermes/state.db) with full-text search. Ask "have we solved this before?" and the agent searches past sessions instead of guessing.

If you want more, you can plug in an external memory provider. Honcho, which builds a model of the user, is one option. Mem0 and Supermemory are others. They run alongside the built-in memory and are optional, not a fixed fourth layer.

Where does Hermes run, and how do you talk to it?

The agent can work in seven terminal backends: local, Docker, SSH, Singularity, Modal, Daytona and Vercel Sandbox. On Modal and Daytona, Nous says, the environment hibernates when idle and wakes up when a task arrives, so it costs almost nothing between sessions.

You talk to it through the terminal or through a gateway for chat platforms. According to the documentation, the gateway supports more than thirty platforms, including Telegram, Discord, Slack, WhatsApp, Signal, email and Microsoft Teams. It also runs a cron scheduler, so you can set up recurring jobs in plain language, such as a daily briefing in your Telegram.

Hermes runs on Linux and macOS, and now also natively on Windows through a PowerShell installer. WSL2 used to be required, and older guides still say so.

Hermes also speaks ACP, Zed's Agent Client Protocol. With hermes acp you can use the agent from editors such as Zed, VS Code and JetBrains IDEs, with diffs and approval prompts inside the editor.

Hermes or OpenClaw?

OpenClaw is the best-known open-source personal agent, so the comparison is obvious. Older comparisons (24 platforms versus 12, OpenClaw "doesn't learn") are out of date. Both projects are MIT-licensed, both run on your own hardware, both connect to dozens of chat platforms, and OpenClaw has memory and skills as well.

The difference Nous Research itself emphasises is that Hermes writes and updates its own skills as it works. If you want to switch, hermes claw migrate copies your persona (SOUL.md), memories, user-created skills, messaging settings and API keys, among other things, from an OpenClaw installation.

Where it can go wrong

The agent writes its own instructions. A skill with a mistake in it gets reused just as faithfully as a good one. That's why Hermes has a skills.write_approval setting: turn it on and skill changes are staged for your review instead of applied directly.

The agent runs real commands. Use an isolated backend such as Docker or a cloud sandbox if it shouldn't touch your personal files.

Other people's skills are instructions from strangers. The skills hub lets you install skills from several sources. It has a security scanner that looks for data exfiltration and prompt injection, among other things, but no scanner catches everything.

Finally, unless you run a local model, you pay for every token. An agent that also reflects on what to record after each task uses more tokens than one that doesn't.

What this means once you start using it

Hermes's "learning" isn't a black box. It's a folder of readable Markdown files. That is the strongest argument for the approach, and it tells you how to use it: after a week, open ~/.hermes/skills/ and read what the agent wrote down about your work. Whatever is in there is what it will do next time. Treat that folder like code you review.

As of September 2026. Hermes Agent changes quickly, so check features and commands against the official documentation.