When an AI's memory fills up, it gets worse — is it running out of room, or drowning in its own mistakes?

This explores which mechanism does the most to stop models from breaking down as their context fills up. The corpus points to one answer: what matters most is controlling what gets in and stays in the model's working view, not adding more room. No note ranks the mechanisms head to head, so this is a synthesis across several.

The main reason is that a full context does harm through what it contains. In the self-conditioning effect, a model's own earlier mistakes sitting in its history make later mistakes more likely, and performance degrades non-linearly. Bigger models don't fix this, and only thinking models, which spend extra compute at test time, reduce it (Do models fail worse when their own errors fill the context?). One paper's diagnosis of multi-turn agent failure is 'weak memory control', not missing knowledge. Replaying the whole transcript, or retrieving from it, has no gate on what counts as trustworthy. Their fix is a small, schema-governed committed state, kept separate from raw recall, which stops errors and constraint drift from piling up (Can agents fail from weak memory control rather than missing knowledge?). A related result makes the gate an independent audit of the environment instead of the executor's own report. That lifted Qwen from 51.8% to 80.7% on WeaveBench (Can task state management alone improve long-horizon agent performance?).

The second mechanism is keeping most of the material out of the window until it's needed. LLM Programs put the task's state in ordinary code and show each LLM call only the context relevant to its step (Can algorithms control LLM reasoning better than LLMs alone?). Recursive Language Models go further: the long prompt lives in a Python REPL, and the model queries it with code. They handle inputs about 100x beyond the window and still beat the base model on shorter prompts. That result suggests capacity isn't the whole story, since a smaller, curated view works better even when everything would fit (Can models treat long prompts as external code environments?). The Thread Inference Model reaches a similar place from inside the model. It structures reasoning as recursive subtasks and prunes the KV cache by rule, staying accurate even while manipulating 90% of the cache (Can recursive subtask trees overcome context window limits?). Prime Agent layers state across weights, context, a persistent REPL, and disk-backed history, so the window holds only the working slice (Can external state caches let models solve harder problems?).

There is no universal pruning rule. AdaCoM trains an external manager to prune context for a frozen agent, and finds that stronger agents do better with high-fidelity preservation, while weaker ones need aggressive compression (Can an external manager handle context for frozen agents?). The mechanism is matching the selection to how reliable the agent is, not simply throwing more away.

Dropping context also isn't free. One line of work argues the long-context bottleneck is the compute needed to turn evicted material into usable internal state, not storage. In that work, more consolidation passes gave better results on harder reasoning tasks (Is long-context bottleneck really about memory or compute?). So good context management is a gated, agent-tuned decision about what to keep, hide, or consolidate, made with the cost of that consolidation in mind.