AI 101: Hermes vs OpenClaw: Local AI Agents Compared

There is a familiar pattern in AI, as in many fast-moving fields: one project helps define a category, and the next wave starts to explore different tradeoffs and directions. OpenClaw helped make the idea of a personal, self-hosted agent feel practical. For the first time, agents were helpful, proactive, and felt like a real extension of the workforce. OpenClaw truly conquered the space in a matter of weeks. And now it is time to challenge it. Quite a few people have reported switching to Hermes Agent by Nous Research, and we are here to investigate why, and whether it is worth it.

A lot of agents today have memory, but not many have a built-in mechanism for turning experience into reusable procedures automatically. Hermes Agent is asking: what happens if a local agent can improve through use, not just execute tasks and store memory? That sounds ambitious, and it is, because making that work requires more than just adding memory. It depends on a fairly sophisticated stack for capturing experience, organizing it, and turning it into behavior the agent can reuse.

In this piece, we will look at what it takes to build a self-improving local agent, how Hermes is designed to accumulate capabilities and skills over time, and what kind of memory system supports that process. We will also compare Hermes with OpenClaw to see where it actually stands, where it differs, and what each system is better suited for in a personal workflow.

In today’s episode:

Nous Research emerged informally in 2022 as an internet-native collective formed across Discord and Twitter, and was later formalized in 2023 with founders including Jeff Quesnelle, Karan Malhotra, Teknium, and Shivani Mitra. From the beginning, they positioned themselves as an open-source-first and decentralization-focused lab. Their goal was to build user-controlled AI, making intelligence widely accessible rather than concentrated in a few closed companies.

Their early work concentrated on the Hermes model series, but in parallel, Nous Research invested heavily in infrastructure and systems questions. With DisTrO (Distributed Training Over the Internet), they explored training models across globally distributed consumer GPUs, treating model training as a decentralized network problem. They developed large-scale simulation environments (e.g. WorldSim, Doomscroll), focusing on multi-agent interaction, long-horizon behavior, and emergent strategies.

Around 2024–2025, their work converges:

Hermes Agent is the logical synthesis of all prior threads. Now it is gaining popularity because it is the first real alternative to the OpenClaw local agent. And “real” means that before we’ve seen a lot of OpenClaw-style agents built around the same idea as OpenClaw. Hermes introduces many changes in the agent’s architecture, betting on another focus – everything is built around self-evaluation and for self-evaluation. Basically, it is an open-source autonomous agent that runs persistently on your own machine or server designed to remember across sessions, learn from experience in self-improvement loop, create and reuse skills, and use scheduled automation. But there is much more under the hood →

From the architectural side, Hermes chooses a new center of gravity, probably fulfilling the hopes of many users and developers who have been waiting for self-improving systems. But first, let’s refresh how today’s most popular OpenClaw agent is built.

For OpenClaw, the Gateway is a control plane – a single long-running process that owns sessions, routing, tool execution, and state. Everything flows through it.

Hermes, by contrast, defines the AIAgent loop itself as the core synchronous orchestration engine, with gateway, cron scheduler, tooling runtime, ACP (Agent Communication Protocol – a standardized way for external tools like code editors to talk to the agent) integration, SQLite-backed session persistence and Reinforcement Learning (RL) environments structured around it.

The difference is this: OpenClaw is organized around a central controller that coordinates everything, while Hermes puts the focus on the agent’s own execution loop – a repeatable “do, learn, improve” cycle – and builds the system around that.

Hermes Agent is portable and it is not tied to one app or one machine. You can simply run it:

While Hermes runs anywhere (see above), you can interact with it via messaging apps – Telegram, Discord, Slack, WhatsApp, Signal, and other connected interfaces – or through CLI. This decouples the assistant from your laptop: the compute happens remotely, but the interface stays lightweight and always available.

Hermes is model-agnostic, as well. You can plug in models from services like OpenAI, OpenRouter, Kimi Moonshot, MiniMax, GLM models, Nous Portal or your own custom endpoint. And notably, model selection is treated as configuration. So you can switch models with a command like “hermes model” instead of changing application code.

Hermes Agent is also a step toward a real interactive development environment for agents, because it includes a text user interface (TUI) with things like multiline editing, autocomplete for commands, conversation history, interrupting a running task, redirecting the agent mid-process, streaming tool output.

But these are not the features that make Hermes especially distinctive today →

The biggest focus and a defining feature at the heart of Hermes is self-improvement. Every set of interactions and tries, Hermes evaluates what worked, what didn’t work, what was useful, what user asked to correct. And here is the moment when we meet with agent’s “skills” again. OpenClaw also works with skills, which are reusable, mostly human-authored tool/workflow instructions loaded from several scopes like workspace, personal, shared, or plugins. Hermes has a different idea:

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.)

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.

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.

Resources from Turing Post