--- title: OpenClaw and Hermes Agent ship the same features with different defaults description: OpenClaw and Hermes Agent are the two big open-source agents that live on your own machine and answer you in your chat apps. By October 2026 their feature lists match and their defaults don't. An interactive comparison with the small claws (NanoClaw, nanobot, ZeroClaw, PicoClaw, IronClaw), what running both taught me, and which to pick for which situation. date: 2026-10-16 tags: AI agents, OpenClaw, Hermes Agent, self-hosting, agent harness --- OpenClaw and Hermes Agent do the same job: an open-source agent that lives on your own machine, answers you in Telegram, Slack or WhatsApp, runs tools, remembers you and writes its own skills. By October 2026 their feature lists mostly match. Their defaults don't. OpenClaw is built for reach: dozens of chat channels, phone apps that act as sensors, many agents behind one gateway. Hermes is built around a learning loop and a wide choice of where its commands run. Both run tools straight on your computer until you change that, and for plenty of people a smaller harness, or none at all, is the better pick. I've run OpenClaw on a Mac mini since May, 17 agents at last count, and I ran Hermes next to it with two profiles until September. This note puts the two side by side, with the five smaller "claws" that grew up around them. The numbers come from each project's docs, README and GitHub page on October 16. The figures move or take a tap, and there's a picker at the end.

GitHub stars, October 16, 2026

  1. OpenClawTypeScript · MIT

    392k

  2. Hermes AgentPython · MIT

    254k

  3. nanobotPython · MIT

    49k

  4. ZeroClawRust · Apache 2.0 / MIT

    33k

  5. NanoClawTypeScript · MIT

    31k

  6. PicoClawGo · MIT

    30k

  7. IronClawRust · Apache 2.0

    13k

This weekOpenClaw 2026.10.4 on October 16, Hermes v0.22.2 on October 15.

Stars measure attention, not quality. Bars to scale; the logos are each project's own.
## Two big projects and a crowd of small ones OpenClaw is the one that started the wave. Peter Steinberger's personal assistant went from Clawd to Moltbot to OpenClaw in January. He joined OpenAI in February, and since July the project belongs to the OpenClaw Foundation, a nonprofit where, in its own words, OpenAI is a donor, not an owner. It's TypeScript under MIT, and it ships often: 2026.10.4 came out on October 16. Hermes Agent comes from Nous Research, the lab behind the Hermes models. It's Python under MIT, first released in March, and it moves just as fast. v0.22, "The Threshold Release", landed on October 14 and cut the source from about 1.06 million lines to 698,000. Around the two, smaller harnesses each picked one thing to do better. NanoClaw puts every agent in a container. nanobot keeps a small Python core. ZeroClaw and PicoClaw fit on cheap boards. IronClaw rebuilds OpenClaw in Rust around security. ## Both are a gateway around a loop Strip the branding and the two have the same shape. A gateway process stays up and listens on your chat accounts. A message arrives, the gateway finds the right session, and an agent loop runs: the model asks for a tool, the tool runs, the result goes back, until the model has an answer. Along the way it writes to Markdown files the next session reads, and the reply goes back to the chat it came from. The differences are inside the boxes. OpenClaw's gateway is one long-lived Node process with a WebSocket on `127.0.0.1:18789`, and every agent, channel and phone talks to it. Hermes runs a Python gateway, and every profile gets its own home with its own memory, skills and cron jobs. OpenClaw also wakes its agents on its own: a heartbeat runs a full agent turn every 30 minutes by default. Hermes waits for you or for cron jobs you describe in plain language, and gives a session a `/heartbeat` only when you ask for one.

OpenClawHermes

  1. 1A message arrives

    About 30 chat channels, plus apps for phones and desktops

    25+ platform adapters and a desktop app

  2. 2The gateway routes it

    One Node process, a WebSocket on 127.0.0.1:18789, every agent behind it

    A Python gateway; each profile is its own home

  3. 3The loop runs tools

    Any model, and Claude Code or Codex can run the loop

    Any model, and local llama.cpp in one click since v0.22

  4. 4It writes things down

    MEMORY.md and daily notes, merged by a Dreaming sweep

    A small MEMORY.md and USER.md, plus search of past sessions

  5. 5It replies, or wakes up

    A heartbeat turn every 30 minutes, on by default

    Cron in plain language; /heartbeat if you ask

