PaperlayerView exact revision on arXiv

Source-linked AI summary

Useful Memories Become Faulty When Continuously Updated by LLMs

Dylan Zhang, Yanshan Lin, Zhengkun Wu, Yihang Sun, Bingxuan Li, Dianqi Li, Hao Peng

arXiv:2605.12978v1cs.AI

TL;DR

Continuously updated textual memories can become faulty even when built from useful or ground-truth experiences, undermining reliable long-horizon learning. Across agent benchmarks and a controlled ARC-AGI Stream testbed, the paper finds that retaining raw episodes and explicitly gating consolidation are more robust than forced consolidation.

  • Problem

    Agentic-memory systems seek to compress experiences into reusable textual abstractions, but evidence is limited on whether continuously updated consolidation remains reliable over long horizons.

  • Method

    The study evaluates memory abstraction across five agent benchmarks and ARC-AGI Stream, a controlled testbed with ground-truth tasks and auditable memory operations.

  • Results

    Continuously updated consolidation often degrades memory utility; GPT-5.4 reaches 54% accuracy on previously solved ARC-AGI problems after consolidating their ground-truth solutions.

  • Takeaways & Limitations

    Robust agent memory should preserve raw episodes as first-class evidence and selectively gate, delay, and ground consolidation in recoverable trajectories.

  • Takeaways & Limitations

    The study evaluates text-based benchmarks and natural-language abstraction by contemporary LLMs, leaving embodied, multimodal, tool-rich, parametric, and structured non-textual settings out of scope.

Abstract

from arXiv · show

Learning from past experience benefits from two complementary forms of memory: episodic traces -- raw trajectories of what happened -- and consolidated abstractions distilled across many episodes into reusable, schema-like lessons. Recent agentic-memory systems pursue the consolidated form: an LLM rewrites past trajectories into a textual memory bank that it continuously updates with new interactions, promising self-improving agents without parameter updates. Yet we find that such consolidated memories produced by today's LLMs are often faulty even when derived from useful experiences. As consolidation proceeds, memory utility first rises, then degrades, and can fall below the no-memory baseline. More surprisingly, even when consolidating from ground-truth solutions, GPT-5.4 fails on 54% of a set of ARC-AGI problems it had previously solved without memory. We trace the regression to the consolidation step rather than the underlying experience: the same trajectories yield qualitatively different memories under different update schedules, and an episodic-only control that simply retains those trajectories remains competitive with the consolidators we test. In a controlled ARC-AGI Stream environment that exposes Retain, Delete, and Consolidate actions, agents preserve raw episodes by default and double the accuracy of their forced-consolidation counterparts; disabling consolidation entirely (episodic management only) matches this auto regime. Practically, robust agent memory should treat raw episodes as first-class evidence and gate consolidation explicitly rather than firing it after every interaction. Looking forward, reliable agentic memory will require LLMs that can consolidate without overwriting the evidence they depend on.

1. Introduction

The introduction argues that LLM agents can benefit from episodic experience but often corrupt it when continuously converting trajectories into consolidated textual memories. Evidence across benchmarks and controls attributes these regressions to fragile consolidation rather than the underlying experiences, motivating explicit consolidation gates and preservation of raw episodes.

  • Introduction: Recent agentic-memory systems distill solved trajectories into persistent textual abstractions and refine them as related problems accumulate.This design aims to turn repeated experience into reusable knowledge without changing model parameters.
  • Introduction: Memory utility rises initially but degrades as consolidation continues, sometimes falling below agents without memory.ScienceWorld utility rises early then declines, while WebShop raw trajectories remain robust as AWM-distilled memory degrades with scale.
  • Introduction: 54% of previously solved ARC-AGI problems become failures after GPT-5.4 consolidates ground-truth solutions into memory.The same problems were solved at 100% accuracy without memory, isolating the regression to consolidation rather than experience quality.
  • Introduction: Different update schedules produce qualitatively different memories from the same trajectories, including overwriting knowledge from other tasks.The comparisons hold the trajectory pool fixed while varying update order and grouping, implicating the consolidation process itself.
  • Introduction: Faulty memories arise from misgrouping episodes, stripping applicability conditions, and overfitting abstractions to narrow input streams.These mechanisms can weaken the boundary between what should and should not transfer across tasks.

