AI 101: Hermes Agent vs OpenClaw: Local AI Agents Compared

Key concepts in this article

Subscribe for weekly operator-grade AI systems analysis

Don’t settle for shallow articles. Learn the basics and go deeper with us. Truly understanding things is deeply satisfying.

Join Premium members from top companies like Microsoft, NVIDIA, Google, Hugging Face, OpenAI, a16z, plus AI labs such as Ai2, MIT, Berkeley, .gov, and thousands of others to really understand what’s going on in AI. 

completed workflows can be abstracted into skills. They become reusable procedures (procedural knowledge) that encode multi-step behavior.

The system generates new skills from experience, refines them during execution, and is used as a living memory layer in ~/.hermes/skills/. The agent can create, refine, and call skills on demand via the “skill_manage” tool as it learns across sessions. Additional skills can also be installed through the Skills Hub, which integrates multiple registries and follows the agentskills.io open standard.

So Hermes is transparent in how it goes through the workflow, showing you all the steps and gaining skills on the fly. And the general idea is that quantity turns into quality: the more Hermes works and the more you run it, the more it improves. Conceptually, this shifts the agent from episodic recall toward procedural abstraction, or, in other words, from remembering facts to remembering methods.

Hermes treats memory as a layered system of persistence. Actually, it has three memory layers:

Before compressing long conversations, Hermes performs a “memory flush” step, where the model is given a chance to extract and persist important long-term information into MEMORY.md or USER.md.

Interestingly, skills can be seen as a fourth layer of memory stack. They sit adjacent to it as a separate layer of procedural memory, because they don’t store what the agent knows, they store what it has learned to do – the reusable workflows, showing how to act.

Hermes memory stack is more structured than naive inconsistent “chat history” storage. The key design principle behind this architecture is to keep the prompt stable for caching and push everything else out of the prompt into tools and retrieval systems. That’s why Hermes Agent keeps always-on memory small and curated, and treats everything else as searchable history. Everything is optimized for token efficiency plus retrieval on demand, so memory becomes searchable, compressible, and selectively re-injectable into the reasoning loop.

OpenClaw memory, in contrast, is grounded in Markdown files that act as the canonical source of truth. On top of this, a hybrid retrieval system indexes both memory files and session transcripts → we’ve covered OpenClaw in more details here.

Both Hermes and OpenClaw use a SOUL.md file that defines identity, which may hint at their similarity in this aspect, but they anchor it differently.

In Hermes, SOUL.md lives in HERMES_HOME, defines the primary identity, and occupies slot #1 in the system prompt. The main thing is that it is intentionally global to the Hermes instance rather than tied to the current working directory. So Hermes’ personality is a property that belongs to the agent itself.

In OpenClaw, SOUL.md is a workspace file. It lives alongside other files like AGENTS.md, USER.md, TOOLS.md, HEARTBEAT.md, MEMORY.md, skills, and daily notes that define behavior and context. OpenClaw’s identity is durable, yes, but it is tied to the workspace the agent inhabits, rather than globally abstracted above it at the instance level.

To summarize: Hermes has one personality that stays the same everywhere, while OpenClaw’s personality depends on the specific workspace it is working in. (Neither is better in general. It depends on whether you think in terms of “projects” or “agents.”)

The thing that many want from agents today is automation and concrete results on a regular basis. Hermes architecture naturally extends into automation.

It includes a built-in cron system that allows tasks to be specified in natural language and executed recurrently. Jobs are stored in “~/.hermes/cron/jobs.json”, the gateway ticks every 60 seconds, and due jobs run in fresh, isolated agent sessions. Results can be delivered back to the originating chat, saved locally, or sent to configured platforms. This is detached, scheduled agent work: reports, checks, recurring tasks, and automations that behave like discrete jobs.