Same five steps, different parts. The highlight walks one message through both.
## Where the defaults pull apart Feature by feature, most rows of a comparison say "both". The useful question is which way each project leans when you install it and change nothing. Switch the tabs. Memory: OpenClaw puts a stack of workspace files into every session, AGENTS.md, SOUL.md, USER.md, MEMORY.md and the daily notes, up to 20,000 characters per file and 60,000 in total, and a scheduled Dreaming sweep consolidates them. Hermes keeps memory deliberately tiny: 2,200 characters of notes and 1,375 about you, frozen when the session starts. When it needs more, it searches its old conversations with SQLite full-text search. Channels: OpenClaw's catalog lists about 30 chat platforms, and its apps for iOS, Android, macOS, Windows and Linux turn a device into a node with a camera, location and notifications. Hermes has more than 25 adapters and a desktop app. I didn't find a phone app. Sandbox: both run commands on the host by default. OpenClaw's sandbox is off until you turn it on, with Docker, Podman or SSH behind it. Hermes treats where commands run as a first-class setting, local, Docker, SSH, Singularity, Modal, Daytona or Vercel Sandbox, and by default asks a second model to judge flagged commands before they run. Models: both take any provider. OpenClaw can also hand the whole loop to Claude Code or Codex. Hermes added one-click local models through llama.cpp, and it can export trajectories for reinforcement learning, which says a lot about who builds it. Agents: OpenClaw routes each chat account to an agent with bindings, and I run 17 agents behind one gateway. A Hermes profile is one agent with its own home, and `delegate_task` hands subtasks to child agents.

OpenClaw

Hermes

60,000

characters of workspace files, at most, in each session

  • AGENTS.md, SOUL.md, USER.md, MEMORY.md, daily notes
  • 20,000 per file, 4,000 for USER.md
  • A scheduled Dreaming sweep consolidates them

3,575

characters of memory, frozen when the session starts

  • MEMORY.md 2,200, USER.md 1,375
  • Older sessions: SQLite full-text search

LeanOpenClaw loads a lot every turn. Hermes keeps a small core and searches the rest.

~30

chat channels in the catalog, plus device apps

  • Telegram is the suggested first one
  • iOS, Android, macOS, Windows and Linux apps become nodes
  • A node lends its camera, location and notifications

25+

platform adapters, plus a desktop app

  • Telegram, Discord, Slack, WhatsApp, Signal, SMS, email
  • Home Assistant, Matrix, iMessage through a bridge
  • No phone app that I found

LeanOpenClaw reaches further, and turns your phone into a sensor.

Off

sandboxing by default: the main session runs tools on the host

  • Modes: off, non-main, all
  • Backends: Docker, Podman, SSH and two more

Local

terminal backend by default: commands run on the host

  • Or Docker, SSH, Singularity, Modal, Daytona, Vercel Sandbox
  • Smart approvals: a second model judges flagged commands
  • Manual, or off, plus deny patterns

LeanBoth start on your machine. Hermes puts the alternatives one setting away.

Any

provider, and the harness is a plugin too

  • Claude Code or Codex can run the agent loop
  • A model per agent

Any

provider, and local models in one click

  • llama.cpp built in since v0.22
  • Trajectory export for reinforcement learning

LeanA draw on choice. Hermes leans research, OpenClaw leans on the coding agents you already run.

17

agents behind my one gateway

  • Bindings route each chat account to an agent
  • sessions_spawn starts sub-agents
  • One Telegram bot per agent, in my setup

1

agent per profile, picked with hermes -p

  • Each profile: its own config, SOUL.md, memory, skills and cron
  • delegate_task hands subtasks to child agents

LeanOpenClaw is built for a fleet. Hermes, for one agent at a time.

Defaults from each project's docs on October 16. Both can be configured toward the other.
## Both teach themselves, on a counter The Hermes README calls it the only agent with a built-in learning loop. That stopped being true in April, when OpenClaw shipped Skill Workshop. Here's what actually triggers each one. Hermes counts. Every 10 of your prompts, a forked review agent rereads the conversation and decides what to save to memory. Every 10 tool iterations inside one turn, the same kind of review decides whether to write or patch a skill. A curator marks a skill stale after 14 days without use and archives it after 30. It never deletes one. OpenClaw counts too. After 10 model iterations in a conversation, a background review saves anything worth keeping as a learned skill, and during a turn the agent patches a learned skill that misled it. Skills nobody uses for 30 days are archived, every change keeps the previous version, and `/learn undo` reverts one. Both have a manual trigger, `/refine` on Hermes and `/learn` on OpenClaw. The real gap is memory: Hermes reviews it on a schedule of its own, while OpenClaw leaves it to the agent and the Dreaming sweep and only automates skills.

