Skip to content

Hermes Agent

Self-improving AI agent by Nous Research 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 model of who you are across sessions. MIT licensed, 210k+ GitHub stars (as of July 2026).

TL;DR

Hermes Agent is an open-source, LLM-agnostic agent (Python 3.14) that you talk to from a terminal UI, a desktop app, or about 28 messaging platforms through one gateway process. Its differentiator is a closed learning loop. Bounded MEMORY.md/USER.md files are injected into every session. A background review after each turn saves memory and creates or patches SKILL.md procedures. A curator archives stale skills. FTS5 search covers every past session. It runs commands on seven terminal backends (local, Docker, SSH, Modal, Daytona, Vercel Sandbox, Singularity), from a $5 VPS to serverless sandboxes. A separate, offline DSPy + GEPA pipeline evolves skill files and proposes the results as pull requests. Latest release: v0.21.5 (2026-09-24).

Key Facts

Property Value
Latest Version 0.21.5, tag v2026.9.24 (2026-09-24)
Previous minor 0.21.0 "Pantheon" (2026-08-31); 0.20.0 "Herald" (2026-08-03)
Release cadence Tagged release every ~3-7 days; calendar tags vYYYY.M.D
Repository NousResearch/hermes-agent
License MIT (Copyright 2025 Nous Research)
Creator Nous Research
Language / runtime Python 3.14 (managed by the PM tool manager); Node.js for TUI/desktop
Stars 210,800+ (as of July 2026)
Install curl -fsSL https://hermes-agent.nousresearch.com/install.sh \| bash, install.ps1 (Windows), desktop bundles, Docker nousresearch/hermes-agent
Unsupported installs PyPI/pip, Homebrew, AUR (retired in v0.20.0)
Tier 1 platforms macOS Apple Silicon, Windows 10/11, Linux/WSL2, Docker
Providers 40+ (Nous Portal recommended; OpenRouter, Anthropic, OpenAI, Gemini, Bedrock, Vertex, local endpoints)
Docs hermes-agent.nousresearch.com/docs
Self-Evolution NousResearch/hermes-agent-self-evolution (Phase 1: skills)

Full release table, platform matrix, defaults, and limits: Reference.

Core Philosophy

"The agent that grows with you."

Hermes Agent's differentiator is compounding intelligence: the longer you use it, the better it gets at helping you specifically. Memory holds small durable facts that are always in context. Skills hold longer procedures that load only when relevant. Session search recalls everything else on demand. Claude Code relies on hand-written CLAUDE.md files and OpenClaw on a human-curated skill marketplace. Hermes writes and maintains its own procedural memory, with an optional human approval gate.

Key Features

1. Autonomous Skill Creation

The agent saves non-trivial workflows as SKILL.md documents via its skill_manage tool, without being asked. A nudge every 15 tool-calling iterations (skills.creation_nudge_interval) and a post-turn background review drive this. /learn turns docs, URLs, or whole books into knowledge-base skills. Skills follow the agentskills.io standard. See Explanation: Skill Engine.

2. Skill Self-Improvement

Skills are patched in place when they are outdated, incomplete, or wrong, preferably with small targeted patches. The curator marks agent-created skills stale after 14 unused days and archives them after 30 (never deletes). LLM consolidation of overlapping skills is opt-in.

Two bounded files (MEMORY.md 2,200 chars, USER.md 1,375 chars) are injected as a frozen snapshot at session start. All sessions are stored in SQLite with FTS5, and the agent searches them with session_search (no LLM calls, ~20 ms). See Explanation: Memory System.

4. Honcho Integration: User Modeling

Honcho dialectic user modeling is available as one of seven bundled optional external memory providers (alongside Mem0, OpenViking, Holographic, RetainDB, ByteRover, Supermemory). It is not the default memory layer.

5. Multi-Platform Gateway

One gateway process serves about 28 platforms (as of 2026-09): Telegram, Discord, Slack, WhatsApp, Signal, Matrix, Mattermost, Email, SMS, Microsoft Teams, Google Chat, LINE, Feishu/Lark, DingTalk, WeCom, Weixin, QQ, BlueBubbles/iMessage, Home Assistant, IRC, SimpleX, and more. It also serves an OpenAI-compatible API server, webhooks, cron delivery, and voice. All platforms get full tool access.

6. Terminal Backends (7 Options)

