Platform Comparison: OpenClaw vs Hermes vs Claude Code¶
Three platforms power Austin's bot fleet. Each has fundamentally different architecture, strengths, and tradeoffs. This comparison is grounded in the Boole Learn propositional analyses and real fleet operations experience.
Fleet Deployment (Current)¶
| Bot | Platform | Host | Channel | Human |
|---|---|---|---|---|
| Sam (primary) | OpenClaw | Mac Studio :18789 | Telegram, Slack | Austin |
| Vesper (primary) | OpenClaw | Mac Studio :18999 | Telegram, Slack | Austin |
| CC Sam | Claude Code | Mac Studio (tmux) | Telegram | Austin |
| CC Vesper | Claude Code | Mac Studio (tmux) | Telegram | Austin |
| Mati | OpenClaw | feral-box-murat :18789 | Telegram | Murat |
| Solenne | OpenClaw | feral-box-murat :18790 | Telegram | Murat |
| Tycho | OpenClaw | feral-box-tycho :18789 | Telegram | TJ |
| Vera | OpenClaw | feral-box-tycho :18795 | Telegram | TJ |
| Nyx | OpenClaw | feral-box-tycho | Telegram | TJ |
| Nyssa | OpenClaw | feral-box-support | Telegram | Ron |
| Cel | OpenClaw | feral-box-cel | Telegram | Kevin |
| Mimi | OpenClaw | feral-box-jun | Telegram | Austin |
Pattern: OpenClaw is the fleet workhorse. Claude Code fills the "coding hands" role. Hermes is available but not currently deployed as a primary companion.
Architecture Comparison¶
| Dimension | OpenClaw | Hermes Agent | Claude Code |
|---|---|---|---|
| Language | TypeScript/Node | Python | TypeScript/Bun |
| Core abstraction | Gateway with plugin channels | Stateful tool-calling loop | Streaming message accumulator |
| State ownership | Gateway (centralized) | Per-agent SQLite | Per-session (local files) |
| Who controls execution | Gateway runtime | Pi runtime (agent proposes, runtime decides) | Query engine (streaming loop) |
| Model support | Any (Anthropic, OpenAI, Google, local, OpenRouter) | Any (same range) | Claude only (Anthropic) |
| Channel support | 20+ (Telegram, Slack, Discord, WhatsApp, Matrix, Teams, etc.) | Telegram, Discord, Slack, CLI | Telegram (via plugin), CLI |
| Multi-bot per host | Yes (profile isolation) | Manual (separate installs) | Yes (separate tmux sessions) |
| Multi-channel per bot | Yes (simultaneous) | Yes (gateway routes) | Limited (one channel plugin) |
Capability Matrix¶
| Capability | OpenClaw | Hermes | Claude Code |
|---|---|---|---|
| Persistent memory | QMD + LCM + memory wiki | Pluggable providers (builtin, Honcho, mem0) | CLAUDE.md files + qmd (manual) |
| Conversation compaction | Automatic (context pressure) | Automatic (context pressure) | Automatic (context pressure) |
| Cron/scheduled tasks | Built-in cron system | Built-in cron | Via external scheduling (CronCreate tool) |
| Tool execution | Plugin-mediated, sandboxed | Registry with check_fn, budget-bounded | Permission triple gate (validate → check → execute) |
| Subagent spawning | Embedded agents with isolation | Delegation with depth limits | AgentTool with isolated contexts |
| Skill/learning system | No native skill system | Self-improving skills from trajectories | Skills via SKILL.md files (static, not self-improving) |
| Prompt caching | Supported (provider-dependent) | Core design principle (system prompt frozen per session) | Core design principle (immutable system context per query) |
| Shell access | Via exec tool (gated) | Via exec tool (gated) | Full (Bash tool, primary capability) |
| Browser automation | Via plugins | Via tool (Playwright, etc.) | Playwright, Chrome DevTools, PinchTab MCP |
| Image generation | Via tools/plugins | Via tools | Via MCP (z-image, etc.) |
| Voice/TTS | Built-in Talk Mode (macOS) | Via Kokoro/ElevenLabs tools | Via MCP tools |
| Email access | Gmail watcher, send | Via tools | Via MCP (Gmail), Himalaya CLI |
| Calendar | Via plugins | Via tools | Via MCP (Google Calendar) |
| Identity/personality | Config-driven (SOUL-like via bootstrap) | SOUL.md (rich identity document) | CLAUDE.md (project instructions) |
| Webhook/API | Gateway REST + WebSocket | Gateway HTTP | No native API |
| Fleet management | Built-in (multi-profile, health monitoring) | Manual | Manual |
Propositional Architecture Comparison¶
From the Boole Learn analyses:
| Architectural Property | OpenClaw | Hermes | Claude Code |
|---|---|---|---|
| Core loop | Gateway routes messages to agents | Synchronous tool-calling loop with iteration budget | Streaming message accumulator (async generator) |
| Security model | Channels as plugins + gateway authority | Tool check_fn + exec policy | Permission triple gate (validate → permissions → execute) |
| State model | Gateway owns all state; clients are read-only | Per-agent SQLite; platform adapters isolated | Per-query immutable context + session persistence |
| Extension model | Lifecycle hooks (plugins intercept boundaries) | Tool registry + skill system | Tool registration + MCP servers |
| Memory model | QMD backend + LCM compaction (separate concerns) | One external provider + builtin (prevents schema bloat) | Context files + manual search |
| Conversation persistence | Append-only JSONL trees | SQLite with WAL mode | JSONL message history |
| Context management | Compaction by token pressure + memory flush hooks | Compaction by token pressure + context compression | Compaction by token threshold |
Strength Profiles¶
OpenClaw — The Infrastructure Layer¶
"OC is infrastructure — channels, multi-bot, fleet management, config-driven."
- Best at: Multi-channel routing, fleet deployment, plugin ecosystem, operational reliability
- Weakest at: No native skill/learning system, no shell-first workflows
- Rock solid propositions: Deterministic routing (P1), channel isolation (P7), compaction (P6)
- Contested: Gateway as single source of truth (filesystem bypass gap)
- Key insight: Centralized authority + append-only persistence + interruptible execution
Hermes Agent — The Cognitive Layer¶
"Hermes is cognition — learning, self-improvement, persistent modeling."
- Best at: Self-improving skills, rich identity (SOUL.md), prompt caching strategy, model flexibility
- Weakest at: No built-in fleet management, single-instance design, skill versioning gap
- Rock solid propositions: Tool-calling loop (P1), memory provider constraint (P3), channel isolation (P4)
- Paradigm-dependent: Skills as self-improvement (depends on model actually calling skill_manage)
- Key insight: Skills injected as user messages (not system) to preserve prompt cache — subtle but critical
Claude Code — The Hands¶
"You're the hands — shell access, code, research, browser, MCP tools."
- Best at: Shell access, code execution, MCP tool ecosystem, browser automation, real-time coding
- Weakest at: Single-model (Claude only), limited channel support, no native fleet management
- Rock solid propositions: Permission triple (P1), message loop (P2), subagent isolation (P5)
- Contested: Immutable system context (MCP tools arrive post-context, Tool Search defers schemas)
- Key insight: Tool availability triple-gated (compile-time + user type + runtime mode)
The Killer Combo¶
From Sam's March 29 analysis:
"The killer combo would be: OC as the chassis, Hermes as the cognitive layer. Like running Hermes's learning loop inside OC's infrastructure."
Current fleet realizes a simpler version: - OpenClaw handles channels, routing, cron, fleet management, memory (the "left brain") - Claude Code handles coding, research, ops, browser automation (the "hands") - Hermes is available as the cognitive/learning layer but isn't deployed as primary companion yet
The gap: no platform combines all three. OC lacks skills/learning. Hermes lacks fleet infrastructure. CC lacks multi-model and channel breadth.
Operational Tradeoffs¶
| Dimension | OpenClaw | Hermes | Claude Code |
|---|---|---|---|
| Cost model | Per-token (multi-provider) | Per-token (multi-provider) | $200/mo flat (Max plan) |
| Model lock-in | None | None | Anthropic only |
| Deployment | LaunchAgent/systemd | Python venv/conda | tmux session |
| Recovery | Gateway auto-restart, session persistence | Process restart, SQLite recovery | Session continue (--continue) |
| Monitoring | Built-in health checks, fleet scripts | Logs, gateway health | Manual (ps, logs) |
| Update path | npm update | git pull + pip install | Automatic (CLI update) |
| Config management | JSON config + profile isolation | YAML config + SOUL.md | CLAUDE.md + settings.json |
| Multi-user isolation | Profile-based (Tier 2a) or hardware-based (Tier 1) | Separate installs | Separate sessions |
Decision Framework¶
Use OpenClaw when: - You need multi-channel presence (Telegram + Slack + Discord simultaneously) - You're deploying bots for clients (fleet management, isolation) - You need cron jobs, scheduled tasks, heartbeat monitoring - You want model flexibility (swap between Opus, GPT-5.4, Gemini, local) - You need production reliability and auto-recovery
Use Hermes when: - You want the bot to learn and improve over time (skill system) - Rich personality/identity is important (SOUL.md) - You're running a single-instance personal companion - You want the cognitive layer with self-improvement - Prompt caching cost savings matter (Anthropic-heavy usage)
Use Claude Code when: - The task is primarily coding, debugging, or infrastructure ops - You need full shell access and filesystem manipulation - You want MCP tool ecosystem (z-image, browser automation, etc.) - You need subagent orchestration for complex multi-step tasks - The work benefits from persistent terminal sessions
Use multiple when: - OC Sam handles email, calendar, memory, cron, multi-channel → CC Sam handles coding tasks she delegates - This is the current architecture: OC Sam is the brain, CC Sam is the hands