Hermes Agent Review: Self-Improving Open-Source AI Agent

What Is Hermes Agent?#

Hermes Agent is Nous Research's open-source AI agent framework, released February 25, 2026. It became one of the fastest-growing agent frameworks of 2026, reaching roughly 95,600 GitHub stars in about seven weeks — check the repository for the live count, since star totals move daily. The framework is built around a single idea that most agent tools have ignored: an agent should get better at your specific workflow over time, not just execute instructions more reliably. Hermes Agent does this through a closed learning loop that automatically generates reusable skills from experience, refines those skills during continued use, and builds a persistent model of you across sessions. It ships under an MIT license, runs on Python 3.11+, and connects to any LLM backend you already use.

The Self-Improving Learning Loop#

The core mechanism that distinguishes Hermes from frameworks like Goose or LangGraph is its autonomous skill creation system. After any task that involves five or more tool calls — retrieving files, running searches, calling APIs — Hermes generates a skill document in Markdown. This document captures the approach taken, the edge cases encountered, and the domain-specific knowledge discovered during that interaction.

The next time a similar task comes up, the agent loads the relevant skill instead of reasoning from scratch. In Nous Research's own benchmarks, agents with 20 or more self-created skills completed research tasks 40% faster than a fresh instance with no prior skills — without any manual prompt tuning. This improvement is domain-specific; a skill built from summarizing GitHub pull requests does not automatically transfer to planning a database migration. Hermes does not claim to solve cross-domain generalization. What it does claim — and appears to deliver — is genuine compounding value within a defined workflow area.

The closed loop works in both directions. Skills created automatically get refined as Hermes uses them. If a skill misses edge cases on the second use, the agent updates it. Over weeks, a developer who runs Hermes daily for code review tasks ends up with a highly specialized code review agent that knows their codebase's conventions, their preferred response style, and the failure modes their team runs into repeatedly.

In June 2026, Nous Research open-sourced a companion project, hermes-agent-self-evolution, that names the mechanism behind the 40% figure: GEPA (Genetic-Pareto Prompt Evolution), an ICLR 2026 Oral paper, applied through DSPy. Rather than mutating prompts at random, GEPA reads a task's execution traces to find where the agent wasted steps — a job that took 47 tool calls when 12 would do — and proposes targeted fixes to the skill's prompt and procedure. Nous reports a full self-evolution pass costs roughly $2–10 in API calls with no GPU required. This is the layer that turns "the agent stores skills" into "the agent measurably improves them," and it is the most concrete evidence that the self-improvement claim is engineering rather than marketing.

Three-Layer Memory Architecture#

Most agent frameworks treat memory as a flat conversation history. Hermes uses three layers:

Session context is the standard in-context working memory for the current conversation — fast, temporary, cleared between sessions.

Persistent store is a SQLite database with FTS5 full-text search indexing. This is where skills, past task summaries, and extracted user preferences get written. Nous Research reports that retrieval stays in the single-digit-millisecond range even across 10,000+ skill documents, so the store is designed not to degrade as you accumulate skills. Treat that as a vendor figure until you profile it on your own dataset.

User model is a drift-adjusting representation of who you are: your communication style, the domains you work in, the tools you prefer, and the decisions you tend to make. The drift-adjusting component is important — it actively updates as your behavior changes rather than locking in early assumptions.

Together these layers let Hermes answer "what did we decide about the deployment pipeline two weeks ago?" with the same speed as "what did I just ask?" The SQLite approach is deliberately boring compared to vector database architectures, but it avoids the cold-start problem, works offline, and requires zero infrastructure beyond the agent process itself.

Installation and Quick Start#

Getting Hermes running takes under five minutes on a standard developer machine. The one-liner install handles Python version management via uv automatically:

curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash

Alternatively, clone the repository directly:

git clone https://github.com/NousResearch/hermes-agent.git
cd hermes-agent
./setup-hermes.sh

The setup script installs uv, creates a virtual environment, and installs all dependencies. It detects what's missing on your system without requiring sudo for Python version management.