local, docker, ssh, modal, daytona, vercel_sandbox, singularity. Modal, Daytona, and Vercel Sandbox persist filesystem state while costing little when idle. See Reference: Terminal Backends.

7. Plugin System

Plugins add tools, 27 lifecycle hooks, slash/CLI commands, platforms, memory providers, context engines, and model providers. General plugins are opt-in (plugins.enabled):

~/.hermes/plugins/my-plugin/
├── plugin.yaml      # manifest
├── __init__.py      # register(ctx): tools, hooks, commands
├── schemas.py       # tool schemas (what the LLM sees)
└── tools.py         # tool handlers

8. Beyond the Core (2026 Additions)

Subagent delegation (delegate_task), cron jobs with persistent memory, multi-profile kanban, MCP client and server, ACP for VS Code/Zed/JetBrains, Hermes Desktop (Electron, plugin SDK, Bot Mode), streaming voice with wake words (v0.20.0), A2A v1.0 and hermes peer agent-to-agent messaging, and migration from OpenClaw, Claude Code, and Codex CLI.

Architecture

The compact map below shows the main runtime pieces. The detailed component diagram, turn lifecycle, and gateway sequence are in Explanation.

flowchart LR
    subgraph Surfaces["Entry points"]
        CLI["CLI / TUI"]
        DESK["Hermes Desktop"]
        GW["Gateway<br/>Telegram, Slack, Discord, ..."]
        API["API server :8642"]
    end
    AG["AIAgent loop<br/>prompt builder, provider resolver,<br/>tool registry"]
    LLM["LLM provider<br/>(Nous Portal, OpenRouter, Anthropic, ...)"]
    subgraph Store["Per-profile state"]
        MEM["MEMORY.md / USER.md"]
        SK["skills/"]
        DB[("state.db FTS5")]
    end
    TB["Terminal backends<br/>local, docker, ssh, modal,<br/>daytona, vercel_sandbox, singularity"]
    REV["Background review<br/>+ curator"]

    Surfaces --> AG
    AG <--> LLM
    AG --> TB
    AG <--> Store
    AG -.->|post-turn| REV
    REV -.-> MEM
    REV -.-> SK

Self-Evolution System

The companion repository hermes-agent-self-evolution uses DSPy + GEPA (Genetic-Pareto reflective prompt evolution, ICLR 2026 Oral) to evolve Hermes' own SKILL.md files offline. It reads execution traces, mutates candidates, evaluates them, gates them on tests and size limits, and opens a PR for human review. It needs no GPU and costs about $2-10 per run. Tool descriptions, system prompts, and code evolution are planned, not implemented (as of 2026-09). Details: Explanation: Self-Evolution System.

Evaluation

Strengths

  • Closed learning loop (memory + skills + curator + session search) that works out of the box, with approval gates when you want review
  • Provider freedom: 40+ providers, OAuth subscription logins (Nous Portal, ChatGPT/Codex, Copilot, Claude Max), local endpoints
  • Very wide reach: ~28 messaging platforms, API server, desktop, ACP, MCP, cron, webhooks
  • Execution decoupled from hosting: seven backends including cheap-when-idle serverless sandboxes
  • Security posture is actively hardened: default-deny gateway, smart approvals with a hardline blocklist, exact-pinned core dependencies, OSV audits

Weaknesses and Risks

  • Extremely fast release pace (hundreds of PRs per tag); defaults and commands change often, and blog posts go stale within weeks
  • At least ten CVEs published in 2026, several with unclear fix versions (see Reference: Known Security Advisories)
  • By default the agent writes memory and skills from any authorized user's chats without review; weak models save wrong or phantom memories
  • Large footprint: Python 3.14, Node, Chromium, and FFmpeg managed by its own PM layer; pip installs unsupported
  • Pre-1.0 versioning; no published support windows

When It Fits

Scenario Fit
Personal assistant reachable from phone chat apps, running on a VPS Strong
Long-running research or ops agent that should get better at recurring tasks Strong
Team bot on Slack/Teams with shared tools Good, with allowlists and write_approval on
Pure coding in an IDE Workable via ACP/worktrees; dedicated coding agents are more focused
Regulated environments needing audited, stable releases Weak: pre-1.0, rapid churn, CVE history

Security

Correction: the 'zero CVEs' claim is outdated