Hermes

Your prompts

Review: save to MEMORY.md?

Tool iterations in one turn

Review: write or patch a skill

Unused 14 days: stale. 30 days: archived. Never deleted.

and

OpenClaw

Model iterations in a conversation

Review: save a learned skill

During a turn

Patch the learned skill that misled it

Unused 30 days: archived. Every change versioned, /learn undo.

By hand/refine on Hermes, /learn on OpenClaw.

Both counters reach ten, then a review decides what to keep. Only Hermes runs one for memory.
## Both run tools on your computer by default This is the part I'd want someone to tell me first. Out of the box, OpenClaw runs tools on the host for your main session. Its README says so, and its sandbox page opens with "Sandboxing is off by default." Hermes's default terminal backend is local too. So a skill you install, or a prompt injected through an email the agent reads, can reach whatever your user account can. It's not hypothetical. In February, CVE-2026-25253 let one click on a crafted link leak an OpenClaw gateway token and run code, fixed in 2026.1.29. A scan of ClawHub, OpenClaw's skill registry, found 341 malicious skills out of 2,857. SecurityScorecard counted 40,214 OpenClaw instances exposed to the internet on February 9. Hermes has had four CVEs of its own. Some of the smaller harnesses exist because of exactly this. NanoClaw runs each agent group in its own container, and outbound requests go through a gateway that adds the credentials, so the agent never holds a raw API key. IronClaw runs untrusted tools in a WebAssembly sandbox with an endpoint allowlist and injects secrets only at the host boundary. Pick a setup in the figure and see what a bad skill can reach.

6 of 6

The default for OpenClaw's main session and Hermes's local backend

1, maybe 3

Opt-in on both: the container sees what you mount and pass in

1, maybe 2

The default: a container per agent group, credentials added outside it

0 unless granted

The default for untrusted tools: WebAssembly with capability permissions

1 clickCVE-2026-25253: token leak to code execution, fixed in 2026.1.29

341malicious skills out of 2,857 on ClawHub, February

40,214OpenClaw instances exposed to the internet, February 9

Schematic: what each setup lets a tool touch by default, from each project's docs. The numbers are OpenClaw's, because it has the biggest crowd to attack.
## The small claws each pick one fight Every small claw is partly a reaction to OpenClaw's size. NanoClaw's README puts it bluntly: OpenClaw is "nearly half a million lines of code, 53 config files, and 70+ dependencies." NanoClaw is "built to be easily understood and completely customized for your needs", and customizing it means changing code, not config. NanoClaw runs on Anthropic's Claude Agent SDK, with a container per agent group, and you add a channel by running a skill such as `/add-telegram`. nanobot, from the Data Intelligence Lab at the University of Hong Kong, is the small Python one, with Telegram, Feishu, WeChat, Slack and Discord among its channels. ZeroClaw and PicoClaw aim at cheap hardware. ZeroClaw is a single Rust binary that talks to about 20 model providers and can drive GPIO pins on a Raspberry Pi, an Arduino or an ESP32. PicoClaw is Go, says it boots in under a second on a 0.6 GHz single core, and is honest that recent builds use 10 to 20 MB of RAM, not the under 10 in its headline. IronClaw, from NEAR AI, describes itself as an agent OS focused on privacy, security and extensibility: a Rust reimplementation inspired by OpenClaw, with tools in WebAssembly, secrets encrypted with AES-256-GCM, PostgreSQL for state and no telemetry. These are the projects' own claims. I haven't benchmarked any of them.

The small claws, in their own words

