Hermes Agent Beginner's Guide: A Self-Evolving AI Assistant

AI Agent fans have been buzzing about one project lately—Hermes Agent racked up 41.7K GitHub stars in just two months. A Bilibili creator put together a step-by-step tutorial covering everything from its positioning to installation. In this piece, I'll combine the video's key takeaways to explain what makes Hermes special and how ordinary users can get it running.

What Exactly Is Hermes Agent

In the creator's words, Hermes isn't "just another Agent tool"—it's "the first AI Agent that comes with reins out of the box." You don't have to write configs or maintain rules yourself; it learns how to work better for you on its own.

Behind this positioning is a key backdrop: in early 2026, the AI coding world reached a consensus that the bottleneck isn't the model itself but the environment. One team ran an experiment where, without changing a single line of the model, they only adjusted the surrounding rule constraints and memory system—and scores jumped from 52.8% to 66.5%, with rankings leaping from Top 30 to Top 5. Mitchell Hashimoto named this Harness Engineering—essentially building reins for AI: every time the AI makes a mistake, you add a rule so it doesn't repeat it.

The problem is that traditional Harness Engineering relies entirely on manual execution: writing docs, configuring sandboxes, building memory systems. What Hermes does is build all five components in—shifting from "you build reins for AI" to "AI builds reins for itself."

Harness Engineering is a practice that emerged in the AI coding world in early 2026. Its core idea: with model capability held constant, improve AI's actual performance by designing external rule constraints, tool permissions, memory systems, and feedback mechanisms. Mitchell Hashimoto systematized and named it, emphasizing the iterative method of "add a rule every time AI makes a mistake." It shifts Agent development from "tuning the model" to "building the environment"—the key backdrop for understanding Hermes's design motivation.

How It Differs from Claude Code and OpenClaw

This is the question everyone cares about most after the OpenClaw^Ad craze. The video offers a comparison table: manual implementation requires some technical skill, while Hermes is ready out of the box—the instruction layer becomes a Skill system, the constraint layer becomes Tool Permissions plus sandboxing, the feedback layer becomes a self-improving learning loop, the memory layer becomes three-tier memory plus user modeling, and the orchestration layer becomes sub-Agent delegation plus Chrome scheduling.

A common misconception is that Hermes will replace Claude Code or OpenClaw, but the three actually solve problems at different levels. Claude Code is interactive coding—you sit at the terminal and converse with it; OpenClaw is configuration-as-behavior—you write docs to make it what you want, with a mature ecosystem of over 44,000 community Skills; Hermes does autonomous operation plus self-awareness—you don't need to sit beside it, it runs, learns, and evolves on its own, staying online 24/7.

Using the creator's metaphor: OpenClaw is a lobster you raise, Hermes is a lobster that grows up on its own—one relies on your careful feeding, the other learns from its own experience. All three adopt the Agent Skills standard, so Skills are interoperable—a Skill written in Claude Code works in Hermes too.

Under the Hood: How the Learning Loop Works

The most surprising thing about Hermes isn't what it can do, but what it will do—the more you use it, the better it gets.

The learning loop has five interlocking stages:

Active memory: After each conversation round, Hermes actively decides which information is worth remembering, rather than passively storing all chat history. Like a person writing a diary, it reviews what was discussed and what preferences the user expressed, then writes what's worth remembering into the database with an FTS5 full-text index.

Autonomous Skill creation: After completing a relatively complex task, it asks itself "will this solution be used again?" If yes, it distills it into a Skill document. For example, if you have it clean a CSV and import it into a database, it might create a CSV2Database.md—next time you say "import this CSV," it directly loads the Skill instead of starting from scratch.

Skill self-improvement: This is the most critical stage. Creating a Skill isn't the endpoint—each time you give feedback during use, Hermes doesn't just fix this instance; it goes back and modifies the Skill document itself. If you say the import script should check whether the table exists first, then next time the Skill is used, the check step is included by default.

FTS recall: The key to memory isn't storing a lot, but finding accurately. Hermes uses the database's FTS5 extension for full-text indexing—before each conversation starts, it searches relevant history based on the current topic and loads only relevant content. All data stays local, no server upload needed; when moving, just copy the Hermes directory.

User modeling: Going further, it reasons about what kind of person you are. You've never said you prefer concise code style, but it infers it by analyzing your patterns of code edits across multiple instances—it can even catch inconsistencies between what you say and what you do.

These five stages form a closed loop: memory feeds Skills, Skills generate new skills during use, new skills trigger Skill improvements, improved Skills produce better results, and better results make user modeling more accurate. The more you use it, the stronger every stage becomes simultaneously.

FTS5 full-text index is a built-in extension module of the SQLite database that uses an inverted index to implement efficient keyword full-text search, supporting prefix matching, phrase queries, and relevance ranking (BM25). In Hermes, FTS5 is used to index historical conversations and memory entries, enabling the Agent to quickly recall relevant history snippets based on the current topic before a conversation begins, without stuffing everything into the context window. Compared to vector retrieval, FTS5 requires no additional models, runs fully locally, and uses few resources—suitable for lightweight memory retrieval in personal-grade Agents.

