What the Brain Knows About Long-Running Agents

A frozen model is a cortex. The hard part is the organ that decides what the cortex learns.

For a couple of years we’ve been building the same thing: a harness. We wrap the model in scaffolding. Memory, tools, planning loops, a context gatherer, traces. And we treat all of it as temporary plumbing. The model keeps getting smarter, and soon, the bet goes, it will be smart enough that most of the harness falls away. A world model will have formed somewhere in the weights, and that will be the mind.

It’s a reasonable bet, and the scaling story has been right often enough that betting against it is a losing trade. But underneath it sits an assumption nobody has demonstrated: that intelligence lives in the weights, and everything around them is plumbing, a crutch we tolerate until the model no longer needs it.

The brain is a counterexample. It’s one long-running agent we have, and it didn’t solve the problem by putting everything in one system.

Two speeds of learning

In 1995, McClelland, McNaughton and O’Reilly asked a question that reads like a bug report: why does the brain need two memory systems instead of one? Their answer became Complementary Learning Systems theory. The finer story of how memories settle is more contested than a clean two-system split suggests, but the broad division of labor has mostly held up. The hippocampus learns fast. It captures a single experience in one shot, keeps similar experiences from blurring into each other, and holds the result in a form that is vivid and fragile. The neocortex learns slow. It folds many experiences together over time into distributed structure, the kind of thing we call knowledge: concepts, regularities, skills.

The reason there are two is the part that matters for agents. If you take a single striking experience and write it straight into the slow distributed system at a high learning rate, you don’t store it. You overwrite. New learning smears across the old weights and corrodes what was there. The field calls this catastrophic interference, and it’s exactly the failure you’d expect from a system asked to be fast and permanent at once. The brain’s fix is to divide the labor: capture the episode fast and cheap somewhere disposable, then teach it to the slow system gradually, interleaved with everything else, so the structure settles instead of shattering.

Fast episodic capture, a selection gate, slow consolidation. Most of what is captured is let go. Writing fast experience straight into slow structure is what produces catastrophic interference; the two-speed split is the fix.

Fast episodic capture, a selection gate, slow consolidation. Most of what is captured is let go. Writing fast experience straight into slow structure is what produces catastrophic interference; the two-speed split is the fix.

Your agent’s hippocampus is a bad one

Now look at a deployed model. Its weights are frozen. It carries enormous slow-learned structure, priors about language and code and causality and how situations tend to go. In 1943, Kenneth Craik described the mind as carrying a small-scale model of the world it could run forward to anticipate what happens next. A frozen model is a powerful version of the predictive side of that idea. But prediction is only half of what a long-running mind does. The other half is the record of what happened to this particular agent: what it tried, what it changed its mind about, what it learned not to do again.

Call it experiential state. A predictive world model lets an agent ask what might happen next. Experiential state lets it answer a different question: what happened to me, and what changed because of it. Durable agency comes from the loop between the two, and that loop is the part agents mostly fake.

Prediction supplies capacity; the record supplies continuity. The agent is the loop between them, and it is the loop, not either box, that current systems struggle to keep running.

Prediction supplies capacity; the record supplies continuity. The agent is the loop between them, and it is the loop, not either box, that current systems struggle to keep running.

It’s tempting to call this a hard wall: a frozen model can’t do fast episodic capture, so something outside the weights has to. But a long-enough context window is fast episodic capture. The agent conditions on what happened this session and acts differently for it. That’s a hippocampus. The trouble is it’s a bad one. It doesn’t persist past the session, so the next run starts cold. It costs more the more it holds, since every token you keep you pay for again on every step. And it can’t tell that one sentence mattered and forty didn’t, so it forgets by position instead of by importance. The gap isn’t that the agent can’t form fast memory. It’s that its fast memory won’t persist and won’t select.

Which is what the harness has been doing all along. Every memory store, every scratchpad, every retrieved transcript stuffed back into the window is a hand-built attempt at the persistent, selective version of that organ. We’ve been building hippocampi without realizing it, most of us. The clearest case predates the current wave: the experience replay buffer in DQN, one of the tricks that made deep reinforcement learning work in 2015, kept past experiences in a separate buffer and replayed them in interleaved batches into the slow network so it wouldn’t catastrophically forget. It was reached for on engineering grounds, data efficiency and breaking correlations between samples, and its authors noticed it rhymed with hippocampal replay. The engineering had rediscovered the shape of Complementary Learning Systems theory, a decade ago.

