Hermes vs OpenClaw Inside Paperclip: Which Runtime Fits Which Job?

Two strong runtimes, different strengths. Here’s how to pick the right one for each agent in your Paperclip company.

One of Paperclip’s core design decisions is adapter-based execution: agents are defined in the orchestration layer, and the runtime that executes them is a configuration choice. That means you can run a Hermes agent and an OpenClaw agent inside the same Paperclip company, on the same org chart, working toward the same goals.

But “you can” doesn’t mean “you should use them interchangeably.” Hermes and OpenClaw have meaningfully different architectures, strengths, and design philosophies. This post breaks down where each one wins.

A Quick Orientation

Before comparing, a note on what both tools are:

Hermes (by Nous Research) is a memory-first agent runtime with persistent multi-level memory, an OpenAI-compatible API server, and strong messaging integrations. It was designed for agents that need to operate continuously and remember what they’ve done across sessions.

OpenClaw is an open-source personal AI assistant with a growing protocol (ACP) for IDE-to-agent communication. It runs across platforms and supports ACPX harnesses that let it drive other coding tools — Claude Code, Codex, Cursor, Copilot, and more.

Both are production-grade. Both integrate with Paperclip as first-class adapters. The question is role fit.

The Core Difference: Memory vs Flexibility

If you had to summarize the two runtimes in one axis, it’s this:

• Hermes is optimized for memory and continuity
• OpenClaw is optimized for flexibility and reach

This shows up everywhere in how the two tools are designed.

Hermes’ multi-level memory (session, task, persistent long-term) means an agent running on Hermes gets smarter about its specific job over time. It remembers what worked, what didn’t, decisions made weeks ago, and why. For roles that do similar work repeatedly over a long time horizon, that compounding memory is a genuine advantage.

OpenClaw’s ACPX harness architecture means an agent running on OpenClaw can itself drive other AI tools — it’s a meta-agent layer. An OpenClaw agent can orchestrate Claude Code for code generation, Codex for parallel tasks, and Cursor for interactive editing, all from a single Paperclip heartbeat. For roles that need to coordinate across multiple AI runtimes, that’s unique.

Where Hermes Wins

Long-running content and research agents

A content writer agent that publishes regularly benefits enormously from memory that spans months. Hermes can remember the brand voice guidelines it internalized in January, the topics that drove the most engagement in February, and the feedback from editing rounds last week — without re-reading all of that on every heartbeat.

Customer-facing agents

If your Paperclip company includes agents that interact directly with customers or users — via WhatsApp, Telegram, Discord, or Slack — Hermes’ native messaging adapters and persistent memory make it the natural fit. The agent builds a model of each customer over time and doesn’t forget their history.

Any role where “forgetting” is costly

Operations agents, support agents, compliance agents — roles where missing context from previous sessions causes real errors. Hermes’ persistent memory layer acts as a safety net against the “I forgot what happened last time” failures that plague agents without it.

Summary: Hermes-first roles

Where OpenClaw Wins

Engineering agents that drive multiple coding tools

OpenClaw’s ACPX harnesses are designed to orchestrate other coding agents as backends. An engineering IC agent that runs on OpenClaw can pick Claude Code for complex architecture work, Codex for parallel code generation, and Gemini for specific tasks — using each model where it’s actually strongest — all within a single Paperclip heartbeat.

Platform-agnostic agents

OpenClaw runs on any OS and integrates cleanly with the ACP protocol for IDE-to-agent communication. If your engineering team uses a mix of VS Code, Zed, JetBrains, and Cursor, an OpenClaw agent can connect to all of them through a single adapter configuration.

Agents that need to route to different LLMs dynamically

Because OpenClaw can drive multiple AI tools as backends, it’s a natural fit for agents whose optimal LLM varies by task type. A senior engineering agent that uses Claude for architecture, GPT-5 for documentation, and a local model for quick edits doesn’t have to be rigidly tied to one model — OpenClaw handles the routing.

Demo and onboarding scenarios

OpenClaw’s accessible setup and broad platform support make it the lower-friction option for getting new team members (or new agents) running quickly. The barrier to a first successful heartbeat is lower than Hermes.

Summary: OpenClaw-first roles

Side-by-Side Comparison

Running Both in the Same Company

The good news: you don’t have to pick one. Inside a Paperclip company, different agents can use different runtimes. This is often the optimal setup.

A typical mixed-runtime company might look like:

Board (you)
└── CEO Agent          ← Claude Code (complex reasoning, governance)
    ├── Content Writer ← Hermes (long-horizon memory, brand continuity)
    ├── Support Agent  ← Hermes (customer memory, messaging integrations)
    ├── Tech Lead      ← OpenClaw (ACPX, drives Claude Code + Codex)
    │   ├── Frontend   ← Claude Code
    │   └── Backend    ← Codex
    └── Ops Agent      ← Hermes (procedural memory, compliance)

The Paperclip orchestration layer handles task routing, budget tracking, and governance regardless of which runtime each agent uses. From Paperclip’s perspective, a Hermes agent and an OpenClaw agent are both just agents with adapters — the coordination logic is identical.

The Honest Tradeoffs

Choose Hermes when: Organizational memory is a first-class requirement. Your agents are doing repetitive, domain-specific work over long time horizons. You need messaging-based customer interactions.

Choose OpenClaw when: You need to route between multiple AI tools within a single agent role. Your team has an existing OpenClaw setup and wants to extend it with Paperclip governance. You’re starting quickly and want low setup friction.

The most common mistake: Defaulting to one runtime for all agents regardless of role fit. A content agent on OpenClaw loses the memory layer it needs. An engineering IC on Hermes misses the ACPX routing that makes multi-tool orchestration easy. Role-runtime fit matters.

Both tools are actively developed and genuinely good. Pick based on role requirements, not brand loyalty.

Related: Which AI Model Should Run Your CEO Agent?

Set up your first Paperclip company: npx paperclipai onboard --yes