From last year into this year, the animal everyone in AI remembered was a lobster.
OpenClaw turned an AI that could only answer in a chat box into a digital colleague living inside everyday workflows. Have you raised a lobster yet? briefly became a greeting in social feeds and developer groups.
But if you have followed this space recently, you may have noticed another animal entering the conversation.
A popular line in the community puts it neatly: Silicon Valley has stopped raising lobsters and started raising horses. The joke comes from the Chinese transliteration of Hermes, which contains the character for horse. It spread for more than wordplay: both GitHub stars and OpenRouter usage, two public indicators, were rising.
That makes this a good time to take an engineering-selection perspective and expand lobster versus Hermes into a third path, examining what problem each design addresses.
The first article, From Raising Lobsters to Raising Crabs, answered why I built HexClaw. This one asks the next question: as OpenClaw and Hermes move forward, which layer does HexClaw occupy?
The Core Judgment
OpenClaw, Hermes, and HexClaw operate at different layers: entry-point distribution, cognitive self-learning, and the local workbench.
This article places the three paths on one architectural map rather than trying to prove one universally stronger.
A one-line selection guide:
For a multi-platform IM / Bot operation, start with OpenClaw。
For a self-learning Agent and long-task planning, start with Hermes。
For a desktop workbench without deployment maintenance that keeps data locally, start with HexClaw。
Why Hermes Gained Attention
First, Hermes (Hermes Agent). To enter the center of developer discussion so quickly, a product needs a clear proposition.
By its public numbers, Hermes was a remarkable open-source project:
- Quietly open-sourced by Nous Research during February–March 2026
- As of 2026-04-25, approximately 116k GitHub stars and 17k（
github.com/NousResearch/hermes-agent） - The OpenRouter application page showed approximately 4.4T Total tokens, ranking number 3（
openrouter.ai/apps/hermes-agent） - Native WeChat access through
iLink Bot APIwith QR-code sign-in
Dispute disclosure: Hermes Agent and EvoMap / Evolver have recently been involved in a similarity dispute. This article makes no finding; it discusses engineering tradeoffs using public repositories, documentation, and product forms. References appear at the end.
The numbers were not the only reason it spread. Hermes brought the self-learning Agent narrative of a Writable Runtime to the foreground.
A frequently cited summary is:
OpenClaw had been closer to a stable executor: give it a clear workflow and it keeps running. The problem was that it did not retain lessons; after completing a complex task once, it started from scratch next time.
Hermes took a different approach: automatically review completed tasks, distill experience into a reusable Skill file, and invoke that experience package for a similar problem later.
In plain terms, the aspiration Agent developers have repeated for two years—smarter with use—became a clear product proposition in Hermes.
Add QR-code WeChat access, a powerful entry point, and its rising profile in Chinese technical communities is unsurprising.
OpenClaw Was Not Replaced; the Division of Work Became Clearer
Architecturally, Hermes did not kill the lobster.
The two products do different work.
- OpenClaw's strength is reliably bringing AI into chat channels people already use: more than twenty platforms, over a hundred plugins, and multi-account operation. Discord administrators, community operators, operations / DevOps teams, and enterprise IT will often consider it first.
- Hermes focuses on making an individual Agent improve through continued use: coding, data analysis, and accumulating domain experience. It is more a center for planning, executing, and reviewing long tasks.
One common architectural combination is: let Hermes handle planning and learning, and OpenClaw handle distribution across entry points.
I agree, with one addition: that combination still needs a workbench connecting the capabilities to local workflows。
Our Animal Is a Crab
Existing readers can skip ahead. If HexClaw is new to you, here is the short introduction.
HexClaw is an open-source AI Agent stack that actually runs, and an engineering example developed with the 《Claude Code SOP》 methodology in the earlier article: design-driven development, a testing feedback loop, and multi-Agent collaboration. Previous articles covered installation, use, and architecture. This one concerns its place alongside OpenClaw and Hermes. It is Apache-2 licensed, locally deployed, and keeps data private.
First, the capability boundary, to distinguish shipping features from plans:
- Stable capabilities released in v0.3.12: chat, native MCP, Markdown Skills, RAG knowledge base, multi-Agent support, IM channels (the backend ecosystem includes additional adapters such as Slack; the desktop currently focuses on Feishu / DingTalk / WeCom / WeChat / Discord / Telegram), voice, and image / video generation
- v0.4.x roadmap (local validation / next-release goals): a Skill self-learning loop, Agent strategy routing, memory injection protection, classified error fallback, model tool-use capability detection, and runtime MCP management, discussed below
Its path differs from the other two.
OpenClaw uses Node.js and deploys through Docker / Fly.io / Render, aimed at Bot operators. Hermes uses Python but provides one-step installation scripts for Linux / macOS / WSL2 / Android Termux, without requiring users to prepare a Python environment. It suits technical users willing to run a gateway / server / container. Both follow a service-deployment path.
HexClaw has pursued another goal from day one: make an AI Agent ordinary desktop software, ready to work after clicking its icon just like a browser, WeChat, or WPS. That led to Go + Tauri and platform installers—DMG / MSI / AppImage—with no Docker, virtual environment, or systemd setup.
The three directions become clearer in this comparison:
OpenClaw excels at putting AI inside your IM stream。
Hermes excels at making an individual Agent improve with use。
HexClaw aims to put those capabilities into a local workbench that runs without operations expertise。
Externally, I call the core engine Hexagon Agent; its repository remains hexagon. Underneath is a six-repository hierarchy: toolkit → ai-core → hexagon → hexclaw → hexclaw-desktop / hexagon-ui . The first four layers are Go repositories, independently versioned and independently go get. The desktop and observability UI build and release separately. The details are in Architecture Deep Dive and are not repeated here.
Three Paths, Three Layers
Strictly speaking, these products are not all competing for the same ground. In a layered system, each occupies a different position:
OpenClaw = entry / distribution layer
Hermes = cognition / self-learning layer
HexClaw = local workbench / private-data foundation
——No product fills the entire three-layer stack. Choose according to the layer you need to address.
Once that distinction is clear, much of the apparent dilemma disappears: they solve problems at different points in the stack rather than simply replacing each other. Here is the detailed comparison.
The 30-Second Version
- OpenClaw: TypeScript / Node.js. Brings AI into existing IM entry points; multiple platforms, accounts, and coordinated operations are its home territory.
- Hermes: Python, packaged as a one-step installation. Focuses on making an individual Agent more accurate with use; Writable Runtime is the central proposition.
- HexClaw: Go + Tauri, Sidecar architecture, double-click DMG / MSI / AppImage installation. A desktop workbench that stays local, requires no operations expertise, and keeps data on the machine.
The 30-second version is enough for mobile readers. The following three profiles provide a fuller reference for those who want the details.
OpenClaw: Entry / Distribution Layer
Position: a multi-platform IM Bot foundation
Team: Peter Steinberger / OpenClaw community
License: MIT
Main language: TypeScript / Node.js
Deployment: Docker / Fly.io / Render / Podman
IM coverage: Telegram / Discord / Slack / WhatsApp / Signal / iMessage / Feishu / LINE / Matrix / IRC, and others
Extensions: a mature extension-package system with sustained community iteration
Typical users: Bot operators / community administrators / enterprise IT
Design: Adapter Capabilities abstraction and declarative capability coordination
Tradeoff: many configuration options and a steep learning curve
Hermes: Cognition / Self-Learning Layer
Position: a self-evolving Agent framework
Team: Nous Research (an AI research organization)
License: MIT
Main language: Python
Deployment: one-step installation scripts (Linux / macOS / WSL2 / Android Termux)
IM coverage: multi-platform gateway, including WeChat
Extensions: multiple providers and extensive tool modules, continually expanded by the official team
Typical users: AI engineers / researchers / advanced enthusiasts
Design: Writable Runtime and dynamic Skill writeback
Tradeoff: operating a persistent gateway / server; Agent-generated Skill changes require auditing
HexClaw: Local Workbench / Private-Data Foundation
Position: a local desktop Agent workbench
Team: hexagon-codes
License: Apache-2.0
Main languages: Go + Tauri
Deployment: double-click DMG / MSI / AppImage installation
IM coverage: the desktop focuses on Feishu / DingTalk / WeCom / WeChat / Discord / Telegram; backend adapters cover more platforms, including Slack
Extensions: Markdown Skills and native MCP; a Skill self-learning loop is on the v0.4.x roadmap
Typical users: individuals / small teams / always-on local use
Design: Sidecar architecture, a single Go binary, and a Tauri frontend
Tradeoff: an early-stage ecosystem, with the Skill collection still growing
Note: IM coverage, extension ecosystems, and similar entries are broad classifications based on official documentation and current repositories, not a rigorous benchmark. Platform, provider, and tool-module counts measure different things across these projects. Apply the comparison to your actual needs.
In everyday terms:
For running many accounts across platforms and messaging large audiences, choose OpenClaw.
For an Agent that gradually adapts to your workflows and preferences, choose Hermes.
For a workbench on your machine that keeps data local and requires no operations expertise, choose HexClaw.
These paths are compatible rather than mutually exclusive. A later section discusses how they could theoretically work together.
One Design Worth Studying in Each of OpenClaw and Hermes
Set aside popularity rankings. The most useful lessons in OpenClaw and Hermes are two foundational design ideas relevant to anyone building Agents.
OpenClaw: Declare Capability Differences
Feishu, Discord, Slack, Telegram, WhatsApp, and Matrix each behave differently: rich-text buttons, editing sent messages, message-length limits, threads, and card protocols vary. A common older approach put separate branches in every adapter, forcing Agent callers to work out the current platform and available actions.
OpenClaw instead elevates those differences into declarative Capabilities. Adapters declare what they support. The engine uses those declarations to select fallbacks and rendering and enforce length limits. The Agent can concentrate on its task without caring where it runs.
It is a clean abstraction built on a deeper judgment than merely supporting many platforms: the hard part of a multi-platform Agent is capability coordination, not connection. That explains how it stays stable across more than twenty platforms: the abstraction keeps that complexity outside the Agent.
Hermes: Treat Skills as Growing Assets
The industry has repeated that Agents should get smarter with use for two years. Hermes deserves attention because it made that idea a clear product feedback loop.
A Skill is not configuration written once and frozen; it is an engineering asset that keeps evolving. If a Skill performs poorly during a task, the Agent distills a patch and writes it to the Skill library for reuse. Once that cycle runs, a static configuration becomes a continually improving capability library.
The mechanism is not technically elaborate: assess, distill, write back. The harder decision is letting an Agent modify itself in real projects and putting it into many developers' hands. Crossing from a familiar idea into broad public discussion helped it gain a six-figure star count quickly.
What These Two Choices Teach
Together, they highlight two frequently neglected foundations:
- Adapter design determines whether you can support N platforms comfortably or maintain N branches that overwhelm the project
- The Skill lifecycle determines whether an Agent becomes easier to use or increasingly redundant
These principles cross languages, stacks, and projects. TypeScript, Python, and Go implement them differently, but understanding both layers clarifies the product's direction.
OpenClaw is written in TypeScript, Hermes in Python, and HexClaw in Go, with its own Go Agent engine underneath: Hexagon Agent (repository hexagon, under development since last year). Languages, engines, and deployment forms differ. Engineering problems can be compared; code and attribution cannot simply be transplanted. This article does not adjudicate originality disputes between external projects. It discusses architectural choices visible in public materials. Implementing a lesson in HexClaw still requires adapting it to its own Go engine, desktop form, and security boundaries.
HexClaw's Approach to a Writable Runtime
HexClaw has also been pursuing the question of making Skills more accurate with use. Its name for that work is the Skill self-learning loop, being introduced progressively in v0.4.x.
The goal is clear: make Skills improve through use。
The implementation takes a slower, more reviewable route.
Hermes follows a Python approach: when a runtime result is insufficient, the Agent generates patch code and writes it into a dynamic Skill library for the next call. It is automatic and learns quickly, fitting Python's natural ability to modify itself at runtime.
HexClaw uses Go, so v0.4.x favors a plain approach consistent with Go engineering. The existing SkillWriter can already create Skills and scan them before writing. Next it will join a fuller loop: an LLM-as-judge scores a completed Skill run, then produces a reviewable v2 draft if the score is low, rather than silently replacing the original at runtime. Open the draft, merge it into the skills directory if it is good, or delete it if not. If you regret a change later, git a rollback restores it.
This is slower, but the benefit is clear: you can always see, change, and stop the Agent's modifications to itself. For a desktop workbench intended for long-term use, visible self-improvement is more reassuring than silent changes.
Two other pieces are needed along the local-workbench path:
One is progressive loading. Once many Skills exist, loading all of them into every context is impractical. The design loads only a lightweight index at startup, roughly 20 tokens per Skill, and expands a Skill when it is needed.
The other is compositional learning. Improving one Skill is only the first layer. If you repeatedly call A, then B, then C, HexClaw can distill that sequence into a meta-Skill draft for review. Whether to keep it remains your decision.
Neither sounds as striking as Writable Runtime, but for someone using the Agent daily, they may be more useful than promises to automate everything.
Other Foundations Being Built for v0.4.x
Status disclosure: the following is the v0.4.x roadmap. Some items have been validated in local development; others target the next release. The published v0.3.12 does not include all of them. Refer to CHANGELOG.md and the release notes for exact status.
Beyond the Skill loop, v0.4.x includes other work. These are less novel features than foundational engineering for an Agent intended to stay in use——
- Agent strategy routing. The Hexagon Agent engine already provides ReAct, Plan-and-Execute, Reflection, Deep, Supervisor, Sequential, Parallel, Loop, and other Agent constructions. HexClaw's v0.4.x initially focuses on four strategies around the current ReAct engine: auto / react / plan-execute / reflection, selected automatically by task or manually in settings.
- Memory injection protection. Long-lived memory becomes an attack surface. XML tags and a system note tell the model that memory is reference material rather than new instructions.
- Error classification and fallback. A 429, 402, or 503 is handled by cause, with backoff, credential changes, context compression, or provider switching rather than indiscriminate retry.
- Model tool-use detection. Some local models imitate a tool call without executing it. A small probe shows a ✅ / ⚠️ / ❌ badge in settings to avoid misleading users.
- Runtime MCP management. MCP servers can be added or removed at runtime, normally without a restart. Disconnections are checked for reconnection every 30 seconds.
These details sound like engineering housekeeping, but they strongly influence whether a local workbench remains useful over time.
They also explain my emphasis on boundaries. More capable Agents need permission control: tool approvals, MCP command allowlists, scans before Skill writes, memory injection protection, and error fallback may be less eye-catching, but affect whether an Agent can keep running on a personal machine.
How the Three Paths Could Work Together
This is an architectural proposal, not an existing official integration. The three can fit into one engineering diagram because their responsibilities differ.
Agent projects have become composable in recent years because open interfaces such as MCP, HTTP / SSE, and OpenAI-compatible APIs have become a shared language, not because everyone uses one framework.
In simple terms: HexClaw provides the local foundation, Hermes handles deep tasks, and OpenClaw sends results to chat channels.Open interfaces let each do its own work without replacing the others.
One practical arrangement would be:
- Run HexClaw on an always-on local machine, such as a Mac mini, NUC, or small server, as the home for its Go sidecar, Ollama models,
MCPhub, knowledge base, and Skills, exposing capabilities through local REST / WebSocket / MCP SSE interfaces. - Delegate long tasks needing substantial planning and reflection through the standard
OpenAI-compatibleprotocol to Hermes, for Skill writeback and multi-step reasoning. - Use OpenClaw for multi-platform distribution, account matrices, and chat entry points. HexClaw passes upstream conclusions through HTTP, and OpenClaw applies its Adapter Capabilities for fallback and rendering.
All communication uses existing open protocols: HTTP, WebSocket, SSE, MCP, and OpenAI-compatible APIs. None needs to lock another in.Clear boundaries let them run independently and make failures easier to locate。
Closing Thoughts
OpenClaw connects entry points, Hermes retains lessons, and HexClaw anchors local work.
In the 2026 open-source Agent space, OpenClaw and Hermes have each advanced a foundational layer: declarative abstraction of multi-platform capabilities, and dynamic Skill lifecycles. Few projects have made both layers solid.
HexClaw's path—a persistent local desktop workbench, a single Go binary, Sidecar architecture, and six-repository layering—addresses another foundation: making a local Agent workbench usable without operations expertise. Upcoming versions will go deeper into specific scenarios, discussed in the next article.
If what you need is a long-running Agent workbench on your computer, rather than a Bot matrix or a research-oriented self-learning framework, download the appropriate installer from GitHub Releases:
DMG / MSI / AppImage：github.com/hexagon-codes/hexclaw-desktop/releases
macOS users can also use the one-step installation script:
curl -fsSL https://raw.githubusercontent.com/hexagon-codes/hexclaw-desktop/main/install.sh | bash
Further Reading — Earlier articles in the HexClaw series:
- Claude Code SOP — Design-driven development, testing feedback, and multi-Agent collaboration
- Architecture Deep Dive — One person, Claude Code, five months, six repositories
- From Raising Lobsters to Raising Crabs — Product launch and the OpenClaw starting point
- The Thinking Process — The last mile for Qwen / Gemma / DeepSeek-R1
- Complete Guide — From zero to a working local Agent in five minutes
- Former Leader Skill — Distilling a leader into an AI Skill
References
- OpenClaw source and documentation:
github.com/openclaw/openclaw/docs.openclaw.ai - Hermes Agent source and documentation:
github.com/NousResearch/hermes-agent/hermes-agent.nousresearch.com - Nous Research website:
nousresearch.com - OpenRouter Hermes Agent application page:
openrouter.ai/apps/hermes-agent - MCP protocol specification:
modelcontextprotocol.io - Hermes WeChat and other integrations: see the integrations section of the official Hermes documentation
- References on the Hermes / Evolver dispute: EvoMap similarity analysis、EvoMap/evolver、Official Hermes Agent repository、Yicai report
- HexClaw source and documentation:
github.com/hexagon-codes/hexclaw-desktop/hexclaw.net
External-project data in this article was checked on 2026-04-25. Upstream repositories and official platforms remain authoritative.