A long-form guide to the open-source agent that’s reshaping how we think about autonomous AI

Introduction: The “Groundhog Day” problem of AI agents

Every developer who has worked seriously with an AI assistant has felt the same quiet frustration. You spend an afternoon teaching the agent the quirks of your codebase, your naming conventions, your deployment pipeline, and the legacy database schema nobody documented. Then you close the session. When you open a new one, most of that context is gone — and you start over.

This cycle of context loss and re-explanation has become one of the most persistent friction points in AI-assisted work. It’s like training a new intern every single morning, forever.

Two open-source projects attacked this problem from fundamentally different directions: OpenClaw, which proved that self-hosted agents could live on your infrastructure and run 24/7, and Hermes Agent, which proved that an agent doesn’t have to start from scratch on every task. This post is a deep dive into Hermes — what it is, how it works, why it exploded in popularity, and exactly where it diverges from OpenClaw.

Part 1: What is Hermes Agent?

Hermes Agent is an open-source, self-improving autonomous AI agent built by Nous Research — the lab behind the Hermes, Nomos, and Psyche model families — and released in February 2026 under the MIT license.

The official framing is deliberately pointed: it’s not a coding copilot tethered to an IDE, and not a chatbot wrapper around a single API. Instead, it’s an autonomous agent that lives on your own server, remembers what it learns, and gets more capable the longer it runs. As one of its taglines puts it bluntly: “Not a chatbot. Not a copilot. An agent that lives on your machine and gets smarter every day.”

A few core principles define the project:

Self-hosted and private. All data stays on your machine. The project advertises no telemetry, no tracking, and no cloud lock-in.
Free forever, open source. One command to install, one command to start.
Model-agnostic. It works with Nous Portal, OpenRouter (200+ models), OpenAI, or your own endpoint — switchable with a single command, no code changes, no lock-in.
Built by model trainers. Beyond task automation, it doubles as a platform for generating training data, running RL experiments, and exporting trajectories for fine-tuning.

The adoption story

The numbers tell their own story. According to NVIDIA’s own reporting, Hermes Agent crossed 140,000 GitHub stars in under three months and became the most-used agent in the world according to OpenRouter. Independent write-ups describe a “migration wave” of developers moving away from OpenClaw, the previously dominant framework. Whatever the exact figures (different sources cite different star counts as the project grew week to week), the trajectory is unambiguous: this project hit a nerve.

Part 2: How Hermes actually works — the learning loop

The single most important concept in Hermes is its learning loop. This is the feature that separates it from nearly every other agent framework, and it’s worth understanding in detail.

Most agent frameworks follow a fixed cycle: receive task → plan → execute → return result. The session ends. Nothing is retained. The next task starts from the same baseline. Run the same type of task a hundred times and the agent doesn’t get better at it — it approaches each one as a brand-new problem.

Hermes adds a layer after execution. When it completes a complex task, it enters what Nous Research calls a “Reflective Phase.” The full cycle looks like this:

Experience — The agent completes a complex, multi-step task.
Evaluate — It analyzes its own performance and what actually happened.
Extract — It pulls out the reusable reasoning pattern.
Skill creation — It writes a new skill file encoding exactly how it solved the problem. Skills are structured templates: “when context looks like this, this approach works.”
Refine — As new evidence arrives, skills are updated. If a better approach consistently outperforms the stored one, the skill is revised.
Nudge — Periodic prompts encourage the agent to persist what it has learned.

The next time a similar task arrives, the agent queries its own skill library instead of reasoning from scratch. Institutional knowledge compounds across sessions. As one comparison put it memorably: OpenClaw stays the same while you use it; Hermes gets better.

The four standout capabilities

NVIDIA’s engineering blog highlighted four capabilities that set Hermes apart from typical agents:

Self-evolving skills. Every time the agent hits a complex task or receives feedback, it saves its learnings as a skill so it can adapt and improve over time.
Contained sub-agents. Hermes treats sub-agents as short-lived, isolated workers dedicated to a single sub-task — each with focused context and its own set of tools, enabling zero-context-cost pipelines.
User modeling. Across sessions, Hermes builds a representation of you — your preferences, decision history, and task patterns — so it becomes progressively more aligned without you re-instructing it every time. (It uses what’s described as “Honcho dialectic user modeling.”)
Cross-session recall. Full-text search over past sessions, with LLM summarization, so the agent can pull relevant history back into context.

The Curator (v0.12)

