Hermes Agent: The Self-Improving AI from Nous Research

Most AI agents have a memory problem: they figure something out, then forget it the moment the session ends. The next time you ask the same question, you watch the same model rediscover the same workaround. Hermes Agent is Nous Research's answer to that. It's an open-source autonomous agent with a built-in learning loop — it writes its own reusable skills from experience, curates its own memory between sessions, and runs anywhere from a $5 VPS to a serverless cloud function.

The latest release, v0.13.0 ("The Tenacity Release"), shipped on May 7, 2026, with 864 commits and 295 community contributors since the prior version. That cadence is unusual for an agent framework — Hermes has been shipping a numbered release roughly every week since March. This guide is a hands-on walkthrough of what Hermes Agent actually is, the architecture decision that makes "self-improving" more than marketing, how to install and run it today, and where it fits relative to the rest of the agent stack.

Hermes Agent is an autonomous AI agent — a long-running process you deploy somewhere, not a chatbot you click into. From the official product page:

"The self-improving AI agent built by Nous Research. 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."

The shape that matters: you install Hermes on a server, configure a few API keys, and connect it to whichever messaging surfaces you actually use — Telegram, Discord, Slack, WhatsApp, Signal, Email, CLI, Home Assistant, Google Chat, IRC, Teams, Mattermost, Matrix, DingTalk, and roughly a half-dozen more. 20 platforms total as of v0.13.0, with Google Chat as the newest. You then talk to the agent from wherever you happen to be, and the agent talks back across platforms with the same memory and the same accumulated skills.

It's MIT-licensed and model-agnostic. 200+ models are supported through OpenRouter alone, plus direct integrations with Nous Portal, OpenAI, Anthropic, NVIDIA NIM (Nemotron), Kimi/Moonshot, z.ai/GLM, Xiaomi MiMo, MiniMax, Hugging Face, and ElevenLabs. You switch the underlying brain with one command — hermes model — and your skills, memory, and history come with you. There is no provider lock-in baked into the design.

This is the section that sets Hermes apart from "ChatGPT wrapped in a terminal." Most agents read their tools list every turn and start fresh. Hermes treats its own past behavior as a first-class data source.

Four components make up the learning loop:

1. Autonomous skill creation. After completing a non-trivial task, the agent decides whether the procedure was reusable and, if so, distills it into a skill file. The next time a similar request shows up, that skill is in the prompt — and the agent doesn't reinvent the wheel.
2. Skills self-improve during use. Skills are not write-once. When a skill misfires, the agent's reflection step can patch the skill in place. The agent is, in effect, doing continuous gradient-free fine-tuning of its own playbook.
3. Agent-curated memory with periodic nudges. Long-running agents drown in context. Hermes ships a curator process (hermes curator) that periodically prunes, archives, and consolidates session history.
4. Cross-session recall. Every session is indexed with SQLite FTS5 full-text search and summarized by an LLM. When a question matches something you discussed three weeks ago in a different channel, the agent surfaces it.

On top of that loop sits Honcho dialectic user modeling — an open-source user-modeling layer that builds a structured representation of who you are and what you care about. Skills are also compatible with the agentskills.io open standard, which means a skill earned in one Hermes install is portable to another agent that speaks the same format.

The editorial way to think about this: most agents are interpreters — they execute one turn at a time and forget. Hermes is closer to a compiler-as-agent — it's writing reusable subroutines from its own experience and caching them for next time. That's a strictly different bet from the distillation-based specialist pattern we covered in our Needle 26M tool-calling model guide, but it points in the same direction: agents that get cheaper and more capable the longer you run them.

The Tenacity Release is mostly about finishing what was started. The headline features:

• Multi-agent Kanban — a durable, multi-profile board where you drop tasks and multiple Hermes workers pick them up, hand off, and close them. Heartbeats, zombie detection, retry budgets, and a hallucination gate keep the team honest. One install, many boards.
• `/goal` command — locks the agent onto a target across turns. The Ralph loop (don't drift, don't lose the thread) as a first-class slash command.
• `video_analyze` tool — native video understanding on Gemini and other multimodal models.
• xAI Custom Voices — voice-cloning TTS provider lands as a first-class integration.
• Seven i18n locales — Chinese, Japanese, German, Spanish, French, Ukrainian, Turkish — for gateway + CLI messages. The docs site adds Chinese (zh-Hans).
• Google Chat as platform #20, plus a generic platform-plugin surface so third-party adapters drop in without touching core.
• Sessions survive restarts — gateway bounces, /update restarts, and source-file reloads now auto-resume in-flight conversations.
• Checkpoints v2 — state persistence rewritten with real pruning and disk guardrails. No more orphan shadow repos.
• Security wave — 8 P0 closures — redaction is now ON by default, Discord role-allowlists are guild-scoped (closes a CVSS 8.1 cross-guild DM bypass), WhatsApp rejects strangers by default, TOCTOU windows close across auth.json and MCP OAuth, browser enforces a cloud-metadata SSRF floor, and cron prompt-injection scanning now includes assembled skill content.

Smaller wins worth knowing: a no_agent cron mode for script-only watchdogs, post-write delta lint on write_file and patch (Python/JSON/YAML/TOML), a provider plugin system (ProviderProfile ABC), per-channel allowlists across Slack/Telegram/Mattermost/Matrix/DingTalk, an X-Hermes-Session-Key header for long-term memory per session in the API server, and MCP SSE transport with OAuth forwarding.

