Technical Summary: Useful Memories Become Faulty When Continuously Updated by LLMs

Problem Statement

Current agentic-memory systems often rely on a paradigm where Large Language Models (LLMs) distill past interaction trajectories into a textual memory bank of "consolidated abstractions" or "lessons." These systems aim to achieve self-improvement without parameter updates by continuously rewriting and updating this memory with new experiences. The core hypothesis is that agents can extract reusable, schema-like knowledge from episodic traces to generalize to novel situations.

However, this paper identifies a critical failure mode: continuous consolidation by current LLMs often degrades memory utility rather than enhancing it. Even when the underlying experiences are useful (e.g., ground-truth solutions or successfully solved trajectories), the process of abstracting and updating these memories introduces errors. The utility of such memory is non-monotonic; it may rise initially but eventually degrades, sometimes falling below the performance of an agent with no memory at all. The paper argues that the consolidation step itself is the source of failure, not the quality of the input data.

Methodology

The authors conduct a systematic evaluation across multiple agent benchmarks (ALFWorld, ScienceWorld, WebShop, AppWorld, Mind2Web) and introduce a controlled testbed, ARC-AGI Stream, to introspect the memory management process under known task families and ground-truth solutions.

Experimental Design

1. Memory Construction Regimes: The study compares three conditions for how trajectories are presented to the memory manager:
   • Static-All: Abstracting the entire pool of trajectories in a single pass.
   • Static-Group: Abstracting trajectories grouped by task type (offline construction).
   • Stream: Incrementally updating memory in batches, simulating a continuously evolving agent.
2. Control Baselines:
   • No Memory: Agents solve tasks without any memory.
   • Episodic-Only: Agents retain raw trajectories as in-context demonstrations without any cross-trajectory abstraction or consolidation.
   • Forced Consolidation (Force): Agents are required to consolidate every interaction, with no raw episodes persisting between rounds.
   • Auto: Agents are given the autonomy to choose between retaining raw episodes, deleting entries, or consolidating them into abstract lessons.
3. ARC-AGI Stream Testbed: This environment exposes specific actions (Retain, Delete, Consolidate) and provides ground-truth solutions at every step. This allows the authors to isolate whether performance drops are due to faulty input or faulty memory abstraction.
4. Ablation and Diagnostics: The study employs "memory surgery" (removing specific memory items to measure impact) and qualitative analysis of memory artifacts to identify specific failure modes (misgrouping, overgeneralization, overfitting).

Key Contributions

1. Empirical Evidence of Memory Erosion

The paper demonstrates that memory utility degrades as consolidation continues.

• In ScienceWorld and WebShop, agents using distilled memory (e.g., AWM, CLIN) show initial gains but suffer significant performance drops as the number of updates increases, eventually underperforming the no-memory baseline.
• In ARC-AGI Stream, GPT-5.4 solves a set of 19 problems at 100% accuracy without memory. After consolidating ground-truth solutions for these same problems, the model's accuracy on the same problems drops to 54%. This proves that the consolidation process itself corrupts the knowledge.

2. The Superiority of Episodic Retention

The study finds that raw episodic traces are a robust baseline.

• An "Episodic-Only" control, which appends raw rollouts to the context without abstraction, matches or exceeds the performance of sophisticated lesson-style consolidators (ACE, AWM, Dynamic Cheatsheet) across ALFWorld, WebShop, and AppWorld.
• In the ARC-AGI Stream, agents that default to retaining raw episodes (Auto mode) significantly outperform those forced to consolidate every step. Disabling abstraction entirely (Episodic Management Only) yields results comparable to the Auto mode, suggesting that the value comes from the raw evidence, not the distilled lessons.

3. Identification of Three Failure Modes

The authors trace the regression to three specific mechanisms in the consolidation loop:

• Misgrouping: Agents fail to correctly segment experiences before abstracting, pooling episodes that do not share underlying structure (e.g., merging distinct task families).
• Overgeneralization: Even with correct grouping, abstraction strips away applicability conditions. Lessons become too broad, interfering with neighboring tasks (e.g., applying a "pick-and-place" rule to a "look-at-light" task).
• Overfitting to Narrow Streams: When the input stream is narrow, abstraction overfits to specific surface regularities of seen instances rather than the underlying strategy, causing performance to collapse on slight variations of the same task family.

4. Architectural Implications

The paper argues that episodic and schema-forming roles should not be collapsed into a single rewrite loop. Current systems that treat every interaction as a candidate for immediate consolidation are fragile. The authors propose that robust agent memory should:

• Treat raw episodes as first-class evidence.
• Gate consolidation explicitly rather than triggering it after every interaction.
• Maintain distinct stores for fast episodic learning and slow schema formation, allowing the agent to preserve raw evidence while selectively abstracting only when appropriate.

Results

• Performance Degradation: In WebShop, AWM-distilled memory drops from a success rate of 0.64 (at 8 examples) to 0.20 (at 128 examples), while the no-memory baseline remains stable at 0.20.
• ARC-AGI Regression: GPT-5.4's accuracy on a solvable ARC-AGI slice drops from 100% (no memory) to 54% after iterative stream consolidation of ground-truth solutions.
• Streaming vs. Static: Streaming updates (batch-by-batch) consistently underperform static, one-shot consolidation (Static-All), indicating that early abstraction errors compound over time.
• Heterogeneity: Mixing different task types in a single update batch accelerates memory erosion compared to homogeneous batches.
• Auto vs. Force: In the ARC-AGI Stream, the "Auto" regime (which preserves raw episodes) achieves a 35.5% cumulative success rate, significantly outperforming the "Force" regime (forced abstraction), which drops to 22.0%.

Significance and Claims

The paper claims that the assumption underlying many recent agentic-memory systems—that continuous rewriting of memory is neutral or beneficial—is incorrect for current LLMs. The authors state:

"For today's models, retaining episodes is the more robust default... Yet episodic accumulation cannot be the long-term answer... We see faulty memory as a central open problem in agentic memory, and our results motivate architectures that keep the episodic and abstraction-forming roles distinct rather than collapsing both into a single rewrite loop."

The significance lies in diagnosing a "silent regression" in long-horizon agents. The paper suggests that until LLMs can reliably control when and how to consolidate without overwriting the evidence they depend on, continuously updated textual memory should be treated as a fragile mechanism that can make more experience produce worse memory. The work calls for a shift from "update-after-every-interaction" designs to systems that explicitly gate abstraction and prioritize the preservation of raw episodic evidence.