Hermes Agent, Explained: The Open-Source Agent That Writes Its Own Skills

Nous Research calls Hermes Agent, in the README on the project's GitHub repository, "the only agent with a built-in learning loop". The repository had 256,360 stars and 56,015 forks when we read it on 23 October 2026, carries the MIT licence, was created on 22 July 2025 and had been pushed to that same day. Stars are attention rather than evidence, and the attention is not a fluke: Google Trends, worldwide, past seven days, read on 23 October 2026, put "hermes" and "hermes agent" up between 30 and 40 percent. What makes the project worth a careful explanation is not the count but the claim underneath it. The agent is model-agnostic — you point it at any OpenAI-compatible endpoint, including ours — and the one thing it says it does that the products it will be compared against do not is learn from its own work.

What you are actually installing

Claude Code, Claude Cowork and Claude Duet are products. You sign in, you get a surface, the vendor runs the model and the plan covers the usage. Hermes Agent is a repository. You install it on a machine you control, hand it a model endpoint, and from there it is yours to configure, break and leave running. The README's own framing is infrastructural rather than consumer: "Run it on a $5 VPS, a GPU cluster, or serverless infrastructure that costs nearly nothing when idle." It is deliberately not tied to a laptop, and the pitch that follows is that you talk to it from Telegram while it works on a cloud VM.

Installation follows the same shape. Linux, macOS and WSL2 get a one-line script; native Windows gets a PowerShell one-liner that the README says runs the CLI, the gateway, the terminal interface and the tools without WSL at all. Android and Termux users get a signed APT repository for aarch64 devices with a stable channel and a canary channel, and the README sends them to a separate Termux guide rather than the desktop installer. The source installer delegates Python 3.14, Node.js, npm, ripgrep, FFmpeg and the Python dependencies to a package manager, and stages a verified Git for Windows archive if Git is missing — without replacing the Git already on the machine. There is even a troubleshooting entry for antivirus software quarantining the bundled uv.exe, which the README identifies as a false positive on the Rust package manager it ships. That level of care about machines the maintainers cannot see is itself a signal about who the software is for.

Where it lives, and where the work happens

Two parts of the feature list are easy to skim past and hard to do well. The first is that it lives where you already are: Telegram, Discord, Slack, WhatsApp, Signal and a plain CLI, all from a single gateway process, with voice memo transcription and conversation continuity carried across the channels. The second is where the work happens. Six terminal backends are built in — local, Docker, SSH, Modal, Daytona and Vercel Sandbox — plus plugin backends such as Singularity and Apptainer. Daytona and Modal offer serverless persistence: the agent's environment hibernates when idle and wakes on demand. That is why the README can offer both "a $5 VPS" and "nearly nothing when idle" in the same breath without the two contradicting each other.

On top of that sits a cron scheduler with delivery to any platform — daily reports, nightly backups, weekly audits, written in natural language and run unattended — and isolated subagents for parallel workstreams, whose provider, model and limits are set in the desktop app under Settings, Model, Subagents. There is a research surface too: batch trajectory generation and trajectory compression for training the next generation of tool-calling models. The terminal interface itself is a full TUI with multiline editing, slash-command autocomplete, conversation history, interrupt-and-redirect, and streaming tool output. None of that is the claim the project leads with, which is telling: it is the unglamorous half of an agent that has to survive being left on.

The loop, decomposed

The phrase "learning loop" is doing a lot of work in the first line of the README, so it is worth unpacking into the five things the document actually names.

• Agent-curated memory, with periodic nudges: the agent decides what is worth keeping and is prompted to persist it rather than waiting for a user to ask.

• Autonomous skill creation after complex tasks, so a long sequence of steps leaves behind a reusable procedure instead of being re-derived the next time.

• Skills that self-improve during use: the procedure is edited the next time it is applied, rather than frozen at the moment it was written.

• FTS5 session search with LLM summarisation, so past conversations are retrievable across sessions instead of sitting in a scrollback buffer that nobody reads.

• User modelling — the README credits Honcho with a dialectic approach — that accumulates into "a deepening model of who you are across sessions".

That is a coherent design, and the artefact question is the one that matters. Nothing in the README describes a training run. The loop produces written material: memory entries and skills, retained and revised in the open. In principle that means a user can read what the agent decided to keep and diff what changed after the next task; it also means the improvement lives outside the model, in files that survive a change of model. The project is also compatible with the agentskills.io open standard, which matters precisely if you care whether those skills outlive the tool that wrote them. Taken one at a time, memory, retrieval, scheduled jobs and subagents all exist elsewhere. The combination, and the emphasis on the agent rewriting its own procedures, is the part that is being claimed as new.

What has been measured

Nothing, publicly. The README publishes no benchmark score, no audited comparison against another agent, no default model, and no hosted pricing page. The superlative in the first sentence arrives without a test attached to it, and a claim of that shape needs one, because the comparison it makes is against every other agent in existence, including agents that already keep memory or author their own tools. "The only agent with a built-in learning loop" is a sentence a reader can check against a feature matrix; whether the loop makes the agent better at your work is a different question, and it has not been answered in public.