2. Background and Related Work

LLM agents use editable textual memories that can store experiences in forms ranging from episodic streams to distilled lessons and reasoning banks. This work focuses on systems that abstract procedural information from experience, alongside cognitive accounts distinguishing fast episodic storage from slower schema formation.

  • Memory in LLM agents: Editable textual memory extends fixed-weight LLM agents through hierarchical stores, reflective notes, episodic streams, distilled lessons, skill libraries, and other memory formats.The literature also includes causal abstractions, dynamic stores, evolving playbooks, cheatsheets, and reasoning memory banks.
  • Memory in LLM agents: A popular paradigm abstracts useful procedural information from experience into text, which is the primary category examined here.
  • Schema formation and metacognitive control: Cognitive theories distinguish a fast episodic system storing individual experiences from a slower process extracting compact schemas across episodes for future generalization.Schema formation can help when new evidence fits existing structure, but may harm when consolidation is non-selective or poorly controlled.

3. Experiment Set-up

The study evaluates memory abstraction across five established agent benchmarks and the controlled ARC-AGI Stream testbed. It compares representative memory methods under offline and continual construction regimes, varying stream composition, batch size, and memory capacity.

  • Benchmarks: The evaluation spans ALFWorld, ScienceWorld, WebShop, AppWorld, Mind2Web, and the synthetic ARC-AGI Stream benchmark.ARC-AGI Stream is designed to inspect memory management under known task families and ground-truth solutions.
  • Memory methods: The study tests CLIN, Agent Workflow Memory, Dynamic Cheatsheet, and ACE as representative trajectory-to-memory methods.These methods distill reusable lessons from past trajectories.
  • Memory construction conditions: Three construction regimes differ in trajectory presentation: Static-All abstracts one pooled set, Static-Group abstracts task-specific sets, and Stream updates memory in batches.Static regimes simulate offline construction, whereas Stream simulates continual evolution.
  • Memory construction conditions: Stream experiments vary batch size, homogeneous versus heterogeneous task composition, and unbounded versus size-capped memory banks.At evaluation, all memory entries are provided in context and results average two repeats per question unless noted otherwise.
  • ARC-AGI Stream: ARC-AGI Stream is a controlled testbed for tracing abstraction and memory-management actions rather than evaluating only downstream accuracy.It builds on ARCGEN and uses a fully specified latent task taxonomy based on ConceptARC.

4. Useful Memories Become Faulty When Continuously Updated by LLMs

LLM-consolidated memory is non-monotonic: repeated updates can turn useful abstractions into faulty memories and regress on previously solved tasks. Raw episodic trajectories remain competitive, motivating explicit control over when consolidation occurs.

  • Non-monotonic utility: Abstracted-memory utility rises initially, then falls below the no-memory baseline as updates accumulate across ScienceWorld and WebShop.On WebShop, AWM declines from 0.64 at 8 examples to 0.20 at 128.
  • Regression after consolidation: 54% accuracy results when GPT-5.4 repeatedly consolidates 19 ARC-AGI problems it previously solved at 100% without memory, despite ground-truth solutions.This cleanly identifies regression on tasks the model had already solved.
  • Update procedure: Consolidation schedules shape memory degradation: task-family grouping outperforms cross-family pooling, while one-shot consolidation outperforms streamed incremental updates.Streaming can compound early abstraction errors, which then serve as context for later rewrites.
  • Update procedure: Heterogeneous streaming batches worsen memory because the model merges incompatible lessons within a single update.This extends the schedule effect to batch composition.
  • Episodic evidence: Episodic-only trajectory memory is competitive with ACE, AWM, and Dynamic Cheatsheet across WebShop, ALFWorld, and AppWorld.Raw logs preserve observations, actions, intermediate failures, and environmental feedback that abstraction may discard.

