Hermes Agent: the self-improving open-source agent

An open-source agent you run yourself, pointed at whichever model you like. What it adds is a layer of its own between you and that model: a personality file, a bounded memory, a library of skills it writes as it works, and a curator that prunes them. Nous Research argues that this layer, rather than the model underneath it, is what makes an agent loyal to the person using it.

Hermes Agent, from the research lab Nous Research, is the open-source AI agent built around a single idea: an agent should get better the more you use it. It runs on your own hardware rather than as a hosted service, connects to the large language model of your choice, and works away autonomously in the background. What sets the hermes agent apart from the rest of the field is a closed learning loop that turns your everyday tasks into permanent skills, so the software you run in July is more capable than the one you installed in February.

That is the product description. The argument underneath it is the more interesting half, and Nous Research makes it directly: the wrapper around a model, what the field calls the harness, decides how much of the model you actually get, and most harnesses spend their prompt budget on things unrelated to your work.

Who builds it

Nous Research began as two people in a Discord server and is now a lab. The names below are the ones the company puts forward on the agent and the research behind it.

TekniumCo-founder · post-training · created Hermes Agent
Karan MalhotraCo-founder · alignment
Dylan RolnickChief executive
Jeffrey QuesnelleChief technology officer · YaRN
Bowen PengChief scientist · YaRN

Around forty volunteer researchers formed the original cohort. Teknium is described by the company as the father of Hermes: he has run the model line since the second release and wrote the first version of the agent.

What it is

The hermes agent is self-hosted by design. Rather than sign in to someone else’s cloud, you run it on your own infrastructure and point it at your preferred model, which keeps both the data and the control on your side.

Local by default. Nous Research has been firm that all data stays on the machine, with no telemetry, no tracking and no cloud lock-in.
Model-agnostic. Claude Code runs Anthropic models and Codex runs OpenAI models, each subsidised by its maker. Hermes runs a hosted frontier model, a local open-weights model or a mixture, with a fallback chain for when the primary provider errors.
Reachable from anywhere. It executes code, searches the web, manages files and answers on more than sixteen messaging platforms, so work can be handed to it from a phone.
MIT licensed. The whole harness is public, which is what allows any part of it, including its self-maintenance, to be edited.
Voice, since Herald. Version 0.20.0, released on 3 August 2026, added real-time conversational voice with barge-in and on-device wake words, along with version 1.0 of the Agent2Agent protocol for talking to other agents and signed outbound webhooks.

The Hermes Agent website: a blue page headed The Agent That Grows With You, with an install command and a desktop app download button — The project's own front page leads on the compounding claim and a one-line installer. Screenshot of hermes-agent.nousresearch.com, Nous Research, 2 August 2026.

The harness is the argument

A harness is everything wrapped around the model: the system prompt, the tool definitions, the memory handed over at the start of a session, and the rules about what the model may and may not do. It is invisible to the user and it is large. Nous puts the big commercial harnesses at tens of thousands of token prompts, and the objection is to what those tokens are spent on.

Where the harness sits

Every agent has a harness. What Nous Research claims for this one is that its contents are yours: an identity file you wrote, a memory of your environment, skills built from your work, and no policy in the prompt that is unrelated to the job.

We don’t introduce arbitrary policy in our prompts or in our system that has nothing to do with your work. We are purely dedicated to making sure the model is aligned to what you need to do with it.

Karan Malhotra, co-founder, Nous Research

The lab is careful about the limits of this:

Anything happening behind a commercial API, a steering vector or a provider-side prompt, is beyond the reach of any harness.
With an open-weights model you are genuinely free; with a hosted one you are working around whatever the provider has already done.
The claim is that harness context can be written to overcome much of it, because the model reads what is in front of it.

Nous also points to third-party harness comparisons that it says found the same Claude model scoring higher inside Hermes Agent than inside Claude Code on the testers’ own task sets. We have not verified those results and neither the benchmark nor the task set has been published, so treat it as the claim of an interested party rather than a settled finding. The mechanism offered for it is the interesting part: by filling the context with your work instead of a vendor’s policy, Malhotra said, “we’ve taken Claude’s main allegiance away from Anthropic to you”.

