What Is Hermes Agent? Memory, Skills, and What It Costs to Run

What Is Hermes Agent?

Hermes Agent is an autonomous AI agent built by Nous Research and released as open source under the MIT licence. Nous describes it as “the self-improving AI agent” and “the only agent with a built-in learning loop — it creates skills from experience, improves them during use, nudges itself to persist knowledge, and builds a deepening model of who you are across sessions” (Hermes Agent docs, accessed September 2026).

The framing matters. Hermes is not a coding copilot bolted into an IDE, and it is not a chat wrapper around one API key. It is a process you start and leave running. Nous’s own documentation puts it plainly: it “lives wherever you put it — a $5 VPS, a GPU cluster, or serverless infrastructure (Daytona, Modal) that costs nearly nothing when idle. Talk to it from Telegram while it works on a cloud VM you never SSH into yourself.”

The clearest way to understand what you are getting is to compare it to the thing most teams already have.

That last row is not a typo. It is the whole trade.

Who makes it, and how big it got

Nous Research is an AI research lab best known for the Hermes family of open-weight models and for distributed-training work such as Psyche. Hermes Agent is their agent project, and the adoption curve has been unusually steep for an open-source release.

It also holds the #1 slot in OpenRouter’s Productivity, Coding Agents, Personal Agents and CLI Agents categories as of the same date. TechCrunch reported in July 2026 that Nous Research was in talks for funding at a $1.5B valuation — in talks, not closed.

Read honestly, those numbers say Hermes is one of the most-used open source AI agent projects in the world, not a curiosity.

[SCREENSHOT: Hermes Agent — the desktop app home screen showing an active conversation, from hermes-agent.nousresearch.com]

How the Self-Improvement Loop Actually Works

“Self-improving” is a phrase that usually means nothing. In Hermes it maps to two concrete subsystems that write files to disk, and it is worth being precise about both, because their limits are where the interesting engineering decisions live.

Memory: two files, a hard budget, and a frozen snapshot

Hermes keeps two stores in the profile directory: MEMORY.md for environment facts, conventions and lessons learned, and USER.md for who you are and how you like to be spoken to. The agent writes to them itself using a memory tool with add, replace and remove actions — there is no read action, because memory is injected into the system prompt at session start.

Three details in the memory documentation matter more than the marketing:

• There is a character budget. The docs show a memory header rendering usage as a percentage against a 2,200-character ceiling. This is a curated notebook, not a vector database.
• The snapshot is frozen at session start. Memory written during a session persists to disk immediately but does not appear in the system prompt until the next session. This is deliberate — it preserves the provider’s prefix cache — but it means “I told it to remember and it forgot” is an expected failure mode, not a bug.
• Memory needs session boundaries to pay off. On messaging platforms a chat is one continuous session that survives restarts. Nous’s own docs warn that a chat left running for weeks “grows expensive (compaction runs repeatedly over an ever-longer history) and the learning loop of forget -> recall from memory -> search past sessions almost never gets to fire.”

Older context is recovered through session_search, an FTS5 full-text search across past sessions with LLM summarisation on top.

Skills: procedural memory the agent writes for itself

Skills are where the “grows with you” claim earns its keep. Per the skills documentation, a skill is a SKILL.md file with frontmatter and a fixed section order — When to Use, Procedure, Pitfalls, Verification — that the agent can author itself after it works something out.

Loading is deliberately tiered, which is the part worth stealing even if you never run Hermes:

Level 0: skills_list()          -> name, description, category   (~3k tokens)
Level 1: skill_view(name)       -> full skill content
Level 2: skill_view(name, path) -> a specific reference file

Only Level 0 is always in context. The agent pays for the rest on demand. There is also a /learn command that turns a directory, a URL, a PDF or “the workflow you just walked the agent through in this conversation” into a skill, and for large sources it builds a knowledge-base skill with an index plus per-topic files under references/ rather than one bloated file. Skills follow the open agentskills.io standard, so they are portable between agents.

