Hermes vs OpenClaw: Which Self-Hosted Personal Agent to Run (October 2026)

Hermes vs OpenClaw is the comparison to make if you want an AI agent you can text from Telegram, running on a box you control. Both are MIT-licensed, both work with any model, and both are huge: on October 2, 2026, OpenClaw had 391,188 GitHub stars and Hermes Agent 250,673.

The comparisons that rank for this query were mostly written in spring, and several of their headline claims no longer hold. So I rebuilt this one from each project's own repo and docs at their latest releases (OpenClaw 2026.9.7, Hermes Agent v0.21.5), pulled the health and security numbers straight from GitHub and NVD, and installed both into a scratch directory to measure them.

The short answer: Pick OpenClaw if you want the widest set of chat apps and device apps, conservative release channels and operator roles for a small team. Pick Hermes Agent if you want small, readable memory, skills it writes and prunes itself, Modal or Daytona execution, no telemetry, and a paid managed option from the same vendor. Both can now run several agents behind one gateway. Whichever you pick, it runs the agent's shell commands on your host by default, so switch on the container backend before you connect a chat app.

Hermes vs OpenClaw at a glance (checked October 2, 2026)

Every cell comes from the project's own repo, docs or API at the release in the first row, except the advisory row (GitHub and NVD).

Which one should you run?

In Hermes Agent vs OpenClaw, choose by the feature you can't live without, not by star count. Each project shipped 18 stable releases between July 1 and October 2, so a gap that matters today may close in a month, but the points below are structural.

Pick OpenClaw if

• Your chat app is only on its list. Nextcloud Talk, Nostr, Synology Chat, Tlon (Urbit), Twitch and three Zalo connection paths are in the OpenClaw channel catalog and absent from Hermes's platform table.
• You want your phone to be a device, not just a chat window. The OpenClaw README lists companion apps and nodes for voice, Canvas, camera and screen actions. Hermes runs on Android only through Termux, which its platform support page rates Tier 2.
• You already pay for Claude. OpenClaw can run agent turns through the Claude Code CLI you're signed into. Per OpenClaw's Anthropic provider page, Anthropic counts that use against your subscription's limits. Hermes can't use a Claude Pro login at all (details in the cost section).
• You update cautiously. OpenClaw has four update channels: stable, beta, dev, and extended-stable, a trailing supported month that never applies itself.
• A small trusted team shares it. Named operator roles cap what each teammate's connection can do. OpenClaw's trust model is explicit that this is a guardrail, not tenant isolation.

Pick Hermes Agent if

• You want memory you can audit in a minute. About 3,575 characters sit in the prompt; everything else is searchable history. Both memory and skill writes can be put behind an approval gate (config below).
• You want commands to run on Modal or Daytona. Hermes has seven terminal backends, and the Modal and Daytona environments hibernate between tasks. OpenClaw's sandbox backends are Docker, Podman, SSH, OpenShell and Crabbox.
• You want email, Home Assistant, DingTalk, SimpleX or ntfy as a chat surface. They're in Hermes's messaging table. By OpenClaw's own account, it handles inbound email as an automation trigger rather than a conversation.
• You want nothing phoning home. The Hermes FAQ says it collects no telemetry. OpenClaw's telemetry page documents a daily version check by default; update.checkOnStart: false turns it off.
• You want a managed fallback from the same vendor. Nous sells Hermes Cloud (prices below). The OpenClaw Foundation runs no hosted service.
• Your tooling is Python. Hermes's core, plugins and research tools (trajectory export, a batch runner) are Python.

Several agents behind one front door no longer separates them. OpenClaw's multi-agent routing runs isolated agents in one gateway and uses bindings to send a given WhatsApp number or Slack workspace to a given agent. Hermes's multi-profile gateway docs for v0.21.5 make one multiplexing gateway serve every profile by default (gateway.multiplex_profiles), call per-profile gateways "a temporary shim, not a supported topology", and route chats on one shared bot to different profiles with gateway.profile_routes.

Run neither as-is if