A later release, Hermes v0.12 — nicknamed the “Curator release” — doubled down on this thesis. The Curator is an autonomous system that maintains your skill library without manual intervention. It monitors skill usage patterns, identifies underperforming skills, suggests improvements, and can autonomously refactor skills based on rubric-based quality assessments. After 30 days of use, the pitch goes, a Hermes deployment is measurably better at your specific tasks than it was on day one.

Part 3: Where Hermes lives — platforms, backends, and tools

Hermes is built around the idea of being everywhere you are, while running wherever you want it to.

It lives where you do

From a single gateway process, Hermes connects to a remarkably long list of platforms: CLI, Telegram, Discord, Slack, WhatsApp, Signal, Matrix, Mattermost, Email, SMS, Microsoft Teams, Google Chat, and a growing list of others — described in its docs as 20+ platforms. You can start a task on one channel and pick it up on another, with voice-memo transcription and cross-platform conversation continuity built in.

It runs anywhere

Hermes supports six terminal backends: local execution, Docker containers, SSH, Daytona, Singularity, and Modal serverless environments. The serverless options (Daytona and Modal) offer hibernation when idle — your environment sleeps when not in use, costing nearly nothing. By contrast, OpenClaw primarily supports local and Docker execution.

Tools and extensibility

Out of the box it ships with 40+ built-in tools, including web search, browser automation, vision, image generation, and text-to-speech. It supports the Model Context Protocol (MCP) for connecting to external tool servers, and its skills are compatible with the agentskills.io open standard, making them portable and shareable via a community Skills Hub.

Hardware note

Because both the agent and the underlying model are designed to run locally, hardware quality directly shapes the experience. NVIDIA has positioned its RTX PCs and DGX Spark as ideal companions for always-on local Hermes deployments, particularly paired with efficient open-weight models like Alibaba’s Qwen 3.6 series, which deliver large-model intelligence in a much smaller memory footprint.

Part 4: The big comparison — Hermes Agent vs OpenClaw

This is the question most people actually want answered. The two projects overlap heavily — both are persistent, self-hosted agents that connect to messaging apps, call LLMs, execute tools, and maintain state. But their centers of gravity are fundamentally different.

One writer captured the inversion perfectly: “Hermes packages a gateway around a learning agent. OpenClaw packages an agent around a messaging gateway.” That single inversion drives most of the practical trade-offs.

Origins and philosophy

	Hermes Agent	OpenClaw
Built by	Nous Research	Community-driven; started by developer Peter Steinberger in late 2025
Released	February 2026	Late 2025
Language	Python	TypeScript / Node.js
License	MIT	Open source
Core thesis	A single agent that learns and improves over time	A gateway-first assistant platform with broad channel routing
Mental model	”A teammate that learns"	"A tool you configure”

Architecture: where the control sits

OpenClaw’s Gateway is the control plane — a single long-running Node.js process that owns sessions, routing, tool execution, and state. Everything flows through it. It routes messages from chat apps into a ReAct loop (reason → act → observe), stores memory as plain Markdown files searchable via SQLite, and uses a heartbeat cron job to wake the agent for proactive tasks.

Hermes, by contrast, defines the agent loop itself as the core orchestration engine. The gateway, scheduler, tooling runtime, session persistence, and RL environments are all structured around that loop. This means the learning cycle is a first-class architectural concern, not an afterthought bolted on.

Skills: the sharpest difference

This is the single biggest reason developers switch.

OpenClaw skills are static. They’re human-written files you create, review, install, and maintain. If a skill is wrong or incomplete, you edit it manually. OpenClaw later launched ClawHub, a marketplace of community-built plugins — emphasizing breadth, with hundreds (some sources cite thousands) of ready-made plugins covering nearly every use case.
Hermes skills are autonomous. The agent creates them from experience, refines them during use, and compounds them across sessions. The trade-off: you get depth on your specific workflows rather than instant breadth.

The clean summary from one analysis: OpenClaw prioritizes broad, reactive capability with low setup overhead and no native learning layer; Hermes prioritizes long-term improvement on a given task set.

Multi-agent model

This is where the worldviews diverge most sharply:

OpenClaw thinks in terms of organizations of agents. It supports persistent agent teams — a Slack agent, an email agent, a research agent, each with its own channel, bot identity, and persona, holding state and working together across sessions. For genuine multi-agent setups, this is the stronger architecture, and users running 5–10 agent fleets consistently cite it as the reason they stay.
Hermes uses a parent–subagent model. The main agent spins up isolated sub-agents for parallel execution, but those sub-agents don’t talk to each other. It’s optimized for delegation and zero-context-cost pipelines, not for a standing organization of communicating personas.

Setup and time-to-value

OpenClaw: Docker Compose gets you running in under 30 minutes. Web search and file tools work immediately. You’re doing real tasks the same day. Higher baseline capability out of the gate thanks to its ecosystem.
Hermes: A simple curl one-liner installs everything (uv, Python, the repo) with no sudo. But a full deployment with custom memory backends and integrations can take 2–4 hours to dial in. Lower starting capability that improves continuously.

The “crossover point” matters here: OpenClaw delivers faster time-to-value; Hermes’s compounding advantage pulls ahead the longer you use it on the same task set.

Security posture

Hermes ships a conservative, safer-by-default model: container hardening with read-only root filesystems, dropped capabilities, namespace isolation, filesystem checkpoints (automatic snapshots before destructive operations, with rollback), and a pre-execution scanner that analyzes terminal commands before they run. Its smaller, younger ecosystem also means a smaller attack surface.
OpenClaw’s breadth is also its risk: a much larger ecosystem and third-party plugin marketplace necessarily introduce more attack surface. Its viral scale made it a bigger target — a project with hundreds of thousands of stars naturally attracts more attackers than one with far fewer.

Cost (rough, illustrative)

For moderate solo usage, community estimates put a Hermes instance on a cheap VPS at roughly $30–65/month in API calls, versus an OpenClaw instance at roughly $40–80/month. The difference isn’t dramatic — the real question, as one writer noted, is whether you’d rather spend your time on Docker configuration or on working with the agent.

Community character

Hermes tends to attract developers deep in the LLM fine-tuning and agent-research space. Discussion is technical and detailed; features often come from people building serious production systems.
OpenClaw has a broader, more beginner-friendly community with more tutorials and starter guides.

⚠️ One shared caveat: neither project has a commercial backer, so long-term maintenance continuity is a genuine risk worth evaluating before you build something critical on either.

Part 5: So which should you choose?

After synthesizing community analysis (one breakdown read through 1,300+ Reddit comments), the honest answer is: there is no single winner. Both have real strengths and real problems, and the biggest pain point isn’t picking one — it’s self-hosting either of them. Here’s a practical framework:

Choose OpenClaw if you want to message your assistant from everywhere, need genuine multi-agent orchestration, want deterministic cron scheduling, or want immediate access to a large plugin ecosystem. Trade-off: more moving parts, heavier footprint, and setup/update complexity.

Choose Hermes if you want an agent that measurably improves at your tasks over time, need multiple sandbox backends (especially serverless options like Modal), value safer-by-default execution, or are doing research-style workflows with subagent delegation and rollback safety. Trade-off: smaller integration ecosystem, more setup effort, and self-evaluation that isn’t perfectly reliable.

Use both if you’re running complex setups. The configuration the community keeps converging on: OpenClaw as the orchestration layer (planning, scheduling, multi-channel routing) and Hermes as the execution agent for repeatable workflows where accumulated learning pays off. They complement each other more than they compete.

Migrating from OpenClaw

One nice detail for the switchers: Hermes can automatically import your OpenClaw settings, memories, skills, and API keys. Its setup wizard detects an existing ~/.openclaw directory and offers to migrate before configuration begins, with a dry-run preview so you can see exactly what would move before committing.

Conclusion: Two bets on what makes an agent valuable

Strip away the benchmarks and star counts, and what’s left is a genuine philosophical fork in the road.

OpenClaw made a bet on reach and breadth: be everywhere, support everything, lean on a big community of pre-built skills. It proved that developers want agents that outlive their browser tabs.

Hermes made a bet on depth and compounding: do fewer things, but get measurably better at them every single day. It proved that an agent doesn’t have to reset to zero every session.

Neither bet is wrong. The right answer depends entirely on whether your problem is coordination (OpenClaw’s strength) or automation that should improve over time (Hermes’s strength). What’s clear is that the era of the stateless, amnesiac agent — the one you re-train every morning like a new intern — is ending. And projects like Hermes are a big part of why.

Want a follow-up that goes deeper on any single piece — the Curator’s skill-refactoring internals, the security architecture, or a hands-on setup walkthrough? Each of those is a full post in its own right.