This is the second post on this site that takes the form of an architectural reading of someone else’s open-source project. The first was OpenClaw. This one is on Hermes Agent — released by Nous Research in February 2026, MIT licensed, currently at v0.15.2. The reasons for the long-form treatment are the same: Hermes encodes a set of architectural ideas that are worth understanding regardless of whether you ever run the software, and the broader 2025–26 self-hosted agent landscape is converging on patterns that are easiest to see when you compare two well-designed implementations of them.
What makes Hermes specifically interesting is the closed learning loop — the architectural commitment that every successful run becomes a reusable skill, and every reusable skill makes the next run faster, cheaper, and more reliable. Most agent frameworks have something resembling skills (folders of instructions, the SKILL.md pattern that’s now standard); what’s different here is that Hermes treats skill creation as a first-class system behavior, not a thing the human does between sessions. The agent does a task, succeeds, distills what it just did, writes it down as a skill, and that skill is available to itself and to any future instance from the next message onward. The growth curve this produces is the headline feature.
The rest of the architecture is built to support that loop: persistent memory so successful runs aren’t forgotten; context compaction so the running history doesn’t blow out the context window; a multi-platform gateway so the agent can be reached the same way regardless of which messaging client is in front of you; an execution sandbox so the act of running skills (often shell scripts or Python) doesn’t compromise the host machine; and a careful cost model that makes the per-message pricing visible enough that you can actually budget for it.
This monograph reads all of that carefully, draws the block diagrams, walks through a worked example turn-by-turn, and includes the comparison to OpenClaw and the other 2025–26 self-hosted agents that lets you decide which architectural choice is right for the system you’re trying to build.
What it covers
Twenty-one sections plus references, about thirty-eight minutes of careful reading. Designed for the engineer who wants to extract reusable architectural ideas rather than for a Hermes user reading the install guide.
§ 01–02 — Foundations. What “agent” actually means in this design (the precise definition, as distinct from the marketing definition). What Hermes is — the elevator description, the five-pillar summary that organizes the rest of the monograph.
§ 03 — System architecture, from the outside in. The block diagram. Gateway, agent loop, memory, skill registry, execution sandbox, model providers. Where the trust boundaries are. What runs in-process vs out-of-process.
§ 04 — Persistent memory. The memory subsystem. Short-term context (current conversation), long-term factual memory (the vector store of things-the-agent-knows-about-you), and the summarization passes that prevent context-window explosion. The relationship to the broader Knowledge & Memory taxonomy.
§ 05 — Context engineering & compaction. The mechanics of fitting a long-running session into a finite context window. How Hermes decides what to summarize, what to evict, what to keep verbatim. The relationship to the From RAG to Context Engineering post for the broader picture.
§ 06 — The closed learning loop & skills. The architectural heart of the system. How a successful task becomes a skill. The distillation process. The progressive-disclosure SKILL.md format. Why this loop is the difference between “agent that does the same thing five times” and “agent that gets better the fifth time.”
§ 07 — A worked example, turn by turn. A single conversation traced through the entire system. The user request, the model’s plan, the skill selection, the tool calls, the response, the post-run distillation, the new skill that was written. Timing notes for where latency lives.
§ 08 — The multi-platform gateway. The channel adapters. WhatsApp, Telegram, Slack, Discord, Signal, iMessage, plus a web UI. How messages from any of them normalize to the same internal format. The pattern Hermes shares with OpenClaw and the few places they differ.
§ 09–10 — Parallel sub-agents & execution. When the agent spawns helper sub-agents (and when it shouldn’t). The execution sandbox — how shell commands and Python scripts run safely on the host. The trade-off between fidelity and isolation.
§ 11 — Security & prompt injection. The threat model. Untrusted user input. Untrusted tool output. The defenses that work and the ones that are still open research. Why “this agent runs on my own hardware” doesn’t, by itself, make it safe.
§ 12 — Models & the Nous Portal. Which models Hermes is designed to work with (Claude, GPT, Llama via Portal, local via Ollama). The portal abstraction that lets you swap providers without rewriting prompts. Performance differences observed in practice.
§ 13 — Cost & sizing. The interactive cost model. Per-message economics. How the closed learning loop drives unit cost down over time (this is the killer chart). The break-even point versus a stateless agent.
§ 14 — MLOps for a personal agent. Version control, observability, the upgrade story. What’s different about ML-ops when there’s one user and one host instead of an enterprise deployment.
§ 15 — Hermes Desktop. The desktop app variant. What changes when the agent has direct access to your filesystem and applications rather than going through messaging APIs.
§ 16–17 — How it compares & engineering fit. Side-by-side with OpenClaw, with LangChain-based agents, with Claude Code and the other 2025–26 reference implementations. The decision matrix for which one to choose for which engineering context.
§ 18–20 — Practical notes, lessons learned, glossary. The hard-won observations from running the system. The architectural lessons that generalize beyond Hermes. The glossary of every term used in the monograph.
§ 21 — FAQ & limits. What Hermes can’t (yet) do. The open questions. The places the architecture would have to change to handle them.
References. Links to the Nous Research documentation, the GitHub repository, the related agent projects (OpenClaw, Claude Code, AutoGPT v3), and the academic literature on agent learning loops.
Read it
The monograph lives at its own URL with a warm-paper editorial layout — rust accent, sticky TOC, twenty-one sections plus block diagrams and an interactive cost model. Written as a careful architectural reading of Nous Research’s published documentation rather than as a tutorial; references to the official sources are collected at the end.
← Back to Autonomy