Hermes agent

Hermes Agent Self-Evolution: Nous Research Ships Genetic Prompt Optimization with DSPy + GEPA

· The Agent Report · 6 min read
Hermes Agent Self-Evolution: Nous Research Ships Genetic Prompt Optimization with DSPy + GEPA
📑 Table of Contents

The Hermes Agent’s self-improvement loop just gained a new dimension. On June 6, 2026, Nous Research quietly open-sourced hermes-agent-self-evolution — a separate repository that applies genetic algorithms to the agent’s own skills, prompts, and tool descriptions. Built on DSPy (Stanford’s declarative LLM programming framework) and GEPA (Genetic-Pareto Prompt Evolution, an ICLR 2026 Oral paper), it reads execution traces to understand why failures happen and proposes targeted fixes — not just random mutations.

The existing Curator prunes unused skills. Self-evolution improves the ones you keep.

How It Works: Read, Mutate, Evaluate, Select

The optimization pipeline follows a four-stage cycle:

  1. Read the current skill, prompt, or tool description from the Hermes Agent repo
  2. Mutate it into candidate variants using GEPA’s reflective evolutionary search — the engine reads execution traces and proposes surgical edits, not random rewrites
  3. Evaluate each candidate against a test suite, size constraints (skills ≤15 KB, tool descriptions ≤500 chars), and semantic drift checks
  4. Select the best-performing variant and open a PR against hermes-agent
Read current skill/prompt/tool ──► GEPA Optimizer ◄── Execution traces
                                        │
                                   Candidate variants ──► Evaluate
                                        │
                                   Constraint gates (tests, size, semantics)
                                        │
                                   Best variant ──► PR against hermes-agent

The entire pipeline costs $2–10 per optimization run and requires no GPU training — it operates entirely through API calls to an LLM that evaluates and mutates text.

Five Phases of Evolution

Nous Research has laid out a five-phase roadmap in PLAN.md:

Phase Target Engine Status
Phase 1 Skill files (SKILL.md) DSPy + GEPA ✅ Implemented
Phase 2 Tool descriptions DSPy + GEPA 🔲 Planned
Phase 3 System prompt sections DSPy + GEPA 🔲 Planned
Phase 4 Tool implementation code Darwinian Evolver 🔲 Planned
Phase 5 Continuous improvement loop Automated pipeline 🔲 Planned

Phase 4 is particularly ambitious: the Darwinian Evolver (AGPL v3, external CLI) treats code as “Git-based organisms,” applying evolutionary pressure to tool implementations themselves. This would close the loop from “the agent writes a skill” to “the agent evolves the code behind its own tools.”

Guardrails: Why This Isn’t Unsupervised Chaos

Every evolved variant must pass five checks before acceptance:

  1. Full test suite — pytest tests/ -q must pass at 100%
  2. Size limits — skills ≤15 KB, tool descriptions ≤500 characters
  3. Caching compatibility — no mid-conversation changes that break caching
  4. Semantic preservation — must not drift from the original purpose
  5. Human-in-the-loop PR review — all changes are proposed via pull request, never directly committed

The repo is explicit: “All evolved changes go through human review and are never directly applied.” This is evolutionary optimization with a safety net — not a runaway feedback loop.

How to Run It

Point the evolution tool at your local Hermes Agent repo and choose your evaluation data source:

git clone https://github.com/NousResearch/hermes-agent-self-evolution.git
cd hermes-agent-self-evolution
pip install -e ".[dev]"
export HERMES_AGENT_REPO=~/.hermes/hermes-agent

# Evolve a skill with synthetic eval data
python -m evolution.skills.evolve_skill \
    --skill github-code-review \
    --iterations 10 \
    --eval-source synthetic

# Or use real session history from Claude Code, Copilot, and Hermes
python -m evolution.skills.evolve_skill \
    --skill github-code-review \
    --iterations 10 \
    --eval-source sessiondb

The sessiondb source pulls from real execution traces across multiple coding agents, giving GEPA rich failure data to learn from.

What This Means for the Agent Ecosystem

The self-evolution repo represents a new layer in Hermes Agent’s autonomy stack:

  • Skill creation — the agent writes skills from experience (built in since v0.2)
  • The Curator — the agent prunes and grades its skill library (since v0.12, April 2026)
  • Self-evolution — the agent improves its skills and prompts through genetic optimization (new)

Together, these three layers form a complete lifecycle: create → maintain → evolve. It’s the closest thing we’ve seen to an agent that genuinely gets better the longer it runs — not just by accumulating more skills, but by refining the ones it has against measurable benchmarks.

At 3.9k stars within days of release, the community is clearly paying attention. The repo is young — only 7 commits on main — but the architecture is ambitious, the guardrails are solid, and the DSPy + GEPA foundation is backed by peer-reviewed research.

The agent that learns from experience can now learn from its own mistakes — and fix them automatically.