What specific failure modes emerge when agents retrieve stale or contaminated memories?
This explores the concrete ways agents break down when their memory contains old, wrong, or polluted information — not whether memory fails in the abstract, but the specific mechanisms by which bad memories degrade behavior.
This explores the concrete ways agents break down when their stored memory goes stale or gets contaminated — the corpus turns out to have unusually precise vocabulary for this, because the failures are named, measured, and mechanistically distinct rather than lumped together as 'memory got worse.' The cleanest map comes from the argument that the real memory problem is quality, not storage Is agent memory capacity or quality the real bottleneck?: the four named hazards are staleness (memory the world has moved past), drift (memory that slowly diverges from reality), contamination (bad entries poisoning good retrieval), and over-generalization (a narrow lesson misapplied broadly). The sharp claim there is that adding capacity without curation doesn't just fail to help — it actively makes performance worse, because more unfiltered memory means more chances to retrieve the wrong thing.
The most striking specifics come from work showing agent memory follows an inverted-U: it helps up to a point, then degrades below having no consolidated memory at all Does agent memory degrade when continuously consolidated?. After consolidation, a frontier model failed 54% of problems it had previously solved — actively un-learning through its own memory. That study isolates three mechanisms worth knowing by name: misgrouping (lumping unrelated experiences together so retrieval pulls the wrong neighbor), applicability stripping (a memory keeps the lesson but loses the conditions under which it was true, so it gets fired in situations where it doesn't apply), and overfitting on narrow streams (over-indexing on whatever the agent happened to see a lot of). Applicability stripping is the quiet killer — it's exactly how a once-correct memory becomes a contaminated one without any new false information entering.
There's a second, scarier flavor: corruption that compounds silently. Across long delegated relay tasks, frontier models corrupted roughly 25% of document content, with errors accumulating through 50 round-trips and never plateauing Do frontier LLMs silently corrupt documents in long workflows?. The failure mode here isn't a bad retrieval — it's that each pass over a memory introduces small distortions that the next pass treats as ground truth, so contamination snowballs invisibly. Nothing flags it; the agent is confidently working from a degraded copy.
The lateral surprise is that the corpus reframes many 'stale memory' failures as connectivity failures, not content failures. One line of work argues memory usefulness is determined by the links between co-activated units, not by what's stored — storage is 'inert,' and topology decides whether the right memory is even reachable at decision time Is agent memory a storage problem or a connectivity problem?. Under that view, 'contamination' often means interference: stale links keep activating outdated memories alongside current ones. That's why the proposed fix is adaptive topology that continuously creates and prunes links based on execution feedback, explicitly to eliminate interference Should agent memory adapt dynamically based on execution feedback? — pruning is presented less as housekeeping and more as the primary defense against drift. Notably, the four-component, two-granularity decomposition of working memory predicts that different parts fail differently and need different update policies How should agent memory split across time scales? — so 'stale memory' isn't one bug to fix but a family of bugs, each tied to a component and its refresh rate.
If you want the thread that ties it together: the recurring design response is autonomy plus structure. Structured, schema-based folding of past interactions is offered specifically as the thing that avoids the degradation that 'plagues poorly designed consolidation' Can agents compress their own memory without losing critical details? — which, read against the inverted-U result, is the direct rebuttal to naive 'just keep summarizing everything' consolidation.
Sources 7 notes
The core challenge in agent memory is not accumulating more data but managing what exists—preventing staleness, drift, contamination, and over-generalization. Adding capacity without curation actively makes performance worse.
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.
Testing 19 models across 52 domains shows even advanced systems degrade documents by ~25% over extended relay tasks, with errors compounding silently without plateauing through 50 round-trips.
FluxMem shows that memory usefulness is determined by links between co-activated units forming an accessible subgraph, not by what is stored. Storage is necessary but inert; topology determines whether useful memories are reachable at decision time.
FluxMem demonstrates that adaptive memory topology—where links form, refine, and consolidate based on closed-loop execution feedback—consistently reaches state-of-the-art across three distinct benchmarks. Dynamic connectivity outperforms fixed retrieval by aligning abstraction and eliminating interference.
RAISE shows that agent memory consists of four components organized by two design axes: dialogue-level (conversation history, scratchpad) versus turn-level (examples, task trajectory). This granularity distinction predicts different failure modes and update policies for each component.
DeepAgent's autonomous memory folding consolidates interaction history into episodic, working, and tool memory schemas. This reduces token overhead while letting agents pause to reconsider strategies—the autonomy and structure together avoid degradation that plagues poorly designed consolidation.