Hermes Agent v0.10: Self-Improving Open-Source AI Agent

Why Hermes Matters in 2026

The agent framework category in 2026 splits into three tiers. Tier 1 is hosted-only (OpenAI Agents, Anthropic Agents): excellent defaults but no self-hosting. Tier 2 is orchestration libraries (LangChain, CrewAI, AutoGen): flexible but stateless per-run by default. Tier 3 is runtime agents that ship with persistent memory, learning, and deployment in the same binary. Until Hermes, Tier 3 was closed-source. Hermes is the first fully MIT-licensed Tier 3 runtime.

v0.10.0 Release Facts

Ship date April 16, 2026. Minor version. Additive: no breaking changes for existing Hermes installations, but several features only light up after re-running the install script to pick up updated dependencies.

Three-Layer Memory Architecture

The memory system is what makes Hermes feel different in practice. Every agent claims “memory” — most mean a vector store bolted on. Hermes ships three layers that serve different purposes and are backed by different storage:

Retrieval is FTS5 full-text search plus LLM summarisation. The combination keeps latency at roughly 10ms for 10,000+ skill documents — the inflection point at which most vector-DB architectures start showing tail latency. Nous Research explicitly chose SQLite + FTS5 over pgvector for the embedded-first deployment story; the whole agent ships as files under ~/.hermes/.

The Closed Learning Loop

This is the piece that distinguishes Hermes. After a task crosses a complexity threshold (Nous Research cites “typically five or more tool calls”), the agent writes a Markdown skill document automatically. The skill captures three things: the procedure it followed, known pitfalls it encountered, and verification steps it took. Next time a similar task fires, the skill surfaces through FTS5 and the agent starts from that file rather than reasoning from scratch.

The loop in six steps

1. Task enters — user prompt or gateway message.
2. Skill search — FTS5 query against the 118 bundled + your created skills; top matches prepended to context.
3. Plan + execute — agent drafts a plan, runs tool calls (up to 8 parallel via ThreadPoolExecutor).
4. Verify — agent runs explicit verification steps (check outputs, compare to expected state).
5. Skill generation — if task was complex and new, write a skill document; if the task refined an existing skill, update it.
6. Memory update — outcome logged to L2; L3 user model nudged based on preferences surfaced during the run.

Example skill file

A generated skill is a plain Markdown file. You can read it, edit it, delete it, or commit it to your agency's shared repo. Here is a representative shape:

---
name: gsc-weekly-regression-audit
description: Pull GSC data, identify week-over-week ranking drops, flag cause hypotheses
tools: [search-console, gsc-fetch, table-diff]
created: 2026-04-17
updated: 2026-04-18
---

## Procedure

1. Authenticate to Search Console via service account creds stored in Vault
2. Fetch last 14 days of query + page performance; pivot on query
3. Compute delta_position; filter where delta_position < -3 AND impressions > 100
4. For each flagged query, run core-update overlap check (see also: information-gain-audit)
5. Return ranked list with cause hypothesis column

## Pitfalls

- GSC data is 48-hour lagged; always exclude the last two days
- Position averages hide device splits — always segment desktop vs mobile

## Verification

- Spot-check 3 flagged queries against Semrush or Ahrefs
- Confirm at least one hypothesis per query before returning to user

The 118-Skill Bundled Catalog

v0.10.0 triples the out-of-box capability surface versus v0.8. The bundled catalog is grouped into functional families:

The Unified Messaging Gateway

One of the most under-sold v0.10 features is the gateway. It is a single long-running Python process that connects Hermes to Telegram, Discord, Slack, WhatsApp, Signal, and the local CLI — simultaneously and from one place. Sessions and skills are shared across channels, so a task started in Slack can be resumed in Telegram without any state transfer.

Channel configuration

Each channel requires an API token in ~/.hermes/config.toml. The dashboard at localhost:7777 now surfaces a form for each — no more manual TOML edits for new channels in v0.10.

# ~/.hermes/config.toml
[gateway]
enabled = true

[gateway.telegram]
bot_token = "${TELEGRAM_BOT_TOKEN}"
allowed_user_ids = [12345678]

[gateway.slack]
bot_token = "${SLACK_BOT_TOKEN}"
signing_secret = "${SLACK_SIGNING_SECRET}"
default_channel = "#hermes-agent"

[gateway.discord]
bot_token = "${DISCORD_BOT_TOKEN}"
guild_id = 1234567890

Launch the gateway with hermes gateway start. The process is designed to run as a systemd service or inside Docker — the GitHub repo ships reference unit files for both.

Installation and First Run

Hermes ships an install script that provisions Python 3.11 via uv, creates a virtual environment, installs dependencies, registers the hermes CLI on your PATH, and initialises ~/.hermes/. No sudo required.

macOS / Linux / WSL2

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

# Verify
hermes --version
# → hermes-agent 0.10.0

# First-run configuration wizard
hermes init

# Install a provider key (pick one or more)
hermes provider add openrouter --key "sk-or-v1-..."
hermes provider add anthropic --key "sk-ant-..."

# Launch interactive session
hermes chat

System requirements

• Python 3.11+ (installed by uv automatically)
• ~500 MB disk at install; ~/.hermes/ grows with skills and session history
• Network egress to your chosen LLM provider(s)
• Optional: Docker for running the gateway in production

LLM Provider Matrix + Fast Mode

Hermes is deliberately multi-provider. v0.10 supports Nous Portal, OpenRouter (200+ models), NVIDIA NIM (Nemotron), Xiaomi MiMo, z.ai/GLM, Kimi/Moonshot, MiniMax, Hugging Face, OpenAI, and custom endpoints. The routing layer lets you set per-skill provider preferences — run research skills on cheap long-context models and code-execution skills on faster coding models.

Fast Mode

Toggle via /fast in the CLI or gateway. Fast Mode reroutes OpenAI and Anthropic requests through priority queues, reducing tail latency on supported models. It does not change the underlying model — only the delivery path — so quality, context windows, and rate limits are identical to the default lane. Use it when a human is waiting; don't use it for background batch work.

Hermes vs. OpenClaw vs. Codex CLI

The three open agent CLIs that matter in April 2026. A fuller benchmark comparison lives in the dedicated OpenClaw vs Hermes vs Codex CLI post; here is the condensed decision matrix.

Production Patterns for Agencies

Hermes is MIT-licensed and self-hosts cleanly, which makes it the first framework where “deploy per client” is both technically and legally straightforward. Two patterns we see working:

Conclusion

Hermes Agent v0.10 earns its 95.6K stars. It is the first MIT runtime agent where persistent memory, skill reuse, and multi-channel delivery are defaults — not bolt-ons. The three-layer memory architecture is the actual differentiator; the 118 bundled skills, six messaging integrations, browser dashboard, and Fast Mode queues are what make the differentiator feel smooth in daily use.

If you are evaluating agent frameworks in Q2 2026, install Hermes on a VPS, connect it to one Slack channel, and let it accumulate skills for two weeks. The 40% research-task time cut is real. The compounding advantage after three months is what separates agencies who adopted early from those still wiring LangChain from scratch.

Frequently Asked Questions