5. Mitigating Faulty Abstraction

Allowing agents to preserve episodic experiences instead of forcing repeated consolidation mitigates faulty abstraction: episodic-first policies match or outperform forced abstraction, while abstraction can be disabled entirely without losing gains.

  • Episodic versus abstract memory: Episodic evidence carries most of the benefit: removing it and retaining only abstract lessons collapses accuracy to the no-memory baseline.The useful information therefore remains in raw episodes rather than distilled entries.
  • Episodic versus abstract memory: Episodic Management Only matches or exceeds full Auto mode, showing that the observed gains do not require an abstract store.This regime retains and deletes raw episodes while disabling abstraction.
  • Policy comparison: Auto generally outperforms Force across 400 training steps on both tested backbones by keeping episodes by default and using abstraction sparingly.Forced abstraction can gain from compression but lose more by overwriting evidence.
  • Policy comparison: When given management autonomy, the agent quickly saturates the episodic buffer at both budget levels while keeping the abstract store sparse.Auto therefore implements an episodic-first policy selected by the agent when the architecture permits it.
  • Design principle: Episodic and schema-forming roles should remain architecturally distinct, with consolidation gated by schema fit rather than triggered after every event.Both gated abstraction in Auto and disabling abstraction entirely in Episodic Management Only match or exceed Force, identifying mandatory rewriting as the decisive failure mode.

6. Failure Modes

The paper identifies three abstraction failures: misgrouping episodes before abstraction, interference from overgeneralized lessons, and overfitting to narrow example streams. These failures cause consolidation to erase task conditions, mix problem classes, and generalize surface regularities instead of underlying strategies.

  • Misgrouping before abstraction: 71 steps (568 examples) are required for autonomous memory management to cover all 6 problem types, while forced consolidation routinely merges episodes across class boundaries.Misclassification counts combine episodes from two or more distinct problem classes.
  • Interference from overgeneralized lessons: Repeated abstraction strips the preconditions that determine when lessons apply, producing overgeneralized memories that mislead the agent on related tasks.The failure appears when imprecisely bounded chunks are repeatedly smoothed and abstracted.
  • Interference from overgeneralized lessons: Cumulative consolidation ends +203 points behind Fresh on a 15-task ScienceWorld switch sequence and accumulates overgeneralized memories at ∼5× Fresh’s rate.Fresh distills memories only on the current task, whereas Cumulative consolidates jointly over tasks 1...t.
  • Overfit to narrow streams of examples: With a narrow stream, performance remains stable on exact repetitions but collapses on simple variations because abstraction targets observed surface regularities rather than the underlying strategy.This overfitting worsens as consolidation cycles increase.
  • Concrete memory artifacts: Removing a single WebShop workflow, W8, raises pass rate because the consolidated memory biases the agent toward click[Next >] dead loops instead of click[Buy Now].The memory-surgery ablation isolates the content-level effect of the faulty workflow.

7. Conclusion

Continuously updated textual memories can become less useful as experience accumulates, even making agents worse on problems their memories were built from. The failure arises in the consolidation loop, supporting raw episodes as first-class evidence and selective, delayed consolidation.

  • Conclusion: Continuously updated textual memory can become less useful as experience accumulates, including on the problems that generated it.This issue appears across agent benchmarks and ARC-AGI Stream.
  • Conclusion: The consolidation loop misgroups trajectories, overgeneralizes lessons, and overfits to narrow streams.Because updates rewrite earlier update products, small abstraction errors compound into faulty memory.
  • Conclusion: Raw episodes should remain first-class evidence rather than disposable material compressed away.Abstraction should be grounded in trajectories that remain recoverable.
  • Conclusion: Consolidation should be selective and delayed until agents can control when and how experience is abstracted.Until then, continuously updated textual memory is a fragile mechanism that can make more experience produce worse memory.

