Wait, What Is OpenClaw Again? Hermes + OpenClaw Integration Explained

Introduction: The Problem

If you've been following my setup, you know I run a pretty sophisticated AI automation system. But I kept getting the same question from friends and readers:

> "Wait, what is OpenClaw again? And how does it relate to Hermes?"

Fair question. Here's the thing: OpenClaw isn't a runtime framework. It's not something that "runs" alongside Hermes. It's a state that gets imported into Hermes — a one-time data migration, not an ongoing connection.

Think of it like this: OpenClaw is the playbook. Hermes is the quarterback. The playbook doesn't "run" with the quarterback — it gets studied before the game, then the QB executes the plays.

After months of iteration, I've landed on a clean integration pattern. Let me break it down.

The Architecture: Migration as State Transfer

What Actually Happened

When I migrated from OpenClaw to Hermes, here's what moved:

OpenClaw State → Hermes State
├── Skills (~/.openclaw/workspace/skills/) → ~/.hermes/skills/openclaw-imports/
├── Agent configs → Hermes profiles
├── Session history → Hermes session search
└── MCP bridges → Native MCP client

Key insight: OpenClaw agents (Scout, Rider, Warner, Argus, Cody, Ledger) don't "exist" as separate processes anymore. They're roles that Hermes fills using the delegate_task tool.

The Current Setup

┌─────────────────────────────────────────────────────────────┐
│                     McGwire (M4 Mac)                        │
│  ┌───────────────────────────────────────────────────────┐  │
│  │              Hermes Agent (Orchestrator)              │  │
│  │  - Discord bot (port 9119)                            │  │
│  │  - Cron scheduler                                     │  │
│  │  - Skills system                                      │  │
│  │  - MCP Bridge (stdio)                                 │  │
│  │  - delegate_task tool                                 │  │
│  └───────────────────────────────────────────────────────┘  │
│                              │                                │
│                              │ stdio                          │
│                              ▼                                │
│  ┌───────────────────────────────────────────────────────┐  │
│  │         OpenClaw MCP Server (port 18789)              │  │
│  │  - Spawns agents on demand                            │  │
│  │  - 6 specialized agents (stdio subprocess)            │  │
│  └───────────────────────────────────────────────────────┘  │
└─────────────────────────────────────────────────────────────┘
│
│ network (optional)
▼
┌─────────────────────────────────────────────────────────────┐
│                  Musial (Ubuntu Server)                     │
│  - Ollama LLM inference                                     │
│  - Local models: gemma4:e4b, qwen3-coder-next, etc.         │
└─────────────────────────────────────────────────────────────┘

How Delegation Actually Works

The delegate_task Pattern

This is the core of the integration. When I need specialized work, I don't "call OpenClaw" — I use Hermes' built-in delegate_task tool:

delegate_task(
agent="scout",
task="Research ESP32-C3 boards for voice assistant project",
toolsets=["web", "browser"]
)


delegate_task(
agent="rider",
task="Draft blog article from Scout's research",
toolsets=["file", "terminal"]
)


delegate_task(
agent="warner",
task="Scan Reddit for CVE mentions of our infrastructure",
toolsets=["web"]
)

Agent Specialization

Each agent has a role and an optimized model assignment:

| Agent | Primary Model | Purpose | Example Tasks | |-------|---------------|---------|---------------| | Scout | glm-5:cloud | Research, web search, HA queries | "Find next Cardinals game", "Research ESP32-C3 boards" | | Rider | deepseek-v3.2:cloud | Writing, HTML emails, blog articles | "Draft blog post", "Write energy report email" | | Warner | glm-5:cloud | Security scanning, CVE monitoring | "Monitor Reddit for security threats" | | Argus | glm-5:cloud | Infrastructure monitoring, health checks | "Check server health", "Verify cron jobs" | | Cody | qwen3-coder-next:cloud | Coding, scripting, debugging | "Write ESPHome config", "Fix Python script" | | Ledger | deepseek-v3.2:cloud | Financial analysis, portfolio management | "Analyze market data", "Track expenses" |

Why different models? Cost and performance optimization. Scout needs fast web search (glm-5). Rider needs quality writing (deepseek-v3.2). Cody needs coding expertise (qwen3-coder-next).

The MCP Bridge: Communication Protocol