[SCREENSHOT: Hermes Agent — the Skills page in the dashboard, showing installed skills and the “Learn a skill” panel]

What Is Built In

The value of any agent harness is measured in what you no longer have to write. As of September 2026 the Hermes docs list:

• 60+ built-in tools — web search and extraction, browser automation, vision, image generation, text-to-speech, persistent shell, file operations.
• Seven terminal backends — local, Docker, SSH, Daytona, Singularity, Modal and Vercel Sandbox. Daytona and Modal offer serverless persistence, so the environment hibernates when idle.
• 20+ chat surfaces from one gateway — CLI, Telegram, Discord, Slack, WhatsApp, Signal, Matrix, Mattermost, Email, SMS, Microsoft Teams, Google Chat, Home Assistant and more. One agent, one memory, every surface.
• Scheduled automations — built-in cron with delivery to any connected platform.
• Subagents and Bot Mode — isolated subagents for parallel workstreams, and named Bots with their own model, memory, skills and chats.
• MCP support — connect any MCP server, with tool filtering.
• Approvals and isolation — per the security docs, a dangerous-command approval system with smart, manual and off modes, container isolation for Docker/Singularity/Modal, MCP credential filtering, context-file prompt-injection scanning and cross-session isolation.

That last bullet is genuinely more than most open-source agents ship with, and it deserves credit.

Hermes Agent Setup: How You Actually Run It

Three paths, all documented on the Nous Research site:

1. Desktop app — installers for macOS 12+ and Windows 10/11.
2. Terminal — curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash on Linux, macOS, WSL2 or Android via Termux; a PowerShell one-liner on native Windows.
3. Cloud — a hosted always-on agent through Nous Portal.

After install, hermes setup --portal runs a single OAuth that covers a model plus the hosted tool gateway (web search, image generation, TTS, browser).

Models are your choice: Nous Portal, OpenRouter, OpenAI, or any compatible endpoint. Portal tiers as published in September 2026 are Free ($0, free models only), Plus ($20/mo, $22 credits), Super ($100/mo, $110 credits) and Ultra ($200/mo, $220 credits), each with access to 200+ models. The agent itself costs nothing.

[SCREENSHOT: Hermes Agent — the terminal install and first-run setup flow on Linux]

Where Teams Hit Trouble

Four failure modes come up repeatedly once a Hermes agent stops being a weekend project.

Always-on is a billing model, not just an architecture. A stateless agent costs money when you call it. An always-on agent with cron jobs, subagents and a messaging gateway costs money whenever it decides to do something. Nous’s own docs flag the compaction cost of long-lived gateway sessions. Without per-agent spend visibility, your first signal is the invoice.

The memory system has sharp edges. A 2,200-character budget and a snapshot frozen at session start are reasonable engineering choices, but they produce behaviour that looks like the agent lying to you. Small local models in particular will say “I’ve saved that” without ever calling the memory tool — the docs call this out directly.

Approvals are per-machine, not per-organisation. approvals.mode lives in one YAML file on one host, and a /yolo toggle or HERMES_YOLO_MODE bypasses every prompt for a session. For one developer that is sensible. For twelve, your safety posture is whatever each of them last typed, and nobody can audit it centrally.

One agent is easy; twenty is a platform problem. Every Hermes instance holds its own credentials, model keys, MCP connections and memory on its own disk. There is no shared identity model, no central budget, no cross-agent trace view. That is not a criticism — Hermes is a single-agent tool and a very good one. It is a description of what sits outside its scope.

Running agents past the first one?

See what a control plane looks like around an open-source harness

Start free

Who Should Not Use Hermes Agent

Being fair to a good project includes being clear about its edges:

• Regulated teams needing centralised audit. If you must show an auditor who approved which tool call across every agent, per-host YAML will not get you there.
• Anyone who cannot operate a long-lived process with shell access. Hermes runs commands. The approval system is good; it is not a substitute for someone owning the host.
• Teams standardising many agents across many people. The strength of Hermes is that it is yours. That is also why it does not solve fleet problems.
• Anyone expecting a managed SLA. It is MIT-licensed software you operate. Cloud hosting through Nous Portal is optional and separate.

If you are one developer who wants a capable open source AI agent that gets better at your specific work, Hermes is a strong default. If you are a platform team, keep reading.

TrueFoundry’s Position: TrueForge and the AI Gateway

There are two distinct layers here, and conflating them is why agent projects stall at pilot.

An agent harness controls how an agent works: the loop, tools, state, sandbox. An AI gateway controls how that agent reaches models and tools: access, budgets, routing, policy, traces. Hermes is an excellent harness. It is not a gateway, and it does not claim to be.

TrueForge is TrueFoundry’s open-source, MIT-licensed, model-neutral agent harness (github.com/truefoundry/trueforge). Like Hermes it handles the agent loop, tool execution, context management and sandboxing. Unlike a single self-hosted agent, it ships the surrounding control plane: centralised MCP access and credentials, human-in-the-loop approvals, sandboxed execution, observability and governance across teams and environments. Run it locally with npx @truefoundry/trueforge, or deploy it for a team with Docker Compose or Helm.

In TrueFoundry’s benchmark against Claude Managed Agents, TrueForge reached roughly the same task accuracy on far fewer tokens.

Want the harness and the control plane together?

TrueForge is open source and MIT licensed

Try it free on TrueFoundry

Governing Model and Tool Access for Any Harness

This is the part that applies whether you run Hermes, TrueForge, or both. The harness decision does not have to be the governance decision.

Because Hermes talks to “any compatible endpoint,” you can point it at a gateway instead of directly at providers. TrueFoundry’s AI Gateway then sits in front of every model and MCP call the agent makes: centralised model access, per-team budgets, rate limits, guardrails, credential management and unified traces. It supports 1,000+ LLMs through one OpenAI-compatible API, adds roughly 3-4 ms of overhead and handles 350+ RPS on a single vCPU, so it can sit in the hot path of a long-running agent without becoming the bottleneck. It runs in your own VPC, on-prem or air-gapped.

It is also the answer to the always-on cost problem. In TrueFoundry’s Auto Routing benchmark across 550 prompts, classifying requests by complexity and routing across model tiers cut cost 69% while retaining 98% of baseline quality, with mean latency dropping from 7.6s to 4.0s. On production-shaped traffic the reduction reached 80%. An agent that runs unattended all day does not need a frontier model for every turn.

Keeping these separate is what lets you change models, or change harnesses, without redesigning either.

Related reading

• Claude Managed Agents vs Hermes Agent — the head-to-head, if you are choosing between managed and self-hosted
• What Is an Agent Harness? — the layer both Hermes and TrueForge occupy
• Best Open Source Agent Harness — the wider field in 2026
• What Is an AI Control Plane? — the governance layer a single agent does not cover
• AI Agent Observability Tools — what to track once an agent runs unattended

Conclusion

Hermes Agent is the most convincing argument yet that a personal, self-hosted, self-improving agent is a real category rather than a demo. The memory and skills design is thoughtful, the documentation is honest about its own failure modes, and the adoption numbers are not marketing — 51.7 trillion tokens and the #1 daily rank on OpenRouter as of September 2026 are what genuine usage looks like.

What it does not do is govern a fleet. Every instance is its own island: its own credentials, its own approval settings, its own spend, its own memory on its own disk. That is exactly right for one person and one machine, and exactly wrong for twenty engineers and an auditor.

So the question is not “Hermes or something else.” It is what you want to own. Own the agent, and Hermes is a fine choice. Own the fleet, and you need a harness with a control plane around it and a gateway in front of the models — which is the problem TrueForge and TrueFoundry’s AI Gateway were built for.

Start free with TrueFoundry