One Open Source Project a Day (No.40): Hermes Agent - Nous Research's Self-Improving AI Agent

Introduction

"The agent that grows with you."

This is article No.40 in the "One Open Source Project a Day" series. Today's project is Hermes Agent (GitHub).

Almost every AI Agent framework today shares one fundamental flaw: statelessness. When a conversation ends, everything the Agent learned — how it solved the problem, your preferences, which strategies worked — vanishes completely. Next time you encounter a similar problem, it starts from scratch again.

Nous Research answers this with Hermes Agent: an agent that actually accumulates experience. Through a closed-loop skill learning system, Hermes automatically distills reusable "Skills" after completing each task and stores them in persistent memory. Through a three-layer memory architecture, it remembers your preferences and habits. Through dialectical user modeling, it understands how your relationship with it evolves over time.

90k+ Stars, 12k+ Forks — one of the most-watched open-source projects in AI Agent space right now. Not just a tool, but a partner that grows.

What You'll Learn

• Hermes Agent's core philosophy: why "self-improvement" is the next inflection point for AI Agents
• The three-layer memory architecture: session context + persistent facts + procedural skills
• How the Skill system works: the closed loop from task to reusable code
• Dialectical user modeling: Honcho's 12-identity-layer tracking
• 6 deployment backends + multi-platform message gateway architecture

Prerequisites

• Basic understanding of AI Agents
• Python basics (optional, for extension development)
• Experience using Claude Code, AutoGPT, or similar AI tools

---

Project Background

What Is It?

Hermes Agent is a self-improving AI Agent framework developed by Nous Research. "Hermes" comes from the Greek messenger god, symbolizing the transmission and accumulation of knowledge — the name hints at the project's core aspiration: letting knowledge accumulate and persist across the Agent's lifetime.

The fundamental problem it solves is Agent amnesia:

Traditional Agent:
  Task A → Solve → End → Forget
  Task B → Solve → End → Forget
  Task N → Solve → End → Forget
  (No learning from experience)

Hermes Agent:
  Task A → Solve → Distill skill → Store
  Task B → Recall relevant skill → Solve faster → Refine skill
  Task N → Richer skill library → Even more efficient
  (Genuine experience accumulation)

About Nous Research

• Positioning: The AI Accelerator Company
• Mission: Democratize AI technology through open-source language models
• Research focus: Model architecture innovation, data synthesis, fine-tuning, reasoning enhancement
• Flagship model: Hermes 4 (high-performance tool-calling LLM)
• GitHub repositories: 71
• Ecosystem partners: NVIDIA NeMo, PyTorch

Nous Research is one of the most important organizations in the American open-source AI movement, known for being "open and research-driven." Hermes Agent is their flagship product combining model research capabilities with engineering practice.

Project Stats

• ⭐ GitHub Stars: 90,300+
• 🍴 Forks: 12,400+
• 📝 Total Commits: 4,306+
• 🐛 Open Issues: 1,700+
• 📦 Latest Version: v0.9.0 (April 2026)
• 📄 License: MIT
• 🤖 Supported Models: 200+

---

Key Features

The Core Differentiator: Closed-Loop Learning

Hermes Agent's most fundamental differentiator is the skill generation closed loop:

User interaction → Agent completes task
                        ↓
              Post-task Reflection
              "What approach did I use? Can it be reused?"
                        ↓
              Skill distillation and storage
              ~/.hermes/skills/task-type-xxx.skill
                        ↓
              Next similar task: recall skill → execute directly
                        ↓
              Post-execution: refine → save improved version

This loop lets Hermes Agent become exponentially more efficient with usage over time.

Three-Layer Memory Architecture

Layer	Content	Persistent	Example
Session context	Short-term memory for current conversation	No	"The file you just asked me to edit was config.py"
Persistent fact memory	Important knowledge across sessions	Yes	"User prefers TypeScript, not JavaScript"
Procedural skill memory	Executable task solutions	Yes	"Steps to deploy to staging: 1. build image 2. push 3. ..."

The three layers work together: when a new task arrives, Hermes first retrieves procedural skills (layer 3), incorporates preference facts (layer 2), and executes within current context (layer 1).

Cross-Session Memory Search

Hermes uses SQLite FTS5 full-text indexing combined with LLM summarization for historical conversation search:

• Conversation history is automatically indexed for full-text keyword search
• LLM produces semantic summaries of search results, extracting the most relevant information
• Agent periodically "nudges" itself to proactively consolidate important information into long-term memory

Dialectical User Modeling (Honcho)

Based on the Honcho framework, Hermes continuously models users through 12 identity layers:

• Remembers not just "who you are" (name, profession, preferences)
• Also tracks "how your relationship with this Agent has evolved"
• As interactions accumulate, the Agent's response style and task execution strategies adapt automatically

40+ Built-in Tools

Tool Category	Included Tools
File operations	Read, write, search, tree view
Shell execution	Command running, script execution
Networking	HTTP requests, page scraping
Code	Python REPL, code analysis
Database	SQLite operations
System	Process management, environment info

Supports extending the tool set via MCP servers and Python RPC for custom tool integration.

Multi-Platform Message Gateway

A single Gateway process bridges 7 platforms simultaneously, maintaining conversation continuity across platforms:

Telegram ──┐
Discord  ──┤
Slack    ──┤── Hermes Gateway ── Hermes Agent Core
WhatsApp ──┤
Signal   ──┤
CLI      ──┤
Email    ──┘

Supports voice memo transcription — send a voice message from your phone, it automatically transcribes and executes the task.

6 Deployment Backends

Backend	Use Case
Local	Daily use on personal laptop
Docker	Containerized isolated deployment
SSH	Remote server execution
Daytona	Serverless elastic scaling
Singularity	HPC / high-security isolation
Modal	GPU clusters / Serverless

The same workflow switches between backends without code changes.

Quick Start

# One-line install (Linux/macOS/WSL2)
curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash

# Launch CLI
hermes

# Configure LLM provider (200+ models supported)
hermes model

# Run full configuration wizard
hermes setup

# Start multi-platform message gateway
hermes gateway

# Check tool status
hermes tools

Developer environment:

git clone https://github.com/NousResearch/hermes-agent.git
cd hermes-agent
uv venv venv --python 3.11 && source venv/bin/activate
uv pip install -e ".[all,dev]"
pytest tests/ -q

How It Compares

Dimension	Hermes Agent	AutoGPT	LangChain Agents	OpenAI Assistants
Skill learning	✅ Auto-distill & persist	❌	❌	❌
Cross-session memory	✅ Three-layer architecture	Limited	Plugin-dependent	❌ Vendor-limited
User modeling	✅ 12-layer dialectical	❌	❌	Limited
Multi-platform gateway	✅ 7 platforms	❌	❌	❌
Deployment flexibility	✅ 6 backends	Medium	Low	❌ Cloud only
RL training integration	✅ Atropos	❌	❌	❌
License	MIT	MIT	MIT	Closed source

---

Deep Dive

System Architecture

┌────────────────────────────────────────────────┐
│  Gateway Layer (7 platform entry points)       │
│  Telegram / Discord / Slack / WhatsApp /       │
│  Signal / CLI / Email                          │
└───────────────────┬────────────────────────────┘
                    │
┌───────────────────▼────────────────────────────┐
│          Agent Orchestration Core (agent/)     │
│   Tool selection → Tool execution → Response   │
│         ↑                    ↓                 │
│    Skill recall          Skill distillation    │
└──────┬──────────────────────────┬──────────────┘
       │                          │
┌──────▼──────────┐  ┌────────────▼───────────────┐
│  Memory System  │  │  Skill System (skills/)    │
│  SQLite FTS5    │  │  ~/.hermes/skills/         │
│  Persistent     │  │  agentskills.io standard   │
│  facts          │  │  Cross-agent sharing       │
│  Honcho user    │  └────────────────────────────┘
│  modeling       │
└─────────────────┘
       │
┌──────▼──────────────────────────────────────────┐
│  Execution Environments (environments/)        │
│  Local / Docker / SSH / Daytona / Modal / ...  │
└─────────────────────────────────────────────────┘

Skill System Deep Dive

Skills are the most technically interesting part of Hermes Agent — essentially executable code units with metadata:

# Skill file example: ~/.hermes/skills/deploy-to-staging.skill
{
  "name": "deploy-to-staging",
  "description": "Deploy current project to staging environment",
  "trigger_patterns": [
    "deploy to staging",
    "push to staging",
    "release to staging"
  ],
  "parameters": {
    "project_path": {"type": "string", "required": True},
    "environment": {"type": "string", "default": "staging"}
  },
  "steps": [
    {"tool": "shell", "command": "docker build -t {project}:{tag} ."},
    {"tool": "shell", "command": "docker push registry/{project}:{tag}"},
    {"tool": "shell", "command": "kubectl rollout restart deployment/{project}"}
  ],
  "success_rate": 0.94,
  "usage_count": 47,
  "last_optimized": "2026-04-10"
}