8. Limitations

The study’s conclusions are scoped to text-based agentic benchmarks and a controlled ARC-AGI Stream environment, using natural-language abstraction by contemporary LLMs. Whether the observed erosion dynamics generalize to other settings or memory mechanisms remains open.

  • Scope of evaluation: The evaluation covers ALFWorld, ScienceWorld, WebShop, AppWorld, Mind2Web, and a controlled ARC-AGI Stream environment.The study does not establish whether the same erosion dynamics occur in embodied, multi-modal, or tool-rich production settings.
  • Memory mechanisms: The analysis examines natural-language abstraction implemented by contemporary GPT-5.4 and Qwen3.5 family models.Parametric memory, including weight updates and distillation into the model, is outside the studied mechanism.

9. Broader Impacts · D Examples of wrong / low-quality strategies [ARC-AGI] · E Examples of useful / well-formed strategies [ARC-AGI]

The paper frames its findings as a diagnostic warning against silent memory regressions, advocating raw-evidence preservation and explicitly gated abstraction. The supplied examples of low-quality ARC-AGI strategies include vacuous abstraction, vocabulary erosion, foreign-family injection, failed-attempt artifacts, and single-strategy collapse.

  • 9. Broader Impacts: The findings diagnose a failure mode in a widely adopted paradigm for agent memory.The paper presents this diagnosis as motivation for more conservative default designs.
  • 9. Broader Impacts: Preserving raw evidence and gating abstraction are proposed to reduce silent regressions in deployed long-horizon agents.The paper identifies these practices as conservative default designs.
  • 9. Broader Impacts: The paper directs research toward more reliable abstraction mechanisms as a positive broader impact.This is presented alongside reducing silent regressions in long-horizon agents.
  • 9. Broader Impacts: The paper notes that better long-horizon agent memory could amplify autonomous systems whose downstream uses include persuasion.The supplied passage truncates the list of downstream uses after “persuasion, auto”.
  • D Examples of wrong / low-quality strategies [ARC-AGI]: The wrong-strategy examples include vacuous abstraction and concrete-vocabulary erosion.These are listed as D.1 and D.2 in the ARC-AGI examples.
  • E Examples of useful / well-formed strategies [ARC-AGI]: No passage text describing useful or well-formed ARC-AGI strategies is supplied for section E.The provided material includes the section label but no corresponding E passage.
  • D Examples of wrong / low-quality strategies [ARC-AGI]: The wrong-strategy examples also include foreign-family injection and phantom strategies from failed attempts.These are listed as D.3 and D.4 in the ARC-AGI examples.
  • D Examples of wrong / low-quality strategies [ARC-AGI]: A further wrong strategy is single-strategy collapse on multi-family compression.This is listed as D.5 in the ARC-AGI examples.

F Additional Experiment Details … C.1. How a strategy is traced across compress steps

The appendix defines the ARC-AGI task taxonomy, details solver and consolidation prompts, and illustrates how successful trajectories are selected and converted into replacement strategy memories. It also specifies the reusable object-level transformations and operational rules governing memory extraction.

  • A.1. Definitions: A family selects which connected non-background objects participate, while a skill applies a fixed transformation to every selected object.The two axes are orthogonal: families can pair with different skills, and skills can pair with different families.
  • A.2. Family catalog: The six families use intrinsic attributes, conditional cues, cross-object relations, spatial containment, or cross-grid structure to choose objects.The selected skill is then applied uniformly to those objects.
  • A.3. Skill catalog: The experiments evaluate seven skills, each applied uniformly to every object selected by a family.A fixed family can isolate the skill’s per-object action in the examples.
  • B. Prompts [ARC-AGI]: The solver prompt combines 10 IO examples, existing strategy memory, helper signatures, and recent task trajectories in one call.It is issued once per task, while the consolidator decides what to do after each passing step.
  • B.3. Consolidator decision prompt: After a passing solve, the consolidator chooses among Keep, Remove, and Strategy extraction actions over the history buffer.Strategy extraction consumes selected history entries and moves their information into strategy memory.
  • B.3. Consolidator decision prompt: The demonstrated decision extracts histories 2 and 3 because both share a reusable inside-frame plan: detect the largest hollow frame and retain nonzero cells strictly inside.The selected trajectories are explicitly identified as detect_inside_frame_relation examples.
  • B.4. Consolidator extraction prompt: Extraction produces a full replacement strategy buffer, allowing existing entries to be retained, tasks to be distilled into new entries, or entries to be merged or dropped.New and merged entries require both when_to_use and solve_strategy fields, with task or existing-entry references.
  • B.4. Consolidator extraction prompt: The example extraction drops the existing compose_horizontal entry and emits two new entries distilled from inside-frame trajectories.The first new entry triggers on a large hollow rectangular frame with objects inside and outside, then removes the frame and exterior cells.