Attention is meanwhile doing the work that evidence would otherwise do. 256,360 stars and 56,015 forks is a large number for a repository created in July 2025, and it is the sort of number a reader absorbs as a verdict. It is not one. A star costs a click. Press reporting in early October 2026 put Nous Research's raise at $90 million at a reported $1.5 billion valuation, with NVIDIA and Samsung among the backers, and put the agent at 24 million plus downloads. Those are figures from reporting rather than claims the company publishes itself, and even taken at face value they measure adoption, not capability.

Measuring this properly is genuinely hard, which is the fairest thing to say on the project's behalf. The unit of improvement is a task you have already done, so the counterfactual is the same agent on the same task without the skill it wrote — the workload has to be run twice, with and without the artefact, across enough tasks to separate a real gain from run-to-run noise. Nobody has published that. Until somebody does, the honest summary is that the mechanism is described in unusual detail and the outcome is asserted.

The Claude products it gets compared to

A reader arriving at Hermes from the Claude side will have a specific set of products in mind, and the comparison is worth making because the categories differ before any feature does. Anthropic's navigation lists Claude itself, Claude Code, Claude Cowork, Claude Duet, Claude Tag, Claude Science and Claude Security. Claude Code is built for software engineering and runs in a terminal, a desktop app, a web interface and a mobile app, with GitHub and IDE integrations, code review generally available on Team and Enterprise, and a security plugin in beta. Claude Cowork takes a goal and works across your files and tools, with a browser in the side panel, and deleting anything needs your approval. Claude Duet is the proactive one: a standalone app, on a waitlist for Claude Pro and Max subscribers in the US, built on Claude Opus 5.5.

Every one of those is the model vendor's own product on the model vendor's own infrastructure. Hermes inverts all three terms. The agent is open source, the model is a parameter, and the infrastructure is whatever you point it at. That inversion is where the learning-loop claim gets its weight, because a closed product can change the agent under you whenever it likes, while an agent whose skills live in files you own can be inspected and, in principle, moved. Anthropic lists Skills and Plugins among its capabilities; what none of the product pages we read on 23 October 2026 describes is an agent that writes a new skill out of its own task history and revises that skill the next time it is used. Whether the difference is valuable is a separate question from whether it is real, and only the second one has been settled.

Pointing it at a model

The README's model story is a single command: hermes model. Switch what the agent runs on without code changes, the README says, and without lock-in. That is the part of the design that should age best, because the interesting variable in an agent of this kind is not the loop but the model underneath it. The same skill library behaves differently on a small open model and on a frontier one, and a tool that turns that swap into a configuration change lets you test the difference instead of arguing about it.

An OpenAI-compatible interface is what makes the swap cheap, and it is the interface we speak. OrcaRouter is one endpoint for more than 200 models under a single key, with 0% markup — the provider's list price passed straight through — automatic failover when a provider degrades, and a routing DSL for the requests where you want to be specific about which model handles what. If you want a frontier model behind the agent, Claude Opus 5.5 is $4.00 per million input tokens and $20.00 per million output tokens, with a 1M-token context and cache reads at $0.20 per million. Hermes does not care which endpoint answers it. One thing worth being clear about: we host models, not Anthropic's apps or anyone else's agent. Hermes is Nous Research's software, and running it means your machine, your channels and your token bill.

If you are going to run it

The honest checklist before installing has little to do with the loop, and the README is unusually direct about most of it.

• The agent needs a host that stays up. A laptop that sleeps is the wrong machine, which is why the README reaches for a small VPS or a serverless backend that hibernates rather than the computer on your desk.

• Channels are a decision, not a default. Wiring Telegram, Discord, Slack, WhatsApp and Signal into one gateway process means that process holds the credentials to all of them, and that is a surface to think about before it is a feature to enjoy.

• The $5 figure is compute. Tokens are billed by whichever endpoint you point the model command at, and an agent running on a cron schedule spends them while you are not watching. Scheduled work and cheap idle time are different economies.

• The skills it writes are yours to review. The advantage of artefacts over weights is that you can read them; the discipline is actually reading them, the same way you would read a script a colleague left in the repository.

The question worth asking

Nous Research has shipped something with a clear thesis: that the next useful thing an agent does is not a longer context window but a growing library of procedures it wrote itself, on infrastructure cheap enough to leave running for months. The README argues that thesis with a detailed feature list, a working install path on every platform a developer might use, and a star count that most projects would trade a roadmap for. What it does not yet carry is the number that would settle the argument — the same agent, the same tasks, before and after its own skills arrived. Until somebody publishes that comparison, the fair reading is that the learning loop is a well-described mechanism and an unmeasured result. That is still a more interesting thing to install than either a promise or a dismissal.