Hermes Agent Beginner's Guide: Hands-On with a Self-Evolving AI Agent

In the AI programming space, an open-source project called Hermes Agent has recently surged in popularity on GitHub, gaining 41.7K stars in just two months. Unlike traditional AI Agent tools, Hermes Agent's standout feature is that it "comes with its own reins from the factory"—users don't need to manually write configurations or maintain rules; instead, it can autonomously learn and optimize its own behavior. Based on a detailed tutorial from a Bilibili creator, this article walks you through everything about this AI agent that can "grow up on its own," from core concepts and technical mechanisms to hands-on installation.

From Harness Engineering to Hermes Agent: Why the Environment Matters More Than the Model

In early 2026, the AI programming community gradually reached a consensus: the bottleneck isn't the model itself, but the runtime environment around it. According to the creator, the Long-term team conducted an experiment: using the same model and only adjusting the surrounding "harness" configuration (rule constraints, memory systems, etc.), scores improved from 52.8% to 66.5%, and ranking jumped from Top 30 to Top 5—without any changes to the model itself.

GitHub co-founder Mitchell Hashimoto named this methodology Harness Engineering. Its core idea is simple: whenever the AI makes a mistake, add a rule so it doesn't repeat it. But the traditional approach relies entirely on manual work—writing rule documents by hand, configuring hooks, and building memory systems. Hermes Agent's innovation lies in building all five components in, transforming "humans building reins for AI" into "AI building reins for itself."

The Agent Skills standard refers to an open specification that allows skill modules to be reused across different AI Agent frameworks. Each Skill is typically a structured Markdown document containing metadata such as skill name, applicable scenarios, operational steps, and constraints. The core value of this standard is decoupling: skills are no longer bound to a specific Agent product, and skills written by developers can be migrated across platforms like Claude Code, OpenClaw^Ad, and Hermes. This interoperability reduces the risk of ecosystem fragmentation and allows community-accumulated Skill assets to be reused across frameworks—this is the basis for understanding the phrase "the three share interoperable Skills" mentioned in the article.

The Essential Difference Between Hermes Agent, Claude Code, and OpenClaw

A common misconception is that Hermes is meant to replace Claude Code or OpenClaw, but in reality, the three solve problems at different levels. The creator used a vivid analogy: Claude Code is a "pair engineer" sitting at the terminal talking with you; OpenClaw is a system where configuration equals behavior—you write rules to make it what you want; and Hermes does autonomous evolution and self-awareness—you don't need to sit beside it; it runs on its own, learns on its own, evolves on its own, and can be online 24/7.

All three adopt the Agent Skills standard, and Skills are interoperable—a Skill written in Claude Code can also be used by Hermes. They are more like three roles with different divisions of labor within one ecosystem, rather than three parallel lines. OpenClaw's advantage is its mature ecosystem, with 44,000+ Skills in the community and ready-made solutions for various scenarios; Hermes's advantage is its learning capability and user modeling—the longer you use it, the more precise its Skills become and the deeper its memory grows. In one sentence: OpenClaw is a lobster you raise yourself; Hermes is a lobster that grows up on its own.

The Learning Loop: The Heart of Hermes's Self-Evolution

What's most surprising about Hermes isn't what it can do, but that it "changes"—the more you use it, the better and smarter it gets. The creator gave an example: the first time you ask Hermes to write a Python scraping script, it works but the style may not suit you; by the tenth time, it already knows you prefer httpx over requests, and that you're used to writing error logs to a file rather than printing them to the terminal.

This learning loop consists of five stages: curated memory, autonomous Skill creation, Skill self-improvement, FTS5 recall, and user modeling. There are causal relationships among them: memory feeds Skills, Skills generate new memories during use, new memories trigger Skill improvements, improved Skills produce better results, and better results make user modeling more accurate. This is a positive feedback loop, similar to Amazon's flywheel effect—except Hermes's flywheel spins for a single user, requiring no millions of users' data; you can feel noticeable changes after just three to five days of use.

The third stage, Skill self-improvement, is particularly critical: creating a Skill isn't the end point. Each time you give feedback during use, Hermes not only executes this time but also goes back to modify the Skill document, writing the rule in so it's included by default next time. This is fundamentally different from traditional AI tools where "memory is an accumulation of conversation records"—Hermes's memory is a refined needle.

FTS5 is the built-in full-text search extension module of the SQLite database (Full-Text Search version 5), which supports building inverted indexes on text content to enable efficient keyword retrieval, phrase matching, and relevance ranking. Compared with traditional LIKE fuzzy queries, FTS5 has a clear speed advantage when processing large amounts of text and supports ranking algorithms such as BM25. In Hermes, FTS5 is used to index each round of conversation, enabling the Agent to recall relevant fragments from historical sessions on demand without loading the entire conversation record into the context window. This is the technical prerequisite for "conversations won't slow down even after months" mentioned in the article, and the key to making the session memory layer scalable.

The Three-Layer Memory System: From Goldfish to Old Friend

