Hermes Agent: The Open-Source AI That Actually Gets Smarter Over Time
Most AI assistants have the same fatal flaw: they forget everything when the session ends. Every project context, every preference, every hard-won solution — gone. Hermes Agent, released by Nous Research in February 2026, is built to solve exactly that. It's an autonomous, open-source agent that lives on your server, remembers what it learns, and gets genuinely more capable the longer it runs.
What Makes It Different
Hermes Agent is not a chatbot with a memory toggle. It is a persistent runtime with a closed learning loop — a system designed to compound knowledge over time rather than start fresh each conversation.
The loop works like this: when you give Hermes a complex task, it solves it. When it finishes, it writes a reusable skill document — a structured procedure it can call on later without re-explaining the context. Skills self-improve during use. The agent periodically nudges itself to persist knowledge it might otherwise lose. And every past conversation is searchable via full-text search with LLM-generated summaries.
In short: it learns like a person who takes notes, not like a session that expires.
The second major differentiator is where it lives. Hermes Agent is not a desktop app or an IDE plugin. It runs as a server-side gateway process on infrastructure you control — a $5 VPS, a GPU cluster, or a serverless platform like Daytona or Modal that costs nearly nothing when idle. You talk to it from Telegram, Discord, Slack, WhatsApp, Signal, or the CLI — and it works on your projects while you sleep.
Architecture at a Glance
The system is organized around three layers:
The Agent Runtime — A Python-based loop that receives messages, calls tools, and manages context. It uses a toolset system with 47 built-in tools covering web search, file operations, code execution, browser control, and more.
The Memory System — Five distinct layers:
- FTS5 full-text search across all session history
- Vector memory for semantic retrieval
- Honcho dialectic — a model of the user's communication style and preferences
- Episodic memory — records of what the agent tried, succeeded at, and failed at
- Skills — procedural documents the agent writes and reuses
The Gateway Layer — Connects the agent to 14+ platforms simultaneously. Telegram, Discord, Slack, WhatsApp, Signal, Matrix, Mattermost, Email, SMS, DingTalk, Feishu, WeCom, and Home Assistant all run from a single process.
Execution Environments
Hermes Agent can run on six backends:
| Backend | Use Case |
|---|---|
| Local | Development, single-machine use |
| Docker | Containerized isolation |
| SSH | Remote servers |
| Daytona | Serverless with persistent state |
| Singularity | HPC environments, GPU clusters |
| Modal | Serverless GPU workloads |
Daytona and Modal are particularly interesting — they hibernate when idle and wake on demand, meaning the agent's environment can persist across days or weeks at near-zero cost between active sessions.
Model Agnosticism
One of the strongest design choices in Hermes Agent is that it is fully model-agnostic. You are not locked into a specific provider. The agent ships pointed at Claude Opus via OpenRouter by default, but you can switch with a single command:
hermes model
Supported providers include:
- Nous Portal — Nous Research's own inference service (first-class OAuth integration)
- OpenRouter — Access to 200+ models
- OpenAI — GPT-4o and family
- Anthropic — Claude models
- Hugging Face — Inference API (added in v0.5.0)
- Custom endpoints — Any OpenAI-compatible API
The v0.5.0 release (March 28, 2026) added Hugging Face as a first-class provider with a setup wizard and model picker, along with Nous Portal expanding to over 400 available models.
Research-Ready Features
Because Hermes Agent comes from an AI research lab, it includes tooling that most personal agents skip entirely:
- Batch trajectory generation — Run the same task across hundreds of variations and collect all the tool-calling traces
- Atropos RL environments — Reinforcement learning environments for training agent behaviors, built by Nous Research
- Trajectory compression — Fit training data into token budgets for fine-tuning
- 11 tool-call parsers — Parsers for different model tool-calling formats, useful for training new models
This positions Hermes Agent as both a daily-driver assistant and a research platform for generating the kind of agentic training data that frontier labs need.
Installation and Setup
Getting started takes about two minutes on Linux, macOS, or WSL2:
# Install everything automatically
curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash
# Run the interactive setup wizard
hermes setup
The installer handles Python, Node.js, dependencies, and the hermes command. No sudo required. After setup, you configure your messaging platforms and model provider.
For development contributions:
git clone https://github.com/NousResearch/hermes-agent.git
cd hermes-agent
curl -LsSf https://astral.sh/uv/install.sh | sh
uv venv venv --python 3.11
source venv/bin/activate
uv pip install -e ".[all,dev]"
python -m pytest tests/ -q
The Skills System and agentskills.io
Hermes Agent uses the agentskills.io open standard for its skill documents. This is the same standard supported by Claude Code, Cursor, GitHub Copilot, and Google Gemini CLI. Skills built for Hermes work on other platforms, and skills built on other platforms work in Hermes.
The Skills Hub at agentskills.io is a community marketplace where users share skill documents for specific tasks — CI pipelines, database migrations, documentation workflows, and more. Hermes Agent can browse and install these directly.
The agent also creates skills autonomously. After solving a complex, multi-step problem, it writes a skill document that captures the procedure so it can repeat it without rebuilding the context from scratch.
Version 0.5.0: The Hardening Release
The most recent release as of April 2026 is v0.5.0 (v2026.3.28), nicknamed "the hardening release." Key additions:
- Hugging Face as a first-class provider — Full HF Inference API integration with auth and a model picker
- Nous Portal now hosts 400+ models — Massive expansion of the native inference portal
- Telegram Private Chat Topics — Project-based conversations with functional skill binding per topic
- Native Modal SDK — First-class Modal integration with the agent's serverless backend
- Plugin lifecycle hooks —
pre_llm_call,post_llm_call,on_session_start, andon_session_endhooks for extensibility - Supply chain hardening — Removed the compromised
litellmdependency, pinned all version ranges, fixed multiple CVEs - Nix flake — Full NixOS module with persistent container mode
- 50+ security and reliability fixes — Including per-model native output limits replacing hardcoded
max_tokensvalues
Comparison to Alternatives
| Factor | Hermes Agent | Claude Code | OpenClaw |
|---|---|---|---|
| License | MIT | Proprietary | MIT |
| Persistent memory | 5-level (FTS5, vector, episodic, skills) | Session-only | Markdown-based |
| Self-improving | Yes (autonomous skill creation) | No | No |
| Local inference | Ollama, vLLM, llama.cpp | No | No |
| Model providers | 6+ | Claude only | Multiple |
| Messaging platforms | 14+ | None | 50+ |
| Research tooling | Yes (Atropos, batch trajectories) | No | No |
| Setup complexity | Moderate | None (SaaS) | Moderate |
Hermes Agent's closest competitor on the self-improvement axis is genuinely hard to find — most agents are session-based. On the multi-platform messaging axis, OpenClaw leads with 50+ channels, but Hermes Agent has a depth advantage: deeper backends, research tooling, and model flexibility.
Who Should Try It
Hermes Agent is a strong fit if you:
- Want a personal AI assistant that builds institutional knowledge over months of use
- Work across multiple messaging platforms and need a single agent that follows you
- Need local or private inference for compliance reasons
- Are an ML researcher who wants to collect tool-calling trajectories for training
It is less ideal if you want a polished, zero-setup SaaS experience (use Claude Code or OpenAI's agents), or if you need the broadest possible channel coverage today (OpenClaw has more integrations).
The Business Model
The agent itself is MIT-licensed and free. Nous Research's monetization is Nous Portal — their inference service that hosts Hermes-4 and hundreds of other models. You get $5 in free credits when you sign up, and the agent has first-class OAuth integration so switching to the paid tier is seamless.
The strategy is straightforward: give away the best agent framework, sell the compute. It's the same playbook as Postgres vendors, Elasticsearch, and Kubernetes. For users, the free tier is genuinely generous — you can run the agent indefinitely on a small VPS or local machine, paying only for API tokens.
The Bottom Line
Hermes Agent is real software with serious engineering behind it. 220 contributors, 38,000+ GitHub stars, 47 built-in tools, six execution backends, 14 messaging platforms, a five-layer memory system, and a research pipeline that produces training data. The "grows with you" tagline is more than marketing — the episodic memory, autonomous skill creation, and FTS5 cross-session recall are genuine architectural features, not session extensions.
Whether the learning loop compounds into something meaningfully smarter over months of use is still being proven in practice. But for developers, researchers, and operators who want a persistent agent that runs on their own infrastructure, learns their stack, and doesn't reset after every conversation, Hermes Agent is currently the most complete open-source option available.
Prompt engineering and agent workflow writer covering orchestration, evaluation, guardrails, and practical ways to ship reliable AI systems.