Agents are closer to products, and user experience matters more.

At the beginning of this year, OpenClaw (Lobster) almost monopolized the attention of the entire AI community, climbing from GitHub to tech media, social networks, and ordinary people's computer desktops. Some people specifically bought Mac minis to deploy OpenClaw, while others integrated it into various software and hardware.

After chatbots, AI Agents began to enter the mainstream vision (view/awareness) of ordinary people on a large scale.

However, today, OpenClaw's attention has faded significantly, not only due to old issues like complex installation, excessive permissions, unstable operation, and uncontrollable costs but also because competitors are more outstanding. Hermes ( Hermès ), developed by Nous Research, is the strongest among them.

Image Source: Hermes

Especially when compared to OpenClaw's recent official mobile launch, which had a poor initial experience—scoring only 2.2 out of 5 after the Android version's release—the latest version of Hermes Agent (v0.18.0) has received widespread acclaim. MoA multi-agent collaboration, self-verification... all elevate Hermes' experience to the next level. Some even proclaim:

Hermes is killing the open-source Agent competition.

So, what has Hermes done right to step out of OpenClaw's shadow? What can domestic Agents learn from it?

Multi-agent collaboration steals the spotlight, but "judgment" is the real upgrade.

In fact, the most widely spread aspect of this update is the Mixture-of-Agents (MoA multi-agent collaboration). Users can create a "model committee" consisting of models like Claude, GPT, Gemini, Grok, etc., have them answer the same question separately, and then let another model aggregate the responses.

Hermes has already supported similar capabilities in the past, but v0.18.0 is the formal version. Users can switch to an MoA combination just like switching ordinary models and see the independent answers from each reference model, as well as the final aggregated conclusion.

Image Source: Leitech@ChatGPT

But frankly, MoA is not new. With enough tokens and workflow tools, a similar system can be built. It does increase information coverage and reduce blind spots of a single model in complex research and decision-making tasks, but it also inflates reasoning time and API bills.

The truly significant change lies in another core of Hermes' update—Agent self-verification.

In the past, using Agents might lead to a laughable situation: you ask it to modify a piece of code, and after a while, it tells you the problem is solved, but when you actually run the program, the build fails. Or you ask it to organize a document, and it claims to have covered all sources, but upon closer inspection, several key facts are unverified.

The model is not intentionally lying; it's just generating a sentence that most resembles a completed task based on the existing context. The problem is that the same entity is responsible for both executing and judging the task. Acting as both the athlete and the referee, it naturally tends to rely on intuition to get the job done.

Hermes v0.18.0 introduces an evidence-based verification mechanism. When handling programming tasks, it can run tests, check build results and file statuses, and use these results as completion evidence. The `/goal` command now includes a completion contract, allowing users to specify exit conditions for tasks in advance. The Agent can only stop the loop after meeting these conditions.

In simpler terms, past Agents would say, "I think I'm done," while Hermes now adds, "Here are the test results, the generated files, and the completion conditions, so this task can be concluded."

If you've read Leitech's previous report, "The 'Loop Engineering' That Global Agents Are Engaged In: AI Working, Supervising, and Reworking By Itself," you'll probably recognize this as a form of Loop engineering.

Goal-Driven Loop. Image Source: Anthropic

Someone on LinkedIn commented that what attracted them to this Hermes update was not that it enabled Agents to do more things but that it started to improve reliability. The hardest part of real-world work is not just getting Agents to write code or execute processes but also confirming whether the task is truly completed, whether the results are correct, and whether previously learned methods can be reused.

In short, Hermes is trying to address the long-standing lack of judgment in Agents.

Agents must learn to "review" to perform well.

Besides the verification mechanism, v0.18.0 introduces two other changes that have gained significant user approval: `/learn` and `/journey`.

Hermes has always emphasized its learning loop, which organizes methods used to complete tasks into Skills for future similar tasks, eliminating the need to start from scratch each time. However, this learning process was somewhat of a black box before—users found it difficult to grasp what the Agent had learned, why it formed certain methods, or whether erroneous experiences were saved.

Now, users can directly use `/learn` to have Hermes learn from a webpage, folder, or just-completed workflow and then use `/journey` to view, modify, and delete these experiences. The desktop version also adds a memory graph to visualize the Agent's long-term accumulated content.

This capability might sound like the "self-evolution" that vendors love to tout, but it's not that mystical.

The first time you ask an Agent to complete a complex task, you need to tell it where the files are, what tools to use, what output format to follow, and constantly correct errors along the way. The second time it encounters a similar task, it can only truly save time if it can directly reuse the previously verified process.