So the harness was never scaffolding on the way to a model that won’t need it. It’s us, by hand, doing the part the window does badly. We just keep reinventing it, badly.

The trick is selection

We reinvent it badly because we copy the wrong part. We assume the job is storage, so we store: the whole chat history, or a lossy summary of it, or everything embedded and retrieved by similarity. But storage is the least interesting version of the problem. The brain’s harder trick is selection.

In 2024, Buzsáki’s lab published a result agent builders should sit with. Recording hundreds of hippocampal neurons in mice running a maze, Yang and colleagues found that during brief high-frequency bursts called sharp-wave ripples, the brain replays the experience it just had, while still awake, in the seconds right after. Those waking ripples appear to act as a tag. The experiences replayed most while awake were the ones replayed again during sleep, and those were the ones that consolidated. It’s a correlational result, but a suggestive one. Not everything that happened. A chosen fraction, weighted toward what was rewarded and what was held weakly. The brain decides, early and physically, what is worth keeping, and lets the rest go.

Forgetting, in that picture, is a feature. A long-running memory that keeps everything at equal weight is no memory at all. It’s a log nobody can read. Selection is the step that turns raw experience into something that can become structure. Some experiences stay episodes, some are forgotten, some harden into facts or skills or reflexes, and some become part of the self.

The neuroscience says selection is necessary and can be cheap. It doesn’t say how. The brain’s tag is wired in by evolution: reward, surprise, novelty, all felt directly. An agent has none of that by default, so the question the whole architecture rests on is what plays the role of the tag. Task relevance, user correction, the severity of a failure, surprise against what the slow store already holds, expected future utility. Each is a real signal, none is solved, and the easy implementations smuggle back the cost you were trying to lose: an LLM reflecting on the day and choosing what to keep is a selection function, and an expensive, chatty one. This is the open problem, and the rest of the design sits downstream of it. Get the substrate perfect and the tag wrong, and you’ve built a flawless diary of the wrong moments.

There was a second detail in that study worthing noting. Laid out in low dimensions, the neural state drifted from one trip through the maze to the next, systematically. Same maze, same reward, and the brain was never in the same state twice. It encoded not only where the animal was but when, which trip this was. No man steps in the same river twice, and it turns out no mouse runs the same maze twice either. (immutable log, anyone?)

Coordinating without a conversation

The brain also points to a different kind of coordination: many specialized processes sharing state without a central executive narrating every step. Bernard Baars formalized this in 1988 as Global Workspace Theory, a limited shared space that parallel specialists read from and write to, with attention deciding what gets broadcast. It’s the cognitive version of an idea AI had already tried. In the 1970s the Hearsay-II speech system ran on a blackboard: independent experts, none in charge, each watching a shared structure and writing to it when it had something to add. No expert called another. Coordination was a property of the shared state and the order of the writes.

Four specialists, one shared workspace. Each reads and writes the same durable state, and none calls another, so coordination becomes a property of what gets written and the order it is written in. The conflict that used to happen in conversation moves into how the writes are reconciled, where it can be seen.

Four specialists, one shared workspace. Each reads and writes the same durable state, and none calls another, so coordination becomes a property of what gets written and the order it is written in. The conflict that used to happen in conversation moves into how the writes are reconciled, where it can be seen.

That’s the opposite of how we wire multi-agent systems today, where agents talk and talking compounds, every message another place for context to leak and cost to grow. A shared workspace moves most of that dialogue somewhere else. The catch is that the old blackboard got its efficiency from narrow specialists at a bottleneck, and once every writer is a general reasoner you can have several capable processes contending over the same state, where reconciling the writes is its own hard problem. Writing to shared state is still communication, only durable and inspectable instead of ephemeral, with the conflict that used to happen in conversation moving into how the writes get reconciled, where you can see it. That’s a real gain even when it isn’t a free one. The substrate was waiting in the old systems literature. We just never had anything capable enough to put on it.

