11 minute read

TL;DR: Hermes Agent by Nous Research (MIT, released in early 2026) is a persistent agent runtime that creates reusable skills from experience, stores them, and loads them in future sessions. It had about 26,300 GitHub stars in early April 2026, when v0.7.0 added pluggable memory backends, and about 260,000 by November 2026. The catch: skill quality depends entirely on the base model’s reasoning ability, and the 2,200-character built-in agent memory forces lossy consolidation once it fills.

A circuit board with branching illuminated pathways ending at specialized connectors, representing an agent building its own skill routes


Most AI agents have amnesia. You spend twenty minutes teaching one how to deploy your staging environment, close the session, and the next day it asks you the same questions. Every session starts from zero. The agent is capable, but it never learns.

Hermes Agent, released by Nous Research in early 2026, bets on a different architecture. Instead of forgetting everything between sessions, Hermes watches what it does, identifies patterns worth preserving, and writes them down as reusable skills. The next time a similar task appears, it loads the skill instead of reasoning from scratch.

That sounds like magic. It isn’t. The skill loop has real constraints that most of the people who starred the GitHub repo haven’t hit yet. I want to explain how it actually works, and where it stops working.

What problem does Hermes actually solve?

Stateless agents treat every conversation as a first date. They have no memory of what worked, what failed, or who you are. RAG-augmented agents retrieve documents but don’t learn from their own execution. Fine-tuned models encode knowledge into weights but can’t adapt to individual users at runtime.

Hermes sits in a different category. Nous Research (founded in 2023 by Jeffrey Quesnelle, Karan Malhotra, Teknium, and Shivani Mitra) built it as a persistent agent runtime: a long-running process that maintains state, creates skills, and models the user across sessions. The agent frameworks landscape has options like LangChain and CrewAI for orchestration, but none of them ship with a built-in learning loop.

The framework is Python-based, runs commands through several terminal backends (local, Docker, SSH, Modal, Daytona and others), connects to messaging platforms including Telegram, Discord, Slack, WhatsApp, and Signal, and integrates with MCP servers for tool extensibility. It is MIT licensed. The repository had about 26,300 GitHub stars in early April 2026 and about 260,000 by November 2026.

How does the skill creation loop work?

The skill loop is the core architectural differentiator. Here’s the actual mechanism:

flowchart TD
    A[Agent executes task] --> B{Task completed successfully?}
    B -->|No| A
    B -->|Yes| C[Evaluate: non-trivial workflow?]
    C -->|No| D[Log to episodic memory]
    C -->|Yes| E[Codify steps into named skill]
    E --> F[Store skill as structured file]
    F --> G[List skill by name + description]
    G --> H[Future task arrives]
    H --> I{Matching skill exists?}
    I -->|Yes| J[Load skill, execute with current context]
    I -->|No| A
    J --> K{Skill needed changes?}
    K -->|No| L[Keep skill as is]
    K -->|Yes| M[Patch skill via skill_manage]
    M --> F

There is no fixed task count. Hermes’s system prompt tells the agent to save non-trivial workflows: a multi-step task worth repeating, a dead end where it found the working path, or a case where the user corrected its approach. A background review after a session can also suggest skill changes. The agent writes the reusable pattern as a SKILL.md file (YAML front matter with name, description and version, plus a Markdown body, compatible with the agentskills.io format). The skill_manage tool handles creating, patching, editing, and deleting skills.

This is not reinforcement learning. The model’s weights don’t change. What changes is the agent’s prompt: the agent sees a list of skill names and descriptions, and loads a full skill into context only when it decides the skill applies. Think of it as the agent writing its own system prompts for specialized workflows.

The sous chef analogy works here. A sous chef who successfully plates a complex dish writes down the recipe for next time. The recipe doesn’t make the chef more skilled. It makes the chef faster at a task they already know how to do. If the chef learned a bad technique, the recipe preserves the bad technique.

What does the memory architecture look like?

Hermes v0.7.0 (released April 3, 2026) made memory an extensible plugin system, which addresses the most common complaint about earlier versions. The architecture loosely maps to the hierarchical memory model covered in an earlier post:

Layer Purpose Storage Limit
Working memory Current session context In-context window Model’s context length
Agent notes Environment facts, conventions, things learned MEMORY.md (built-in) or external backend 2,200 chars built-in
User profile Preferences, communication style USER.md, optionally Honcho dialectic modeling 1,375 chars built-in

The built-in memory uses two small text files: MEMORY.md for the agent’s notes (2,200 characters) and USER.md for the user profile (1,375 characters). Memory does not auto-compact. When a write would exceed the limit, the memory tool returns an error and the agent has to consolidate or delete entries before retrying. That consolidation is lossy. Details get flattened. Nuance disappears.

v0.7.0’s fix: pluggable memory providers. As of November 2026, the docs list RetainDB and ByteRover as bundled plugins, with Honcho, Hindsight, Supermemory, Mem0, OpenViking, and Holographic installable from the plugin catalog. Swap out the built-in store for a dedicated memory backend and the capacity constraint largely goes away. But the default experience, the one most new users encounter, still hits that wall.

The user modeling layer uses Honcho’s dialectic profiling to build a persistent model of who you are: your preferences, communication style, domain expertise. This runs across sessions and informs how the agent frames responses. It’s the difference between an agent that says “here’s how to deploy to Kubernetes” and one that says “since you prefer Helm charts over raw manifests, here’s the Helm approach.”

Where does self-improvement break down?

This is the section most Hermes coverage skips. Three failure modes matter in practice.