Strangers or semi-trusted people will message the bot. Both projects support exactly one trust boundary per running instance: OpenClaw wants separate gateways, ideally on separate OS users or hosts, for users who don't trust each other, and Hermes's security policy calls it a single-tenant personal agent. One instance per person is the supported shape for both.

If neither fits, our OpenClaw alternatives roundup covers the other options.

Six claims in other comparisons that are now wrong

Each row was checked against the primary source on October 2, 2026.

Two more drift quickly enough to re-check yourself: Hermes's approval default is now smart, not manual, and Hermes is past 250,000 stars, not 22,000.

How do memory and self-learning differ?

Hermes keeps a deliberately small memory inside every prompt and searches everything else on demand. OpenClaw keeps larger Markdown files on disk and consolidates them in the background. Both now write their own skills by default, which is the part you should decide to gate.

Hermes. Its memory docs cap MEMORY.md at 2,200 characters (about 800 tokens) and USER.md at 1,375 (about 500). When a write would overflow, the tool returns an error and the agent must merge or delete entries first. Every CLI and chat session also goes into a SQLite database with full-text search, and the docs put a query at about 20 ms. After a turn, a background review may save a memory or patch a skill; you can point that review at a cheaper model under auxiliary.background_review, which the docs say costs 3–5× less. The curator runs at most every 7 days, marks agent-written skills stale after 14 unused days and archives them after 30. Its LLM merge pass is off by default. If you want semantic recall on top, seven external memory plugins (Honcho, Mem0 and others) run alongside the built-in files.

OpenClaw. The OpenClaw memory overview uses MEMORY.md, an optional USER.md and dated daily notes. Today's and yesterday's notes load on /new, older ones are searchable, and a background "dreaming" sweep distills notes into MEMORY.md. There's no hard cap: when MEMORY.md outgrows the prompt budget, the copy injected into context is truncated while the file stays whole, so check /context list or openclaw doctor now and then. Self-learning reviews a turn only after at least 10 model iterations and 30 quiet seconds. In auto mode those edits skip proposals and rollback snapshots, so your backups are the undo button.

If you'd rather approve what the agent learns, here are the switches:

# Hermes: ~/.hermes/config.yaml
memory:
  write_approval: true # stage memory writes; review with /memory pending
skills:
  write_approval: true # stage skill writes; review with /skills pending and /skills diff <id>

# OpenClaw: drafts wait for you instead of applying
openclaw config set skills.workshop.autonomous.mode propose

Two failure modes the docs describe:

• "It said it would remember, then forgot." In Hermes, memory only persists when the model actually calls the memory tool. The docs single out small local models, roughly under 30B parameters, for confirming a save they never made. Check ~/.hermes/memories/MEMORY.md; if the entry isn't there, use a stronger model for setup.
• A chat that never ends. Hermes treats a Telegram or Discord chat as one continuous session that survives restarts. Without a /new at natural breaks, compaction keeps re-running over a growing history and the memory loop rarely fires.

Is Hermes or OpenClaw safer?

Neither is safe by default on a machine that holds your secrets. Out of the box both run the agent's shell commands on the host, and both projects say plainly that real containment comes from the operating system, not from approval prompts.

The defaults, from each project's own docs:

• OpenClaw. Sandboxing defaults to off. For the trusted single operator, host commands run "without approval prompts" (security="full", ask="off"), per the trust model. By default, any tool-enabled agent running unsandboxed can list and read every other agent's sessions on the same gateway. DM pairing for unknown senders is on.
• Hermes. The default terminal backend runs commands directly on the host. The default approval mode, smart, lets a helper model auto-approve commands it judges low-risk; a hardline blocklist (root wipes, fork bombs, raw disk writes) can't be overridden even in --yolo. With no allowlist configured, the gateway denies every user. Hermes's security policy states: "The only security boundary against an adversarial LLM is the operating system." It also says running the default local backend with untrusted input, such as inbound chat, email or web content, is outside its supported posture.

The record, checked October 2, 2026:

• OpenClaw has published 722 GitHub security advisories since January 2026: 14 critical, 249 high, 390 medium, 69 low. Seventy-five came out in September 2026 alone. Its skill registry has a history too: Koi Security's ClawHavoc report found 341 malicious skills in February, and after ClawHub added VirusTotal and ClawScan checks, Unit 42 (June 23, 2026) still found five unblocked ones, including one padded to slip past scanner size limits. OpenClaw deleted them.
• Hermes has zero GitHub advisories. NVD lists 39 CVEs for hermes-agent, all filed by VulDB as the numbering authority, with CVSS 3.1 scores up to 7.3. In 28 of them, the record says the vendor didn't respond to the disclosure. CVE-2026-14625, a protection-mechanism failure in the TUI gateway's shell.exec up to 0.15.2, is a representative entry.

Don't read 722 versus 39 as a safety score. OpenClaw's maintainers publish their own advisories, so the count also measures a working disclosure pipeline; Hermes's public record comes from a third party, often without vendor confirmation. What the numbers do tell you: OpenClaw reports what it fixed, while with Hermes you'll track issues and CVE records yourself.

What to change on day one. Run the agent on a box or VM that doesn't hold your personal keys, then add tool sandboxing:

# Hermes: ~/.hermes/config.yaml
terminal:
  backend: docker # shell and file tools run in a hardened container
  container_persistent: false # optional: a fresh container per chat

// OpenClaw: ~/.openclaw/openclaw.json
{
	agents: {
		defaults: {
			sandbox: { mode: 'all', scope: 'session', workspaceAccess: 'rw' }
		}
	}
}

Then the three things that bite after you flip those switches:

• OpenClaw sandbox runs fail immediately. It won't fall back to a stock image; you have to build openclaw-sandbox:bookworm-slim first. npm installs use the inline docker build in the images and setup page.
• OpenClaw's sandboxed tools can't reach the internet. The Docker backend defaults to network: "none". Give network access only to agents that need it, via agents.defaults.sandbox.docker.network.
• Hermes's container doesn't cover everything. Its policy says the terminal backend confines shell and file tools, not MCP servers, plugins or skill loading, which still run in the agent's own process. If the agent reads email, the open web or group chats, run the whole thing in the official Docker image instead.

For the wider pre-launch list, see our AI agent security checklist.

What does each cost to run?

The software is free; you pay for a machine with 1–2 GB of RAM and for model tokens. OpenClaw's deploy guides run from no-cost options (Oracle Cloud's Always Free ARM tier, the free tiers on Render and Fly) and a one-time $35–80 Raspberry Pi to a $6-a-month DigitalOcean droplet, the cheapest paid VPS they quote. Inference runs from nothing on a local model to whatever your provider charges.

Disk and install. I installed both into a scratch directory on an Apple Silicon Mac on October 2, 2026. npm install [email protected] --ignore-scripts added 343 packages and 728 MB of node_modules (404 MB of it the openclaw package), before the Node runtime itself. Hermes v0.21.5, synced from its lockfile with the all extra, came to 103 Python packages: a 230 MB virtualenv, 210 MB of source and a 50 MB Python, before the Node.js, ripgrep and FFmpeg its installer adds. On Docker Hub, the compressed amd64 images are 970 MB for Hermes latest and 1.23 GB for OpenClaw latest, whose slim tag is the same size; OpenClaw's extended-stable 2026.8.34 image is 535 MB. Disk won't decide this.

RAM and the box. Both document the same 1 GB, 1-core floor (OpenClaw in its Raspberry Pi guide, Hermes in its Docker guide), and both recommend 2 GB or more; Hermes ties that to running browser tools. OpenClaw's DigitalOcean guide prices the 1 GB droplet at about $6 a month and warns against Marketplace 1-click images you haven't reviewed.

Install and connect Telegram (both installers also have a PowerShell variant for Windows):

# OpenClaw: installs Node if missing, then starts onboarding
curl -fsSL https://openclaw.ai/install.sh | bash
openclaw channels add --channel telegram --token <bot-token>
openclaw pairing approve telegram <code>   # the code your bot sends you on first DM