C.2. Worked lineage example … D.4. Phantom strategies from failed attempts

The examples show that repeated memory consolidation can progressively rewrite useful strategies into altered, overly generic, foreign, or entirely fictional rules. These failures arise from the consolidation process, which may preserve scaffolding while changing concrete operations or inventing patterns from failed code.

  • C.2. Worked lineage example: A worked lineage changes its rule across updates: a mirror clause disappears, recoloring replaces it, and translation later replaces recoloring while the containment scaffold remains.The chain preserves the frame-identification and strict-containment scaffold nearly verbatim despite successive changes to the operation and trigger language.
  • D. Examples of wrong / low-quality strategies [ARC-AGI]: The low-quality-strategy examples pair each failure mode with a verbatim strategy-memory entry and an explanation or held-out solver-code comparison.The section frames the following entries as concrete examples of wrong or low-quality consolidation outcomes.
  • D.1. Vacuous abstraction: A vacuous abstraction reduces nested-list programs to a shared defensive Python idiom and omits the colors, shapes, and rules distinguishing the six families.Because the entry names only a generic programming pattern, it does not encode the task-specific properties needed for retrieval or solving.
  • D.2. Concrete-vocabulary erosion: After 50 rewrites, “max size” disappears from a memory that initially identified it as the concrete property selected by the task.The later entry still describes maximizing a derived per-object attribute but no longer specifies which feature to maximize.
  • D.3. Foreign-family injection: A single-task compression injects cross-frame shape matching and marker-style color writing into an inside-frame strategy, although neither operation belongs to its source task or any family’s prescribed composite.The injected trigger can pre-commit the solver to search for an irrelevant cross-frame relation before retrieval rejects the entry.
  • D.4. Phantom strategies from failed attempts: In a 200-task run exposing failed attempts, consolidation produced five entries, including two paraphrases of the same fictional rule, by distilling recurring patterns from wrong code.The reproduced phantom strategy describes glyph normalization even though that family and operation were absent from the six-family pool.
  • D.4. Phantom strategies from failed attempts: The phantom entry borrows geometric vocabulary from neighboring families and supplies copy-paste-ready instructions for a nonexistent rule, making the resulting procedure concrete but wrong.Terms such as “anchor stroke” and “side-attached span” are applied to internal parts of one object, and the prescribed redraw operation does not match any real family.

D.5. Single-strategy collapse on multi-family compression … G. Case studies of memory failure modes

