What Is Hermes Agent?
TL;DR
- Hermes Agent is an open-source AI assistant from Nous Research (MIT, ~128k GitHub stars, v0.12.0 released 2026-04-30)
- Agent-first architecture: it plans, executes, reflects, and retries, not just a gateway in front of an LLM
- Persistent memory: remembers context across sessions; builds a knowledge base about your workflows over time
- Learning loop: after completing a task successfully, Hermes writes a reusable skill document, so it gets faster the second time
Hermes Agent is the agent-first counterpart to OpenClaw's gateway-first architecture. The architectural difference matters in practice: OpenClaw routes your messages to an LLM and runs skills in per-session containers. Hermes maintains a persistent memory store across sessions and, when it successfully solves a novel problem, distils the solution into a reusable skill document. Repeated workflows improve measurably.
Who built it and is it maintained?
Hermes Agent is built by Nous Research, an AI safety and capabilities research lab. The project is MIT-licensed and actively maintained. v0.12.0 shipped 2026-04-30, and the repo sees weekly commits. Nous Research is funded and independent, with no single company controlling the project direction. (Stability flag: healthy as of 2026-05-01.)
GitHub: github.com/nousresearch/hermes-agent
Core architecture
Hermes has three layers that set it apart from gateway-first assistants:
1. Agent runtime (planning and execution)
Instead of routing a single message to an LLM and returning the response, Hermes follows an agentic loop:
User task
↓
Plan (break task into steps)
↓
Execute (call tools, run code, search memory)
↓
Reflect (did the output meet the goal?)
↓ (if not)
Retry with updated plan
↓ (if yes)
Synthesise response
↓
Update skill document (if task was novel and confidence > 0.7)
This loop is what makes Hermes handle complex, multi-step workflows that a simple gateway cannot. Asking "prepare the weekly sales summary from the CRM, compare it to last week, and flag any accounts that dropped > 20%" is a 4-step workflow. Hermes plans it, executes each step with tool calls, and reflects on whether the output looks right before responding.
2. Persistent memory system
Hermes stores three types of memory:
| Memory type | Scope | What it stores | Backend |
|---|---|---|---|
| Working memory | Current session | Active context, intermediate results | In-process |
| Episodic memory | Cross-session | Past task outcomes, user preferences, error history | PostgreSQL |
| Semantic memory | Cross-session, indexed | Extracted knowledge: facts, procedures, relationships | PostgreSQL + pgvector |
When you start a new Hermes session, it loads relevant episodic and semantic memories automatically, so it "remembers" that you prefer concise summaries, that the CRM API uses OAuth2, that the monthly report template lives in /reports/. A fresh OpenClaw session starts with none of this.
3. Learning loop (skill distillation)
When Hermes completes a task with confidence ≥ 0.7, it runs the learning loop:
- Distil: extract the successful steps, tool calls, and decision points from working memory
- Generalise: rewrite the procedure as a reusable skill document (Markdown with structured frontmatter)
- Index: add the skill to semantic memory so future tasks can retrieve and apply it
- Test: run a quick self-test against a synthetic variant of the original task to confirm the skill generalises
The resulting skill document looks like an OpenClaw ClawHub skill (SKILL.md format is compatible) but is auto-generated from Hermes's own experience rather than written by hand.
Comparison to OpenClaw
| OpenClaw | Hermes Agent | |
|---|---|---|
| Architecture | Gateway-first | Agent-first |
| Persistent memory | Session only | Cross-session (PostgreSQL) |
| Learning loop | No | Yes, auto-generates skill docs |
| Messaging platform integration | Yes (10+ platforms) | No |
| Skill system | ClawHub (5,700+ community) | Auto-generated + importable |
| Setup complexity | Low | Medium |
| Idle RAM | ~180 MB (gateway only) | ~2 GB (agent + memory + DB) |
| GPU requirement | No (remote LLM API) | No (remote LLM API); yes for local inference |
| License | MIT | MIT |
Choose OpenClaw when you need messaging platform integration, lower resource requirements, or the ClawHub skill ecosystem.
Choose Hermes when you run the same complex workflows repeatedly and want the assistant to improve over time.
See the full comparison for a broader field including Open WebUI, Dify, AutoGen, and CrewAI.
System requirements
| Configuration | Minimum RAM | Recommended RAM | GPU |
|---|---|---|---|
| Remote LLM API (Claude, OpenAI) | 2 GB | 4 GB | Not required |
| Local Ollama (7B parameter model) | 12 GB | 16 GB | Required (8+ GB VRAM) |
| Local Ollama (70B parameter model) | 52 GB | 64 GB | Required (48+ GB VRAM) |
| Production multi-user | 8 GB | 16 GB | Depends on inference mode |
For remote LLM API mode: a Liquid Web 4 GB Managed VPS is sufficient. Pricing subject to change, so verify at liquidweb.com/vps-hosting/managed-vps/.
For local GPU inference: Liquid Web L40S (48 GB VRAM) covers 70B models. Pricing subject to change, so verify at liquidweb.com/gpu-hosting/.
What Hermes can and cannot do
Can do:
- Multi-step workflows that require planning (research → draft → validate → send)
- Persistent knowledge of your specific context (your tools, your team, your preferences)
- Self-improving skill library that compounds over time
- Tool use: web search, code execution, file I/O, API calls, database queries
Cannot do (as of v0.12.0):
- Messaging platform integration (no Slack/WhatsApp/Telegram bot): use OpenClaw for this
- HIPAA compliance without significant additional configuration and infrastructure controls: a NemoClaw + Liquid Web HIPAA environment is needed for regulated workloads
- Real-time streaming responses: Hermes completes the full agentic loop before responding. For quick one-shot queries, OpenClaw or Open WebUI is faster
v0.12.0 is the first release Nous Research marks as production-ready for remote LLM API mode. Local Ollama integration is stable. The learning loop is experimental, so monitor skill quality for the first few weeks of use. Pin to a specific version tag in production to avoid breaking changes between releases.
No. They solve different problems. Hermes is better for repeated complex workflows where memory and learning matter. OpenClaw is better for messaging platform integration and simpler, lower-resource deployments. Many teams will run both: OpenClaw as the day-to-day messaging bot, Hermes for deep workflow automation.
Hermes writes a skill document when: (1) the task required multiple steps (not a simple one-shot answer), (2) the task succeeded with a confidence score >= 0.7 from self-reflection, and (3) the task type hasn't been successfully solved in the last 10 similar tasks (to avoid writing duplicate skills). You can configure these thresholds in hermes.config.yaml.
Yes, for skill documents in SKILL.md format. Hermes reads the SKILL.md frontmatter and instruction body and adds the skill to its semantic memory as a pre-loaded capability. Not all tool types are supported (Hermes doesn't have ClawHub's platform-specific tool implementations) but the instruction layer is compatible.
Hermes supports any OpenAI-compatible API endpoint: Anthropic Claude (via the official Anthropic SDK), OpenAI GPT-4o, Ollama (local inference), LiteLLM (proxy to 100+ providers), and Groq. Set HERMES_LLM_ENDPOINT and HERMES_LLM_API_KEY in the environment.
Common mistakes and fixes
Hermes Agent starts but reports 'memory backend unavailable'.
Hermes requires a PostgreSQL database for its persistent memory store. Confirm the HERMES_DB_URL environment variable is set and the database is reachable: docker compose exec hermes psql $HERMES_DB_URL -c '\l'. If the memory_backend table doesn't exist, the DB was not initialised. Run: docker compose exec hermes hermes db migrate.
Hermes learning loop produces empty skill documents.
The learning loop only writes a skill document when it completes a task successfully AND rates its own confidence above 0.7. If tasks fail or produce low-confidence outputs, no skill is written. Check logs: docker compose logs hermes --tail 50 and look for 'Skill write threshold not met'. Increase task specificity to produce higher-confidence outputs.
Hermes connection to local Ollama fails with 'connection refused'.
Hermes and Ollama must be on the same Docker network. Add Ollama to the same Compose file (not run separately with 'docker run') and set HERMES_LLM_ENDPOINT=http://ollama:11434. If running Ollama on the host, use the host's Docker bridge IP (typically 172.17.0.1) instead of localhost.
