What Is Hermes Agent?
Who should self-host Hermes Agent? Run Hermes if you do the same multi-step job over and over, like a weekly report pulled from a CRM or a research-then-draft pipeline, and you want the assistant to keep what it learned and write its own procedure for next time. Run OpenClaw instead if what you actually want is a chat bridge to an LLM on the smallest possible box, with a large library of skills other people already wrote. Both are MIT and both self-host, so this is not a lock-in decision: Hermes ships a one-command importer that pulls an existing OpenClaw setup across.
TL;DR
- Hermes Agent is an open-source AI assistant from Nous Research (MIT, ~243.9k GitHub stars checked 2026-09-10, latest tag v2026.9.7)
- Agent-first architecture: it plans, executes, reflects, and retries, not just a gateway in front of an LLM
- Persistent memory: carries curated notes about you and your environment across sessions, and can full-text search its own past conversations
- Learning loop: when it works out a workflow worth repeating, Hermes writes a reusable skill document, so it is faster the second time
- It ships its own messaging gateway (27 chat, SMS and email connectors) and can call Apify Actors as tools over MCP
Hermes Agent is the agent-first counterpart to OpenClaw's gateway-first architecture. The difference shows up in practice: OpenClaw routes your messages to an LLM and runs skills in per-session containers. Hermes carries memory across sessions and, when it works something out, distils the procedure into a skill document it can reuse next time.
What changed on this page (2026-09-10): the memory section previously described a three-tier working/episodic/semantic store, and the learning loop ended with an automated self-test step. Neither is what Nous Research documents. Both are corrected below against the live docs, along with the connector count (27, not 28), the star count, and the hardware section, which now carries real hosting prices instead of unsourced RAM minimums.
Who built it and is it maintained?
Hermes Agent is built by Nous Research, an independent open-source AI lab best known for the Hermes model series. The project is MIT-licensed and actively maintained: every release carries both a semantic version and a dated git tag, and the latest is titled "Hermes Agent v0.21.1 (v2026.9.7)" — tagged v2026.9.7, published 2026-09-07 (checked 2026-09-10) — with commits landing multiple times a week. Nous Research is funded independently, with no single company controlling the project's direction.
GitHub: github.com/nousresearch/hermes-agent — 243.9k stars as of 2026-09-10.
How does Hermes Agent actually work?
Three layers, and the first two are what a gateway-first assistant does not have: a loop that plans and retries instead of answering once, and state on disk that outlives the session. The third layer turns the first two into skills.
1. Agent runtime (planning and execution)
Instead of routing a single message to an LLM and returning the response, Hermes follows an agentic loop. Read the diagram below top to bottom: it is one user turn, from arrival to answer. The branch in the middle is the retry, and Hermes can go round the execute-and-reflect step several times before it responds to you at all.
User task
↓
Plan (break task into steps)
↓
Execute (call tools, run code, search memory)
↓
Reflect (did the output meet the goal?)
↓ (if not)
Retry with updated plan
↓ (if yes)
Synthesise response
↓
Background review may write or update a skill document
(no numeric gate: the agent decides when a workflow is worth repeating)
This loop is what makes Hermes handle complex, multi-step workflows that a simple gateway cannot. Asking "prepare the weekly sales summary from the CRM, compare it to last week, and flag any accounts that dropped > 20%" is a 4-step workflow. Hermes plans it, executes each step with tool calls, and reflects on whether the output looks right before responding.
2. Persistent memory system
Everything Hermes remembers lives under ~/.hermes/ on local disk. There is no PostgreSQL and no vector database to operate:
| What it holds | Where it lives | Format |
|---|---|---|
| Agent memory: environment facts, conventions, lessons it learned | ~/.hermes/memories/MEMORY.md | Markdown you can open and edit |
| User profile: your preferences, communication style, identity | ~/.hermes/memories/USER.md | Markdown you can open and edit |
| Session history, searchable | ~/.hermes/state.db | SQLite with FTS5 full-text search |
| Skills: procedures it wrote or you imported | ~/.hermes/skills/ | SKILL.md documents |
The design choice worth knowing about before you commit: the two memory files are deliberately bounded and curated rather than an ever-growing embedding index, so what Hermes "knows" about you is a page you can read and correct by hand. Past conversations are handled separately, by full-text search over the session database. That is why a new Hermes session starts already knowing that you want concise summaries and that the CRM uses OAuth2, while a fresh OpenClaw session starts with none of it.
If bounded Markdown is not enough, Nous ships eight external memory-provider plugins (Honcho, OpenViking, Mem0, Hindsight, Holographic, RetainDB, ByteRover, Supermemory) that run alongside built-in memory rather than replacing it (hermes-agent.nousresearch.com/docs/user-guide/features/memory, checked 2026-09-10).
3. Learning loop (skill distillation)
After a turn, a background review forks and may write a skill. Nous Research documents no confidence score and no numeric threshold: its system prompt asks the agent to record a non-trivial workflow with skill_manage when it worked out a multi-step workflow worth repeating, when it hit errors and found the path that worked, or when you corrected its approach (hermes-agent.nousresearch.com/docs/user-guide/features/skills, checked 2026-09-10). When it fires, the loop:
- Distil: extract the steps, tool calls, and decision points that worked
- Generalise: rewrite the procedure as a reusable skill document (Markdown with structured frontmatter)
- Write: save it through
skill_manage, which cancreate,patch,edit,delete, and attach or remove supporting files, so a later run refines an existing skill instead of piling up near-duplicates
There is no automated correctness check on the result. skill_manage runs an advisory linter that warns about things like incident-log-shaped content or reference-file sprawl, but the warnings never block a write. The one hard control is skills.write_approval: switch it on and every skill write, foreground or background, is staged in ~/.hermes/pending/skills/ for you to review first.
The resulting skill document looks like an OpenClaw ClawHub skill (SKILL.md format is compatible) but is auto-generated from Hermes's own experience rather than written by hand. See Hermes' learning loop and skills for how to guide what it learns.
Hermes Agent or OpenClaw: which should you self-host?
Choose OpenClaw for the simpler, lower-resource deployment and a large library of hand-written skills. Choose Hermes when you run the same complex workflows repeatedly and want the assistant to write and reuse its own procedures. Messaging is no longer the tiebreaker, because both ship a full gateway.
| OpenClaw | Hermes Agent | |
|---|---|---|
| Architecture | Gateway-first | Agent-first |
| Persistent memory | Session only | Cross-session, local Markdown files plus a searchable SQLite session history |
| Learning loop | No | Yes, auto-generates skill docs |
| Messaging platform integration | Yes, just over 30 channels documented at docs.openclaw.ai/channels, plus channel plugins | Yes, a full gateway in one process (Telegram, Discord, Slack, WhatsApp, Signal, Matrix, Teams, SMS, email, and more) |
| Skill system | ClawHub, a large third-party marketplace (count moves too fast to pin down) | Auto-generated, plus imports |
| Migration between them | — | hermes claw migrate imports an existing OpenClaw setup: persona and memory files, skills, model and provider config, MCP servers, and messaging tokens |
| Setup complexity | Low | Medium |
| GPU requirement | No (remote LLM API) | No (remote LLM API); yes for local inference |
| License | MIT | MIT |
The migration row is the part that changes the decision. Trying Hermes does not mean rebuilding your OpenClaw configuration by hand, and the migrator copies rather than moves, so ~/.openclaw is left untouched and rolling back is just running OpenClaw again. Preview it first with hermes claw migrate --dry-run, and use --preset user-data if you'd rather move memories and skills without copying API keys.
We couldn't find a published idle-RAM figure for either tool from either vendor, so we're not repeating the old page's ~180 MB / ~2 GB comparison here. It wasn't sourced and we can't stand behind it.
See the full comparison for a broader field including Open WebUI, Dify, AutoGen, and CrewAI.
Does Hermes Agent work with Apify Actors?
Yes. Hermes speaks MCP over stdio and streamable HTTP, and Apify runs a hosted MCP server at mcp.apify.com that exposes Actor discovery and execution as tools. Point Hermes at that endpoint (OAuth or an Apify API token, with tokens persisted and refreshed across sessions) and it can search the Apify Store, run an Actor, and read back the dataset the same way it uses any other MCP tool server. This is the cleanest way to give a self-hosted Hermes instance access to Apify's 70,000+ Actors without writing custom tool code.
Connecting the server costs nothing; you pay for what the Actors consume. Apify's Free plan includes $5/month subject to change · verified 2026-09-10 of platform usage, which is enough to see whether the integration earns its place, and Starter is $19/month subject to change · verified 2026-09-10 with $19 of usage included. Both tiers bill compute at the same rate, so upgrading buys headroom rather than a discount.
What does it cost to run, and on what hardware?
Nous Research publishes no RAM or CPU minimums. The installation docs list only Git (plus curl and xz-utils on Linux) as prerequisites and pull Python 3.11 in automatically via uv, on Linux, macOS, WSL2, native Windows, Termux and NixOS (checked 2026-09-10). We're not going to invent numbers to fill that gap. What decides your bill is one question: does the model run somewhere else, or on your box?
Remote LLM API. Hermes itself is a Python process talking to Anthropic, OpenAI, or any OpenAI-compatible endpoint, so a small VPS carries it and your model provider bills separately per token. Liquid Web's 4 GB Managed VPS is $36/mo subject to change · verified 2026-09-10 for the first two months on the listed "save 50% for 2 mos" promotion, then $72/mo; the 8 GB plan is $50/mo subject to change · verified 2026-09-10 then $100/mo. Budget from the post-promotional price, not the sticker.
Local inference. Here the RAM and VRAM you need is set by the model you picked, not by Hermes, and the GPU is the whole line item. Liquid Web lists the L4 (24 GB VRAM) at $0.80/hr subject to change · verified 2026-09-10 and the L40S (48 GB VRAM) at $1.44/hr subject to change · verified 2026-09-10, both after a listed 25% discount off $1.07 and $1.92. Run either continuously and you are at roughly $584 and $1,051 a month.
That gap is the actual decision. A dedicated GPU only beats a remote API on cost at high, steady volume; below that, self-hosting Hermes on a VPS and paying per token is cheaper. Data residency or privacy requirements can still justify the GPU on their own.
What can Hermes Agent not do?
Three limits are worth knowing before you commit, and the first one is the one people get burned by.
- It does not verify the skills it writes. The
skill_managelinter is advisory and never blocks a write, and nothing tests a new skill against the task it came from. Skill quality tracks the judgement of whichever model you configured. If that matters, turn onskills.write_approvaland read them before they land. - It publishes no capacity guidance. No RAM figures, no throughput numbers, no sizing table from the vendor. You will be measuring your own deployment to size it.
- It is not HIPAA compliance in a box. A regulated deployment needs infrastructure controls that no self-hosted agent gives you by installing it: see the HIPAA-compliant OpenClaw + Liquid Web setup for what that actually involves. The same controls apply here.
What it does do, per the features documentation (checked 2026-09-10): multi-step workflows with planning and retry, persistent memory and context files, a skills system, scheduled tasks via cron, subagent delegation, code execution, browser automation, vision, voice mode, MCP tool servers, and provider routing with fallbacks.
Hermes has no single 'production-ready' milestone: it ships multiple releases a week, each given a dated git tag on top of a continuing semantic version — the latest is v0.21.1, tagged v2026.9.7 (checked 2026-09-10). There's no 'stable' tag on Docker Hub — pin your Compose file to a specific dated tag like v2026.9.7 rather than 'latest' or 'main', or a routine update can change behaviour under you. The learning loop is the newest piece, so watch skill quality for the first few weeks of real use.
No, and not primarily because of messaging support — both tools ship a messaging gateway now. Hermes is better for repeated complex workflows where memory and learning matter; OpenClaw is better for a simpler, lower-resource deployment and its larger hand-written skill library. Many teams will run both.
There is no numeric threshold. Nous Research documents skill creation as prompt-driven: the agent is asked to record a non-trivial workflow with skill_manage when it has worked out a multi-step workflow worth repeating, when it hit errors and dead ends and found the working path, or when you corrected its approach. The judgement is the model's. The one real control is skills.write_approval, which stages suggested skills for your approval instead of saving them, and you can always write one yourself with the /learn command.
Yes, with one command: hermes claw migrate. It imports persona and memory files, skills, model and provider configuration, MCP servers, messaging platform tokens and approval modes. Imported skills land in ~/.hermes/skills/openclaw-imports/, and imported skills and memories take effect in new sessions rather than the one you are in; run hermes status afterwards to check provider authentication. The migrator copies rather than moves, so ~/.openclaw survives untouched and rolling back means running OpenClaw again. Preview with --dry-run, use --preset user-data to bring memories and skills across without copying API keys, --overwrite to replace conflicts, or --source to point at a non-default path. It looks for ~/.openclaw, then ~/.clawdbot, then ~/.moltbot. Once you have confirmed everything works, hermes claw cleanup renames the leftover OpenClaw directories to .pre-migration/ so the two states cannot be confused. Caveat: SKILL.md instructions port cleanly, but skills that call OpenClaw-specific tool implementations won't find those tools on the other side.
Dozens of named providers (Anthropic, OpenAI, Google, AWS Bedrock, DeepSeek, xAI, and more), each configured with its own API key in ~/.hermes/.env, plus any OpenAI-compatible custom endpoint for local inference: Ollama, vLLM, llama.cpp, or LiteLLM as a proxy in front of 100+ providers. Configuration goes through the 'hermes setup' wizard or ~/.hermes/config.yaml, not a single generic endpoint variable.
Common mistakes and fixes
Hermes Agent starts but reports 'memory backend unavailable'.
Hermes keeps every piece of state under ~/.hermes/ on local disk, so this is almost always a volume-mount problem in Docker. Memory is two Markdown files, ~/.hermes/memories/MEMORY.md and ~/.hermes/memories/USER.md; session history is ~/.hermes/state.db, a SQLite database with FTS5 full-text search. There is no external database to point at. Confirm the container's ~/.hermes/ path is mapped to a persistent named volume in your Compose file, and that the container user has write access to it: docker compose exec hermes ls -la ~/.hermes/. If the directory is empty on every restart, the volume isn't mounted.
Hermes learning loop produces empty skill documents.
There is no numeric gate to miss, so there is no 'threshold not met' line to grep for. Nous Research documents skill creation as prompt-driven: the agent records a workflow with skill_manage when it judges one worth repeating. If nothing is being written, check whether skills.write_approval is true, in which case suggested skills are staged in ~/.hermes/pending/skills/ for your approval rather than saved, and check docker compose logs hermes --tail 50 for skill_manage calls. Working through a genuinely multi-step task, or using /learn explicitly, is what produces skills.
Hermes connection to local Ollama fails with 'connection refused'.
Hermes talks to Ollama as a custom OpenAI-compatible endpoint, configured in ~/.hermes/config.yaml (provider: custom, base_url), not an env var. If Ollama runs in the same Compose file, add it to the same Docker network and set base_url to http://ollama:11434/v1 (note the /v1 suffix). If Ollama runs on the host, use the host's Docker bridge IP (typically 172.17.0.1) in place of localhost.