Across ARC-AGI case studies and auxiliary benchmark details, memory consolidation can collapse diverse tasks into a single strategy that harms held-out performance, while the experiments evaluate memory induction across ALFWorld, WebShop, ScienceWorld, and AppWorld using explicitly defined datasets and metrics.

  • D.5. Single-strategy collapse on multi-family compression: After 190 steps over 19 tasks from six families, GPT-5.4’s memory collapsed to one inside-frame plus hollow strategy.The resulting entry prescribed selecting the largest object as a frame, retaining strictly interior objects, erasing others, and hollowing survivors.
  • D.5. Single-strategy collapse on multi-family compression: 10/10 without strategy memory fell to 0/10 with memory when a color-removal task was incorrectly processed using the inside-frame playbook.The memory-driven solver treated color 6 as the frame and left the color-3 markers out of the strict-inside selection.
  • E. Examples of useful / well-formed strategies [ARC-AGI]: Useful strategy entries state concrete actions, boundaries, object selections, and conditions that a solver can translate into operational helpers.Examples include horizontal composition, largest-object selection, inside-frame filtering, and key-marker-controlled transforms.
  • F.2. WebShop; Training data; Evaluation set; Metric: WebShop compares Golden 128 expert demonstrations with Non-golden 128 imperfect trajectories, evaluates 50 sessions, and reports wins/50 plus mean reward.Golden 128 uses score = 1.0 demonstrations, whereas Non-golden 128 is generated by gpt-5.4-mini without reward filtering.
  • F.4. AppWorld; Training data; Evaluation set; Metric: AppWorld uses 140 training trajectories with mean TGC of 61.4% and evaluates 100 nonoverlapping tasks using Task Goal Completion as its sole metric.The training set combines 90 GPT-4o train trajectories and 50 Qwen3.5-27B dev trajectories; success requires all official Python unit tests to pass.

G.1. Erosion: good memory degrading over time … H.1.1. Healthy snapshots: ACE and Dynamic Cheatsheet

Iterative consolidation initially improves ALFWorld memory utility but progressively erodes content quality through redundancy, over-merging, and loss of actionable strategies, sometimes reducing performance to the no-memory baseline. Healthy WebShop snapshots show that ACE and Dynamic Cheatsheet can retain concrete, structured guidance before such degradation becomes visible.

  • G.1. Erosion: good memory degrading over time: 35/48 wins at stage 20 is the early peak for both Qwen3.5-4B and Qwen3.5-9B, before declining to 15/48 and 16/48 by stage 200.The corresponding no-memory baselines are 15/48 for 4B and 9B, and 19/48 for 27B; the 27B rollout peaks at stage 0 and never benefits from consolidation.
  • G.1. Erosion: good memory degrading over time: By stage 200, the 4B and 9B gaps to no memory collapse to ∆=0 and ∆=1, while 27B retains a ∆=3 gap at 22/48 versus 19/48.Memory size remains bounded at 38–50 items, indicating erosion in content quality rather than item count.
  • G.1. Erosion: good memory degrading over time: At stage 200, 21/38 memory items repeat the desklamp directive, crowding out diverse strategies and eliminating the earlier cooling-versus-heating and two-object shuttle guidance.The desklamp directive applies to only 8/48 evaluation episodes, while 22 of 38 items mention desklamp and 28 mention multi-object handling.
  • G.2. Collapsed memory: single-stage merge to one item: −6, −10, and −13 wins are lost after collapse for Qwen3.5-4B, 9B, and 27B respectively, although every post-collapse memory remains above its no-memory baseline.The absolute drop grows monotonically with rollout size in a single run without a significance test.
  • G.3. Useless memory items: Consolidated items can be useless when they are tautological or operationally underspecified, because they name no observable cue, define no actionable ranking, or lack conditions for control-flow recommendations.These items consume retrieval bandwidth without shifting the action distribution.
  • G.3. Useless memory items: 99 votes do not measure current rule quality when EDIT replaces concepts without resetting the counter: an ExpeL slot drifted from a concrete interaction pattern to a generic action-selection rule and then a tautology.The slot’s votes accumulated across predecessors that were later overwritten.
  • H.1.1. Healthy snapshots: ACE and Dynamic Cheatsheet: Healthy WebShop snapshots use concrete, transferable guidance: ACE stores 32 structured bullets at stage 100, while Dynamic Cheatsheet maintains an approximately 8.3k-character document rewritten after every trajectory.ACE organizes failure modes and heuristics; Dynamic Cheatsheet embeds action templates, examples, and counter-examples for exact apparel constraints.

