Hermes Agent: what 'self-improving' actually means
TL;DR: Hermes Agent is Nous Research’s open-source, self-hosted agent, and its README calls it “the only agent with a built-in learning loop.” We cloned the repo and read the loop instead of the marketing. It’s three separate mechanisms: a memory nudge every 10 user turns, a background review that can fork the agent after a turn to decide whether to save a memory or a skill, and a weekly curator that prunes the skills the agent wrote. All three are on by default. The background review is the interesting one and the expensive one: the code itself puts it at about 30,000 extra tokens per review event. Nothing we found phones home. What you get is a real, inspectable loop that writes Markdown files under ~/.hermes, not magic.
What Hermes Agent is
Hermes Agent is a Python agent you run yourself. The repo is MIT-licensed, was created in July 2025, and had 234,000 stars when we checked on August 23, 2026, with a release tag most days (v2026.8.19 was the latest; our code read below is at v2026.8.18, pyproject.toml version 0.20.4). It’s big: north of 900,000 lines of Python by a plain wc -l over every .py outside tests/ and node_modules/, generated files included, 122 Python modules under tools/ (the docs count “40+ tools” at the user-facing level), and 82 bundled skills as SKILL.md folders compatible with the agentskills.io format.
You point it at any provider (OpenRouter, OpenAI, Anthropic, a local endpoint, or Nous’s own Portal, an optional subscription that bundles 300+ models plus a tool gateway for web search, image generation, TTS and a cloud browser so you don’t collect separate keys) and use it from a terminal TUI or through a gateway process that speaks Telegram, Discord, Slack, WhatsApp, Signal and email. It runs commands through one of seven terminal backends: local, Docker, SSH, Singularity, Modal, Daytona or Vercel Sandbox. There’s a cron scheduler, MCP support, subagent delegation, and a migration command for people coming from OpenClaw. It is not a coding tool the way Claude Code or Codex are; it’s a general operator that happens to be very good at shell work, and the developer interest comes from the fact that you can read all of it.
The learning loop, mechanism by mechanism
The README bundles several things under one phrase. In the code they’re separate modules with separate defaults. We’re describing the state of the tree at tag v2026.8.18; the paths are there for you to check.
1. The memory nudge (every 10 user turns). agent/agent_init.py sets _memory_nudge_interval = 10, overridable through the memory config. When the counter trips, the agent is prompted to write down anything worth keeping. Memory is two plain-text files, per tools/memory_tool.py: MEMORY.md for the agent’s notes about the environment and projects, USER.md for what it knows about you. They’re capped by characters, not tokens, so the limits hold across models: 2,200 characters for MEMORY.md, 1,375 for USER.md. That’s small on purpose. It forces the agent to curate rather than hoard, and it means the memory that lands in every system prompt stays cheap.
2. The background review (after every turn). This is the piece that makes the “learns while you work” claim true. agent/background_review.py describes it: after a turn, the agent may spawn a daemon thread that replays the conversation snapshot in a forked copy of itself and asks “should any skill/memory be saved or updated?” The fork runs with a tool whitelist limited to memory and skill management; everything else is denied. It inherits the parent’s provider, model and credentials so it hits the same prompt cache, and it never touches the main conversation. It’s on by default (auxiliary.background_review.enabled, default true).
The cost is stated in the code, in a comment on the opt-out flag in agent/agent_init.py: skipping the fork “avoids ~30K tokens / event of extra LLM cost on cron-style sessions where review forks provide no value.” On the same model most of those tokens are cache reads, which is why the authors call it cheap, but if you route the review to a different model (the config allows auxiliary.background_review.{provider,model}) the fork goes cold and you pay full price for the replay. 
It’s also the mechanism behind “autonomous skill creation”: the fork can call the skill tools and write a new SKILL.md if it decides the task was worth remembering as a procedure.
3. The curator (every 7 days). agent/curator.py is Hermes Agent’s background maintenance job for the skills the agent wrote for itself. Defaults: it runs when the agent has been idle for at least 2 hours and the last run was more than 168 hours ago; a skill unused for 30 days is marked stale and archived after 90. Its invariants are spelled out at the top of the file: it only touches agent-created skills, it never deletes (archive is recoverable), pinned skills are exempt, and it runs on the auxiliary client so it never disturbs your session’s cache. Consolidation of overlapping skills exists but is off by default.
Each of the three ends in a file write you can cat.
How much does the learning loop cost, and how do you turn it down?
The learning loop is a second, quieter agent riding along with yours. On a chatty session that’s a lot of turns, and each one may trigger a ~30K-token replay. If your provider bills cache reads at a steep discount, that’s tolerable; if you’re on a flat-rate plan with usage limits, it draws down the same allowance as your foreground work. Cron-style unattended sessions are the case the authors explicitly call out as not worth it, and there’s a skip_background_review flag for exactly that.
Dials worth knowing about before you install:
auxiliary.background_review.enabled: falseturns the per-turn fork off entirely; the memory nudge still works.- Routing the review to a cheaper model saves per-token cost but loses the warm cache. Measure before assuming it’s a win.
- The memory nudge interval and the curator’s
interval_hours,min_idle_hours,stale_after_days,archive_after_daysare all config keys. hermes doctorand/usagein a session are where you’ll see what the loop is actually consuming.
For a sense of how much a coding agent burns before it does anything useful, our measured startup token overhead piece is the comparison point; Hermes adds a per-turn tail rather than a startup head.
Does Hermes Agent send your data to Nous Research?
We grepped the whole tree for telemetry, analytics, PostHog and Sentry. Nothing. Outbound calls to Nous domains are the inference API (used only when Nous is your provider), the Portal login, JWKS and subscription pages, a model-catalog.json fetch, and an update check in hermes_cli/banner.py that caches its answer for six hours. Everything the loop produces lives on disk under the Hermes home directory: MEMORY.md, USER.md, the skills folder, an SQLite session store with FTS5 search that the agent can query for past conversations, and the curator’s state file. If you run the terminal backend in Docker or a remote sandbox, the commands go there; the memory stays local.
Two things we couldn’t check from a code read alone and want to be clear about: how good the self-written skills are after a week of real use, and how often the background review decides to write something versus deciding there’s nothing to save. Both need a running instance and a log, not a grep. Reddit threads asking whether it’s genuinely useful in production or still a promising concept are asking the right question, and nobody in the SERP for that query has answered it with data either.
Who it’s for
Hermes makes sense if you want an agent that runs on a box you control, talks to you from your phone, and keeps its own notes in files you can read and edit. The loop is real, its intervals are sane, and the cost is disclosed in the code even if not on the landing page. It makes less sense if what you actually need is a coding assistant inside an editor, or if you’re on a metered plan and don’t want a second agent spending tokens after every message. Turn the review off, keep the nudge, and it’s a very capable ordinary agent with a memory file.
If you’re weighing self-hosted agents against the hosted ones, our guide to setting up MCP servers covers the integration side that Hermes also supports, and Claude Code review is the reference point for what a hosted, subscription-priced agent gives you for the same money. The rest of our guides cover the surrounding tooling.
Frequently asked questions
What is Hermes Agent?
Hermes Agent is an open-source (MIT), self-hosted AI agent from Nous Research. It's a Python project you install on your own machine, VPS or sandbox, point at any model provider (Nous Portal, OpenRouter, OpenAI, Anthropic, a local endpoint), and talk to from a terminal or through Telegram, Discord, Slack, WhatsApp or Signal. It ships with 122 tool modules and 82 bundled skills, and its main claim is a learning loop that writes memory and creates skills on its own.
Is Hermes Agent free?
The software is free and MIT-licensed. You pay for whatever model you point it at. Nous sells an optional subscription, Nous Portal, that bundles model access and a tool gateway (web search, image generation, TTS, cloud browser) so you don't need separate API keys, but you can bring your own keys for every piece instead.
Does Hermes Agent's learning loop cost extra tokens?
Yes. By default, after a turn Hermes can fork a copy of the agent to replay the conversation and decide whether to save a memory or a skill. A comment in the source puts that at roughly 30,000 tokens per event of extra LLM cost, mostly cache reads when the review runs on the same model as your session. It can be turned off with the background-review setting or routed to a cheaper model.
Does Hermes Agent send data back to Nous Research?
We found no analytics or telemetry endpoints in the code. The outbound calls to nousresearch.com domains we found are the inference API (only if Nous is your provider), the Portal login and subscription endpoints, a model-catalog fetch, and an update check cached for six hours. Your memory files, skills and session database live under the Hermes home directory on your own machine.