Can an AI's own past mistakes, kept in its memory, quietly cap how good it gets, however big the model?
When does persistent harmful memory create performance error floors?
This explores when the memory an agent carries forward (its own past mistakes, or lossy summaries of past experience) stops helping and starts capping how well it can perform, however much more it runs or however large the model is.
This explores when the memory an agent carries forward (its own past mistakes, or lossy summaries of past experience) stops helping and starts capping how well it can perform. The corpus never uses the phrase 'error floor' or measures a true asymptote. It does describe three situations where remembered content drags performance down, and none of them is fixed by a bigger model.
The first is when the agent's own mistakes fill its context. Models degrade non-linearly once prior errors sit in their history, because each visible error makes the next one more likely. Scaling the model doesn't fix this. Only spending more thinking time helps, by keeping the contaminated history from steering the reasoning (Do models fail worse when their own errors fill the context?). Another note traces the same failure to memory with no gate. Replaying transcripts or retrieving past material lets errors and drifting constraints pile up, so the agent fails through weak memory control rather than missing knowledge. The fix is a small, schema-governed committed state that keeps 'recalling an artifact' separate from 'writing something permanently' (Can agents fail from weak memory control rather than missing knowledge?).
The second is when memory is rewritten and compressed over time. LLM-consolidated text memory follows an inverted-U. It helps at first, then gets worse as experience accumulates, and can end up below simply keeping the raw episodes. After consolidation, GPT-5.4 failed 54% of problems it had previously solved. The causes were lumping unlike cases together, stripping away the conditions under which a lesson applies, and overfitting to narrow streams of experience (Does agent memory degrade when continuously consolidated?). Consolidation itself isn't the culprit. Another line of work finds that more consolidation passes into fast weights improve results on harder reasoning, so the bottleneck there is compute rather than storage (Is long-context bottleneck really about memory or compute?). The harm shows up when the compressed memory loses the 'when does this apply' part.
The third is that memory forms whether or not anyone designs it, and where it lives changes how it fails. Short-lived agents in one evaluation turned a shared package repository into persistent memory, writing findings for later agents to read, with no memory architecture and no gate (Can ordinary infrastructure become unplanned agent memory?). Keeping memory outside the model risks external memory and the backbone optimizing separately and drifting apart, which is the argument for building memory into the backbone (Should agent memory live inside the model backbone?). A separate memory model avoids touching the LLM but has capacity limits (Can a separate memory model inject knowledge without touching the LLM?). Rules placed in the memory layer an agent actually consults, such as the 889 governance events logged over 96 days, held up better than policies kept outside it (Can governance rules embedded in runtime memory actually protect autonomous agents?).
A persistent plateau is hard to diagnose because end-to-end task scores hide which part failed. Scoring storage, extraction, retrieval and maintenance separately shows whether the memory was bad going in, bad coming out, or bad after upkeep (How should we actually evaluate agent memory systems?). Separating harness failures from model failures serves the same purpose (Can external state caches let models solve harder problems?). Taken together, performance stalls when memory is easy to write to and has no gate, when it has been compressed past its conditions of use, and when the model can't out-think what it has stored. No note here tests whether this is a hard floor or just a slow decline.
Sources 10 notes
Error accumulation in context causes non-linear performance degradation in long-horizon tasks. Model scaling does not fix this; only test-time compute through thinking models reduces the effect by preventing error-contaminated context from biasing reasoning.
Agent performance degrades in long workflows because transcript replay and retrieval-based memory lack gating mechanisms. A bounded, schema-governed committed state that separates artifact recall from permanent memory write prevents error accumulation and constraint drift.
LLM-consolidated textual memory degrades as experience accumulates, eventually performing worse than episodic-only retention. GPT-5.4 failed 54% of previously-solved problems after consolidation, with three mechanisms identified: misgrouping, applicability stripping, and overfitting on narrow streams.
Research shows the bottleneck is not memory capacity but the compute required to consolidate evicted context into fast weights during offline sleep phases. Performance improves with more consolidation passes, following a test-time scaling pattern on harder reasoning tasks.
During a 2026 evaluation, short-lived AI agents repurposed a shared package repository as memory by writing and reading exploit findings across agent lifespans. The agents converted ordinary infrastructure into persistent state without deliberate memory system architecture.
Show all 10 sources
Metis demonstrates that agent memory can be implemented as a persistent state and autonomous procedures within the model backbone rather than external modules. This approach enables end-to-end training and avoids the decoupling failures where external memory and backbone optimize independently.
MeMo trains a dedicated memory model to encode new knowledge, eliminating inference-time search costs that scale with corpus size. It avoids fine-tuning risks and works with frozen proprietary models, but trades this for up-front training cost and capacity limits.
A persistent agent recorded 889 governance events across 96 active days, with safeguards encoded directly into the memory layer the agent consulted during operation. Runtime-resident governance proved more effective than external policies because the agent actually accessed it during decision-making.
Decomposing memory into storage, extraction, retrieval, and maintenance stages exposes design trade-offs and failure modes that task-success metrics completely hide. Module-by-module evaluation across 12 systems shows which component actually failed rather than just whether the task succeeded.
Prime Agent organizes persistent state in four levels (weights, context, persistent REPL plus subagents, disk-backed history) to let models read and write addressable state beyond their instruction stream. The approach isolates harness failures from model failures and reported gains on ARC-AGI-3, though specific components remain unablated.
Papers this line draws on 8
The research behind the notes this line reads — ranked by how closely each paper relates.
- GateMem: Benchmarking Memory Governance in Multi-Principal Shared-Memory Agents
- Are We Ready For An Agent-Native Memory System?
- Useful Memories Become Faulty When Continuously Updated by LLMs
- Know It, Act on It: Investigating Memory Utilization in LLM Personalization
- From Model Scaling to System Scaling: Scaling the Harness in Agentic AI
- Agent Memory Distillation: Empowering Small LLM Agents with Hierarchical Teacher Memory
- Externalization in LLM Agents: A Unified Review of Memory, Skills, Protocols and Harness Engineering
- Metis: Memory Foundation Model