Reward, and why an agent tells you that you are absolutely right

The most useful part of the company’s reasoning has nothing to do with Hermes specifically. It is about why assistants behave the way they do.

A language model is trained towards a reward. It is not trained towards your satisfaction, and the two come apart more often than the marketing suggests. The illustration Nous uses is the classic one from reinforcement learning: point a system at a Mario level with a badly specified goal and it will not learn to play the game, it will learn to trigger the end-of-level flag by whatever route is cheapest. The flag was the reward. The game was incidental.

Two loops that look identical from the outside

Sycophancy is not loyalty. An agreeable reply that keeps you typing collects the model's reward whether or not your work moved forward, which is why the fix is procedural rather than a question of asking more nicely.

Anytime it says you’re absolutely right in that way, you’re being reward hacked. You are fuel for its reward function.

Karan Malhotra, on sycophancy in chat assistants

The prescription is the one you would use on a person stuck in a bad habit: change the surroundings.

Set a personality that is supposed to disagree with you. A session-level overlay, rather than a politer request.
Hand each pass to a fresh agent. One with no history of the conversation and an instruction to tear the work down has nothing to be agreeable about.
Keep the critiques that landed. Saved as skills and memories, the correction survives into later sessions.

Nous describes the result as a sort of test-time reinforcement learning: no weights change, but the examples in front of the model do, and in-context learning is the strongest lever available without retraining.

The self-improving loop, in the files it writes

The defining feature is what Nous Research calls a closed learning loop. When the hermes agent finishes a complex task, it writes a reusable skill describing how it did it. When it notices a task pattern repeating, it generates a skill file of its own accord, built from your actual workflows rather than a generic library. The effect compounds: routine jobs get faster and the system needs less hand-holding over time.

The Hermes Agent features overview in its documentation, listing tools and toolsets, the skills system, persistent memory, context files and checkpoints — The feature list behind the loop: skills, bounded memory, context files and automatic checkpoints before file changes. Screenshot of the Hermes Agent documentation, 2 August 2026.

None of it is abstract. It is files on your disk, and the sizes are deliberately small:

~/.hermes/SOUL.md is the identity file. First in the system prompt, never overwritten once edited, holding tone and standing instructions rather than anything project-specific.
~/.hermes/memories/MEMORY.md holds what the agent has learned about your environment, capped at about 2,200 characters.
USER.md alongside it holds your preferences and working style, capped at about 1,375. A write that would exceed either cap returns an error rather than silently dropping something, which forces a consolidation instead of an ever-growing file.
~/.hermes/skills/ holds the procedures, one directory per skill with a SKILL.md at its root. Every installed skill becomes a slash command, and several can be stacked in one message.
AGENTS.md in a project root carries the rules for that project, read at session start. Existing .cursorrules files are picked up too, rather than duplicated.

The split is the thing new users get wrong: memory is for what is true, skills are for how something is done. Facts in one, procedures in the other.

The Skills System page of the Hermes Agent documentation, showing that skills live in the tilde slash dot hermes slash skills directory — Skills are on-demand documents the agent loads only when a turn needs them, which is how the library grows without taxing every message. Screenshot of the Hermes Agent documentation, 2 August 2026.

Everything in the harness is context management

The company's own summary of the design, as Malhotra put it: "Everything in the harness is context management." Memory and skills exist so that knowledge can sit outside the context window and be fetched at the moment it is needed, rather than taxing every turn.

Hermes Curator, and the slop problem

The obvious objection to an agent that writes its own skills is that it will write bad ones, then read them back, then write worse ones. Anyone who has run a self-improving loop for a fortnight will describe the same decay.

Nous Research’s answer is Hermes Curator, a background process that runs on a schedule and cleans the library:

It reads the skills and the memories, merges duplicates, archives what is not earning its place and trims what has bloated.
A default set of criteria ships with it, which the company credits for why most users have not run into decay.
The criteria are yours to change. Ask the agent to show you the curator and its definition of slop, tell it how you want your skills refined, and it edits the loop, so even the maintenance runs your way.
There is a safety net: the curator takes snapshots, individual skills can be pinned so it never touches them, and archived skills can be restored.

