This is a submission for the Hermes Agent Challenge

Most AI agents have a memory problem they don't admit to. Every session ends, the context resets, and tomorrow you're explaining your codebase, your preferences, and your constraints from scratch again. Hermes Agent by Nous Research is the first open-source agent that structurally solves this - not through a configurable memory feature, but through a closed learning loop baked into the agent runtime itself.

Why Every Other Agent Forgets

The standard agentic loop is three steps: receive task, plan and execute, return result. State resets. The next task starts blank.

Most frameworks tried to patch this with long-term memory bolted on after the fact - a vector database that stores embeddings of past conversations. The problem is that vector retrieval answers the question "what did we talk about that was similar to this?" It doesn't answer "how did I actually solve this class of problem last time, and what were the exact steps?" Those are different questions, and conflating them is why most "memory-enabled" agents still feel stateless in practice.

Hermes Agent adds two steps after the response is returned. Step four: the agent receives an internal nudge to evaluate whether the session is worth persisting. Step five: if the task involved five or more tool calls, the agent autonomously writes a skill document describing exactly how it was solved, then indexes it into memory for every future session. That's the loop. And it's the reason the project crossed 100,000 GitHub stars seven weeks after launching on February 25, 2026.

The Five Stages in Practice

Understanding the loop means understanding what actually happens between "you send a message" and "the agent responds."

A message arrives - from CLI, Telegram, Discord, Slack, WhatsApp, Signal, or a scheduled cron job. They all enter the same execution engine. Before the model sees your query, the agent runs retrieval: it queries a local SQLite database with FTS5 full-text search, pulling relevant past skills and notes at roughly 10ms latency across 10,000+ indexed documents. The model then plans, invokes tools, executes, and streams output - that's the ordinary agent loop you know.

After the response, the loop diverges. The agent checks its own session. Did this involve meaningful tool sequences? Is there a generalizable procedure here? If yes, a skill document gets written to ~/.hermes/skills/ in plain Markdown following the agentskills.io open standard. That file is immediately searchable by every future session. The next time a similar problem arrives, Hermes retrieves the procedure rather than rediscovering it.

The practical result: independent benchmarks show agents carrying 20+ self-created skills complete similar future research tasks roughly 40% faster than fresh agent instances on the same job. The honest caveat is domain specificity - a skill learned from summarizing GitHub PRs doesn't transfer to planning database migrations. Cross-domain generalization is still unsolved. But within a narrow, repetitive domain, the compounding effect is real and measurable.

Four Memory Layers, Each Solving a Different Problem

The learning loop is the process. The memory system is what it writes into, and it's split across four distinct layers.

Session memory is ordinary context management - the current conversation window. Nothing novel, but Hermes exposes /compress, /usage, and /insights slash commands so you can monitor and control it explicitly rather than waiting for silent overflow.

Persistent memory is the SQLite FTS5 store where completed task outcomes and agent-curated notes live. Everything sits in ~/.hermes/ on your own machine - no cloud round-trips, no telemetry, no third-party memory provider. The architecture scales comfortably to around 100K documents before you'd want to swap in a dedicated vector store like Qdrant or Chroma.

The skill document store is the output of the learning loop. Skills are plain Markdown files - portable, human-readable, diff-able in version control. Crucially, only skill names and brief descriptions load into the system prompt by default. Full skill bodies load on demand. That design is why a library of 200 skills doesn't blow your context budget. As of v0.10.0, Hermes ships 96 bundled skills plus 22 optional ones across 26+ categories covering MLOps, GitHub workflows, research pipelines, scraping, code execution, and more.

Honcho is the optional fourth layer - a user modeling system built via integration with Plastic Labs' dialectic architecture. Honcho passively accumulates your preferences, communication style, tech stack, and domain vocabulary across sessions. It's the layer that gives the "grows with you" quality after several hundred interactions. For task-specific deployments, the other three layers are usually sufficient.

One trade-off worth naming: the memory system is automatic but not fully transparent. You can't export "everything Hermes knows about me" as a single human-readable file. If you're operating under GDPR, HIPAA, or CMMC constraints, factor that into your deployment decision.

Skills Are the Interface Between Learning and Utility

A skill in Hermes terms is a Markdown document describing how to accomplish a specific procedure - which tools to invoke, in what order, with what parameters, and what pitfalls to avoid. Two kinds coexist: the bundled catalog that ships with every install (curated and security-reviewed by Nous Research), and auto-created skills generated by the learning loop itself.

Because skills follow the agentskills.io open standard, they're not locked to Hermes. The same file can run inside any framework that implements the spec. As of mid-April, the community hub was carrying 643 reviewed skills - smaller than OpenClaw's 13,000+ marketplace, but curated in a way that sprawling open marketplaces typically aren't.

One practical gotcha: auto-generated skills from moderate tasks (5–10 tool calls) tend to be tight and reusable. Skills generated from very complex multi-phase tasks (50+ tool calls) sometimes over-generalize or bake in too much session-specific context. A manual review pass of auto-generated skills during your first month of use is time well spent.

Why This Architecture Actually Matters

The agent space in 2025 and early 2026 was dominated by a certain kind of demo: impressive one-shot task execution, elegant tool orchestration, clean architecture diagrams. What almost nobody shipped was an agent that got measurably better at your specific workflows the longer it ran.

Hermes Agent's learning loop is a structural bet that agents are most valuable not as general-purpose task executors but as accumulating specialists. If your workflows are repetitive and structured - running the same class of tasks against the same codebase over months - Hermes compounds in ways that prompt-engineered agents simply cannot match. If your workflows are broad and constantly different, the loop has nothing to work with, and the skill library stays thin.

Know which category you're in before architecting around this. The self-improving agent is a compelling abstraction, but it earns its value through repetition. A month of daily use inside a narrow domain will teach you more about whether this architecture fits your work than any benchmark.

There's also a research angle that doesn't get enough coverage. Nous Research built Atropos RL environment integration and trajectory export directly into Hermes. Every run, every successful tool sequence, every generated skill is a candidate trajectory for fine-tuning smaller, purpose-built models. Hermes isn't just an application - it's a data pipeline for the next generation of tool-calling models, built by the lab that trains them. That dual-use architecture is rare, and it's worth understanding if you're thinking about this space beyond the immediate "build an agent" use case.

Getting Started

# Install on Linux / macOS / WSL2
curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash

# Set your model provider
hermes model

# Start your first session
hermes

Full documentation at hermes-agent.nousresearch.com/docs. The quickstart gets you to a running agent in under five minutes.

The Bigger Question

The open-source agent field is still mostly asking "can the agent do this task?" Hermes Agent is asking a different question: "does the agent get better at this task over time?" Those are not the same question, and the second one is harder.

Whether the learning loop delivers compounding improvement at the architectural level - not just better UX - is something the research community is still working out. The hermes-agent-self-evolution companion project applies DSPy and GEPA to optimize skills and prompts against benchmarks. If that feedback loop produces measurable improvement on public evals, the "self-improving" framing holds. If gains plateau after a few iterations, the learning loop is a better developer experience - not a better algorithm. Either way, it's the most honest attempt at the problem anyone has shipped in the open.

Every other agent forgets. That's still the baseline. Hermes is trying to make the baseline obsolete.

Follow for more coverage on MCP, agentic AI, and AI infrastructure.