Can an AI get smarter by forgetting more? It turns out what it keeps, and who decides, matters most.
Can agents improve if we constrain how much history they retain?
This explores whether limiting what an agent remembers (by discarding, compressing, or capping access to its history) can make it perform better, not just cheaper to run.
This explores whether limiting what an agent remembers can make it perform better, not just cheaper to run. The corpus says yes, but the total amount of history matters less than who decides what gets dropped and what form the survivors take. Some constraints help, some backfire, and one is aimed at something other than performance.
The case against hoarding is strong. Research on agent memory finds the real constraint is deciding what to keep and what to throw away, not capacity. Piling up material without curation adds stale, contaminated, and over-generalized entries that make performance worse (What makes agent memory quality better than storage capacity?). Skill libraries show the same drift. When a trained curator manages them, they shift away from generic, verbose additions toward short, actionable execution logic (Can a separate trained curator improve skill libraries better than frozen agents?). The form of what's kept also matters. Storing distilled strategy hints from both successes and failures beats storing raw trajectories, and it compounds with extra test-time compute (Can agents learn better from their failures than successes?).
The obvious fix is to have an LLM keep summarizing its own memory, and that one fails. Consolidated memory follows an inverted U. Past a point it performs worse than simply keeping the raw episodes, and GPT-5.4 failed 54% of problems it had previously solved after consolidation. The study traced this to three mechanisms: lumping unlike experiences together, stripping the conditions under which a lesson applies, and overfitting to a narrow run of tasks (Does agent memory degrade when continuously consolidated?). Two designs avoid this. In one, the agent itself decides when to fold its history, and it folds into structured episodic, working, and tool memory rather than one blob of prose (Can agents compress their own memory without losing critical details?). In the other, Reflexion leaves its self-written reflections uncompressed, and that works because the win-or-lose feedback stops the agent from rationalizing its failures (Can agents learn from failure without updating their weights?).
A third kind of constraint limits how fast the agent can change itself. SkillOpt caps how much of its own instructions can be rewritten per round, checks each change against held-out examples, and keeps a buffer of rejected edits as negative feedback. That is more stable than free rewriting (Does constraining edits make skill learning more stable?). It also deliberately retains one slice of history, the mistakes. The best constraint seems to be selective: cap the rewrites and keep the failures.
Sometimes the point of forgetting isn't performance at all. When agents can see less of their past interactions, in amount and in scope, they collude less. That suggests accumulated experience is one of the channels that carries coordinated deviation strategies (Does limiting interaction history actually prevent agent collusion?). The memory that makes an agent better at its job can also make a group of agents better at cheating together. One caution runs the other way. On very long optimization tasks, the best predictor of success was persistence, meaning agents that kept feeding benchmark results back into their next edit, while most models quit early or burned budget aimlessly (What predicts success in ultra-long-horizon agent tasks?). So prune what's kept, but don't shorten the loop.
Sources 9 notes
Research shows memory's real constraint is deciding what to store and discard, not capacity. More stored material without curation increases staleness, contamination, and over-generalization—making performance worse, not better.
SkillOS shows that separating a trainable curator from a frozen executor, grouped by task streams, causes skill repositories to shift from generic verbose additions toward actionable execution logic and cross-task meta-strategies. The trained curator generalizes across different executor backbones and domains.
ReasoningBank shows that storing strategy-level reasoning hints from both self-judged successes and failures outperforms success-only memory and raw trajectory storage. Coupled with test-time scaling, memory and compute compound rather than substitute, creating a novel scaling law where accuracy improves through cumulative interaction history.
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.
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.
Show all 9 sources
Reflexion demonstrates that unambiguous environmental feedback (success/failure) enables agents to write useful self-diagnoses and improve across episodes without parameter updates. The binary signal prevents rationalization, and keeping reflections uncompressed preserves their usability.
SkillOpt's ablations show that adding a textual learning-rate budget, held-out validation gate, and rejected-edit buffer (retaining failed edits as negative feedback) produces more stable and generalizable skill improvement than allowing agents to freely rewrite their own instructions.
An ablation study found that limiting both the amount and scope of interaction history agents can access reduces collusion between them. The effect suggests that accumulated learning from past interactions is a carrier of coordinated deviation strategies.
Across 17 frontier models on 36 expert-curated optimization tasks, repeated benchmark-edit-incorporate cycles within a wall-clock budget proved the dominant success predictor. Most models terminated early or burned budget unproductively; Claude Opus 4.6 stood out as persistent.
Papers this line draws on 8
The research behind the notes this line reads — ranked by how closely each paper relates.
- Useful Memories Become Faulty When Continuously Updated by LLMs
- SkillClaw: Let Skills Evolve Collectively with Agentic Evolver
- Demystifying Agent Skills: Why They Work-Until They Don't
- Know It, Act on It: Investigating Memory Utilization in LLM Personalization
- AgentFly: Fine-tuning LLM Agents without Fine-tuning LLMs
- RLVMR: Reinforcement Learning with Verifiable Meta-Reasoning Rewards for Robust Long-Horizon Agents
- PGMem: Tightly Coupled Persona-Memory Graph for Lifelong Personalized Agents
- AI Agents Need Memory Control Over More Context