What is a harness? Run OpenClaw agents stably

Florian · · ~6 Min. Lesezeit
AI Blog KI
What is a harness? Run OpenClaw agents stably

Last updated: May 26, 2026

What is a harness? The missing layer between LLM and real execution

A lot of people talk about “agentic AI,” but hardly anyone explains the difference between a model and a harness properly. That is exactly where false expectations start: a strong model alone does not give you a stable workflow — and an impressive agent stack is not worth much if updates or backups keep blowing up old parts of your setup.

In this article, we break down:

  • what a harness actually is,
  • why Codex/Claude Code currently have an advantage here,
  • why Google/Gemini setups are still not equally mature in many environments,
  • where OpenClaw is still functionally stronger,
  • and why Hermes often wins in everyday use with the more boring but more important strength: less operational chaos after updates, backups, and maintenance.

Content

  1. Model ≠ harness: the most misunderstood point
  2. What a harness actually does (tooling, permissions, execution)
  3. Why Codex/Claude Code feel more productive because of it
  4. Why Gemini/Google still do not have the same harness maturity everywhere
  5. How close harness-based setups already get to OpenClaw
  6. Where OpenClaw still clearly stands out
  7. Practical conclusion: when Hermes makes more sense — and when OpenClaw does

1) Model ≠ harness: the most misunderstood point

An LLM is the thinking engine. A harness is the execution layer around it.

Without a harness, you get good answers. With a harness, you get reproducible work:

  • reading and writing files
  • running commands
  • validating intermediate steps
  • detecting errors and retrying
  • returning results in a structured way

Simple rule: The model thinks. The harness delivers.

2) What a harness actually does (tooling, permissions, execution)

A useful harness connects the model to a controlled runtime:

  • tool calls instead of just text suggestions
  • execution context (repo, paths, processes)
  • permission and scope boundaries
  • logs and traceability
  • optionally: session isolation

Without this layer, “agentic AI” is often just demo theater. With it, it becomes operational.

3) Why Codex/Claude Code feel more productive because of it

Codex/Claude Code are often perceived as “just smarter models” — but the real leverage is the harness integration:

  • direct access to the codebase and shell
  • iterative loops (plan → edit → run → fix)
  • structured context across multiple steps

It feels less like chat and more like a fast junior-to-mid engineer loop.

4) Why Gemini/Google still do not have the same harness maturity everywhere

Important: this is not about saying “Gemini is bad.” It is about execution-environment maturity.

In many setups, the gap today is not primarily model quality, but:

  • less standardized harness integration in the actual tool stack
  • weaker end-to-end workflows out of the box
  • more integration effort for the same operational mode

That can change. But in real-world comparisons, what matters is what runs reliably today.

5) How close harness-based setups already get to OpenClaw

With a good harness, we are already surprisingly close to core OpenClaw ideas:

  • multi-step execution
  • tooling instead of pure text replies
  • reproducible workflows

For pure coding tasks, that is often enough.

6) Where OpenClaw still clearly stands out

The more interesting question is not “Does OpenClaw also have tools?” but: Where is it visibly stronger than a leaner Hermes setup in real operation today? Three concrete public examples show the pattern.

First: channel-first workflows with real messaging depth. OpenClaw clearly invests in Telegram as a primary working surface, not just as a notification channel. You can see that in how specific its public fixes are — for example around TTS/voice-note routing, where replies are expected to arrive as true voice messages instead of generic audio files.[1] If your daily workflow depends on Telegram, threads, voice notes, and agentic feedback loops, that is a real product advantage.

Second: more complex subagent lifecycles. For longer thread-bound work, OpenClaw now even documents explicit “completion ownership” logic: whether the final result belongs to the worker thread, the requesting session, or gets bridged back to the original channel.[2] That is a good example of an area where OpenClaw feels more like an operating system for agents, while Hermes intentionally stays lighter and more direct.

Third: deeper memory/privacy workflows for long-running agent operation. With topics like privacy audits and encrypted memory export, the public tracker shows that OpenClaw is aiming harder at persistent, stateful agent systems.[3] For setups with multiple surfaces, persistent agents, and shared long-term continuity, this is an area where OpenClaw is often functionally ahead of Hermes.

In short: Harness tools like Codex or Claude Code dominate the editor loop. OpenClaw dominates more where agentic workflows have to stay connected across channels, threads, memory, and long-running operations.

7) Practical conclusion: when Hermes makes more sense — and when OpenClaw does

Now for the uncomfortable but important part: for many users, the biggest Hermes advantage is not the flashier feature set, but less maintenance drama. That is exactly where public OpenClaw issues show a recurring pattern: updates can leave gateways hanging, keep running processes stuck with stale bundle imports, trigger restart loops for macOS services, or overwrite TLS-related variables during reinstall.[4][5][6][7]

That is more than “a bug here and there.” In practice, for operators, it means: you did a backup, you ran an update, and suddenly two old things no longer work while three new things feel half-finished. That is exactly why power users of systems like this often stay on older stable versions on purpose instead of installing every release immediately. Not out of laziness, but because a productive agent stack can otherwise turn into a subscription to repair work — ideally with Claude Code or Codex standing by to help sweep up the shards.

This is where Hermes often scores better right now: less platform magic, fewer overloaded runtime paths, less “everything depends on the gateway” complexity. That does not automatically make Hermes more powerful, but in many everyday setups it makes it more maintainable. To be fair, Hermes is not bug-free either — the public tracker also contains a hard report about cron jobs disappearing after an update.[8] The difference is more about operating economics: if you want to use a system every day without spending hours debugging after every maintenance window, that boring stability suddenly becomes a very good feature.

That leads to a much more practical decision matrix:

  • Only coding/repo tasks: Codex or Claude Code with a good harness are usually the fastest choice.
  • Multi-channel, voice, subagent topologies, deep memory: OpenClaw currently has the more interesting specialty capabilities here.
  • Everyday automation with a focus on stability and less repair work: Hermes is often the more sensible choice.
  • Gemini/Google setups: high potential, but still highly dependent on the concrete integration level in the actual stack.

Conclusion and outlook

The relevant question is not “Which model is the smartest?” but: Which runtime turns intelligence into reliable execution?

Part 5 shows exactly that transition from chat to operational agentic behavior. In the next part, we could turn this into a concrete matrix: task type → best setup (harness-only vs. OpenClaw orchestration).

Sources for the practical examples

[1] OpenClaw PR: Fix Telegram TTS voice-note routing — https://github.com/openclaw/openclaw/pull/84791 [2] OpenClaw PR: Add native subagent completion ownership — https://github.com/openclaw/openclaw/pull/80544 [3] OpenClaw PR: Memory Privacy Audit + Encrypted Backup — https://github.com/openclaw/openclaw/pull/81008 [4] OpenClaw Issue: UI Update button breaks Gateway when npm global + launchd — https://github.com/openclaw/openclaw/issues/85246 [5] OpenClaw Issue: Auto-update can leave running gateway with stale hashed bundle imports — https://github.com/openclaw/openclaw/issues/85844 [6] OpenClaw Issue: macOS launchd Gateway still restarts via gateway-update/update.run — https://github.com/openclaw/openclaw/issues/86417 [7] OpenClaw Issue: gateway install –force overwrites NODE_EXTRA_CA_CERTS, breaking TLS trust on update — https://github.com/openclaw/openclaw/issues/86579 [8] Hermes Issue: Updated deleted all my cron — https://github.com/NousResearch/hermes-agent/issues/26737

Weiterführende Artikel