The skill lifecycle:

1. Creation
   Agent completes complex task → analyzes execution steps
   → abstracts into reusable pattern → saves as .skill file

2. Retrieval
   New task arrives → semantic matching against trigger patterns
   → recall most relevant skill → inject into execution context

3. Optimization
   Skill executes → record success/failure → update success rate
   → rewrite steps if needed

4. Sharing
   Via agentskills.io open standard
   → community skill sharing → cross-agent reuse

FTS5 Memory Retrieval

Hermes chose SQLite + FTS5 (Full-Text Search 5) over a vector database — an interesting design choice:

-- Conversation history with FTS5 index
CREATE VIRTUAL TABLE conversation_fts USING fts5(
  content,
  speaker,
  timestamp,
  session_id
);

-- Periodic memory consolidation
CREATE TABLE long_term_memory (
  id INTEGER PRIMARY KEY,
  fact TEXT NOT NULL,
  confidence REAL,
  source_session TEXT,
  created_at TIMESTAMP,
  last_reinforced TIMESTAMP
);

Why not a vector database?

• SQLite requires no additional services — zero operational overhead
• FTS5 full-text search is more precise for exact memories (names, project names)
• The LLM summarization layer compensates for the lack of semantic search
• In local deployment scenarios, being lightweight matters more than semantic retrieval sophistication

RL Training Integration: Tinker-Atropos

Hermes Agent's built-in integration with Atropos (Nous Research's RL training framework) is what makes it unique among all other Agent frameworks:

• Agent execution trajectories are automatically recorded as RL training data
• Can be used to train the next generation of tool-calling specialized models (one source of Hermes 4's training data)
• Creates a flywheel: application-layer product → training data → better model → better application layer product

Migrating from OpenClaw

Hermes Agent provides a seamless migration path from OpenClaw, supporting import of:

• SOUL.md persona files
• MEMORY.md memory entries
• Custom skill libraries
• API key configurations

---

Resources

Official

• 🌟 GitHub: https://github.com/NousResearch/hermes-agent
• 📚 Documentation: https://hermes-agent.nousresearch.com/docs/
• 🌐 Nous Research: https://nousresearch.com
• 🤖 Skills Standard: https://agentskills.io
• 🐛 Issues: https://github.com/NousResearch/hermes-agent/issues

Other Nous Research Projects

• Atropos (1k ⭐): LLM reinforcement learning environment framework
• Hermes Agent Self-Evolution (1.8k ⭐): Agent evolution system built on DSPy + GEPA
• Hermes 4: Flagship tool-calling language model

---

Summary

Key Takeaways

1. Closed-loop learning: The automatic skill generation → recall → optimization cycle is the most complete self-improvement implementation in open-source Agent frameworks
2. Three-layer memory: Session context + persistent facts + procedural skills covers the full spectrum of AI memory
3. Dialectical user modeling: Honcho's 12-layer identity tracking lets the Agent truly understand "who you are" and "how your relationship has evolved"
4. Multi-platform gateway: 7 platforms unified behind one gateway — cross-platform conversation continuity is a unique competitive advantage
5. RL flywheel: Application-layer trajectory data → train better models → improve the application layer. Nous Research is building a self-reinforcing research flywheel

Who Should Use This

• Personal AI assistant builders: People who want an AI that becomes increasingly attuned to them over time
• AI engineers: Practitioners researching Agent self-improvement mechanisms
• Indie developers / solo founders: Users who need unified AI workflows across multiple platforms
• AI researchers: Scholars researching persistent memory, skill learning, and user modeling (Nous Research will open training data)

A Question Worth Sitting With

Hermes Agent represents a bet on a specific direction of AI Agent evolution: from "tool" to "partner". Tools are stateless — you use them and put them down. Partners have memory — they grow with you. When AI Agents start having something like a "career" — accumulating skills and rapport through long-term collaboration with a specific user — the fundamental model of how humans and AI relate will shift.

---

Visit my personal site for more useful knowledge and interesting products

← No.74: OpenCLI | Series Index