Once installed, the interactive terminal UI starts with:

hermes

The full setup wizard — which configures your model provider, messaging gateway platforms, and tool integrations — runs with:

hermes setup

Model selection is handled via hermes model. Hermes supports Nous Portal, OpenRouter (200+ models), NVIDIA NIM (Nemotron), Xiaomi MiMo, z.ai/GLM, Kimi/Moonshot, MiniMax, Hugging Face, and OpenAI endpoints. Switching providers requires no code changes — just re-run hermes model and select a different backend.

Messaging Gateway: All Your Channels, One Process#

Hermes ships with a messaging gateway that routes conversations from external platforms to the same agent backend — including Telegram, Discord, Slack, WhatsApp, Signal, and Email, with the current channel list published in the docs. The gateway runs as a single background process that handles session management, cron-scheduled tasks, and voice message transcription across all connected channels simultaneously.

Starting the gateway is a single command:

hermes gateway

Platform-specific configuration lives in hermes gateway setup, which walks through OAuth tokens and webhook configuration per channel. Once running, you can send a task to your Hermes agent from Telegram, get the response in Slack if you switch devices, and the agent maintains session continuity across the switch.

The v0.10.0 release added the Tool Gateway for Nous Portal subscribers: automatic access to Firecrawl (web search), FAL/FLUX 2 Pro (image generation), OpenAI TTS (text-to-speech), and Browser Use (browser automation) without managing separate API keys. The agent selects the appropriate tool at inference time.

The 118 Bundled Skills#

Version v0.10.0 ships with 118 pre-built skills covering developer workflows, research tasks, writing, data processing, and system administration. These are starting-point skills written by the Nous Research team — useful immediately but designed to be overwritten by the superior domain-specific versions that Hermes generates from your actual usage patterns.

Unlike OpenClaw's ClawHub marketplace (which distributes community-written skills for download), Hermes does not have a centralized third-party skill repository. Skills in Hermes are generated from your sessions and live locally. This is a deliberate security tradeoff. ClawHub's community marketplace has been a repeated supply-chain target: a February 2026 scan flagged roughly 824 malicious skills across a ~10,700-skill catalog — about 1 in 13, not a fifth — and the confirmed count has since climbed past 1,100 as the registry grew past 13,700 skills (Dark Reading, The Hacker News). Snyk's audit went further, reporting detectable prompt injection in about 36% of ClawHub skills. Hermes sidesteps that entire attack surface because it does not download executable skills from strangers — though "no marketplace" is a smaller blast radius, not a security guarantee, and no agent runtime is exempt from careful credential handling.

Pricing Breakdown#

Hermes Agent itself is free. The framework has no subscription cost, usage fee, or seat limit. You self-host it on any machine that runs Python 3.11+.

The real cost is LLM API usage. On budget models (Gemini Flash, Qwen3, DeepSeek V3.2), typical interactive sessions run in the cents-per-task range for moderate use. On frontier models, costs scale quickly: heavy agentic use on Claude Opus 4.6 can run well over $100/day, because each message resends the full conversation history to the API. The numbers below are planning estimates — your bill depends on model, context length, and how much the agent runs unattended, so meter a representative week before committing.

Practical cost estimates for a solo developer:

The Nous Portal subscription (required for Tool Gateway auto-access) has separate pricing not disclosed publicly at time of writing; tools can also be wired manually with individual API keys at no cost.

Who Should Use Hermes Agent?#

The ideal Hermes user is a solo developer or small team that runs the same classes of tasks repeatedly over weeks or months. A backend engineer who does daily code review, weekly architecture documentation, and regular incident post-mortems will see compounding improvement: the agent gets faster and more accurate on those specific tasks as self-created skills accumulate. The learning loop delivers its 40% speed improvement most clearly after consistent use in a narrow domain — not in one-off varied sessions.

Hermes also makes sense if security posture matters to you. The local-only skill system means you are not downloading execution instructions from a community marketplace where malware detection is reactive, not preventive. If you are running Hermes on a machine with production credentials, that matters.

