Hermes Agent: The AI That Learns, Remembers, and Gets Better Every Session
Nous Research's open-source agent creates skills from experience, improves them during use, and builds a deepening model of who you are. Run it on a $5 VPS or a GPU cluster. Talk to it from Telegram while it works on a cloud VM.
- Hermes Agent is the first open-source AI agent with a closed learning loop: it autonomously creates procedural skills from complex tasks, then self-improves those skills during future use.
- Multi-level memory (MEMORY.md, USER.md, Honcho user modeling, FTS5 session search) means the agent genuinely remembers your projects, preferences, and past conversations across sessions.
- Model-agnostic and infrastructure-agnostic: use any LLM provider, run on six different terminal backends from local to serverless, and reach the agent from Telegram, Discord, Slack, WhatsApp, Signal, or CLI.
- Research-grade internals with trajectory compression, Atropos RL environments, and on-policy distillation make it a platform for training next-generation tool-calling models, not just a consumer product.
The Problem Every Other Agent Ignores
Most AI agents today are goldfish. They do impressive things within a single session, then forget everything the moment you close the terminal. Your next conversation starts from zero. The agent has no idea what you worked on yesterday, what tools you prefer, or what mistakes it already made and corrected.
Claude Code, Codex, Cursor, Aider: they are powerful session-by-session tools. But none of them learn from experience in a persistent, compounding way. You get the same starting intelligence every time.
Nous Research, the lab behind the Hermes, Nomos, and Psyche model families, decided to fix this. Their answer is Hermes Agent: an agent that does not just assist but accumulates competence over time.
"Hermes Agent remembers what it learns and gets more capable over time, with a multi-level memory system and persistent dedicated machine access."
The Closed Learning Loop
The core innovation is not any single feature. It is how the features connect into a self-reinforcing cycle.
When you complete a complex task with Hermes Agent, the agent can synthesize that experience into a permanent skill document. These are not vague summaries. They are structured, searchable markdown files following the agentskills.io open standard. They capture the exact steps, commands, edge cases, and reasoning that made the approach work.
Next session, when a similar task comes up, the Prompt Builder automatically matches relevant skills and injects them into the system prompt. The agent starts the conversation already knowing how to handle problems it has solved before.
Here is the part that makes it genuinely different: skills self-improve during use. If a skill's steps fail or produce suboptimal results, the agent patches the skill document with corrections. The more you use Hermes Agent, the more reliable its procedural knowledge becomes. This is not prompt engineering. It is earned competence.
Memory That Actually Works
Skills are the procedural memory. But Hermes Agent has three other memory systems working in parallel.
MEMORY.md holds the agent's personal observations: environment facts, project conventions, tool quirks, things it learned. USER.md captures what the agent knows about you: your communication style, workflow habits, and preferences. Both files are injected as frozen snapshots at session start, preserving the prefix cache for the entire session while updates write to disk immediately for the next one.
The memory tool itself is hardened against prompt injection. Content passes through pattern scanning for exfiltration attempts, invisible unicode characters, role hijacking, and secret access before anything gets persisted. This is not an afterthought. The threat patterns are specific and the scanning happens on every write.
Session Search is the third layer. Every conversation is indexed in an FTS5 database. The agent can search its own past conversations by keyword, load relevant sessions, and have the LLM summarize them for context. When you ask "what did we do with that Kubernetes config last week?", the agent can actually answer.
The fourth layer is Honcho, a dialectic user modeling system from Plastic Labs. Where USER.md captures explicit preferences, Honcho builds a latent model of your work style, domain knowledge, and communication patterns. It runs asynchronously, writes memories in the background, and supports multi-user isolation in gateway mode so different people talking to the same Hermes instance get personalized experiences.
40+ Tools, 6 Terminal Backends
The tool system is where the agent interacts with the world. Hermes ships with over 40 tools: terminal execution, file operations, web search, browser automation (including live Chrome CDP connect), image generation, text-to-speech, voice transcription via faster-whisper, code execution, todo management, MCP server integration, and more.
The terminal tool is particularly interesting because it supports six different backends. Local execution is the default, but you can also run commands in Docker containers, SSH sessions, Daytona cloud workspaces, Singularity containers, or Modal serverless sandboxes.
# Switch terminal backends on the fly
hermes config set terminal.env docker
hermes config set terminal.env modal
hermes config set terminal.env daytonaDaytona and Modal offer serverless persistence. Your agent's environment hibernates when idle and wakes on demand. A team running Hermes Agent on Modal might pay nearly nothing between sessions while retaining full state.
The v0.3.0 release added persistent shell mode for local and SSH backends. Environment variables, aliases, and directory state now survive across tool calls. This sounds minor but it eliminates an entire class of frustrating "the agent forgot I cd'd into the project directory" bugs.
The Gateway: One Agent, Every Platform
Most coding agents live in your terminal and die when you close the lid. Hermes Agent runs as a gateway process that connects to Telegram, Discord, Slack, WhatsApp, Signal, Matrix, Mattermost, Home Assistant, SMS, email, and a REST API. Voice memos get transcribed. Conversations maintain continuity across platforms.
You can start a conversation in the CLI, leave your desk, and continue it from Telegram on your phone. The agent keeps working on a cloud VM while you walk the dog.
# Start the messaging gateway
hermes gateway setup # Configure platforms
hermes gateway start # Connect to all configured platformsThe gateway runs as a systemd service (or macOS launchd) with automatic restart on failure, SSL certificate auto-detection, and session isolation for multi-user group chats. The v0.3.0 release fixed a number of edge cases: dual gateway processes on macOS after updates, Telegram media group buffering, Discord auto-threading on mentions, and Slack thread handling for progress messages.
"It's not tied to your laptop. Talk to it from Telegram while it works on a cloud VM."
Subagent Delegation
When a task can be parallelized, Hermes Agent spawns isolated child agents. Each child gets a fresh conversation, its own terminal session, a restricted toolset, and a focused system prompt built from the delegated goal.
The parent's context only sees the delegation call and the summary result. It never absorbs the child's intermediate reasoning or tool calls. This is important for context window management: a complex multi-step subtask that would consume thousands of tokens in the parent's context instead costs a single tool call and a summary paragraph.
# Blocked tools for child agents -- no recursive delegation,
# no user interaction, no shared memory writes
DELEGATE_BLOCKED_TOOLS = frozenset([
"delegate_task", # no recursive delegation
"clarify", # no user interaction
"memory", # no writes to shared MEMORY.md
"send_message", # no cross-platform side effects
"execute_code", # children reason step-by-step
])Children cannot delegate further (MAX_DEPTH = 2), cannot interact with the user, and cannot write to shared memory. Up to three children run concurrently via ThreadPoolExecutor. The constraints are deliberate: subagents are workers, not autonomous entities.
Security From the Ground Up
Hermes Agent takes security seriously at every layer. Context files (.hermes.md, AGENTS.md, SOUL.md) pass through injection scanning before they reach the system prompt. The scanner checks for invisible unicode, prompt injection patterns, role hijacking, exfiltration via curl or wget, secret file access, and HTML comment injection.
The v0.3.0 release introduced Codex-inspired smart approvals. The system learns which terminal commands are safe based on your history and preferences. When something risky comes up, it blocks and asks. PII redaction can automatically scrub personally identifiable information before context reaches LLM providers.
Skills created by the agent go through the same security scanning as community hub installs. If a generated skill contains exfiltration patterns or injection attempts, it gets blocked before it can be stored.
Model Freedom, Zero Lock-In
Hermes Agent works with any LLM provider. Nous Portal, OpenRouter (200+ models), OpenAI, Anthropic (with native prompt caching and OAuth auto-discovery), Vercel AI Gateway, z.ai/GLM, Kimi/Moonshot, MiniMax, or your own custom endpoint. Switching is a single command.
hermes model # Interactive model picker
hermes model openrouter:anthropic/claude-opus-4
hermes model anthropic:claude-sonnet-4-20250514
hermes model openai:gpt-5The centralized provider router in v0.3.0 rebuilt the entire model switching system. Auto-detection figures out which provider a model belongs to. Direct endpoint overrides let you point vision or subagent calls at different services. Smart model routing handles reasoning parameter differences across providers.
This model freedom is a strategic advantage for teams with compliance requirements. Pair Hermes Agent with a local Ollama model and you have a fully private agent pipeline where no data leaves your infrastructure.
Research Platform, Not Just a Product
Nous Research is first and foremost a research lab. Hermes Agent reflects this in features most consumer products would never build.
Trajectory compression takes agent interaction traces and compresses them for use as training data. Batch trajectory generation runs the agent against batches of tasks to generate diverse training examples. Atropos RL environments provide reinforcement learning training loops for agent behavior. The v0.3.0 release added Agentic On-Policy Distillation (OPD) for distilling agent policies into smaller models.
A companion repo, hermes-agent-self-evolution, uses DSPy and GEPA (Guided Evolutionary Policy Adaptation) to read execution traces, understand why things failed, and propose targeted improvements. This work was presented as an ICLR 2026 Oral.
"Agent scaffolding matters as much as the underlying model. Three frameworks running identical models scored 17 issues apart on 731 problems in the same February 2026 test."
The research pipeline creates a flywheel. Hermes Agent generates trajectories. Those trajectories train better tool-calling models. Better models make Hermes Agent more capable. Which generates better trajectories. Nous Research is not just building an agent. They are building the infrastructure to improve agents systematically.
The Competitive Landscape
The AI agent space in early 2026 is crowded. Claude Code dominates coding tasks with deep terminal integration and Opus 4.5's 80.9% SWE-bench score. OpenAI's Codex has re-emerged as a serious agentic tool with GPT-5's efficiency advantage. Cursor, GitHub Copilot, and Aider each serve specific niches.
Hermes Agent occupies a different position. It is not optimized for coding benchmarks. It is optimized for being a persistent, learning, cross-platform assistant that compounds value over time. The closest comparison might be the cancelled Google Jarvis project or the concept of a personal AI from science fiction, except it actually exists and runs on commodity hardware.
| Capability | Claude Code | OpenAI Codex | Hermes Agent |
|---|---|---|---|
| Cross-session learning | CLAUDE.md (manual) | None | Automatic skills + memory |
| Model lock-in | Anthropic only | OpenAI only | Any provider |
| Messaging platforms | Terminal only | Web + Terminal | 7+ platforms + API |
| Self-hosted / private | No | No | Yes, fully |
| User modeling | None | None | Honcho dialectic model |
| Terminal backends | Local | Sandboxed | 6 backends (incl. serverless) |
| Scheduled automations | None | None | Built-in cron with delivery |
| RL training pipeline | None | Internal | Open (Atropos + OPD) |
Where Claude Code wins on raw coding quality, Hermes Agent wins on data privacy, cost transparency, extensibility, and the compounding value of persistent learning. For teams that cannot send code to a third-party API, Hermes Agent with a local model is one of the few fully private options in the agentic space.
The Plugin Architecture
The v0.3.0 release introduced a first-class plugin system. Drop Python files into ~/.hermes/plugins/ and they become available as tools, commands, or hooks. No forking required. No PR to the main repo needed.
This matters because it transforms Hermes Agent from "an agent you use" to "an agent platform you extend." Combined with MCP server integration and the agentskills.io skill standard, the extensibility surface is enormous. A company can build internal tools as plugins, share skills across teams via the Skills Hub, and connect to enterprise systems through MCP servers.
The ACP Bridge to IDEs
VS Code, Zed, and JetBrains can now connect to Hermes Agent as a backend through the Agent Client Protocol server. This means you can use your editor's familiar interface while the actual agent logic, memory, skills, and tool execution all run through Hermes.
The ACP integration is clever because it lets Hermes Agent be the persistent brain while different frontends serve as situational interfaces. Edit code in VS Code with Hermes's accumulated project knowledge. Debug from the terminal with full tool access. Get status updates on Telegram while away from the desk. Same agent, same memory, different windows into it.
What to Watch
The project has gone from zero to 8,500 stars and over 1,000 forks since its July 2025 launch. The v0.3.0 release alone touched streaming infrastructure, plugin architecture, the provider system, voice mode, concurrent tool execution, PII redaction, and 50+ bug fixes across every platform. The pace is aggressive.
The self-evolution research (GEPA at ICLR 2026) hints at where this is heading. Today the learning loop creates and refines skills from single-session experience. Tomorrow, evolutionary optimization across trajectory batches could make the improvement process itself more systematic.
The OpenClaw migration path (hermes claw migrate) suggests Nous Research sees the broader personal-agent wave and wants to capture users who outgrow simpler tools. That over a thousand forks exist already shows the community is not just using Hermes Agent but building on top of it.
The bet Nous Research is making is simple: the most valuable agent is not the one with the highest single-session benchmark score. It is the one that knows you, knows your projects, and gets measurably better at helping you over time. If that bet pays off, Hermes Agent will be hard to leave once the learning loop has a few months of accumulated skill.