Most memory systems decide on the write path. An event happens, a model extracts what seems important, and the rest is discarded. That keeps the store clean. It also asks the write path to know, at ingest, what will matter in three months. A detail that looks irrelevant in a support chat may explain an escalation later. Once the raw event is gone, better retrieval cannot recover it.

The better pattern is the old data-lakehouse move: preserve what happened, then build the useful representations later. Summaries, embeddings, graphs, and memories become replaceable views over an immutable history. The same conversation can yield one set of facts today and another next year. Better models can re-index old history. New agents can use it in ways nobody planned at capture time.

If agents work with other agents, they need a standard way to talk. That was the case for an explicit agent-to-agent protocol. Adoption is real. Meanwhile the rest of the stack has reduced how often agents need to appear to one another as independently addressable peers.

A remote agent can look like a capability. Inference stays behind the interface. Subagents live inside one runtime and die with the task. A supervisor presents one identity while specialists stay internal. Software factories coordinate the work, not a mesh of persistent agent relationships. Workflow engines treat agents as steps in a graph they already own. Handoffs can be artifacts in durable state rather than messages. Queues and event buses already do this at scale.

Most long-horizon agents compress or summarize the past as it arrives. That decision is made before future needs are known. Once discarded, the original evidence is gone.

Scroll treats each session as an executable environment. An append-only Event Log keeps lossless historical ground truth. A persistent Python kernel holds tool outputs, retrieved history, and derived state as variables rather than prompt text. The model writes code to search, materialize, and transform that state. Only the projections it prints enter the next working view.

Most agent frameworks split the system across prompt templates, tool schemas, callback code, and workflow graphs. The result is fragile and hard to reason about.

A simpler model is possible. Treat the agent as an ordinary Python object. Its methods are the actions the model can take. Its fields hold state. Its docstrings serve as prompts. Its type annotations act as contracts. Methods whose body is an ellipsis are completed at runtime by an LLM-driven loop. Methods with normal bodies remain ordinary deterministic Python.

Most systems still give models knowledge the hard way. They retrieve raw chunks at query time and force the model to re-derive understanding on every question. Nothing accumulates.

A better pattern has quietly emerged in 2026.

In multi-agent systems today, knowledge still lives in individual “skulls”. Each agent operates with its own isolated context window and memory, even when tools or repositories are shared. This creates fragmented islands of intelligence instead of true collective capability.

The repo is not enough. The next critical layer is a persistent, shared memory system — a real “hive mind” — that allows agents to build on each other’s insights in real time, retain long-term context across sessions, and evolve collective intelligence.

The biggest performance gains in agents are no longer coming from larger foundation models.

The new high-leverage frontier is treating every component of the agent pipeline as its own optimizable model — memory systems, skill libraries, routing logic, tool interfaces, orchestration layers, and evaluation mechanisms.