The self-improvement machinery, as commands

hermes skills listEvery skill currently installed, bundled, written or fetched from a registry.
/learn <source>Point it at a directory, a URL or a described procedure and it authors the skill itself.
hermes journeyThe timeline of skills and memories learned over time. This is the compounding, made visible.
hermes curator statusCurator state and skill statistics: what it has been doing while you were away.
hermes curator runTrigger a review now rather than waiting for the schedule.
hermes curator pin <skill>Protect a skill so the curator never archives or rewrites it.
hermes curator rollbackRestore the skill library from a snapshot when a pass goes wrong.

Approval gate: set skills.write_approval: true and every agent-authored skill is staged in ~/.hermes/pending/skills/ for review with /skills pending and /skills approve. Start there if the idea of software writing its own procedures makes you uneasy.

What people are actually doing with it

Two patterns deserve more attention than they get.

One board for humans and agents

Hermes ships a kanban board as a first-class part of the CLI, with tasks, dependencies, assignment, claiming, comments and a dispatcher. A board does not care what kind of worker picks a card up:

A human project manager can work the board by hand while Hermes profiles fill in the cards beneath them.
An agent can hold the board and hand work out to people.
Humans and agents swap into any position on it, which turns a solo CLI tool into an orchestration layer a team can stand in.

The board does not care who picks up the card

The board is a real SQLite-backed feature, not a metaphor: hermes kanban creates, assigns, links, claims, blocks and dispatches tasks across profiles.

Proactivity, which mostly emerges

The scheduled route is well documented: hermes cron runs jobs on a timetable and hermes webhook wakes the agent on an external event. What the company reports seeing in the field is less prescribed. Given enough standing context about a person’s calendar and habits, an agent told to cover the gaps starts to act on them, reporting that it has already booked the flight for next week’s meeting.

Nous frames this as a comfort setting rather than a feature. It depends entirely on what accounts and cards the agent has been handed, plenty of users will want an approval prompt in front of every action, and preset configurations are planned so the behaviour can be dialled in deliberately.

The CLI Interface page of the Hermes Agent documentation, describing a full terminal user interface with multiline editing, slash-command autocomplete and streaming tool output — The agent is a terminal interface rather than a web app: slash-command autocomplete, interrupt-and-redirect, streaming tool output, and a modal TUI behind `hermes --tui`. Screenshot of the Hermes Agent documentation, 2 August 2026.

Running work, not just chatting

hermes kanban create “<title>”Put a task on the active board. assign, link and claim do the rest.
hermes kanban dispatchOne dispatcher pass: hand ready tasks to whichever profile is free.
hermes cron createTurn a prompt into a scheduled job, with its own skills loaded.
hermes webhook subscribeWake the agent on an external event and route the result to a chat.
hermes send -t telegramOne-shot message out to a configured messaging platform.
hermes -cResume the last session with its history intact. -r “title” resumes by name.
hermes –worktreeStart in an isolated git worktree, for running several agents in parallel.

Full reference: hermes --help, or the published CLI command list ↗. Our own prompting guide covers the slash commands and the habits that make these pay off.

What it can do when the documentation runs out

The strongest evidence for the learning loop is not a benchmark. It is what the agent manages in a domain no model was trained for.

Set on modding a 2001 console game, an area with almost no public documentation and a tiny community, it worked in an unfamiliar toolchain end to end:

Read its way in. It learned the formats from scattered documentation and other people’s published mods, then saved what it worked out as skills and memories, so the knowledge was there the next time it opened the same code base.
Wrote low-level code. C and C-like tooling against a 1999 game engine, importing assets from a 1997 one.
Drove a 3D application. The Blender extension handled modelling, rigging, texturing and animation, with the agent operating it rather than a person.
Added what the engine did not support. A scripted non-player character with a random walk, idle animations and interactions, in a mode that never allowed characters at all.
Got the physics right. Collision, walkable ground, working water, and a sky box with a day and night cycle, none of which the original build has.

