I wrote recently about how OpenClaw is bloated. 600,000 lines of code, 700+ community skills, and most people just use Telegram to chat with Claude. The post ended with a teaser about Hermes Agent from Nous Research, a project taking a fundamentally different approach to personal AI agents. Since then I've been running Hermes alongside my OpenClaw setup. The question everyone keeps asking is whether Hermes is the "OpenClaw killer." After a few weeks of daily use, I think the answer is more nuanced than a simple yes or no.

What Hermes actually is

Hermes Agent is an open-source, self-hosted AI agent built by Nous Research, the team behind some of the most popular fine-tuned open-source language models. It launched in February 2026 and has already crossed 95,000 GitHub stars, which is remarkable growth for a project that's barely two months old. The elevator pitch is simple: it's the only agent with a built-in learning loop. It creates skills from experience, improves them during use, nudges itself to persist knowledge, searches its own past conversations, and builds a deepening model of who you are across sessions. That sounds like marketing copy, and it is, straight from the README. But the difference with Hermes is that this actually works in practice.

The philosophical split

The cleanest way to understand the difference between OpenClaw and Hermes is this: OpenClaw treats an agent as a system to be orchestrated. Hermes treats an agent as a mind to be developed. OpenClaw wraps a language model in layers of tooling, memory, routing logic, and execution pipelines. The model itself is only one component in a broader architecture. It reasons and decides, while the surrounding system handles everything else. Hermes flips this. Instead of building complexity around the model, it pushes capability into the model itself. Tool usage, memory interaction, and execution patterns aren't externalized, they're internalized. The agent doesn't rely on a system to function. It embodies the system. This is a meaningful distinction. OpenClaw's gateway-first architecture means the gateway is the product and the AI model is a replaceable part. Hermes's agent-first architecture means the agent's own learning and execution loop is the product, and everything else, including the gateway, is just plumbing.

The learning loop in practice

Hermes has what it calls "procedural memory," a three-layer system that actually changes how the agent behaves over time. The first layer is conversation memory. Like OpenClaw, Hermes remembers past conversations and can search them. Nothing revolutionary here. Both use SQLite-backed full-text search to recall previous sessions. The second layer is the user model. Hermes builds and continuously updates a profile of who you are, your preferences, your project structures, your communication style. This is stored in a SOUL.md file, which is analogous to OpenClaw's MEMORY.md, but Hermes updates it automatically rather than requiring manual curation. The third layer is where it gets interesting: skills. After completing a non-trivial task, Hermes evaluates what happened and, if the approach was worth remembering, extracts the reasoning pattern as a named skill. These skills are structured templates that say "when context looks like this, this approach works." Future tasks search this library for relevant patterns, and skills are refined over time as new outcomes update what the best approach looks like. In practice this means Hermes gets noticeably better at tasks you do repeatedly. The first time you ask it to set up a new Next.js project with your preferred stack, it takes the usual back-and-forth. The third time, it remembers the entire pattern and just does it. No re-explaining, no forgotten preferences. OpenClaw's memory system, by contrast, is transparent but static. Every memory entry is a visible file you can inspect and edit. That's great for auditability. But the agent never improves its own approach. It remembers facts, not methods.

Architecture and security

Hermes supports five sandbox backends: local execution, Docker, SSH, Singularity, and Modal for serverless. Container hardening includes read-only root filesystems, dropped capabilities, and namespace isolation. There's a pre-execution scanner called Tirith that analyzes terminal commands before they run. Filesystem checkpoints create automatic snapshots before destructive operations, with rollback available if something goes wrong. Compare that to OpenClaw, which has had well-documented security issues. Cisco published a detailed analysis calling personal AI agents like OpenClaw a "security nightmare," specifically highlighting prompt injection vulnerabilities. When your agent has shell access, browser control, and file management capabilities, the attack surface is enormous. OpenClaw's approach of making the LLM handle everything, including security decisions, is a design choice that trades safety for simplicity. Hermes takes security more seriously because Nous Research comes from the model training side of the industry. They understand what language models are actually good at and, more importantly, what they're not good at. Delegating security decisions to an LLM is something they explicitly avoid.

The token problem