Failure 1: weak models create weak skills. Hermes is model-agnostic: it runs on DeepSeek, MiniMax, OpenAI, or local models via Ollama and vLLM. A cheap model costing a few dollars a month will create skills, but those skills reflect that model’s reasoning quality. If the model makes a suboptimal choice during task execution, the skill codifies that suboptimal choice. The learning loop amplifies whatever the base model does, good or bad. Tool-calling ability varies a lot between models of similar size (Nous Research reported 90% for its own Hermes 2 Pro on a function-calling evaluation it built with Fireworks.ai), and the gap between a well-chosen and poorly-chosen base model compounds over time.

Failure 2: skill proliferation without curation. An agent that creates skills aggressively accumulates hundreds of them. Hermes uses progressive disclosure, so the agent sees only names and descriptions until it opens a skill, but a list of 200 overlapping skills is still noisier to choose from than a list of 40. Without manual curation (reviewing, pruning, merging), the skill library becomes a junk drawer. Profiles can segment skills by context, but the curation burden still falls on the operator.

Failure 3: memory compression destroys context. The built-in 2,200-character agent memory forces aggressive summarization once it fills. A conversation about debugging a specific PostgreSQL replication issue becomes “user works with PostgreSQL.” The fix exists (pluggable backends in v0.7.0), but it requires infrastructure setup that most users skipping-through-the-README won’t do.

How does Hermes compare to other agent frameworks?

The comparison most people reach for, Hermes vs. ChatGPT, is wrong. ChatGPT is a conversational interface. Hermes is a persistent process. The right comparisons:

Feature Hermes Agent OpenClaw LangChain/CrewAI Claude Code
Persistent memory Yes (pluggable) Yes (stored locally) No (manual) CLAUDE.md memory files
Skill creation Autonomous Skills and plugins (ClawHub) No Agent Skills, written by user or on request
Self-hosted Yes (MIT) Yes (MIT) Yes Runs locally, model via API
Messaging platforms Telegram, Discord, Slack, WhatsApp, Signal, more 20+ None built-in Terminal, IDE, web
MCP integration Yes Yes Partial Yes
GitHub stars (Nov 2026) ~260,000 ~394,000 ~149,000 (LangChain) N/A

OpenClaw is the closest competitor (see OpenClaw as a gateway layer). A useful framing is learning depth (Hermes) vs. ecosystem breadth (OpenClaw). Both are self-hosted and MIT licensed; Hermes is cheap to run for light users but, like any self-hosted runtime, requires operational overhead.

LangChain and CrewAI are orchestration frameworks, not persistent runtimes. They manage agent workflows but don’t create skills or maintain cross-session memory. If you need a persistent agent that grows over time, these aren’t direct alternatives.

Protocol choice matters here too. Hermes adopted MCP for tool extensibility, meaning any MCP-compatible service (GitHub, databases, custom APIs) plugs in directly; for how MCP and agent-to-agent protocols divide the work, see A2A at 150+ organizations.

When should you actually use Hermes?

Hermes fits a specific profile. Use it when:

  • Tasks repeat with variation. Deploying to staging, processing invoices, triaging support tickets: workflows where the structure is stable but the details change. The skill loop pays off here.
  • You need persistent context. If your agent needs to remember that the user prefers Python over TypeScript, or that the staging server uses port 3001, session-based tools waste time re-establishing context.
  • You want model flexibility. Running DeepSeek locally for cost, switching to Claude for complex reasoning, using MiniMax for specific tasks. Hermes supports all of these through OpenRouter (hundreds of models) or direct API connections.
  • You control infrastructure. Hermes requires a machine to run on, API key management, and memory backend configuration. If you want a managed service, look at hosted options instead.

Skip Hermes when tasks are one-off and diverse (no skill reuse), when you need true multi-agent coordination (as of April 2026, subagents could not share state), or when your team doesn’t have the operational capacity to manage a self-hosted agent runtime.


Frequently asked questions

What is Hermes Agent?

Hermes Agent is an open-source (MIT) Python-based agent runtime built by Nous Research, released in early 2026. It creates reusable skills from non-trivial tasks, maintains persistent memory across sessions, and connects to messaging platforms such as Telegram, Discord, Slack, WhatsApp, and Signal. Unlike stateless chatbots, Hermes remembers context and improves its workflows over time through autonomous skill codification. The repository had about 26,300 GitHub stars in early April 2026 and about 260,000 by November 2026.

How does Hermes Agent’s skill creation work?

Hermes’s system prompt asks it to save non-trivial workflows as skills: multi-step tasks worth repeating, dead ends where it found the working path, or cases where the user corrected it. It writes them as SKILL.md files with the skill_manage tool. On future tasks, the agent sees skill names and descriptions and loads the full skill only when it applies. Skills can be edited, versioned, and shared through skill hubs or GitHub repositories.

How much does it cost to run Hermes Agent?

The software is free (MIT license). You pay for a server if you do not run it on your own machine (a small VPS costs a few dollars a month) and for model API usage, from a few dollars a month on cheap models for light use to hundreds of dollars a month on frontier models for heavy coding work.

What are Hermes Agent’s main limitations?

Three to watch: (1) the built-in agent memory caps at 2,200 characters (plus 1,375 for the user profile), forcing lossy consolidation once it fills (v0.7.0 added pluggable backends to mitigate this); (2) skill quality depends on the base model’s reasoning, so weaker models create weaker, less generalizable skills; (3) as of April 2026, subagents could not share state or coordinate directly, limiting true multi-agent orchestration.