Quotes from each README on October 16. Footprints are the projects' own numbers, not my measurements.
## What running two harnesses taught me OpenClaw is the one I kept: 17 agents, 16 Telegram bots, one per agent, and four MCP servers into my own apps. It's also the one that's cost me the most evenings. On September 1, the update from 2026.7.1 to 2026.8.1 turned into a multi-hour incident. Stricter config schemas rejected settings that had worked the day before, any warning during the startup migration now stopped the gateway, and the state database moved to a schema the old version couldn't read, so there was no going back. Two weeks later, 2026.9.4 needed Node 24.16 and quietly skipped any skill without a description in its frontmatter. One of my agents lost a skill that way. Hermes went the other way. I ran it with two profiles, updated it on August 14 across 7,183 commits, and then stopped using it. By September 14 both of its gateways were crash-looping on Telegram tokens I'd revoked, so I removed it. The catch: my OpenClaw gateway turned out to be running on the Node binary that Hermes had bundled. Deleting one harness nearly took down the other. Shared limits bite everything at once too. My agents share one Claude login, and on October 15 its five-hour limit stalled all of them together. Nothing retried after the reset. None of that is a reason to skip either project. It's the price of software that moves this fast: read the release notes before you update, and back up the state folder first.

  1. May 2026

    OpenClaw on a Mac miniGrows to 17 agents, 16 Telegram bots and four MCP servers.

  2. Aug 14

    Hermes 0.18.2 to 0.20.1Two profiles, one update, 7,183 commits.

  3. Sep 1

    OpenClaw 2026.8.1Strict config, fatal migration warnings, a state database with no way back. Hours.

  4. Sep 14

    Hermes out, 2026.9.4 inGateways looping on revoked tokens; OpenClaw ran on Hermes's Node. Then Node 24.16, and a skill silently skipped.

  5. Oct 15

    One limit, every agentA five-hour limit stalls the fleet. Nothing retries after the reset.

My own setup, from my notes. Red marks a break.
## Pick by situation So which one? Here's how I'd choose today. If you want many agents across many chat apps, with your phone as a sensor, take OpenClaw, and turn the sandbox on for everything except your main session. If you want one agent that gets better at your recurring work, and you'd rather hack Python, take Hermes. If you're already on OpenClaw, `hermes claw migrate --dry-run` shows what would come across: your SOUL.md, memories, skills, allowlists and channel settings. If you want to read every line and keep each agent in a container, take NanoClaw. For a Raspberry Pi or a cheap board, PicoClaw or ZeroClaw. If secrets and untrusted tools are your main worry, IronClaw. For a small Python agent with Chinese chat platforms, nanobot. And if all you want is to reach a coding session from your phone, you might not need a harness at all. Claude Code's Remote Control and Channels, and Codex's remote mode in the ChatGPT app, do that while your machine stays awake.

Your situation

TakeOpenClaw

WhyAbout 30 channels, phone nodes, and bindings that route each chat to its own agent. I run 17 behind one gateway.

CatchBig and fast-moving. Read the release notes, back up first, and sandbox everything but your main session.

TakeHermes Agent

WhyThe learning loop is on by default, memory stays small and searchable, and commands can run in seven places.

CatchNo phone app, and smart approvals are still one model judging another.

TryHermes, migrated

Howhermes claw migrate --dry-run lists what comes across: SOUL.md, memories, skills, allowlists, channel settings.

CatchRunning both? Check which Node each service runs on before you delete one.

TakeNanoClaw

WhyA small TypeScript codebase on the Claude Agent SDK, a container per agent group, keys kept outside.

CatchCustomizing means changing code, and it's built around Claude.

TakePicoClaw or ZeroClaw

WhySingle binaries in Go and Rust. ZeroClaw drives GPIO pins.

CatchThe footprints are their own claims. PicoClaw admits 10 to 20 MB on recent builds.

TakeIronClaw

WhyWebAssembly tools with capability permissions, an endpoint allowlist, secrets injected at the boundary and scanned for leaks.

CatchIt needs PostgreSQL, and its community is the smallest of the seven.

Takenanobot

WhyA compact Python core, and Feishu and WeChat next to Telegram and Slack.

CatchIts sandbox is optional and off by default.

TakeNo harness

WhyClaude Code Remote Control or Channels, or Codex remote in the ChatGPT app, reach the session you already run.

CatchOnly while the session or the machine is up, with no memory or schedule of its own.

My picks as of October 16, 2026. Both big projects ship often, so check the release notes before you trust any row.
If you want more: - [An agent fleet at home](/talks/openclaw/), my talk on the 17-agent OpenClaw setup - [Don't be your team's meat proxy](/notes/dont-be-your-teams-meat-proxy.html), Peter Steinberger on teammates reaching your agents - [AI coworkers in Slack need their own identity](/notes/ai-coworkers-slack-agent-identity.html), what changes when an agent posts as itself If you run one of these, tell me which one and what broke first. I'd like to compare notes.