Who should skip Hermes for now: Teams that need deployment stability and semantic versioning guarantees. At v0.x, breaking changes between minor releases are possible, and the API surface is actively evolving. Organizations that want the widest messaging-platform breadth out of the box — OpenClaw's gateway reach is currently unmatched there. And developers looking for a one-week experiment: Hermes's core value proposition requires sustained use to demonstrate. A short evaluation won't show what the learning loop actually produces.

When to Use / When to Skip Hermes Agent#

The decision turns on one question: do you run the same shapes of task repeatedly, or mostly one-off work?

Use Hermes Agent when:

• You repeat a small number of task types (code review, extraction, triage, doc generation) daily or weekly, so self-created skills have something to compound on.
• You want provider independence — one command switches among 200+ models, so a price or quality change at one vendor is not a rewrite.
• Local-only skill generation is a feature for you: no marketplace download path means no ClawHub-style supply-chain exposure.
• You can absorb v0.x churn by pinning a version and upgrading on your own schedule.

Skip Hermes Agent (for now) when:

• You need a stable, semver-guaranteed API for an automated production pipeline — v0.x breaks between minor releases.
• Your work is mostly one-off and varied; the learning loop never reaches the ~20-skill threshold where the reported 40% speedup appears.
• You need the broadest possible messaging-platform matrix on day one — OpenClaw leads on raw channel breadth.
• You are evaluating in an afternoon. Hermes's value is a multi-week curve, not a first-run demo.

Hermes Agent Adoption Checklist#

Run these six checks before committing Hermes to a workflow. Answer them in order — each one can end the evaluation early and save you the setup.

1. Name the repeated task. Write down the one or two task types you run at least a few times a week. If you cannot name them, the learning loop has nothing to compound and a simpler agent is the better fit.
2. Set a baseline first. Run those tasks with your current tool (or a plain prompt) and record time and quality. The only meaningful test of Hermes is the delta against this baseline, not its demo output.
3. Pick the model tier deliberately. Start on a budget model (Qwen3, DeepSeek, Gemini Flash) to learn the workflow cheaply; reserve frontier models for tasks that measurably need them, given the >$100/day frontier ceiling.
4. Pin the version. Record the exact release (e.g. v0.10.0) and treat minor-version upgrades as changes to test, not to auto-apply, because the API is still moving.
5. Give it three weeks, not three hours. Track task time weekly. If self-created skills are not accumulating and repeat tasks are not getting faster by roughly the 20-skill mark, the learning loop is not paying off for your workload — stop there.
6. Confirm the security posture you actually need. Local skill generation removes the marketplace risk, but you still control credentials the agent can reach. Scope its file, shell, and API access to the task before you point it at anything sensitive.

If you would rather have that baseline-vs-Hermes comparison run and documented as a citable evidence package — fixed task set, pass criteria defined up front, model IDs and costs published — the Proof Studio method is built for exactly that kind of adoption test.

Hermes Agent vs. OpenClaw#

OpenClaw and Hermes Agent are the two most-discussed open-source agent frameworks of 2026, and they reflect fundamentally different product philosophies.

OpenClaw was built gateway-first: it maximizes integration breadth with many messaging platforms and a large community skill marketplace. Hermes Agent was built learning-first: it maximizes depth of improvement through a self-generating skill loop and three-layer memory.

The practical difference: if you need an agent that works seamlessly across many platforms from day one, OpenClaw wins on breadth. If you need an agent that gets significantly better at your specific workflows over three months, Hermes wins on depth. For developers choosing between them, the deciding question is: do you need ecosystem reach, or compounding improvement? If you are weighing more than these two, our AI agent frameworks compared guide sets Hermes-style tools against LangGraph, CrewAI, and the orchestration frameworks, and the best AI coding agents roundup covers the coding-specific field.

For context on the LiteLLM-style multi-provider routing that Hermes uses to support 200+ models, the principle is similar: provider-agnostic routing lets you switch backends without touching application code.

Frequently Asked Questions#

Q: Does Hermes Agent work with local models?#