Three-Tier Memory System: From Goldfish to Old Friend

Most AI chat tools have goldfish-like memory—what was said last round is forgotten the next. Hermes aims to be an old friend.

An active user chats a few thousand words a day with AI, which adds up to tens of thousands a month. Storing everything either overflows the context window or makes the model sluggish from too much information. Hermes solves this with a three-tier architecture:

Session memory answers "what happened"—each conversation round is written to the database with a full-text index, retrieved on demand rather than fully loaded. Persistent memory answers "who you are"—it stores persistent state distilled from conversations: preferences, project structure, habits, commonly used tools, maintained across sessions. Skill memory answers "how to do things"—each Skill is a Markdown document recording methodology and operating standards.

These three tiers correspond to three types of memory in cognitive science: episodic memory, semantic memory, and procedural memory. Like learning to ride a bike—after falling a few times, your body knows to lower its center of gravity.

The creator also pointed out limitations: there's currently no automatic expiration mechanism, so the memory database keeps growing with long-term use, requiring periodic checks and cleanup of outdated Skill documents; also watch out for memory pollution—erroneous information remembered early on may persistently affect subsequent behavior.

Episodic, semantic, and procedural memory are three categories of long-term memory in cognitive psychology: episodic memory stores specific events and experiences ("last Wednesday we discussed that project"), semantic memory stores abstract facts and concepts ("the user prefers Python over Java"), and procedural memory stores skills and operation flows ("how to ride a bike"). Hermes's three-tier architecture is an engineering mapping of this division: session memory corresponds to episodic memory, persistent memory corresponds to user-profile-style semantic memory, and Skill memory corresponds to reusable procedural memory. This analogy isn't just rhetoric—it also explains why tiering is necessary: the three types of information differ fundamentally in storage duration, retrieval method, and update frequency.

Tools and Security: 40+ Tools Plus Triple Constraints

No matter how smart an Agent is, it can't get real work done without tools. Hermes has 40+ built-in tools in five categories: execution (running commands and manipulating documents), information (search and browser automation), media (processing images and voice), memory (managing memory and Skills), and coordination (delegating sub-Agents and multi-model reasoning).

A few worth mentioning separately: Session Search uses FTS full-text search over historical conversations—most Agents lack this capability; Chrome Job defines scheduled tasks in natural language, no Cron expressions needed; Delegation launches up to three sub-Agents working in parallel. MCP can be enabled on demand to connect to services like GitHub, databases, and Slack.

Security has triple constraints: Tool Set controls which tools are available, Code Execution runs in a sandbox, and Session can specify a restricted toolset—giving enough capability to complete the task but no excess permissions.

MCP (Model Context Protocol) is an open protocol proposed by Anthropic for connecting AI models to external tools and data sources in a standardized way. It defines communication specifications between clients and servers, enabling Agents to connect on demand to services like GitHub, databases, and Slack without writing separate adapter code for each integration. Hermes supports enabling MCP on demand, meaning users can extend the tool ecosystem without modifying core code—another interoperability path beyond the Agent Skills standard.

Step-by-Step Installation: Windows Users Go Through WSL

Theoretically it supports Windows, macOS, and Linux, but Windows is conditionally supported—you can't install directly in CMD or PowerShell; you need WSL (Windows' built-in Linux subsystem). macOS and Linux can install directly.

The video demonstrates the WSL flow: open PowerShell, launch WSL to enter the Ubuntu system, first use apt install to install Git (skip if already installed), then copy the installation script from the Hermes Agent official website and run it. Installation takes about ten-plus minutes and installs dependencies like Node.js and FFmpeg.

After installation, choose a model—it supports OpenAI, Anthropic, GitHub, and several domestic providers; pick one for which you have an API Key. The video uses DeepSeek^Ad. Then configure the API Key, Base URL, and model ID, and select an instant messaging tool (WeChat and others supported). When the success screen appears, it's installed.

To use it, just run the hermes command to enter the terminal interface. Operation is similar to Claude Code, but it has no graphical interface—terminal only. Unlike Claude Code, which doesn't support instant messaging apps, Hermes supports WeChat, DingTalk, and others—a practical differentiator.

A Few Judgments

Hermes's approach represents one direction for AI Agents: shifting from passive tool execution to proactive learning partnership. Its self-improvement loop and three-tier memory do solve some real pain points—finding memory accurately matters more than storing a lot, and automatic Skill evolution is more sustainable than manual maintenance. But be clear-eyed: results depend on large model capability and feedback quality, and memory pollution and database bloat are real issues users must manage themselves. For developers wanting to try it out, following the video's flow costs little and gives a direct feel for what "self-evolution" actually means.