Memory won the agent wars

On May 10, 2026, an open-source agent called Hermes processed 224 billion tokens in a single day through OpenRouter. It overtook OpenClaw to become the most-used AI agent in the world. It achieved this in roughly 90 days from near-zero awareness.

The story made it to Communications of the ACM on May 28 — and the headline says everything the industry has been missing: the most-used AI agent in the world won on memory, not intelligence.

This is not a story about a better model. It is a story about a better architecture.

The reasoning race is a distraction

For two years, the AI industry has been obsessed with one metric: how smart is the model? Benchmark scores, reasoning chains, chain-of-thought length, model size, parameter count. Every lab is racing to build the most capable reasoning engine. Every benchmark is a proxy for “can this thing think harder?”

But the agents winning in production are not the ones that think hardest. They are the ones that remember most.

An agent that reasons brilliantly from a blank slate every session will keep losing to an agent that reasons adequately from three months of accumulated experience. This is not intuitive — it contradicts everything we have been trained to believe about AI. But it is empirically true, and the data is now unambiguous.

How it actually works

The architecture is straightforward once you see it:

1. Solve the problem. The agent does its work — fixes a bug, deploys infrastructure, writes a feature. It uses reasoning, tools, and whatever model capability it has available.

2. Extract the pattern. After completion, the agent pauses and analyzes what it just did. It identifies the successful steps, the decisions that mattered, the pitfalls it avoided. It writes a structured, reusable skill file.

3. Store it as memory. The skill goes into a library — a collection of markdown files that document proven approaches. Next time a similar problem appears, the agent queries this library first.

4. Reason becomes the fallback. Memory is the default. Reasoning is what happens when memory has no relevant entry. This inverts the traditional agent loop entirely.

The skill library grows with every task. Six hundred community-contributed skills at last count. Each one is institutional knowledge, captured in markdown, version-controlled, and shared. The system ships its learning as software.

The networking analogy

A cloud infrastructure specialist at ACM put it perfectly: carrier networks don’t reason about routes per packet. BGP builds routing tables from accumulated path advertisements. OSPF maintains a link-state database that enriches over time. The network gets smarter the longer it runs, not because the routers are thinking harder, but because they are remembering more.

Experienced systems beat smart systems every time when the workload involves repeating patterns. And software development, infrastructure management, and operational workflows are nothing but repeating patterns.

What everyone else is doing wrong

Most enterprise agent frameworks treat memory as an afterthought — a vector database bolted on to store some embeddings, a context window stuffed with conversation history, a system prompt that grows until the model can no longer use it effectively.

Meanwhile, three major platforms shipped persistent memory features on the same day in mid-May:

• xAI (Grok) added cross-session persistent Skills that retain user-defined functions across web and mobile, shifting from a Q&A bot to a configured automation layer.
• Manus added persistent context to scheduled tasks, so automated jobs carry project state between runs instead of resetting to zero.
• Lovable introduced reusable, markdown-based Skills that auto-load into projects, eliminating repetitive prompt setup.

And before that, Anthropic shipped “Dreaming” — a scheduled background process that lets Claude Managed Agents review their own past sessions, extract behavioral patterns, and update their memory stores without human intervention.

Every serious platform is converging on the same conclusion: stateless chat is no longer a viable product baseline.

The three layers of agent memory

The architecture that works has three distinct layers:

In-context memory — the working memory during a single session. What the model sees right now. This is bounded by the context window and disappears when the session ends.

External memory stores — vector databases, key-value stores, or skill libraries that survive between sessions. Retrievable, but require explicit logic to query. This is where most implementations stop.

The offline learning phase — the process that extracts meaning from accumulated session data and writes it back into the memory system so the next session starts smarter. This is what separates agents that compound value from agents that reset to zero.

The first two are table stakes now. The third is the differentiator.

The risks nobody is talking about

Persistent memory is not just a feature. It is a responsibility. And the industry is not ready for it.

Retention and decay. Not all memory is equally valuable forever. An API parsing skill may last years. A vendor pricing skill may expire in months. Systems need explicit lifecycle policies — retention rules, review triggers, decay schedules. Most don’t have them.

Governance. Skill files are proprietary institutional knowledge. Who owns them? Who can modify them? What is the review process? Most implementations have no answers.

The security surface. Persistent memory can encode attack patterns or poisoned inputs. If an agent learns a bad approach and writes it to its skill library, that bad approach becomes the default for every future task. This requires integrity checks, strict access control, and audit logging. Currently, most implementations lack all three.

These are not theoretical concerns. They are production risks that will bite teams who ship memory without governance.

The benchmark problem

Static benchmarks are obsolete. This is no longer a researcher’s complaint — it is a deployment risk. Current text-completion evaluations fail to measure AI agents handling high-stakes tasks like coding and medicine. They measure how well a model completes a prompt, not how well an agent accumulates and applies knowledge over weeks of operation.

An agent with a mediocre model score and a rich skill library will outperform a frontier model with no memory on any recurring task. Benchmarks that don’t account for this are measuring the wrong thing.

What this means for builders

If you are building or deploying AI agents, here is what matters:

Treat memory as architecture, not a feature. Design your memory layer first. What gets stored? How is it retrieved? How does it decay? Who maintains it? These decisions matter more than your model choice.

Ship skills, not prompts. Structured, version-controlled skill files beat system prompt engineering every time. They are auditable, shareable, and compound over time.

Plan for governance. Before your agent’s memory grows to hundreds of skills, you need policies. Ownership, review, decay, security. Write them now.

Measure accumulated knowledge, not session intelligence. The right metric is not “how smart was this session?” It is “how much did the system learn from this session?”

The verdict

The agent that became the world’s most-used did not have the best model. It had the best memory architecture. That is not a coincidence. It is a signal.

The reasoning race will continue — labs will keep building smarter models, and benchmarks will keep getting updated. But the production winners will be the ones that remember.

Memory is not a feature in production agent deployments. It is what decides whether the system gets better over time or stays where it started.