Yes. Hermes supports Ollama endpoints, Hugging Face local inference, and any provider that exposes an OpenAI-compatible API. Switch with hermes model — no code changes needed.

Q: How long does it take to see real improvement from the learning loop?#

The 40% speed improvement reported by Nous Research appears after approximately 20 self-generated skills in a given domain. For a developer running 2–3 complex tasks daily, that typically takes 2–3 weeks of regular use in the same workflow area.

Q: Is Hermes Agent stable enough for a production environment?#

Not yet, if "production" means automated pipelines with zero tolerance for breaking changes. At v0.x, the Nous Research team is actively iterating on the API surface. For interactive developer tooling where you manage the upgrade cycle manually, v0.10.0 is solid for daily use.

Q: Can I use Hermes Agent without a Nous Portal subscription?#

Yes. The 118 bundled skills, messaging gateway, and self-improving learning loop all work without any Nous subscription. The Nous Portal subscription only adds the Tool Gateway auto-routing feature (Firecrawl, FAL image gen, OpenAI TTS, Browser Use). You can wire any of those tools manually with individual API keys at no cost.

Q: How does skill generation work behind the scenes?#

After a task that involves five or more tool calls, Hermes generates a Markdown file capturing the approach, edge cases, and domain knowledge from that interaction. The file is stored in the persistent SQLite store with FTS5 indexing for fast retrieval. On subsequent similar tasks, the agent queries the store, loads the relevant skill, and uses it as working context.

What Effloow Added#

Hermes Agent's pitch — "an agent that learns your workflow" — is easy to repeat and hard to evaluate. We turned the pitch into a buyer's read:

• A six-step adoption checklist that turns "should I use this?" into a repeatable test: name the repeated task, set a baseline first, pick the model tier, pin the version, give it three weeks, and scope its access — with each step able to end the evaluation early.
• An explicit when-to-use / when-to-skip split, so the learning-loop-vs-newer-project-risk tradeoff is a decision, not a vibe.
• The mechanism behind the headline number, GEPA (an ICLR 2026 Oral paper applied via DSPy), with the "40% faster after 20+ skills" figure attributed to Nous Research rather than presented as independent fact.
• A corrected, sourced security comparison — the ClawHub malicious-skill figure fixed to about 1 in 13 of the catalog (not "20%") and tied to the Dark Reading, Hacker News, and Snyk reporting, so the "local skills are safer" point rests on numbers rather than alarm.
• Vendor claims marked as vendor claims — retrieval latency, per-day API cost, and star count all framed as figures to verify yourself, with the volatile ones softened rather than asserted.

The value is a grounded read of whether the self-improvement actually pays off for you, not an amplification of the launch hype.

Primary sources checked (current as of 2026-07-06):

• Hermes Agent site and docs: https://hermes-agent.org/
• Hermes Agent repository: https://github.com/NousResearch/hermes-agent
• Hermes Agent self-evolution (GEPA/DSPy) repository: https://github.com/NousResearch/hermes-agent-self-evolution
• Nous Research: https://nousresearch.com/
• ClawHub supply-chain reporting (Dark Reading): https://www.darkreading.com/cyber-risk/malicious-openclaw-skills-clawhub-threaten-ai-supply-chain
• ClawHub malicious-skill findings (The Hacker News): https://thehackernews.com/2026/02/researchers-find-341-malicious-clawhub.html

Key Takeaways#

Hermes Agent is the most technically interesting open-source agent framework released in 2026, and it earns that distinction by solving a problem that most frameworks ignore: making agents genuinely better at your specific tasks over time, not just more capable in general. The three-layer memory architecture and autonomous skill generation are the real innovations here — not the star count.

The meaningful caveat is timing. At v0.10.0, Hermes is two months old. Its API will change, its documentation is a moving target, and the compounding learning value requires weeks of consistent use to materialize. If you can invest that time — and you work in defined workflow areas rather than random one-off tasks — it is one of the most rewarding open-source agents to evaluate right now.

Prefer a deep-dive walkthrough? Watch the full video on YouTube.