Compared to an Agent that merely invokes tools like a temporary worker, requiring background explain (explanation) every time it's opened, an Agent that can save, verify, and improve Skills has the opportunity to gradually familiarize itself with users and work styles. The longer it's used, the greater the difference between it and an ordinary chatbot.

Hermes Update Log. Image Source: Github

v0.18.0 also strengthens backend sub-Agents. Hermes can distribute multiple tasks to different sub-Agents for parallel execution, eliminating the need for the main conversation to remain idle while waiting. After the tasks are completed, the results are merged back.

Additionally, the desktop version adds project, terminal, code difference review, and work tree management, increasingly resembling a complete Agent workstation.

Individually, none of these features are revolutionary. What Hermes does right is integrating them into a relatively complete work cycle: the user proposes a goal, the Agent breaks down and executes the task, backend sub-Agents work separately, the system verifies the results based on evidence, and effective methods are precipitate (accumulated/solidified) into Skills.

This closed loop may be more important than integrating dozens more tools.

"OpenClaw" sparks imagination, while "Hermes" solves real problems.

Both OpenClaw and Hermes belong to the open-source Agent Harness category. The model is responsible for thinking and generation, while the Harness handles tools, memory, permissions, context, runtime environment, and task loops. In other words, they don't necessarily possess the strongest models themselves; their value mainly comes from enabling models to complete tasks stably.

OpenClaw's early-year explosion captured the most striking aspect of Agents. It could reside on a computer, integrating with chat software, email, calendars, and various external services. A user could send a message in WeChat, Feishu, or Telegram, and it would open programs, process files, or execute scripts on another machine.

This experience was thrilling because AI, which could only answer questions before, finally extended its "hand." However, while OpenClaw demonstrated what Agents could do, it didn't simultaneously answer the other half of the question: how to ensure they do it right every time?

Image Source: Leitech@Gemini

When Agents gain file system, Shell, browser, and account permissions, a mistake is no longer just generating nonsense. It could delete the wrong files, send incorrect emails, execute unsafe commands, or even save malicious instructions from webpages and messages into long-term states.

Of course, this is not unique to OpenClaw. Any Agent with long-term memory and system permissions faces security, verification, and control challenges. Hermes is no exception. `/learn` can acquire correct experiences but may also solidify outdated methods and erroneous operations; MoA can increase answer coverage but might also amplify collective errors.

More importantly, features like completion conditions, verification evidence, editable learning records, backend task management, and code difference reviews may not seem as "sexy" as "letting AI automatically control a computer," but they determine an Agent's daily usability.

OpenClaw remains active, with new versions continuously fixing plugin, configuration, messaging channel, memory, and runtime issues. Thus, their situations cannot be simply reduced to one winning and the other losing. More accurately, OpenClaw pushed Agent imagination to the forefront for everyone, while Hermes began addressing the series of problems left after Agent implementation.

From competing on features to competing on quality: This wave is worth learning for domestic Agents.

Over the past six months, domestic Agents have made rapid progress. However, they now tend to compete on who can do more or go further. Hermes v0.18.0 reminds everyone that an Agent's delivery quality matters.

Products should not only showcase how complex the task process is but also let users see which sources it called upon, what verifications it performed, and why it judged the task as completed. Failures should not be hidden in a vague summary but should explicitly inform users where it got stuck, which parts were not completed, and whether manual intervention is needed.

Learning and memory also require similar transparency. Many domestic Agents promote "getting smarter with use," but users rarely can view what it has remembered, let alone modify or delete it. When long-term memory becomes invisible, it may not only bring convenience but also Continuous accumulation (continuously accumulate) misunderstandings.

The same goes for multi-Agents. The industry tends to package multiple Agents running simultaneously as advanced productivity, implying that more Agents mean better results. In reality, multi-Agents first mean higher costs, longer chains, and more potential error points. Hermes' MoA is valuable not just because of multiple models but also because users can see the answers from different models and the final aggregation process.

Observability, verifiability, and intervenability matter more than the number of Agents.

Ultimately, what domestic Agents need to learn is not just a few commands from Hermes or rushing to implement a MoA portal. What's truly worth learning may be the product focus.

Today, models are becoming increasingly powerful, and tools are more abundant. What will truly make a difference next is who can keep Agents on track in long tasks, stop them promptly when problems arise, provide evidence upon completion, and safely carry this experience to the next task.

OpenClaw, Hermès, Agent, AI, Intelligent Agent

Source: Leitech

All images in this article come from the 123RF licensed image library. Source: Leitech