DEV Community: Lei Ma

Hermes Agent Beats OpenClaw

Lei Ma — Wed, 03 Jun 2026 12:15:53 +0000

Just as OpenClaw found itself beleaguered on all sides, Hermes Agent made its quiet yet powerful debut. Open-sourced in late February 2026 by the Silicon Valley-based team Nous Research, this AI Agent project leveraged a fundamentally different design philosophy to overtake OpenClaw in a remarkably short span of time.

Differentiator 1: From "Resetting upon Completion" to "Growing Smarter with Use"

OpenClaw’s memory architecture has long been a major pain point for developers: at the end of each session, the Agent's memory virtually resets to zero, failing to retain any accumulated experience or user preferences for the next run. In contrast, Hermes’ core design philosophy is encapsulated in its slogan—“the agent that grows with you.” It features a built-in, self-evolving learning loop: upon completing a complex task, the Agent automatically analyzes its execution trajectory, identifies high-frequency operational patterns, and encapsulates successful experiences into structured "Skill" files stored in the user's local repository. When a task triggers specific criteria—such as invoking tools more than 5 times, self-healing after a mid-way error, or incorporating explicit user corrections—it automatically generates a reusable skill for future, similar tasks to invoke directly. Empirical tests show that after 3 months of continuous operation, 65% of new tasks can directly leverage existing skills, yielding measurable improvements in both execution efficiency and accuracy.

Differentiator 2: Persistent Memory for Cross-Platform Continuity of User Preferences

Hermes is powered by a persistent architecture known as the "Three-Tier Memory System": Working Memory handles the current session context, Episodic Memory stores historical sessions for retrieval, and Procedural Memory solidifies the operational patterns the Agent has mastered. Crucially, this memory system retains continuity across platforms and devices. A user's preferred terminology and command style on WeChat will be seamlessly carried over to Feishu (Lark) or Telegram by the exact same underlying memory layer, eliminating the need for repetitive training.

Differentiator 3. Security First: Guarding the Baseline of Data Privacy

In stark contrast to the trust crisis OpenClaw faced due to security vulnerabilities, Hermes took an entirely different path in its security design. With zero-telemetry by default, automated masking of confidential information, and default rejection of stranger messages on WhatsApp, these design choices are highly compelling for enterprise and domestic users operating under increasingly stringent data sovereignty and privacy compliance mandates. To date, the number of documented CVE vulnerabilities for Hermes Agent stands at a clean zero—a safety record exceedingly rare among open-source intelligent agents.

These distinct advantages translated directly into community acclaim and market validation. Hermes hit 40,000 GitHub Stars in just 45 days from its launch, eclipsing OpenClaw’s 61-day timeline. By mid-May, that figure shattered 135,000 stars, sporting an MIT license and shipping with over 40 out-of-the-box Skill modules. On OpenRouter’s daily token volume charts, Hermes officially dethroned OpenClaw on May 11, claiming the global top spot with a staggering 271 billion tokens consumed daily.
More importantly, Hermes unlocked its own "commercial accelerator." Mainstream model providers such as Xiaomi, NVIDIA, and StepFun have aggressively integrated the Hermes Agent framework into their ecosystems. Among them, Xiaomi’s MiMo alone contributed a massive 1.45 trillion tokens to Hermes within a single month. In tandem, Xiaomi launched a 100-trillion-token incentive program and an Agent Ecosystem Co-construction Initiative tailored for global AI users, deep-linking its operations with top-tier frameworks like Hermes Agent. This has catalyzed a powerful flywheel effect: a more active community drives larger token volumes; larger token volumes incentivize model vendors to hook into the ecosystem; and a more prosperous ecosystem drastically lowers the barrier to entry for end users.

Naturally, Hermes is not without its imperfections. As the skill repository swells and tasks scale in complexity, the retrieval efficiency of its memory system will inevitably face friction. Some developers have noted in real-world testing that if the path initially taught to the Agent is flawed, the skill file will "learn" the incorrect methodology, causing performance to drift progressively off-course. Correcting "mislearned habits" proves far more challenging than training an agent from scratch, placing higher demands on Hermes’ skill validation and error-correction mechanics. Furthermore, skeptics argue that its meteoric rise carries distinct hallmarks of a "manufactured blockbuster"—its WeChat Index and Baidu Index display a steep growth curve almost identical to OpenClaw’s historical data. While this logic of "engineered hype" may hold water commercially, whether it can truly translate into long-term user retention remains to be seen through the lens of time.

What does “Harness” mean to AI Agents?

Lei Ma — Mon, 01 Jun 2026 13:03:36 +0000

The term “Harness” originally refers to the gear strapped to a horse to control and guide it.
As the name implies, a Harness serves as both the "equestrian gear" and the "control tower" for an AI Agent. This concept is a precise metaphor for the core of next-generation AI engineering: what we need is not an untamed, uncontrollable wild horse (a raw foundation model), but a complete system of reins, saddles, wheels, and navigation to transform it into a "smart chariot" that can arrive at its destination safely and accurately. From a technical perspective, the Harness architecture encompasses every component within an Agent except for the core LLM itself. It is a systemic engineering framework designed to constrain, guide, and enhance the model's capabilities, enabling it to complete real-world tasks stably and reliably.
The core formula of a Harness is so simple it sticks with you at first glance:

Agent = Model + Harness。

While the Model is the LLM itself—responsible for comprehension, reasoning, and generation as the "brain" of the AI—the Harness is the runtime control system wrapping around the periphery. It manages scheduling, constraints, recovery, and auditing, serving as the "workbench + command center" that keeps the brain working stably.
In the field of AI engineering, a Harness is defined as the infrastructure wrapping around an AI model, specifically designed as a runtime control system to manage long-running tasks and complex executions. If the Large Language Model (LLM) is the "brain" of AI, then the Harness is its "body" and "nervous system."

The Core Metaphor: The Horse Harness

• The Model is a powerful but untamed stallion (providing raw power and intelligence).
• The Harness consists of the reins, saddle, and wheels (providing direction, constraints, and structural support).
• Therefore, the core formula holds true:

Agent = Model (Brain) + Harness (Body/OS)

The Six Core Modules of a Harness Architecture

Based on the blueprints of representative projects like DeerFlow 2.0, a complete, fully engineered Harness Agent is built upon six core components. Leaving out even one means it falls short of true production-ready engineering. These six core modules collectively construct the AI’s "execution closed-loop":

Planning & Orchestration Engine Acting as the "cerebellum" of the Harness, this engine is responsible for task decomposition and workflow control. • Function: Breaks down vague, complex objectives (e.g., "build a website") into an ordered sequence of sub-steps. • Key Capabilities: o Task Decomposition: Automatically breaks a monolithic task into granular sub-tasks. o State Machine Management: Leverages technologies like LangGraph to govern task state transitions (e.g., Planning -> Execution -> Evaluation -> Refinement).

o Breakpoint Resumption: Utilizes checkpointing mechanisms to ensure that if a task is interrupted, it can resume precisely from where it left off, rather than restarting from scratch.

Sandbox / Execution Environment

These are the "hands" of the Harness, granting the AI the tangible capability to operate a computer rather than just text-chat.
• Function: Provides an isolated, secure environment for code execution and file manipulations.
• Key Capabilities:
o File I/O operations: Empowers the AI to create, modify, and persist files (e.g., within /mnt/workspace/).
o Code Execution: Runs Python or Bash commands inside Docker or local secure containers.
o Security Isolation: Enforces network access restrictions and CPU/memory quotas to prevent accidental AI operations from compromising the host system.

Skills & Tools System

This is the "arsenal" of the Harness, defining the boundaries of what the AI is capable of doing.

• Function: Standardizes and encapsulates external APIs, libraries, and operational workflows.
• Key Capabilities:
o Progressive Loading: Modeled after DeerFlow’s Skills system, it dynamically loads relevant capabilities (e.g., a "Video Generation" skill) only when the task demands it, preventing the context window from being flooded.
o Standardized Tool Calling: Uniformly encapsulates interfaces like web search, code interpreters, and third-party APIs while systematically handling parameter validation and exceptions.

Memory & Context Engineering
Serving as the "hippocampus" of the Harness, this module mitigates the model's inherent challenges with short-term memory rot and context window overflow.
• Function: Manages short-term working memory and long-term knowledge bases.
• Key Capabilities:
o Context Compression: Automatically condenses over-extended conversation histories through algorithmic summarization, preserving only the vital core information.
o Cross-Session Memory: Persistently stores user preferences and project backgrounds, ensuring the AI "remembers" its prior configurations upon the next initialization.
System Prompts & Guardrails

This acts as the "constitution" of the Harness, drawing the hard behavioral boundaries for the AI.

• Function: Constraints AI behavior through a matrix of preset prompt templates and hard-coded rules.
• Key Capabilities:
o Persona Alignment: Explicitly defines whether the AI acts as a "Senior Software Engineer" or a "Rigorous Financial Analyst."
o Hard Constraints: Enforces absolute mandates, such as "Never execute rm -rf commands" or "Always validate factual claims using the search tool before answering." These rules are strictly executed via programmatic hooks and do not rely on the model’s self-discipline.

Observability & Feedback Loop

This is the "control tower" of the Harness, bringing absolute transparency to what would otherwise be a black-box AI execution process.

• Function: Records the entire lineage of the AI’s chain-of-thought, tool invocations, and execution outcomes.
• Key Capabilities:
o Full-Lineage Logging: Captures the exact inputs and outputs of every single transactional step.
o Automated Error Correction: When a tool call fails or code throws an exception, the Harness intercepts the error log and feeds it back to the AI for self-healing (e.g., Code throws runtime error $\rightarrow$ Harness injects error logs back into context $\rightarrow$ AI rewrites the code).

Summary
Fundamentally, these six components exist to force a non-deterministic Large Language Model to run stably within a deterministic framework—this is the foundational logic of AI engineering.