Earlier versions of this note said Hermes had zero agent-specific CVEs as of April 2026. At least ten CVEs have since been published against hermes-agent (April to September 2026). They cover API-server auth, approval-guard authorization, cross-user session access, webhook path traversal, SSRF, and memory-scanner injection. Stay on the latest tag and follow the security advisories.

Security layers: gateway authorization (allowlists, DM pairing, default deny), dangerous-command approval (hardline blocklist + smart/manual/off modes), file-write safety, hardened container backends, MCP credential filtering, context-file injection scanning, and cross-session isolation. Threat model: Explanation: Threat Model. Setup tasks: How-to Guides: Channel Authentication.

Pricing

Component Cost
Software Free (MIT)
API usage Depends on the model and usage; no official estimate is published
Nous Portal subscription (optional; 300+ models + Tool Gateway) Free $0; Plus $20/month ($22 credits); Super $100/month ($110 credits); Ultra $200/month ($220 credits), per the Nous Portal plans page (via search listing and third-party pricing guides, 2026-09-27)
Hosting (VPS) ~$5-10/month
Self-evolution run ~$2-10 per optimization (README)
Total typical VPS (~$5-10/month) + model usage or a Portal plan

Daytona, Modal, and Vercel Sandbox backends keep compute costs low while idle. Routing the background review and curator to a cheaper auxiliary model cuts learning-loop cost by about 3-5x (per the memory docs). More: Reference: Cost Reference.

Comparison with OpenClaw

See the full comparison and the OpenClaw topic.

Dimension Hermes Agent OpenClaw
Philosophy Self-improving depth Universal breadth
Skills Agent-created and self-patched, plus hubs (skills.sh, ClawHub, official) Human-written, ClawHub marketplace
Memory Bounded MEMORY.md/USER.md + FTS5 session search + optional external provider MEMORY.md + daily notes
Channels ~28 platforms (2026-09) 32 channels (per OpenClaw topic)
Stars 210k (2026-07) ~390k (2026-09, per OpenClaw topic)
Security 10+ CVEs published in 2026 CVE cluster in late March 2026, incl. CVE-2026-32922 (CVSS 9.9) (per OpenClaw topic)
Stability No comparable published measurement No published measurement; 2026.9.x releases added restart and unfinished-work recovery
Migration hermes claw migrate imports OpenClaw settings, memories, skills, keys —

Topic Map

  • How-to Guides: install, configure, secure, operate and troubleshoot Hermes Agent (v0.21.x).
  • Reference: releases, platform support, install layouts, defaults, config keys, limits, ports, providers, advisories.
  • Explanation: the AIAgent orchestration core, memory, skills, terminal backends, platform adapters, provider profiles.

Sources

Questions

Open

  • Will the GEPA self-evolution approach become standard for agent frameworks, and when will Phases 2-5 (tool descriptions, prompts, code) ship?
  • How does built-in bounded memory (plus optional Honcho) compare with Claude Code's CLAUDE.md approach after months of use?
  • What is Nous Research's roadmap to v1.0, and will it come with support windows or an LTS channel?
  • Can the in-product learning loop avoid degrading skills over time without write_approval? How well does the curator's archival counteract drift?
  • Which releases fixed each 2026 CVE? The CVE records often omit fixed versions.
  • What does a Nous Portal subscription cost, and how do its limits compare with bring-your-own-key usage?

Answered

  • Q: Does Hermes Agent require a GPU? No. It operates entirely via LLM API calls (or a local endpoint you run). Self-evolution also uses API calls, not local training.
  • Q: Can it work with Claude as the LLM? Yes. It is LLM-agnostic, with a native anthropic_messages API mode, Anthropic API keys or Claude Max OAuth, plus OpenAI, Gemini, DeepSeek, Bedrock, Vertex, local endpoints, and more.
  • Q: How does it compare to OpenClaw? Hermes maximizes depth of learning (self-written, self-patched skills and persistent memory). OpenClaw maximizes breadth of integration and its marketplace. Hermes ships a migration command for OpenClaw users.
  • Q: Can I still pip install hermes-agent? No. PyPI stops at 0.19.0 (2026-07-20), and pip, uv-tool, and Homebrew installs have been unsupported since v0.20.0. Use the shell installer, desktop bundle, or Docker.
  • Q: Is Honcho required for memory? No. Built-in MEMORY.md/USER.md plus FTS5 session search is the default. Honcho is one optional external provider.