Appearance
What Hermes Is (and Isn't)
A lot of tools call themselves "AI agents" when what they really are is a chatbot with a system prompt and a file-reading library. Hermes Agent is in a different category, it's an autonomous agent platform that gets more capable the longer it runs, because it remembers what it's done and writes down reusable procedures from its own experience. This lesson places it in the ecosystem so you know what you're working with before you install anything.
What you'll learn
- Hermes is not a coding copilot tethered to an IDE, it runs on servers, messaging platforms, and desktop apps from a single agent core
- The self-improving skill loop is the mechanical difference: when Hermes solves something non-trivial, it can write a SKILL.md that loads automatically in future sessions
- It's provider-agnostic, swap between Anthropic, OpenAI, Google, DeepSeek, or 20+ other providers without changing anything else
The problem: "agent" means too many things
Most tools marketed as agents are really just chatbots with tool access. They take your message, call a tool if the model decides to, return a response, and forget everything when the conversation ends. This is fine for a coding copilot or a Q&A bot. It's not enough for anything that needs to keep running when you close your laptop.
Hermes is designed for the other category: an agent that lives on infrastructure. It runs as a persistent service. It's reachable from Telegram, Discord, Slack, or your terminal, whichever surface you happen to be on. It schedules its own work. It delegates sub-tasks to isolated child agents. And it builds a deepening model of your environment, preferences, and past solutions that makes each session more capable than the last.
Options: where Hermes sits in the ecosystem
| Tool | What it is | Hermes vs. it |
|---|---|---|
| Claude Code / Codex CLI | IDE-centric coding copilots that run in your terminal for a session | Hermes runs as a persistent service, not a session-bound CLI. You can use Claude Code through Hermes (it delegates to Codex and Claude Code as subagents), but Hermes itself is the orchestration layer above them |
| OpenClaw Gateway | A messaging gateway that connects your agent to chat platforms | Hermes has its own built-in gateway with 20+ platform adapters. OpenClaw and Hermes can interoperate, but Hermes doesn't need a separate gateway |
| LangChain / LangGraph | Python frameworks for building agent workflows in code | Hermes is a finished product, not a framework. You configure it with YAML and markdown, not Python. If you need a custom tool, you can register one as a Python plugin |
| ChatGPT / Claude.ai | Browser-based chatbots with no system access | Hermes has full system access: terminal, file I/O, process management, web browsing. It's not limited to a chat window |
The self-improving loop, the thing that's actually different
The feature that separates Hermes from every other agent platform is the closed learning loop. Here's how it works:
This is not a metaphor. The skill_manage tool is a real tool in Hermes's toolset. When the agent works through a complex task, configuring a CI/CD pipeline, debugging a recurring error, setting up a monitoring dashboard, it can write down exactly what it did as a markdown instruction file. That file becomes a skill. Next time a similar task comes up, Hermes loads the skill and follows the procedure it already proved works.
This loop is also why Hermes doesn't need you to pre-author every procedure it might ever need. It builds up its own library over time. The Curator , a background process that tracks skill usage, marks idle skills stale, and archives old ones, keeps the library from becoming cluttered.
What this course assumes
You should be comfortable in a terminal and have a basic understanding of what an AI agent does. If the idea of a tool-calling loop is new to you, start with the flagship course's What Makes an Agent lesson first, this course builds on that foundation and gets moving fast.
This course covers the platform as it exists today. Every command, config key, and feature described here is verified against the current Hermes Agent documentation and the live codebase. Nothing is invented. If a feature changes after this is published, the change log at hermes-agent.nousresearch.com/docs is the authoritative reference.
What goes wrong
| Mistake | How you notice it | The fix |
|---|---|---|
| Assuming Hermes is just "Claude Code but for messaging apps" | You try to use it the same way and hit friction on features that work differently | Hermes is an orchestration platform. It delegates to coding agents like Claude Code and Codex for code-specific work. The agent loop, memory system, and skill system are the platform; coding is one of many things it can do |
| Expecting skills to emerge immediately | After one session, no new skills appear in ~/.hermes/skills/ | The agent creates skills when a task is genuinely non-trivial and reusable. A one-shot "what's the weather" won't produce a skill. A "set up this project's entire CI/CD pipeline" probably will |
| Confusing the memory system with a vector database | You expect semantic search and get keyword results | Hermes uses SQLite FTS5 for session search, it's full-text, not vector. For vector-based retrieval, Hermes connects to external stores (pgvector via MCP, or memory backends like Mem0) |
Confirm it worked
This is a conceptual lesson, the confirmation is being able to answer these questions before moving on:
- What is the mechanical difference between Hermes and a chatbot with tool access?
- What happens in the skill loop when Hermes completes a complex task?
- Which part of the platform would you use to make Hermes reachable from your phone?
If the answers are (1) the persistent self-improving skill loop plus the gateway, (2) it writes a SKILL.md using the skill_manage tool, and (3) the gateway, you're ready for installation.
Next: Installation & Provider Setup , getting Hermes running on your machine.