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, and builds a deepening model of who you are across sessions. MIT licensed, 48k+ GitHub stars.

TL;DR

Hermes Agent is the only major AI agent with autonomous self-improvement: it creates reusable skills from complex tasks, patches them when they're outdated, searches its own past conversations via full-text search, and evolves its prompts/code using genetic optimization (DSPy + GEPA). Supports 15+ messaging platforms from one gateway, 6 terminal backends, and runs anywhere from a $5 VPS to Modal serverless.

Overview

Property Value
Repository NousResearch/hermes-agent
License MIT
Language Python (≥ 3.11)
Stars 48,700+ (as of April 2026)
Creator Nous Research
Version 0.9.0
Docs hermes-agent.nousresearch.com/docs
Self-Evolution NousResearch/hermes-agent-self-evolution

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. Neither Claude Code nor OpenClaw learn autonomously from their own experience in the same way.

Key Features

1. Autonomous Skill Creation

After complex tasks (5+ tool calls), the agent automatically creates reusable skill documents. These skills are:

  • Created without prompting
  • Stored as structured markdown
  • Searchable and composable
  • Automatically improved during subsequent use

2. Skill Self-Improvement

Skills are patched in real-time when they are:

  • Outdated (API changed, dependency updated)
  • Incomplete (missing edge case)
  • Wrong (produces incorrect output)

Full-text search across all past sessions using SQLite FTS5:

  • Search your own conversation history from weeks or months ago
  • LLM-powered summarization of search results
  • Cross-session recall without manual tagging

4. Honcho Integration — User Modeling

Dialectic user modeling that builds a persistent model of who you are across sessions:

  • Learns preferences, working patterns, and domain expertise
  • Adapts behavior to your evolving needs
  • Deepens understanding over time without explicit configuration

5. Multi-Platform Gateway

15+ supported platforms from one installation:

CLI, Telegram, Discord, Slack, WhatsApp, Signal, Matrix, Mattermost, Email, SMS, DingTalk, Feishu, WeCom, BlueBubbles, Home Assistant.

6. Terminal Backends (6 Options)

Backend Use Case
Local Development, personal use
Docker Isolation, reproducibility
SSH Remote server execution
Daytona Serverless persistence (hibernates when idle)
Singularity HPC clusters
Modal Serverless cloud (pay-per-use, near-zero idle cost)

7. Plugin System

Extend Hermes with custom tools, commands, and hooks:

~/.hermes/plugins/
├── my-tool.py          # Custom tool
├── my-command.py       # Custom command
└── my-hook.py          # Event hook

Self-Evolution System

The companion repository hermes-agent-self-evolution uses DSPy + GEPA (Genetic-Pareto Prompt Evolution) to automatically evolve:

  • Skills (workflow documents)
  • Tool descriptions
  • System prompts
  • Agent code

How It Works

graph LR
    A[Current Skills/Prompts] --> B[Mutation via LLM]
    B --> C[Evaluation]
    C --> D{Pareto-Optimal?}
    D -->|Yes| E[Keep Variant]
    D -->|No| F[Discard]
    E --> A
  • No GPU training required — operates entirely via API calls
  • Cost: $2–10 per optimization run
  • Underlying research: ICLR 2026 Oral Paper
  • MIT licensed

GEPA Process

  1. Mutate — LLM generates text variants of skills/prompts
  2. Evaluate — Run variants against test cases
  3. Select — Keep Pareto-optimal variants (multi-objective: quality, cost, speed)
  4. Repeat — Evolutionary pressure produces measurably better versions

Architecture

graph TB
    subgraph Core["Hermes Agent Core"]
        AGENT["Agent Loop<br>(Python)"]
        MEMORY["Memory System<br>(SQLite + FTS5)"]
        SKILLS["Skill Engine<br>(Auto-create + Self-improve)"]
        HONCHO["Honcho<br>(User Modeling)"]
    end

    subgraph Gateway["Multi-Platform Gateway"]
        CLI_G[CLI]
        TG[Telegram]
        DC[Discord]
        SL[Slack]
        WA[WhatsApp]
        MORE[10+ more...]
    end

    subgraph Backends["Terminal Backends"]
        LOCAL[Local]
        DOCKER[Docker]
        SSH_B[SSH]
        DAYTONA[Daytona]
        MODAL[Modal]
        SING[Singularity]
    end

    subgraph Evolution["Self-Evolution (Optional)"]
        DSPY["DSPy + GEPA"]
        EVAL[Evaluation]
        SELECT[Selection]
    end

    Gateway --> AGENT
    AGENT --> Backends
    AGENT <--> MEMORY
    AGENT <--> SKILLS
    AGENT <--> HONCHO
    SKILLS -.->|Periodic| Evolution
    Evolution -.->|Improved| SKILLS

Memory Architecture

Layer Storage Scope Retrieval
Session context In-memory Current conversation Immediate
Session history SQLite + FTS5 All past sessions Full-text search
User model Honcho Cross-session identity Dialectic modeling
Skills Markdown files Persistent knowledge Pattern matching

Security

Security Track Record

As of April 2026, Hermes Agent has zero agent-specific CVEs — in contrast to OpenClaw's 9 CVEs in 4 days (March 2026).

Pricing

Component Cost
Software Free (MIT)
API usage $15–80/month typical
Hosting (VPS) $5–10/month
Self-evolution run $2–10 per optimization
Total typical $20–90/month

Daytona and Modal backends can reduce hosting costs to near-zero during idle periods.

Comparison with OpenClaw

See Full Comparison.

Key differences:

Dimension Hermes Agent OpenClaw
Philosophy Self-improving depth Universal breadth
Skills Auto-created, self-improving Human-written, marketplace
Memory FTS5 + user modeling MEMORY.md + daily notes
Channels 15+ platforms 24+ platforms
Stars 48k 360k
Security 0 CVEs 9+ CVEs
Stability More stable (fewer crash reports) 3–4 crashes/day reported

Sources

Questions

Open

  • Will the GEPA self-evolution approach become standard for all agent frameworks, or is it too complex for mainstream adoption?
  • How does Honcho's user modeling compare to Claude Code's CLAUDE.md approach at scale (months of use)?
  • What is Nous Research's roadmap for Hermes Agent — is v1.0 imminent?
  • Can the self-evolution system be trusted to not degrade skills over time (evolutionary dead ends)?

Answered

  • Q: Does Hermes Agent require a GPU? — No. Operates entirely via LLM API calls. Self-evolution also uses API calls, not local training.
  • Q: Can it work with Claude as the LLM? — Yes. LLM-agnostic; works with Claude, GPT, DeepSeek, Gemini, Ollama, etc.
  • Q: How does it compare to OpenClaw? — Hermes maximizes depth of learning (self-improving skills, persistent memory); OpenClaw maximizes breadth of integration (24+ channels, 13k+ marketplace skills).