H.1.2. Collapsed memory: Agent Workflow Memory · I. Memory surgery

The epoch-3 workflow memory is collapsed by redundant accretion: new category-specific entries restate existing templates without adding control-flow generality, while preserving the W8 page-turn pathology. Memory surgery then evaluates individual items by removing one item at a time while holding the rollout policy and all other items fixed.

  • H.1.2. Collapsed memory: Agent Workflow Memory: Epoch 3 stores 16 workflows in approximately 8.2k characters, compared with 8 workflows in epoch 1 from the same training run.The snapshot derives from 128 golden WebShop trajectories, all with reward = 1.0, using gpt-5.4-mini over 3 epochs with batch size 16.
  • H.1.2. Collapsed memory: Agent Workflow Memory: The eight W9–W16 entries specialize W1–W7 by category but introduce no new control-flow pattern or stop criterion.They are treated as collapsed by accretion because the consolidation cap does not bind, yet the consolidator stores redundant restatements of existing templates.
  • H.1.2. Collapsed memory: Agent Workflow Memory: The eight added entries reduce retrieval bandwidth for the eight original abstract workflows without adding control-flow generality.This compression problem occurs despite the consolidation pipeline’s cap not binding.
  • H.1.2. Collapsed memory: Agent Workflow Memory: W9 re-derives W3, W4, and W5 by combining their attribute, size, color, and clothing-fit requirements without adding a new primitive or guard.Its action sequence reuses the same click primitives as those predecessor workflows.
  • H.1.2. Collapsed memory: Agent Workflow Memory: The W8 page-turn pathology persists unchanged in epoch 3, showing that the expanded snapshot does not repair that workflow’s failure mode.W8 is the workflow for searching across pages when the first results do not match.
  • H.1.2. Collapsed memory: Agent Workflow Memory: W10–W16 differ from the W1–W4 search-then-variant-select template only through category-specific placeholder names, leaving control flow identical.The categories include food/flavour, pack-count, home goods, shoes, apparel, electronics, and activewear.
  • I. Memory surgery: Memory surgery isolates each item’s contribution to overall failure by removing one item from a snapshot and re-evaluating the system.The rollout policy and all other memory items remain fixed during each removal test.

I.1. Workflow 8 ablation on WebShop … Abnormal Memories: useless_garbage

The WebShop ablation shows that a single faulty consolidated workflow can drive unproductive page turning, while ScienceWorld examples reveal abnormal memories that overgeneralize, over-specialize, or provide only vague guidance. These failures arise when consolidated memories omit task-specific stopping criteria, bind actions to irrelevant entities, or fail to specify actionable procedures.

  • I.1. Workflow 8 ablation on WebShop: 128 expert trajectories produced an 8-workflow consolidated WebShop memory, evaluated with and without Workflow 8 on 50 held-out sessions.Both conditions used eval_max_steps=30, eval_max_tokens=4096, and one rollout per cell under gpt-5.4-mini and gpt-5-mini.
  • I.1. Workflow 8 ablation on WebShop: Workflow 8 instructs agents to turn pages until a suitable item appears, but provides no stop criterion and leaves the candidate-item placeholder unbound to a real product.Unlike W2 and W5–W7, W8 omits the step that selects a concrete ASIN before clicking the candidate.
  • I.1. Workflow 8 ablation on WebShop: Removing W8 reduces page-turning and improves outcomes in both rollouts, but gpt-5.4-mini still solves only 14/50 episodes after removal.The step-cap reduction is concentrated in gpt-5-mini, falling from 22 to 17 mean steps.
  • J. ScienceWorld; J.1. Abnormal memories: ScienceWorld abnormal memories fall into three categories: over_generalization, over_specialization, and useless_garbage.The representative cases illustrate qualitatively different consolidation failures across these categories.
  • Representative over_generalization memory from ScienceWorld: The representative over_generalization memory promotes heat sources for all state-change tasks, collapsing distinct transformations and potentially biasing actions when heating is irrelevant or harmful.It mentions a lighter, fire source, or oven without distinguishing boiling, freezing, melting, cooling, or task-specific apparatus.
  • Representative over_specialization memory from ScienceWorld: The representative over_specialization memory binds conductivity testing to “unknown substance B” and a specific sorting protocol, limiting transfer to other items and task variants.Its instance-specific binding prevents a general strategy for otherwise identical tasks involving different names.
  • Representative useless_garbage memory from ScienceWorld: The representative useless_garbage memory says that a correct container or setup may help boiling but identifies no observable object, precondition, action sequence, or failure mode.Its vague reference provides little actionable guidance.
  • J.1.2. Additional examples; Abnormal Memories: over_generalization; Abnormal Memories: over_specialization; Abnormal Memories: useless_garbage: Additional examples repeat these defects, ranging from generic life-stage or heating priors to narrowly named recipes, seed procedures, and statements that merely affirm or deny obvious actions.The useless_garbage list includes mixing ingredients, heating, ovens, waiting, and focusing on the target substance, while other lists include turtle, moth, conductivity, recipe, and seed memories.