# Hermes Agent: needs git; brings its own Python, Node.js, ripgrep, FFmpeg
curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash
hermes gateway setup                       # pick Telegram, paste the bot token
hermes gateway install && hermes gateway start   # run it as a user service
hermes pairing approve telegram <code>

Models. Both take any OpenAI-compatible endpoint plus dozens of named providers. What differs is which consumer subscriptions they can use:

The Hermes column comes from its provider docs. Nous Portal has a free tier limited to free models; Plus is $20 a month with $22 of credits, Super $100 and Ultra $200.

Local models. Hermes refuses any model with less than 64,000 tokens of context, and Ollama defaults to 4,096 on GPUs with under 24 GB of VRAM, so a fresh Ollama setup fails at startup. The fix from the Hermes docs:

OLLAMA_CONTEXT_LENGTH=64000 ollama serve

OpenClaw's managed llama.cpp recipes also use a 64K context and start at 8 GiB of host memory, per its local models page. Its DigitalOcean guide adds that local inference won't fit on a 1 GB droplet, so plan on a hosted model there.

OpenClaw vs Hermes: which project is healthier?

Both are among the most active repositories on GitHub. The difference is how much of the incoming work gets merged.

OpenClaw merged about four PRs for every five opened in that window. Hermes merged about one in five, and carries a backlog of nearly 34,000 open pull requests. If you plan to contribute a fix, expect it to wait longer on Hermes.

The last row is a trap worth fixing on day one. On a Hermes source install, hermes update pulls the latest commits from git, which means main, not the latest release. When I ran hermes --version on v0.21.5, it reported the install as 5,710 commits behind. Hermes's docs on main describe a hermes update --set-channel stable option, but the v0.21.5 updater doesn't have it yet. On a server, run the Hermes Agent Docker image pinned to a release tag instead, using the commands from the Hermes Docker guide:

# one-time setup wizard, writes keys to ~/.hermes/.env
docker run -it --rm -v ~/.hermes:/opt/data nousresearch/hermes-agent:v2026.9.24 setup

# the gateway, restarted with the host
docker run -d --name hermes --restart unless-stopped \
  -v ~/.hermes:/opt/data \
  nousresearch/hermes-agent:v2026.9.24 gateway run

Leave off the -p 8642:8642 port mapping you'll see in the Hermes Docker guide unless you need its API server; the guide says it's optional when you only use chat apps. On OpenClaw, npm's latest already means the stable channel, and openclaw update --channel extended-stable holds you a month back.

How do you switch, or try both?

Both ship importers, so a wrong first pick costs an afternoon, not your memory. Preview before applying (the OpenClaw import expects a fresh OpenClaw setup):

# OpenClaw → Hermes: imports SOUL.md, memories, skills, allowlists; secrets only with --migrate-secrets
hermes claw migrate --dry-run

# Hermes → OpenClaw: model config, MCP servers, SOUL.md, AGENTS.md, memories, skills
openclaw migrate hermes --dry-run

