OpenClaw vs Hermes vs Claude Code: Which Agent Actually Runs Your AI Business

The short gave you the headline pick. The reason this guide exists is everything underneath it. These three agents differ most in places a benchmark never shows: where your memory lives, what one config line controls, and who sends you a bill when the agent runs all night. Read the table, then the three setup walkthroughs, then the trade-offs. By the end you'll know not just which to pick but exactly what you're signing up to operate.

• OpenClaw — open-source (MIT), Node/TypeScript. A gateway-first messaging assistant: one long-running Gateway process is the control plane that owns every session and channel, so it meets people on WhatsApp, Telegram, Slack, Discord, Signal, iMessage and more. Skills are SKILL.md files you author; community ones come from ClawHub.
• Hermes Agent — open-source (MIT), by Nous Research. Built to run unattended and improve itself: its docs describe autonomous skill creation, a global SOUL.md identity, layered memory on disk, cron scheduling, and self-improvement. Runs locally, on a VPS, in Docker, over SSH, or serverless.
• Claude Code — Anthropic's agentic coding tool. Proprietary. The deepest single model and the most polished operator/coder copilot, but hosted and billed through a Claude subscription or the Anthropic Console (with Bedrock/Vertex as enterprise routes).

Every cell is attributed to the right project's own repo or docs. Read it as: no tool wins every row, and the rows you weight depend on whether you're running customer messaging, an unattended back-office agent, or a coding copilot.

OpenClaw's whole model is the Gateway: a single long-running control-plane process that holds sessions and fans messages out to channels. You stand it up once, then bolt channels on.

1. Run openclaw onboard — the interactive flow sets up the Gateway, workspace, channels and skills in one pass.
2. Add a channel from the CLI, e.g. openclaw channels add --channel telegram --token <bot-token>. Each channel gets its own block under channels.<provider> in config.
3. Tighten who can talk to it: per-channel keys like dmPolicy: "pairing" and an allowFrom list keep the gateway from answering strangers — set these before you connect anything customer-facing.
4. Author skills as SKILL.md files in your workspace (workspace / personal / shared / plugin scopes), and pull community skills from ClawHub — but review each one first (see the supply-chain note below).

Hermes is the one that 'grows with you', and the reason that's more than a slogan is that its state is plain files on infra you own. You can open them, diff them, and back them up.

1. Install with the one-line script from the Nous Research repo, then point it at any OpenAI-compatible provider — OpenAI, OpenRouter, Kimi/Moonshot, MiniMax, GLM, or your own endpoint.
2. Identity lives in a global SOUL.md — the agent's voice and defaults, consistent across every workspace and channel.
3. Memory is two markdown files in ~/.hermes/memories/: MEMORY.md (env facts, conventions, lessons it learned; ~2,200-char budget) and USER.md (who you are / how you work; ~1,375-char budget). They're injected as a frozen snapshot at session start, so edits show up next session — handy to know when you tweak them by hand.
4. Conversation history is separate: every CLI and messaging session lands in SQLite at ~/.hermes/state.db with FTS5 full-text search, so it can recall an actual message from months ago — not a summary of it.
5. Skills it writes itself live in ~/.hermes/skills/ (agentskills.io standard, installable via Skills Hub). Gate them: ~/.hermes/config.yaml has a write_approval setting so the agent asks before it rewrites its own memory or skills.

Claude Code is the deepest model and the smoothest copilot, but it's the one where 'where it runs' and 'who bills you' are decisions you make up front — and they changed in 2026.

1. Default path: a Claude subscription (Pro/Max) or the Anthropic Console. The Console route is pre-paid credits and auto-creates a 'Claude Code' workspace so you can see spend.
2. To run it on another backend, set env vars: CLAUDE_CODE_USE_BEDROCK=1 (plus AWS_REGION) for Amazon Bedrock, or CLAUDE_CODE_USE_VERTEX=1 with ANTHROPIC_VERTEX_PROJECT_ID for Google Vertex. Some surfaces also accept other third-party providers.
3. Project memory is CLAUDE.md (instructions you write, checked into the repo) plus an auto-memory the tool maintains itself. Note a gotcha: some features — Anthropic's Session Memory among them — are gated to first-party API access and don't light up on every provider.
4. If you'll run it unattended, decide the billing path deliberately: a flat subscription is fine for hands-on coding, but agent-style continuous use is metered at API rates (next section).

Each strength has a tax. This is the part the demos skip.

• OpenClaw's reach is also its blast radius. The same ClawHub registry that makes it powerful was the vector for an early-2026 supply-chain campaign — security researchers found malicious instructions hidden inside SKILL.md files, including payloads that pulled a macOS infostealer. The defence is boring and mandatory: pin versions, read every skill before install, don't auto-trust the registry.
• Hermes accumulates state you now own. Self-improvement means it writes its own skills and curates its own memory — great, until you realise you are the backup, the reviewer, and the keeper of SOUL.md. It's also more to stand up than a one-command toy, and you're responsible for the box it runs on.
• Claude Code's risk is policy, not code. From 4 April 2026 Anthropic stopped flat-rate Claude Pro/Max plans from subsidising third-party agents and moved that usage to metered API-rate billing — a $200 Max plan had been running, by the company's own framing, $1,000–$5,000 of agent compute. It later reinstated third-party agent use on subscriptions, but with a catch: a fixed, non-rollover monthly credit (roughly $20–$200 by plan tier), then API rates beyond it. Some heavy users reported bills jumping up to ~50× (reported across multiple outlets). Brilliant tool — just don't wire an always-on business to one provider's pricing page.

Match the job to the tool. Most real setups run two of these for different layers, not one for everything.

• Pick Hermes if you want an agent that runs unattended, gets better at the jobs it repeats, and keeps memory + identity as files on infra you control — and you're comfortable owning the box and the backups.
• Pick OpenClaw if you want to meet customers on every messaging channel from one process, stand it up fast, and lean on a big skill library — and you'll vet what you install.
• Pick Claude Code if you want the sharpest hands-on coding/operator copilot with the deepest model, and you accept proprietary plus subscription/Console (or Bedrock/Vertex) billing.
• Whatever you pick: own the layer beneath it — your keys, your infra, and the brand/billing on top — so a vendor's pricing change is a config edit, not a business crisis.

Two of these (OpenClaw, Hermes) are open-source and yours to run. The moment a client uses what you built, a new question shows up that none of the three answers: how do you put your name on it and charge for it? That's a layer above the agent. If you'd rather not build the white-label front, the multi-provider model access, and the metered billing yourself, that's exactly what Knotie's reseller platform is for — package the agent you assembled under your own brand and domain, point it at multiple model families through one OpenAI-compatible endpoint (swap the model with a one-line change, not a new integration), and meter usage per customer on built-in credit billing so you keep the margin. The agent does the work; you own the business around it.

Before you build a business on any agent — open-source or not — answer these. Every 'no' is a future migration you're signing up for.

1. Can I self-host it on infra I control, or does the heavy lifting run on the vendor's servers?
2. Is the licence open (I can fork it) or proprietary (I'm a tenant)?
3. Can I point it at my own keys / swap the model behind it without a rebuild?
4. Does its memory + identity live in files I own and back up (e.g. ~/.hermes/, CLAUDE.md), not a vendor-only database?
5. If it has a skill marketplace, will I pin and review every skill — or auto-trust strangers' code?
6. If the vendor changed pricing tomorrow, what breaks, and how many days to switch?