From OpenClaw at the start of the year, to the “harness” concept Anthropic introduced later, to Hermes — which stirred up another wave of attention two months ago — this whole tide raised by agents and their offshoots seems to be slowly settling down.

OpenClaw is rarely mentioned anymore; the buzz around Hermes is fading too. Even the conversation around Claude Code has drifted from the initial amazement toward grumbling about its later versions.

When yesterday’s surprises become today’s habits, and yesterday’s fervor cools into calm, perhaps it is worth asking the question again:

How should we really think about agents?

Let me start with two recent experiences.

1. Hermes’s Self-Evolution

I have been using Hermes as a personal assistant for everyday learning and work. Two of its capabilities stand out: its Memory-management mechanism, and its ability to distill experience into Skills.

I once came across a Skill in the “recently installed” list of the Skill-management tool (HarnessKit) that I had never installed myself — it turned out to have been distilled automatically by Hermes from an earlier task.

It had not merely remembered some information; it had compressed one concrete experience into a reusable working method. And this Skill could, in turn, be shared with other agents.

In other words, knowledge can be distilled from one agent’s experience and then transferred into another agent’s workflow.

Between agents, a way of propagating knowledge has emerged.

2. Codex Didn’t Fully Follow the Skill

I once wrote a Skill that explicitly required the output to be listed item by item. But the last time I used it, Codex ended up rendering the content as a table. This Skill had been used many times before, and most of the time it worked fine. This time, though, it did not fully follow the instructions in the Skill.

This points to something else: a Skill is not a rule engine; it is not a compiler; it is not a formal constraint.
In the end it still has to pass through the model’s understanding, choices, and execution. And as long as there is a model in the middle, there will always be deviation.

These two examples:

One is a pleasant surprise: agents really do seem to be starting to acquire some capacity to learn and to accumulate.
One is a quiet worry: even when knowledge has been written into a Skill, an agent will not necessarily execute it in a stable, strict, and predictable way.

3. What Agents Bring Is More Than Efficiency

The progress of human civilization depends, to a large degree, on the circulation of knowledge.

From word of mouth to inscriptions on clay tablets;
from bamboo slips and paper to movable type;
from encyclopedias to search engines;
from browsing web pages to conversing with large models.

Every change in the medium of knowledge has changed the speed at which knowledge spreads.
And every increase in that speed has reshaped how society collaborates and how technology advances.

Now, in the age of agents, the circulation of knowledge seems to have been accelerated once again.

An experienced engineer can write their hands-on experience into a Skill. Someone from outside that field only needs to load that Skill into their own agent to gain — almost instantly — a portion of the operational ability that would otherwise take years to accumulate.

And when agents can summarize and distill Skills on their own, knowledge will travel faster still. Because this time, even the step of “an expert manually organizing experience” may be partly automated.

This is, of course, exciting. But it also raises a deeper question:

The recipient of knowledge is shifting from humans to agents.

When a Skill is deployed inside an agent, do we really understand that skill?
When an agent spends tokens to complete a task for us, do we really know how it understood those instructions?
When it produces a seemingly reasonable result, can we really tell whether it strictly followed the rules we gave it?

In the past, we worried about whether the model would talk nonsense.
Now, we also have to worry about whether the agent will misunderstand, misuse, or omit — or even confidently carry out an action that departs from what we meant.

4. After the Hype Fades, What Remains of the Agent?

In the past, discussions of agents were mostly about whether they “can get things done.”
Next, the question that really matters may become: can they get things done in a way that is stable, controllable, and auditable.

Once an agent begins to remember, summarize, call tools, and reuse Skills, it is no longer merely a model that generates answers — it gradually becomes an execution system that takes part in real workflows. How to manage it, monitor it, and understand and constrain its reasoning and execution may be a question worth continuing to discuss after the agent hype has faded.