To run them side by side for a week, give each its own directory or container (~/.hermes and ~/.openclaw don't collide) and its own bot. Hermes's FAQ notes that a bot token serves one running gateway at a time, and the second one to connect fails. After an import that brought over OAuth credentials, OpenClaw's docs say to sign in again on one side so the two aren't sharing one refresh grant.

Hermes Agent vs Claude Code: different jobs

Claude Code is Anthropic's coding agent: it works in your repo from the terminal, IDE, desktop app or browser, and you review its output as diffs and pull requests. Hermes Agent and OpenClaw are general assistants that live in your chat apps, remember you across weeks, and run scheduled jobs on any model.

The lines are blurring. Claude Code's Channels (a research preview) push Telegram, Discord and iMessage messages into a running session, but they arrive only while that session is open, and its scheduled Routines run in Anthropic's cloud. Use Claude Code for repository work you'll review. Use Hermes or OpenClaw for the assistant you message about inboxes, research, reminders or your home. To combine them, OpenClaw can use your Claude Code login as its runtime; Hermes needs an API key or a Max plan with extra usage.

Don't want to run a box?

Two managed routes exist, and only one comes from the projects themselves.

• Hermes Cloud. Nous's hosting page prices a Medium instance (2 GB RAM, 4 vCPU, 10 concurrent sessions) at $0.56 a day while running and $0.03 stopped, and a Large (4 GB, 8 vCPU) at $1.09. Billing is daily from your Nous credit, inference is extra, and deploying needs $2 in credit or an active subscription. A Medium left running all month comes to about $16.80 before models.
• OpenClaw. The Foundation offers no hosting. Its docs carry deploy guides for DigitalOcean, Hetzner, Fly, Railway, Render and others, but you operate the result.

A third option is ours, and it's a different runtime, not a host for either project. In Octomind Cloud each octo is one agent per workstream with its own folder, memory, conversations and scheduled routines, reachable from Telegram, WhatsApp, Slack, Discord, email and GitHub, with models through a built-in gateway so you hold no API keys. Routines fire on a timer, a manual run or a webhook, and the Import page takes an OpenClaw or Hermes folder directly: persona, memories, skills, cron jobs and the Telegram bot come over in one step (how the import works). The limits are real. An idle machine sleeps after an hour by default and the next message wakes it; keeping it always on costs its memory, about $18 a month on Small. Octos on one machine share a user and a container, so a folder isn't a security wall. And there's no free cloud: Pro is $50 a month, $20 for the first month, with $50 of usage included.

What this comparison can't tell you

• Answer quality and speed. I didn't connect either agent to a model, so nothing here says which one completes your tasks better. Latency figures you'll find elsewhere come from single tests on one model.
• Counts across projects. Channel lists mix vendors, transports and plugin types, and advisory counts reflect disclosure habits as much as bugs. OpenClaw's own Hermes comparison, written by one of the two parties, calls channel counts not directly comparable and advisory counts not a safety score.
• Next month. At thousands of commits a week, specifics here will date fast. Re-run the gh api numbers and re-check the release tags before you commit.
• Neutral ground. OpenClaw's docs include their own Hermes comparison, reviewed against Hermes source from August 27, 2026. It's detailed and well-sourced, and it's also a vendor's view.

Start with Pro — if you'd rather hand the box to us, your first month is $20.

FAQ

Is Hermes Agent free?

Yes. Hermes Agent is MIT-licensed and free to run; you pay only for the model tokens and the machine. Nous Portal adds an optional subscription with a free tier for free models and paid tiers from $20 a month, and Hermes Cloud hosting is billed per day on top.

Is Hermes a fork of OpenClaw?

No. Nous Research built Hermes Agent as its own Python codebase, while OpenClaw is TypeScript, maintained by the OpenClaw Foundation. They share the SKILL.md skill format, and each ships an importer for the other: hermes claw migrate and openclaw migrate hermes.

Can I run Hermes and OpenClaw on the same server?

Yes, as long as each has its own data directory or container and its own bot tokens. A bot token can be polled by only one gateway process at a time, so Hermes and OpenClaw can't share one. Both document a 1 GB RAM floor, so plan on 2 GB or more for the pair, more with browser tools.

Which is safer, Hermes Agent or OpenClaw?

Neither is safe by default: both run the agent's shell commands on the host until you enable a container backend (terminal.backend: docker in Hermes, agents.defaults.sandbox.mode: "all" in OpenClaw). OpenClaw has the larger public advisory record because its maintainers publish fixes, while Hermes's 39 CVEs were filed by a third party. Run either on a machine without your personal credentials.

How do I uninstall Hermes Agent or OpenClaw?

For Hermes, stop the gateway (hermes gateway stop), preview with hermes uninstall --dry-run, then run hermes uninstall; add --full to remove your data too. For OpenClaw, preview with openclaw uninstall --dry-run --all, then run openclaw uninstall --all to remove the service, state, workspace and app.