What this tells us to build

Put the old ideas together and you get a fairly specific shape for a long-running agent. Two of the pieces come from the brain and two from software. The two-speed split and the selection gate are the brain’s. The append-only log, replay, and forking are event sourcing, the pattern behind git and Datomic and Kafka, and the log is best exactly where it stops imitating the brain: biological memory overwrites and confabulates and can’t replay or fork its past.

You want two stores at two speeds: a fast one, cheap to write, that captures episodes as they happen and keeps them separable instead of averaging them into mush, and a slow one that holds distilled structure and changes carefully. You want the agent’s state to be a projection over an append-only record rather than the thing you mutate in place, so the history survives and every change stays inspectable. You want replay and selective consolidation as real operations you can invoke, the agent’s version of sleep, deciding which slice of recent experience is promoted into the slow store while the rest decays. You want to be able to fork: spin off a copy, let it try a change to its own behavior, run it forward against the same history, and keep the result or throw it away without betting the running system on the experiment. The brain can’t fork its past, and pays for it in every bad habit it can’t safely test its way out of. Our agents can. And you want coordination to flow through that shared, projected state, the workspace, rather than through agents narrating themselves to one another.

The log is the source of truth; state is a projection over it. Because the record is immutable and append-only, history can be replayed to any point, and a change can be tried in a fork that is later merged or discarded. A self-edit that fails becomes a branch that didn’t take.

The log is the source of truth; state is a projection over it. Because the record is immutable and append-only, history can be replayed to any point, and a change can be tried in a fork that is later merged or discarded. A self-edit that fails becomes a branch that didn’t take.

None of this is free. Forking is clean for state and not for consequences: you can discard a branch, you can’t unsend the email it wrote or unplace the trade it made, so the line between reversible experiments and irreversible acts has to be part of the design. Skills are awkward too. In the brain a skill consolidates into slow weights; in a frozen agent a learned procedure has no obvious home that isn’t the context window again, unless it’s promoted through the same gated, evaluated loop as any other self-edit. And consolidation drifts, because promote-and-prune is lossy and compounds, though keeping the original episodes in the log at least leaves the drift detectable. The ordinary costs are real too: projection complexity, schema evolution, snapshots, compaction, replay. The case for paying them is that the alternative hides the same costs inside mutable state, lossy summaries, and failures nobody can reconstruct after the fact. And long context plus retrieval, the obvious objection, helps without substituting. A window is still a window, and retrieval over raw history can recover the events while losing the things that made them matter: the decision that turned an event into a belief, the reconciliation that resolved a contradiction, the branch the agent rejected and why. Those are matters of lineage, and more context doesn’t preserve them.

The frozen boundary looks like it’s going to to continue softenening. Test-time training, fast weights, continual learning, agent self-improvement: there’s real work on pushing some of what happens during use back into the weights, and I suspect some of it lands. But that doesn’t remove the record. It raises the stakes on selection, because now something has to decide which experiences become training signal, which failures to replay, which changes to merge, which to keep local. That is roughly the hippocampus’s job. It doesn’t vanish when the cortex finally learns something. It’s the thing that chose what the cortex learned. The record becomes more important the moment learning becomes real.

On a slightly more meta level, as I mentioned this in my talk earlier this month, but you and I are not defined by our reasoning capability. We are better defined by our knowledge, beliefs, and behaviors that are a result of the events in our lives.

ActiveGraph is an extension of continued experimentation around BabyAGI and knowledge graphs, and the inspiration was always the brain. It was fun to find that a lot of brain research reflected the architecture: make the agent’s history an append-only event log, treat its working state as a projection over that log, and you get replay, forking, and full lineage out of the structure. The system is in this paper (arXiv:2605.21997).

And there’s plenty of others. People are building agent memory everywhere: vector stores, temporal knowledge graphs, OS-style paging, reflection layers that summarize and consolidate. Most of it treats memory as a store the model reads from and writes to, parked beside the agent and optimized for recall. The part ActiveGraph is poking at is different: making the record the agent itself, its behaviors and its own edits included, so a whole run can be replayed, forked, and traced rather than only queried.