Last week every production AI agent you deployed worked the same way. When it needed to remember something, it embedded the current state, ran a cosine similarity search against a vector database, and stuffed the top 3 results into context.

This approach failed 41% of the time on standard web navigation benchmarks. Nobody had a better idea. Until this month.

The broken memory consensus

For 24 months this was the standard architecture. Every tutorial, every framework, every vendor sold you this. Nobody stopped to ask if we should be retrieving memory at all.

Retrieval has one fatal flaw: it returns static entries written for some past context. It does not adapt. It will pull the exact same note about API authentication when you are debugging rate limits, when you are writing tests, and when you are deleting old keys. 70% of the time it is irrelevant, partially wrong, or just distracting noise.

We all tolerated this because there was no alternative. We tuned chunk sizes, rerankers, threshold values. We added 12 different memory tiers. None of them closed the performance gap. We were optimizing a bad model instead of replacing it.

Mem-π generates memory instead of retrieving it

The paper that breaks this landed on arXiv May 19. Mem-π does not store memory entries. It does not run vector searches. It has a dedicated small 7B parameter model trained exclusively to decide two things: should I produce guidance right now, and if yes what should that guidance say.

This is not a semantic difference. This is a complete inversion of the memory model.

Instead of pulling old entries, the memory model observes the agent's full running context, and only intervenes when it determines output will improve task success. It abstains 62% of the time. When it does act, it writes exactly the 1-2 sentences the agent needs, rewritten for the exact current situation.

It is trained with a decoupled RL objective that separately scores the decision to intervene and the quality of the output. On WebArena it delivered 32% relative improvement over the best prior retrieval memory baseline. That is not an incremental gain. That is the single largest performance jump on agent benchmarks ever published.

Nobody will be building vector database memory for agents 12 months from now. This paper killed that approach.

Context databases replace vector stores

While the academic result landed, production infrastructure caught up this same week. OpenViking launched as the first purpose built agent context database.

Not vector database. Context database.

OpenViking uses a file system model, not flat embedding vectors. It stores memory, skills, resources and state in a hierarchical structure that agents can traverse, modify, and prune. It does not do similarity search by default. It delivers context incrementally as the agent moves through a task.

This is exactly the shift that Mem-π predicts. Agents do not need a search engine for their past. They need a working directory they can trust. Vector stores were always a bad hack we borrowed from RAG chatbots. We finally have storage built for the thing agents actually do.

Standardized execution layers landed

The other quiet release this month was E2B 1.0. For the first time there is a standard, secure, sandboxed execution environment that every agent can target.

Before this, every team built their own code execution sandbox. Every agent had incompatible tool calling conventions. Half of all agent failure modes were just broken environment boundaries.

E2B runs unmodified system tools, network access, and persistent state with per-agent permission boundaries. It already has native integration with every major model provider. This is the POSIX layer for agents. Everyone will standardize on this.

Alongside E2B, CLI-Anything demonstrated that every existing command line tool can be made agent native without modification, no wrapper APIs required. There are now zero remaining barriers for agents to use every piece of software already running on every server.

At the same time Anthropic published their official plugin directory. This is not a random list of third party tools. This is the first standardized interface contract for agent tooling. There will be no more 17 incompatible plugin formats. We got the standard.

Agents run on single GPUs now

Andrej Karpathy dropped autoresearch this week. It is a complete research agent that runs end to end on one consumer 4090. It designs training runs, executes them, analyses results, iterates on hyperparameters. No API calls. No cloud.

This is the signal most people missed. All of this infrastructure is not just making agents better. It is making them small enough to run locally.

You do not need a 400B model to run a capable agent. You need a good memory system, good execution environment, and a small good base model. That was always the case. We just spent two years wasting compute on bad architecture.

Autoresearch does not do anything fancy. It does not have any novel prompting tricks. It just has clean memory management, reliable execution, and no unnecessary overhead. That is enough. This is what all agents will look like by the end of the year.

What this changes next week

You can stop tuning vector database chunk sizes today. You can stop building custom sandboxes. You can stop writing your own memory eviction logic.

All of that work is obsolete.

This is not a gradual shift. This is the point where the entire field moved past the prototype phase. For two years we were all building the same wrong components, arguing over minor optimizations. In the space of 14 days we got every missing piece required to build production agents that actually work reliably.

There will be a lot of noise over the next months about new agent models. Ignore that. The hard part was never the base LLM. The hard part was the infrastructure around it. That infrastructure landed this month.

We are no longer experimenting with if agents can work. We are now building the ones that will.