The MCP (Model Context Protocol) bridge is how Hermes talks to OpenClaw agents. Here's the actual config:

mcp:
servers:
openclaw:
command: "openclaw-mcp"
args: ["--stdio"]
env:
OPENCLAW_PORT: "18789"
OPENCLAW_HOST: "127.0.0.1"

What this does:

1. Hermes starts the OpenClaw MCP server as a stdio subprocess 2. MCP server listens on port 18789 (local only) 3. When delegate_task is called, Hermes sends the task via MCP protocol 4. OpenClaw spawns the appropriate agent (Scout, Rider, etc.) 5. Agent completes task, returns result via MCP 6. Hermes bundles results and delivers to user

Key benefit: Agents are spawned on demand, not running constantly. No resource waste.

Real-World Example: ESP32-C3 Voice Assistant Project

Here's how this played out today:

Task 1: Research (Scout)

delegate_task(
goal="Research ESP32-C3 boards for voice assistant",
toolsets=["web"]
)

Task 2: Motion Sensor Analysis (Argus)

delegate_task(
goal="Research motion detection sensors, compare power consumption",
toolsets=["web"]
)

Task 3: Blog Research (Scout)

delegate_task(
goal="Research Hermes + OpenClaw integration pattern from architecture doc",
toolsets=["file"]
)

Task 4: Blog Draft (Rider)

delegate_task(
goal="Draft blog article from Scout's research",
context="[Scout's research output]",
toolsets=["file"]
)

Total time: ~14 minutes Total cost: Fractions of a cent per agent Quality: Production-ready output

Benefits of This Pattern

1. One Source of Truth

No more syncing state between frameworks. Hermes owns everything — skills, sessions, memory, MCP.

2. Safe Migration

OpenClaw configs are imported, not live-coupled. If something breaks, I can roll back to the imported state.

3. Simple Patterns

delegate_task is the only tool I need. No complex orchestration logic, no custom RPC layers.

4. Model Optimization

Each agent gets the best model for its role. Scout doesn't need coding skills. Cody doesn't need creative writing.

5. Resource Efficiency

Agents spawn on demand, complete their task, and exit. No idle processes burning CPU.

5 Lessons Learned

1. Don't Over-Engineer the Integration

My first attempt had Hermes and OpenClaw running as separate processes with HTTP RPC. Wrong approach. Now it's just stdio + MCP. Simple.

2. Skills Are the Key to Continuity

Migrating skills from OpenClaw to Hermes preserved all my hard-won knowledge. The hermes-agent-troubleshooting skill (21KB, 609 lines) is a perfect example — it encodes everything I know about debugging this system.

3. Agent Specialization Matters

Early on, I used one model for everything. Big mistake. Now Scout uses glm-5 (fast, good at search), Rider uses deepseek-v3.2 (quality writing), and Cody uses qwen3-coder-next (coding expert). Results improved dramatically.

4. Document the Architecture

The /Volumes/McGwire/openclaw/ARCHITECTURE.md file (source of truth, synced to Obsidian and Hermes skills) is my single most valuable asset. It covers:

• Machine inventory
• Model config
• File system layout
• Credentials (encrypted)
• All cron jobs
• MCP bridge details
• Agent skills
• Network/DNS
• Startup sequence
• Monitoring
• Known issues
• Quick reference commands

If it's not documented, it doesn't exist.

5. Test the Troubleshooting Path

Creating the troubleshooting skill forced me to document exactly what to do when things break. That's invaluable at 2 AM when a cron job fails and I'm half-asleep.

The Bottom Line

Hermes + OpenClaw isn't a runtime integration. It's a migration pattern.

• OpenClaw agents become roles that Hermes fills via delegate_task
• Skills, sessions, and configs are imported into Hermes
• MCP Bridge provides on-demand agent spawning via stdio
• Model optimization happens at the agent role level

The result? A clean, simple, efficient system that scales with my needs.

Quick Reference Commands

ps aux | grep hermes

openclaw-mcp --status


openclaw agents list


openclaw sessions scout


hermes delegate --agent scout --task "What's the weather?"


tail -f ~/.hermes/logs/hermes.log
tail -f ~/.openclaw/logs/mcp.log

That's the pattern. Clean, documented, and battle-tested. If you're building a similar system, I hope this saves you some iteration time. Go Cardinals. 🐦🔴