Safety issues were a major sticking point when OpenClaw was just released: unrestricted tool use, risky autonomy, secret exposure, prompt injection, lack of proper isolation. Too much power, but not enough guardrails by default. Its guidance emphasizes operator responsibility with tight tool policies, sandboxing, careful permissions, and controlled deployment boundaries. (The OpenClaw maintainers and Peter Steinberger are constantly working to improve that).

It seems that Hermes found a loophole that makes it feel more ready for people who want a safer-by-default long-running agent on a server. It presents a five-layer defense-in-depth model:

Hermes extends that baseline with SSRF (Server-Side Request Forgery) protections, website blocklists, environment-variable filtering, messaging-user pairing, and pre-execution scanning for risky commands. The overall posture is designed for long-running agents that may operate across messaging surfaces, tool backends, and more exposed environments.

On top of its local agent capabilities, Hermes can be seen not only as an application layer, but also as a form of research infrastructure. By capturing trajectories, sequences of prompts, actions, tool calls, and outputs, it helps collect data that can later be used to train or improve agentic systems. It also includes a large set of built-in tools, including ones useful for ML engineers, which makes it convenient for those who want to experiment with and adapt the models they work with. In that sense, Hermes paired with open models can become a strong environment for fine-tuning (though it still requires additional work to turn raw trajectories into high-quality training data.) For a deeper look at how AI agents execute actions through UI tools, API calls, and function calling, see our guide to AI agent actions and frameworks.

Hermes is designed to be operational almost immediately. Installation is reduced to a single command, with configuration handled through a unified CLI.

This one command takes care of everything for you: pulls the repo, sets up Python and Node dependencies, creates a virtual environment, and installs a global Hermes CLI.

The only thing you need beforehand is a Git tool that downloads code from GitHub (simply because Hermes Agent lives on GitHub). Also, it doesn’t support Native Windows, so for that you will need to install WSL2.

Once installed, you reload your terminal and run hermes to start chatting with the agent.

Manual setup is also available, but the default path is intentionally minimal. One command, a configured environment, and a working agent in under a couple of minutes.

There is one more interesting feature. Hermes is explicitly aimed at the same self-hosted personal-assistant territory as OpenClaw, and in fact, you can easily switch from OpenClaw to Hermes. Hermes can detect an existing “~/.openclaw setup” during onboarding and offer to migrate the main OpenClaw files and settings, importing memory files, automatically converting them from Markdown to SQLite, and bringing skills and user preferences as well.

This looks like a direct attempt to win the same users with a different architectural bet. All this together lowers the barrier to adoption while preserving accumulated agent knowledge.

So what do we have as a result if we explicitly compare the two much-talked-about agents?

Both systems operate in the same space – self-hosted agents with messaging interfaces, tools, memory, and automation – but they emphasize different things. OpenClaw puts identity and behavior into a file-backed workspace, making the agent inspectable, traceable and versionable. Hermes, in contrast, leans toward structuring the runtime itself: it splits things like prompts, tools, memory, and interfaces into separate systems, and extends the agent into scheduling, editor integrations, and even training.

The most important differences to pay attention to are, of course, skill building and memory:

So if OpenClaw feels like “your agent, under your rules,” Hermes feels like “your agent, but increasingly shaped by accumulated workflows.”

Some users also noticed that Hermes works faster than OpenClaw, but at the same time OpenClaw is more stable.

Another aspect that may matter for tech and less-tech people is that Hermes is pre-configured, while in OpenClaw you need to do all the configuration yourself.

However, another point goes to OpenClaw for its larger infrastructure and stronger backing, with NVIDIA and OpenAI providing resources. The recent list of updates on GitHub from 2026.3.22 is just insane.

Putting all Hermes’ capabilities together, Hermes system can act as an interactive assistant, a tool-using agent, an editor-integrated helper, or a trajectory generator for training, not by switching modes, but by exposing different layers of the same runtime.

Here are some interesting use cases for Hermes:

You could fairly point out that you can do more or less the same things with OpenClaw. So what’s the point then? It comes down to the choice of paradigm and the core workflow idea →