Here's where Hermes stumbles. Multiple users on Reddit report that Hermes burns through tokens at a rate that makes even OpenClaw look efficient. One user running GPT-5.4 Mini described the token usage as "genuinely crazy," even for what felt like simple single-pass tasks. The learning loop has a cost. Every time Hermes evaluates whether to create a skill, refines an existing one, updates your user model, or searches past conversations for relevant patterns, that's additional LLM inference. The agent is doing more thinking per task than OpenClaw, and thinking costs tokens. Hermes is also notably more multi-turn than OpenClaw. It asks for clarification more often, sometimes keeps going when the task should already be complete, and generally behaves like it's trying harder. Whether that's a feature or a bug depends on your patience and your API budget. The counterargument is that this front-loaded cost pays off over time. If Hermes learns a workflow in three sessions that OpenClaw needs you to manually configure and maintain forever, the total cost might actually be lower. But that's a bet on the future versus paying real money today.

What Hermes does better

The self-improvement loop is real and it works. For repetitive workflows, code reviews, data processing, project scaffolding, deployment pipelines, Hermes genuinely gets better the longer you use it. This isn't theoretical. You can watch the skills library grow and see the agent applying learned patterns to new tasks. The security architecture is meaningfully stronger. Five sandbox backends, pre-execution scanning, and filesystem checkpoints give you defense-in-depth that OpenClaw simply doesn't offer. Setup is arguably easier. Multiple comparisons note that Hermes works more "out of the box" than OpenClaw, which can require significant configuration to get working well. Hermes's v0.10.0 release added a Tool Gateway that lets paid Nous Portal subscribers use web search, image generation, text-to-speech, and browser automation through their existing subscription with zero additional API keys. The skills ecosystem follows the open agentskills.io standard, which means skills are portable to any agent that implements the spec. OpenClaw skills are locked to OpenClaw.

What OpenClaw still does better

Channel breadth. OpenClaw supports over 30 messaging platforms out of the box. Hermes covers the major ones, Telegram, Discord, Slack, WhatsApp, Signal, but the long tail of integrations isn't there yet. Ecosystem size. OpenClaw has 345,000+ GitHub stars and a massive community. The skill marketplace, while mostly unused by individual users, represents a library of solved problems that Hermes's younger community hasn't built yet. Multi-agent orchestration. OpenClaw's gateway-first design is naturally better at coordinating multiple agents across channels with access controls. Hermes is designed around a single agent that improves deeply, not a fleet of agents that coordinate broadly. Transparency. OpenClaw's file-based memory system lets you see exactly what the agent knows and edit it directly. Hermes's automatic memory management is convenient but opaque. Some users find it unsettling that they can't easily inspect what the agent has learned about them.

So is it the OpenClaw killer?

No. But it might be something more important: the proof that a different approach works. OpenClaw bet on breadth. Connect to everything, support every channel, build the largest skill ecosystem, and let the community figure out the rest. That bet paid off in stars and adoption. But it also created a bloated, fragile system where the core value, a useful AI agent, is buried under layers of integration scaffolding. Hermes bet on depth. One agent that gets genuinely smarter over time, with proper sandboxing, portable skills, and a clean architecture. It has fewer integrations, a smaller community, and higher token costs. But it solves the problem that OpenClaw never did: making the agent itself better, not just the system around it. The interesting thing is that these approaches are converging. Both projects have adopted the same skill format. Both are compatible with the Open Gateway Protocol (OGP), a lightweight federation layer that lets agents on different frameworks exchange signed, cryptographically-verified messages. An OpenClaw agent and a Hermes agent can already talk to each other. The future probably isn't one killer agent framework. It's a world where different agent runtimes specialize in what they're good at and federate when they need capabilities they don't have. OpenClaw as the orchestration layer. Hermes as the learning agent. Claude Code for raw coding power. Each doing what it does best. The real OpenClaw killer isn't Hermes. It's the realization that the "everything agent" approach was never the right one. The next generation of personal AI isn't about one tool that does it all. It's about sharp tools that compose well. Hermes is one of those sharp tools. If you care about an agent that learns your patterns and improves over time, it's the best option available today. If you need to orchestrate a fleet of agents across 30 messaging platforms, OpenClaw is still your thing. Pick the right tool for the right job.

References