Why AI Claimed Software Developers First: The Counterintuitive Reality

Lei Ma — Sat, 09 May 2026 13:50:24 +0000

*Reason 1: Programming is the "Cleanest" Form of Language *

What makes a language "clean"? Natural languages (like Chinese or English) are inherently ambiguous:

• "I almost didn't make it" — Did I succeed or fail?
• "Wear as much as you can" — Is it freezing winter or a scorching summer?

Programming languages operate on an entirely different logic:

# This statement has only one possible meaning
def add(a, b):
    return a + b
# Inputting 2 and 3 will always, without exception, output 5.

Code is devoid of metaphors, cultural subtext, or hidden nuances. While Large Language Models (LLMs) are essentially "probability machines," predicting the next most likely token , programming languages serve as their "native tongue"—rigid in syntax, transparent in logic, and precise in feedback.

Language Type Characteristics AI Learning Difficulty
Natural Language Ambiguous, context-heavy ⭐⭐⭐⭐⭐
Programming Language Precise, unambiguous, structured ⭐⭐

*Reason 2: The "Instant Feedback" Mechanism *

The Dilemma of Fiction Writing: If you ask an AI to write a story: "As the sun set, the old man sat by the sea..." Is this good? There is no objective answer. Some might find it poetic, others may find it cliché or emotionally hollow. Quality remains entirely subjective.

The Binary Nature of Code: 
def factorial(n):
    if n == 0: return 1
    return n * factorial(n-1)
# Test: factorial(5) should output 120 [cite: 28, 29, 30, 31, 33]
The execution result is objective: 
• ✅ Output 120: The code is correct. 
• ❌ Error/Wrong Output: The code is flawed.

There is no gray area. Training AI in programming is like having a student with an "automated grading machine". While a creative writer must wait days for human feedback, an AI coder learns and iterates in milliseconds.

*Reason 3: Code as a "Data Gold Mine" *

Content Type Share Quality Labeling Status
Web Text 80% Inconsistent Unlabeled
Media (Img/Vid) 15% Diverse Partially Labeled
Open Source Code <5% Extremely High Self-Labeled

Why is code a "Gold Mine"?

Inherently Structured: Every line serves a specific, documented function.
Self-Documenting: Function names, parameters, and comments (docstrings) act as built-in "instruction manuals".
Rich Version History: Platforms like GitHub provide a complete record of "Problem → Solution" (Commit History), allowing AI to learn the evolution from buggy code to a final fix.
Colossal Scale: With over 100 million repositories on GitHub, AI has billions of lines of high-quality material to study across every domain.

*Reason 4: The Pragmatic Paradigm of Developers *

The way a developer uses AI differs fundamentally from a casual user:

Casual User: Requests a "stunning poem about spring". If it’s not "breathtaking," they discard it.
Developer: Requests a "Python function to convert CSV to JSON". They copy, run, and test.

Developers don't demand "stunning" code; they demand functional code.

Scenario Success Metric Tolerance for Error
Poetry Aesthetic, evocative Extremely Low (Subjective)
Coding Successful execution Higher (Iterative/Debuggable)

Programmers treat AI as a high-leverage tool, not a human replacement.

*Reason 5: The Modular Nature of Programming *

Complex vs. Decomposable Tasks: Writing a novel is a deeply interconnected task where plot, character, and dialogue are inseparable. AI often loses the thread over long distances.
Programming, however, is naturally modular. A login system can be broken down into discrete steps:

 Receive input → Validate format → Query database → Compare hash → Generate Token → Return result.

Each step is independent and verifiable. AI excels at this type of "short-range" pattern matching and modular logic.

The Law of AI Adoption
The fields AI "conquers" first invariably possess:

✅ Explicit rules and syntax.
✅ Instantly verifiable results.
✅ Massive volumes of high-quality training data.
✅ Modular and decomposable tasks.

Deeper Implications
For Developers: The era of 100% manual coding is ending. Future developers will spend 20% of their time writing code and 80% on architectural design, system debugging, and AI orchestration. Architecture and system-level thinking are the new "moats".
For Other Industries: To gauge your risk of displacement, ask if your work is:

Governed by clear rules?
Instantly verifiable?
Back-logged by massive historical data?
Easily decomposed into sub-tasks?

For the Future of AI: The roadmap is clear: AI will move from "Structured & Verifiable" to "Ambiguous & Creative".

Stage 1: Coding, Data Analysis, Mathematical Proofs.
Stage 2: Documentation, Translation, Customer Support.
Stage 3: Creative Writing, High-end Design, Artistic Creation.

*Conclusion *

Why did AI conquer programmers first? Not because they were the "low-hanging fruit," but because programming is the most compatible playground for AI's strengths.

Just as cars first replaced horse carriages on paved, fixed routes before tackling off-road terrain, AI targets domains with clear rules before expanding into the fog of human creativity. For developers, this is not just a challenge—it is the ultimate efficiency upgrade.