I Called It Memory. The 2026 Benchmarks Say It Is Narrower Than That.

A while back I wrote that AI coding agents honour an architectural constraint at the start of a session and quietly violate it later, and I called the cause memory.

Three benchmarks published in 2026 now measure that pattern directly. They support the observation and they sharpen the diagnosis, and the sharpening matters: memory is the wrong word for what is actually failing.

Performance degrades across persistent rounds

EvoCode-Bench evaluates coding agents across 26 tasks spanning 227 sequential rounds, five to fifteen per task. The workspace persists, so decisions from round one are still present at round fifteen. Specifications evolve, and some new instructions deliberately conflict with earlier ones. Every round is scored against all accumulated requirements, not just the newest.

Only two of the evaluated agents exceed half the available multi-round credit. The failure profile is the more useful result: weaker agents drop early requirements, while stronger agents get further and then fail on conflict resolution, self-correction and regression management. Capability does not remove the problem. It moves it later in the trajectory.

Working code can still be deteriorating code

SlopCodeBench asks what happens to a codebase when an agent repeatedly extends its own prior output. Structural erosion increased across 80% of trajectories and verbosity across 89.8%.

The finding worth sitting with concerns prompting. Asking for cleaner code improved the starting state and did not prevent the later decline. Better instructions moved the intercept without changing the slope. That is a harder result to argue with than any claim about what models cannot do.

The repository is not the whole handoff

The obvious objection to all of this is that if context is lost, the next agent can just read the code.

Handoff Debt tests that assumption. It interrupts an agent at deterministic points, freezes the repository, and hands the work to a successor under four conditions. Handoffs carrying context reduce median agent events by 20% to 59% and prompt tokens by 42% to 63% against repository-only takeover. The successor can always read the code. Reading it is expensive, and some of what the predecessor knew is not in the files at all.

Where I was imprecise

Calling it memory implies the fix is a bigger container. That framing is getting weaker every quarter, because context windows are growing, compaction is improving and retrieval is improving. If capacity were the binding constraint, this problem would be receding. It is not.

The sharper statement separates three things that fail independently:

Availability is whether the decision is recorded anywhere the agent could reach. Retrieval is whether it was surfaced for this particular change. Continuity is whether it still governs the action after compaction, a new session, a competing requirement and possibly a different model.

The first two are context problems, and the industry is solving them fast. The third is not a storage property at all. A decision can be perfectly available, correctly retrieved, read by the model, and still not binding on what the model produces.

More context solves context capacity. It does not solve decision continuity.

What the evidence still does not show

None of these studies demonstrate that any particular governance mechanism prevents the degradation. They establish the failure class carefully and they do not validate a cure. I have run my own experiment on one candidate mechanism, and it failed its own gate before a blinded diagnosis explained why.

The honest position is that the problem is now well measured and the treatment is not. Those are different claims, and collapsing them is how this field generates noise.