The person directing it does not write code. When the resulting mod was shown to the modding community, the reaction was the useful data point:

They said there’s no way an AI like Claude could do that, it doesn’t know this kind of code. But with something like Hermes being able to learn from the documentation, learn from other mods, save to memory and skill the things that allow it to understand these code bases, it was able to get into this niche and perform at the top 1% of modders.

Karan Malhotra, on the community's response to the finished mod

Top one per cent is a community’s own judgement of difficulty, not a score anyone can audit, so take it as that. The transferable point holds regardless: nothing in a model’s training makes it competent at an obscure, badly documented toolchain, and what closed the gap was an agent that read the material, kept what it learned, and had it to hand the next time.

Where the money comes from

An open-source harness that runs anyone’s models has an obvious question hanging over it. The company’s answer is that the consumer side is meant to be free, including for people who bring their own keys and never pay Nous anything: intelligence should be a public good first, and a person using Hermes to build a business is worth more to the project than a subscription.

The revenue sits in three places:

RouteNous PortalA router across many models, so you can move between hosted and open-weights models without collecting API keys. Nous expects to price competitively where a model is not being subsidised by its maker.
BundleTool GatewayImage generation, audio, web search and server spin-up included under one sign-in, through deals with the providers, instead of ten separate accounts and ten API keys. hermes setup --portal covers it in one OAuth.
ServeBusiness workSupport, custom deployments, model routing, and reinforcement learning on a company's own traces to produce a private model that stays on their infrastructure. The classic model, aimed at organisations rather than individuals.

What Nous sells to individuals, in short, is convenience. What it sells to companies is the team that built the thing.

Open against closed, argued honestly

Nous does not take the maximalist line here, and the page is better for reporting that accurately. The company says outright that it does not violate Anthropic’s or OpenAI’s safety and security paradigms, and is not interested in that kind of work.

Its argument is about the shape of the field rather than about guardrails:

Safeguards buy time, not certainty. Any model that is not vastly more capable than every human is jailbreakable, because an attacker gets unlimited attempts against a system with no memory of the previous ones.
Concentration is the risk. Ending up with three companies and two models is a live possibility, and it is one the lab campaigns against.
An open system treats a good actor more fairly. The hospital running its monitoring on an approved enterprise model is fine until the approval is withdrawn, the price changes, or the model is retired.
The field was built in public. The transformer was published by Google, and OpenAI’s GPT is a generative pre-trained transformer built on that open work.
Nous has contributed to that record. The YaRN method that extended context windows from around 16,000 tokens towards 128,000 came from Quesnelle and Peng, and the lab lists Meta, DeepSeek and Moonshot’s Kimi among those that have cited or used it.

The conclusion drawn is that the biggest advances arrived in the open, and closing the field now is a capital and regulatory question rather than a technical one.

How it got here

The Nous Research homepage, a pale blue page describing the lab as a leader in the American open source AI movement — The lab's stated mission: open source language models, and infrastructure for distributed training. Screenshot of nousresearch.com, 2 August 2026.

The origin story is unusually small.

2023, the accident. Malhotra was doing document-chat work with GPT-3 and volunteering on the Open Assistant project, which had eight A100 nodes. He read the Alpaca paper, changed the seed tasks, synthesised data using GPT-4 rather than GPT-3.5, and messaged Teknium, who was doing much the same thing. They trained a model together. It was fine. Running the same recipe on a Llama base model produced hundreds of thousands of downloads in days.
The accusation. Companies suggested they were training on the benchmarks. Teknium had been coding for under a year and Malhotra had studied religion; they had to ask what benchmarks were. Independent testing found the models to be the best open fine-tunes available at the time, in mid-2023.
From volunteers to a lab. Hermes 1 and Hermes 2 followed, the cohort grew to around forty researchers, Quesnelle and Peng produced YaRN, and the DisTrO optimiser followed for training large models across machines that are not physically co-located. An email from Dylan Rolnick, now chief executive, turned the group into a company. The models have since passed 50 million downloads.
The predecessor. Forge was an earlier project with the same ambition, an orchestrator that learns, remembers and builds its own tools, demonstrated at GitHub’s offices and then shelved because the models of the day could not carry it.
The restart. Watching the commercial coding harnesses work as reinforcement learning environments, collecting user traces to improve the labs’ own models, Teknium built an open harness so anyone could do that for themselves, on top of Atropos, the lab’s existing service for building such environments. It was released free, turned out to be far more capable than the narrow purpose it was built for, and the project reorganised around it.