Hermes offers much more potential for system growth through self-evolution. After a couple of weeks of active use, you can come back to an updated set of skills that the agent has developed itself, also shaped by your feedback. Its specific layered approach to memory makes this easier to maintain. However, if you care more about direct control and the ability to manually shape the system’s skills, then stick to OpenClaw.

In terms of identity, if you run one main assistant that should “be itself” everywhere, Hermes has a neat model. If you think in terms of agent workspaces as durable homes with files, habits, and daily notes, OpenClaw’s framing is stronger.

Scheduling also matters. If your goal is “run jobs on a schedule and deliver outputs,” Hermes has the cleaner default story. If your goal is “have my assistant periodically review life context and only ping when something matters,” OpenClaw still has a more convenient native concept.

Another aspect to base your choice on is security. The philosophical split is less about whether security exists in both systems, and more about emphasis. Hermes foregrounds layered safeguards with five layers of security and safer defaults. It is more explicitly safety-structured for persistent server-side deployment. OpenClaw’s philosophy foregrounds control, inspectability, and the assumption that the operator understands the risks of delegated tool authority. It is a powerful operator-driven system that can be hardened deeply, but expects that hardening to be part of how you run it.

Since Hermes is also a research agent, it is seen as more suitable for developers, while OpenClaw is more for everyone.

And if we sum up everything that we discussed:

But our advice is: don’t limit yourself. Use both agents. You can run them in parallel, reuse outputs across systems, and even connect them if you set up a lightweight interface between them. That is part of the real beauty of this new agentic world.

Hermes is truly exciting, but it is not magic. Its own docs show that it still requires setup discipline, native Windows is not supported, tool execution remains risky without approvals or container isolation, and that memory is intentionally constrained. The learning loop is powerful as a concept, but there is still a typical bottleneck: self-improvement helps if the model, tools, and guardrails are good enough to make the right things reusable.

On June 5, the v0.16.0 “Surface Release” shipped Hermes Agent as a native desktop app for macOS, Linux, and Windows. It also remote gateway login, browser-based admin controls, and full Simplified Chinese UI support. The release itself was huge and interesting: 874 commits, 542 merged PRs, 1,962 files changed, 399 issues closed, and 170 community contributors.

By June 2026, Hermes Agent overtook OpenClaw on OpenRouter’s global daily app and agent rankings by usage volume: 224 billion daily tokens compared with OpenClaw's 186 billion. As of June 14, 2026, the official OpenRouter app page shows Daily global rank #1 with 18.2T total tokens compared with OpenClaw's 4.96T tokens, and activity since March 2026.

The project also grew unusually fast. Within only a few months of its initial GitHub release, Hermes accumulated well over 193,000 stars and 33,6 forks, while, attracted hundreds of contributors, and shipped multiple major releases. For a local agent project, that level of adoption matters because a larger contributor base leads to faster bxug fixes and a richer ecosystem of workflows and tools.

Velocity Release from May 28,2026 made Hermes faster for the community to build on and more modular. Its huge run_agent.py file shrank by 76%, from 16,083 lines to 3,821, split across 14 cleaner agent modules. Startup became faster, per-conversation function calls dropped by 47%, and session_search became 4,500× faster and free.

This release also pushed Hermes deeper into agentic workflows. Kanban – a board-based workflow where AI agents split work into tasks, move them through stages like To do → In progress → Done, and coordinate like a project team – became a real multi-agent platform.

In Hermes, Kanban means where AI agents split work into tasks, move them through stages like To do → In progress → Done, and coordinate like a project team.

Another reason Hermes entered the conversation was the HERMES.md billing incident around Claude Code. On April 25, 2026, a user reported that the exact string “HERMES.md” appearing in local Git commit history could cause Claude Code to route usage outside a fixed Claude Max subscription and into pay-as-you-go billing.