That's an awful lot for one release. Read the full notes on the v2026.5.7 release page before pinning a version in production.

Setup is one command on Linux, macOS, WSL2, or Termux:

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

Windows uses PowerShell:

irm https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.ps1 | iex

After install, reload your shell and start the agent:

source ~/.bashrc    # or: source ~/.zshrc
hermes

The first run drops you into the TUI, which has multiline editing, slash-command autocomplete, and streaming tool output. Walk through the wizard:

hermes setup            # full setup wizard
hermes model            # pick your LLM provider/model
hermes tools            # toggle the 40+ built-in tools
hermes config set       # adjust individual settings
hermes gateway          # start messaging bridges (Telegram, Discord, etc.)
hermes doctor           # diagnose problems
hermes claw migrate     # import an OpenClaw configuration
hermes update           # update to the latest release

Inside a session, the slash commands you'll use most:

/new            Start a fresh conversation
/reset          Clear history
/model          Change the active model
/skills         Browse / manage learned skills
/goal           Lock the agent onto a target (Ralph loop)
/steer          Direct the in-flight agent
/queue          Queue follow-up requests
/compress       Compress the current context window
/usage          Show token usage and cost so far

You'll need at least one model provider API key. The cheapest path is an OpenRouter account, which gets you access to most open and closed models through one billing relationship — including small open specialists like Moonshot's Kimi K2.6 and Google's Gemma 4, as well as Claude, GPT, Gemini, and DeepSeek. If you want voice features, add ElevenLabs or xAI Custom Voices. If you want to run anything heavier than a chat in a sandbox, configure one of the seven sandboxing backends: local, Docker, SSH, Singularity, Modal, Daytona, or Vercel Sandbox.

Hermes is general-purpose, multi-platform, long-running. That positions it differently from most of the other agents getting attention right now.

• vs Claude Code — Claude Code is a dev tool that lives inside your terminal and IDE. We covered the new multi-session UX in Claude Code's agent view. Hermes overlaps in CLI usage but extends to messaging, scheduling, and platforms Claude Code doesn't try to be. Claude Code is for shipping code; Hermes is for running your life.
• vs OpenClaw — OpenClaw is the closest direct alternative. Hermes ships a documented migration path: hermes claw migrate imports an existing OpenClaw setup. The marketing claim is feature parity plus the learning loop; the practical answer is to try both and keep the one your skills feel at home in.
• vs specialist callers like Needle or FunctionGemma — these aren't replacements for Hermes. They're tools Hermes can call. The Needle 26M tool-calling model is exactly the kind of cheap, on-device router that fits cleanly into an orchestrator like Hermes for the fast 80% of intents.
• vs generic LangChain / LlamaIndex pipelines — those are libraries. Hermes is a product. If you want to spend your time defining tools and shipping value, not gluing together a runtime, the difference matters.

The mental shortcut: Hermes is what you reach for when you want one assistant that knows you across phone, laptop, watch, Slack, and email. Specialist agents are what you reach for when you want one task done fast.

The deepest claim Hermes is making is not technical — it's about time. Most agents are useful for the length of one task. Hermes is built to be useful over months, learning your idioms, accumulating skills, and getting cheaper to run as it gets better at routing requests to smaller models for the things it has already figured out.

That bet depends on two things working out:

• A portable skills format. If skills earned in one Hermes deployment can move to another agent — or to a future, better version of the same agent — the time you spend teaching it is not wasted. The agentskills.io standard is the bet that this becomes table stakes.
• User-model interoperability. Honcho's dialectic user modeling is one early answer to "how do we represent a user's preferences in a way that survives the model behind the agent changing." That's a quiet, important problem.

The broader trend lines up with what we wrote in our Stanford AI Index 2026 coverage: the interesting AI products of 2026 are the ones that compound — they get better the more you use them, not just the more compute you throw at them.

A few things to keep in mind before you ship Hermes anywhere serious:

• It's still v0.13.0, not 1.0. The project ships a numbered release every few days. That cadence is great for momentum and bad for stability — pin a specific tag if you put it in front of users.
• "Self-improving" is bounded by the underlying LLM. Skills make the agent smarter at routing; they don't make a 7B base model think like Claude. Plan your model choice accordingly.
• Not zero-config. You need a server (a VPS works), a model provider key, and a few minutes for the wizard. Compared to opening a browser tab, that's friction.
• Skill auditing is manual. The agent decides what to remember about you. Reviewing that takes real time — /skills is the entry point, but there's no built-in red-team mode yet.
• The 8 P0 security closures in v0.13.0 are a tell. They're good news — the team is patching seriously — but it also tells you what kind of project Hermes is. Don't deploy a v0.X agent to a customer-facing channel without reading the threat model.

If you're a developer who wants one place to run all your automations, talk to it from any platform, and trust it to remember what you taught it last week — Hermes is the most ambitious open-source agent currently shipping at this cadence. As we argued in our piece on whether software engineering is dead, the role of the builder is shifting from "write every line" to "compose specialist agents." Hermes is one of the cleanest demonstrations of that shift in production today.