Today the biggest contributor of Hermes Agent is Hermes Agent. It is the most active contributor of its own repo. And if that’s not self-improvement, then you tell me what is.

Karan Malhotra, on where the code now comes from

Timeline

25 February 2026. The framework launches at version 0.1.0.
7 May 2026. Version 0.13.0, nicknamed The Tenacity Release.
2 June 2026. The first official desktop application ships as a public preview at version 0.15.2, with native builds for macOS, Windows and Linux, taking it from a developer tool towards something a wider audience can install.
Mid-2026. Widely described as the fastest-growing open-source AI agent framework of the year.
20 July 2026. The Quicksilver release.
3 August 2026. Version 0.20.0, The Herald Release: real-time conversational voice with barge-in, on-device wake words, version 1.0 of the Agent2Agent protocol, signed outbound webhooks, a grounded-citations skill and a desktop plugin SDK. By this release the project counted roughly 3,650 commits from more than 650 contributors.

How it compares

	Hermes Agent	Claude Code	OpenAI Codex	OpenClaw
Licence	Open source	Proprietary	Proprietary	Open source
Models	Any provider, plus local	Anthropic	OpenAI	Any provider
Runs	Your machine	Your machine, hosted models	Your machine or cloud	Your machine
Learns between sessions	Skills and memory, curated	Memory and skills files	Session memory	Memory files
Built-in orchestration	Kanban, cron, webhooks, profiles	Subagents, hooks	Cloud tasks	Integrations
Leans on	Compounding personalisation	Model quality	Model quality	Breadth of integrations

Hermes Agent and OpenClaw are the two names most often mentioned in the same breath when people talk about open-source agents in 2026, and they share a philosophy: local-first, self-hosted, reachable through the messaging apps you already use. The difference is emphasis. OpenClaw leads on the sheer breadth of its integrations and the scale of its community, while Hermes Agent leans on persistent memory and the self-written skills that let it improve with use.

Hermes will import from either camp: hermes claw migrate brings an OpenClaw setup across, and hermes import-agent reads an existing Claude Code or Codex configuration.

What to watch

What compounding actually buys. An agent that writes its own skills builds a toolkit shaped by one person’s work, so its second month is genuinely different from its first, and two installations of the same software drift apart as they learn. That is rare in consumer software, where everybody runs the same build, and it opens questions the field has not settled: how a skill written by one agent gets reviewed or shared, and whether a personal toolkit travels between machines and models.

The harness claim needs independent testing. If a wrapper really does lift a given model’s performance above what the same model does inside its maker’s own tool, other people should be able to reproduce it, and Nous would benefit from publishing the comparison rather than referring to it.

The curator is the load-bearing part. A self-improving library is only as good as the process that throws things away, and its failures will be slow and hard to spot from the inside.

The desktop app moves those questions from developer workshops to ordinary desks, which is where they get answered. Hermes Agent sits at the centre of the agentic AI story, where the shift from models that answer to agents that act is being worked out in public, and the learning loop is one of the more testable ideas in it. If you are setting one up, start with our Hermes Agent prompting guide.

Sources

Karan Malhotra, co-founder of Nous Research, interviewed by Peter Yang: Hermes Co-Founder on Building an AI Agent That Improves Itself, YouTube. Every quotation on this page comes from there.
Hermes Agent documentation, Nous Research, including the CLI command reference, features overview, skills system, memory system and personality pages, checked 2 August 2026.
Nous Research, the lab’s own site, for the mission statement and product line. Screenshots on this page were taken on 2 August 2026 and are reproduced for review.