The user was charged $200.98 while more than 86% of their Max 20x weekly capacity was still unused. The issue was reproducible on Claude Code v2.1.119 on macOS Apple Silicon, including with claude-opus-4-6[1m] and claude-opus-4-7. Anthropic support initially denied a refund, describing the issue as a "non-refundable technical error." Anthropic acknowledged the issue and promised refunds plus additional credits.

By June 2026, the incident had become part of the broader discussion around AI coding agents. Many users searching for Hermes are not only asking “What is Hermes Agent?” or “Is Hermes better than OpenClaw?” They are also asking: What happened with Anthropic and Hermes? And the answer is that this was not a flaw in Hermes Agent itself. It was a Claude Code billing-routing bug apparently triggered by HERMES.md appearing in Git history, and server-side billing logic treated that string as a signal of third-party tool usage.

Hermes’ rise also needs the OpenClaw security context. In March 2026, multiple security reports and analyses described a cluster of OpenClaw vulnerabilities. One account summarized the period as nine CVEs (Common Vulnerabilities and Exposures) disclosed in four days, including a critical vulnerability with a CVSS 9.9 score.

This doesn’t mean OpenClaw is unusable or that Hermes is automatically safer in every deployment. OpenClaw is still more mature in some parts of the ecosystem, especially around integrations and workspace-native control. But the CVE cluster changed the risk calculation for some developers.

For users running local agents with filesystem access, shell access, credentials, messaging interfaces, and long-running background processes, security is not a side issue. It is central to the choice. Hermes’ pitch – safer defaults, authorization, approval checks, filtering, and context scanning – became more attractive precisely because OpenClaw’s attack surface was under public scrutiny.

So Hermes vs OpenClaw decision is about adoption velocity, billing trust, security posture.

The real difference between Hermes and OpenClaw is not just a list of features. It is a different idea of what a personal agent should become. OpenClaw made self-hosted agents practical by giving users a strong sense of control, structure, and workspace-native identity. Hermes pushes in another direction: it treats the agent as a system that should accumulate ability over time, not only execute tasks.

Hermes is an early sign that the local agent category is shifting from helpful assistant software toward compounding personal infrastructure. The next serious competition in this space will likely not be about who has more integrations or better chat UX, but about which systems can turn repeated use into durable capability without becoming opaque or unreliable. It may also be about whether the next generation can combine both: direct user control and compounding capability, without forcing a tradeoff. That is still the architecture to watch. Meanwhile, we are excited to heavily use both of the agents.

Sources and further reading

Resources from Turing Post

Hermes Agent is an open-source, self-hosted personal AI agent built by Nous Research. It runs persistently on your machine or server, remembers context across sessions, and improves its own behavior over time by converting successful workflows into reusable procedural skills. It is model-agnostic and works with OpenAI, OpenRouter, and custom model endpoints.

Hermes Agent's core capabilities include a self-improving loop that builds reusable skills from experience, a layered memory system (persistent notes, searchable session history, and procedural skills stored in SQLite), cron-based scheduling for recurring tasks, and multi-platform interfaces including Telegram, Discord, Slack, WhatsApp, and CLI. It also includes safety defaults: user authorization, approval checks, and credential filtering.

OpenClaw is organized around a central gateway that controls all sessions and routing. Hermes is built around the agent's own execution loop — a "do, learn, improve" cycle — and treats self-improvement as the primary design principle. Hermes is better for long-running autonomous workflows that compound through use; OpenClaw is better for tighter manual control and workspace-native assistant behavior.

SOUL.md is a file that defines the agent's identity and personality — its tone, communication style, and behavioral defaults. In Hermes, it is global to the agent instance rather than tied to a specific workspace, meaning the agent's personality stays consistent regardless of which project or environment it is running in.

Hermes Agent is developed by Nous Research, an open-source AI lab founded in 2023 by Jeff Quesnelle, Karan Malhotra, Teknium, and Shivani Mitra. Nous Research is known for the Hermes model series and a focus on decentralized, user-controlled AI systems.