Most AI tools' memory is like a goldfish—what was said last round is forgotten the next. Hermes aims to be an "old friend"—remembering what you've said, knowing what kind of person you are, and having learned how you do things. It solves the memory problem with a three-layer architecture:

• Session memory: Answers "what happened." Each round of conversation is written to the database and indexed with FTS5 full-text search, retrieved on demand rather than loaded in full—conversations won't slow down even after months.
• Persistent memory: Answers "who you are." Stores persistent state distilled from conversations (coding hobbies, project structure, habits, commonly used tools), maintained across sessions. All data is in the local Hermes directory; backup is just copying the directory.
• Skill memory: Answers "how to do things." Each Skill is a Markdown document recording methodology and operational standards.

This design corresponds to three types of memory in cognitive science: episodic memory, semantic memory, and procedural memory. The creator also pointed out limitations: there is currently no automatic expiration mechanism, so the database will keep growing with long-term use, requiring periodic checks to clean up outdated Skills; memory contamination is also an issue—early incorrect information may continue to affect behavior, so regular memory review is necessary.

The Skill System and Tool Ecosystem: A Capability Library That Grows on Its Own

OpenClaw's Skills need to be written and maintained manually, while Hermes's Skills are "found" and can even edit themselves. Each Skill is an independent Markdown document, with three sources: the 40 Skills bundled with the repository, those created by the Agent itself, and those installed from the community Hub. These three aren't parallel—repository Skills are the starting point, the Skill Hub is an accelerator, and Agent-autonomous creation is the real killer feature.

Hermes has 40+ built-in tools covering 15 major categories: execution (running commands, manipulating documents), information (search, browser automation), media (image and voice processing), memory management, and coordination (delegating sub-Agents, multi-model reasoning). Three deserve special attention: Session Search uses FTS5 to search historical conversations—most Agents don't have this capability; Cron Job defines scheduled tasks in natural language without writing cron expressions; Delegation can launch up to three sub-Agents working in parallel simultaneously. On the security side, there are three constraints: token-controlled available tools, code running in a sandbox, and sessions that can specify a restricted tool set.

MCP (Model Context Protocol) is an open protocol proposed by Anthropic to standardize how AI models connect with external tools and data sources. You can think of MCP as the "USB interface" of the AI world: whether the tool is a database, a file system, or a third-party API, as long as it implements an MCP server, the model can call it in a unified way. After combining Hermes's tool ecosystem with MCP, extensibility is significantly enhanced—community-developed MCP servers can be plugged in directly without writing separate adapter code for each tool. The phrase "tools and MCP complete Hermes's capabilities" in the article refers precisely to the ecosystem access capability brought by this protocol layer.

Step-by-Step Installation: Windows Requires WSL; Mac/Linux Can Install Directly

Hermes theoretically supports Windows, MacOS, and Linux, but Windows is conditionally supported—it cannot be installed directly in CMD or PowerShell and requires WSL (Windows' built-in Linux subsystem). MacOS and Linux can be installed directly.

Installation steps are as follows:

1. Open PowerShell and enter wsl -d Ubuntu to start the Ubuntu environment.
2. Use apt install git to install Git (usually pre-installed).
3. Visit the Hermes Agent official website, copy the installation script, and execute it in the terminal. The process takes about ten-odd minutes and will install dependencies such as Node.js and FFmpeg.
4. After installation, select a model. It supports domestic and international models such as OpenAI, NVIDIA, Tongyi Qianwen, and DeepSeek^Ad; configure the API Key, BaseURL, and model ID.
5. Select an instant messaging tool (WeChat and others are supported). A success screen appearing means installation succeeded.

Run the Hermes command to start using it. The creator demonstrated using the DeepSeek Chat model; after entering "Who are you," Hermes responded normally. The operation is similar to Claude Code, but Hermes doesn't support a visual interface and can only be operated in the terminal; however, it supports instant messaging software like WeChat, which Claude Code doesn't have.

WSL (Windows Subsystem for Linux) is a compatibility layer provided by Microsoft in Windows 10 and later, allowing users to run a full Linux kernel environment (such as Ubuntu) directly on Windows without a virtual machine or dual boot. WSL2 uses lightweight virtual machine technology, with file system performance and system call compatibility approaching native Linux. For AI Agent projects like Hermes that rely on a POSIX environment, Shell scripts, and the Node.js toolchain, WSL provides the necessary runtime foundation. Executing wsl -d Ubuntu starts the specified Ubuntu distribution instance; subsequent commands like apt and git all run on the Linux side, interoperating with the Windows file system through mount points such as /mnt/c.

Conclusion

Hermes Agent's innovation isn't in any single breakthrough, but in combining five modules—the learning loop, three-layer memory, Skill system, tool ecosystem, and orchestration layer—into a closed loop. Memory feeds Skills, Skill improvements make results better, and better results make user modeling more accurate—each link strengthens simultaneously. As the creator said, this isn't some mysterious AI breakthrough; it's automating the process of "user correction, rule update, next execution" into a closed loop. For users who want a personal assistant that can self-evolve, Hermes Agent offers an out-of-the-box choice.