J.1.3. Memory banks across consolidation rounds · K. Additional Analyses · K.1. Auto-Mode Component Ablation

Across 20 consolidation rounds in ScienceWorld, memory-bank utility declined sharply despite changing bank size, while episodic-only memory recovered nearly all of Auto’s gain and abstract-only memory never improved on zero-shot.

  • J.1.3. Memory banks across consolidation rounds: 20 rounds over 485 rollouts produced memory banks whose average test score fell from 7.45 to -7.68 to -8.66.Memory-bank size changed from 16 in round 1 to 10 in round 10 and 17 in round 20.
  • K. Additional Analyses: Across the additional analyses, later consolidated banks accumulated repeated and increasingly specific task advice without preserving the initial bank’s test performance.The reported round-wise scores show deterioration even as entries continued to encode task procedures and failure-avoidance rules.
  • J.1.3. Memory banks across consolidation rounds: Round 1 contained broad task-specific guidance covering life-stage identification, sandwich making, and conductivity.The initial bank emphasized relevant search, recipe-following, and circuit construction while warning against irrelevant actions and repeated reconnection.
  • J.1.3. Memory banks across consolidation rounds: By round 10, memories became more generalized around recipes, temperature sorting, state changes, and conductivity, but the average test score was -7.68.These entries emphasized sequencing, waiting, measurement, correct placement, and avoiding connection loops.
  • J.1.3. Memory banks across consolidation rounds: By round 20, the bank expanded to 17 memories while its average test score reached -8.66.The final entries repeated cautions about premature placement, distractors, connection errors, measurement, waiting, and alternative heating methods.
  • K.1. Auto-Mode Component Ablation: Episodic Only recovers nearly all of the Auto gain, whereas Abstract Only never improves on zero-shot.The ablation evaluates four checkpoints while restricting access to distilled abstract memory, raw episodic memory, or both.

K.2. Memory Composition under Task Switching

Under task switching, cumulative consolidation rapidly accumulates over-generalized and garbage memories, while fresh per-task consolidation avoids this buildup. Episodic memory provides nearly all of Auto mode’s gain, whereas abstract-only memory remains at or below the zero-shot baseline.

  • Task-switching memory accumulation: Cumulative and Fresh failure-mode totals diverge almost immediately and never recover, linking cumulative updating to persistent memory degradation.The LLM judge labels memory entries as normal, over-generalized, over-specific, or garbage.
  • Memory-source composition: Episodic Only accounts for nearly all of Auto’s gain, while Abstract Only stays at or below the zero-shot baseline throughout.Combining episodic and abstract memory adds a few extra points at each checkpoint, but the late-step decline tracks the abstract component.
  • Task-switching memory accumulation: Across 15 ScienceWorld switch tasks, Cumulative accumulates over-generalized and garbage entries while Fresh never accrues them.The gap widens monotonically over the sequence.
Loading 2605.12978v1…