Forgetting Is the Strongest Amplifier: UC Berkeley Finds AI Researchers Need to Erase Memory to Keep Discovering
A Counterintuitive Finding
Imagine giving an AI research agent an unlimited budget to keep optimizing a piece of code. Day one: rapid progress. Day two: slowdown. Day three: it starts spinning in place. Not because compute is lacking, or the model is dumb — but because it remembers too much.
In their paper *Scaling Discovery Requires Forgetting*, Shangyin Tan and Matei Zaharia's team at UC Berkeley (yes, Databricks founder Zaharia) discovered something counterintuitive: when AI research agents hit a bottleneck in automated discovery, the most effective way to break through is not more compute, not more parallelism, not more agent communication — it's making them collectively forget.
Paper: https://arxiv.org/abs/2610.20563
Three Amplification Strategies, One Ceiling
The basic autoresearch loop is simple: propose → score → improve from feedback → propose again. LLM agents can run this loop end-to-end, with real results in math, algorithm design, and prompt optimization.
There are three intuitive ways to scale the system:
1. Run a single agent longer — more iterations 2. Run many agents in parallel — explore different directions simultaneously 3. Let parallel agents communicate — good ideas get developed by others
These mirror human research teams: one person digging longer, hiring more people, or team collaboration. But the authors found all three strategies hit the same wall.
The cause is remarkably consistent: every agent carries its ever-growing history (session context + search state) into each new proposal. As history accumulates, proposals become more conservative, edits shrink, and agents end up micro-tweaking in place — with most of the budget still unspent.
How Memory Becomes a Shackle
A striking experimental observation: the authors tracked lines of code changed and reasoning tokens per proposal:
- Start: ~100–150 lines changed, ~28k reasoning tokens
- After a few dollars: ~30 lines, ~7k tokens
- Late stage: only a few lines, ~1/3 of initial tokens
- Fast effect (bad): agents converge after reading each other's proposals, reducing short-term diversity.
- Slow effect (good): a good idea spreads through the team within a few rounds, accumulating long-term advantage.
This isn't agents "running out of ideas." On a VLIW kernel optimization task, a single agent produced 532 empty proposals out of 763 — consuming 66.2% of the budget while doing nothing. Most of the time, the agent read a single file and declared "I've reached the machine's practical limit." One agent said this at 1710 cycles; the same agent later reached 1644 cycles, and the team+forgetting configuration reached 1077. The 'practical limit' was a psychological barrier the agent set for itself, not a physical one.
The most fascinating finding: agents didn't stop generating new ideas — they stopped turning ideas into experiments. In one session, the agent developed a "choice tree" implementation idea across 11 consecutive rounds, abandoning it each time as "too complex, too risky" — even after correcting its own earlier cost misestimate.
Memory's role here: the agent's history of failures forms an increasingly narrow prior about what's worth trying. Each 'too risky' judgment reinforces the next.
Forgetting: Wipe Everything, Keep Only the Best
The authors' fix is almost suspiciously simple:
> Periodically, discard all agents' sessions and search state, keeping only the best candidate found so far. Then let fresh agents start from that candidate with blank contexts.
No sophisticated memory management, no selective forgetting, no importance sampling. Delete everything, keep the single best.
Why it works:
1. The best candidate already contains most of the effective progress. Discarded intermediate states record *how* progress was made, not *what* the progress is. For new agents, the "what" suffices; the "how" is a burden. 2. New agents aren't conditioned by past failures. The "too risky" judgments and "we've hit the limit" conclusions vanish with the sessions. New agents re-evaluate everything with fresh judgment.
Forgetting + Communication = Best Partners
Forgetting and inter-agent communication are natural complements. The implementation: 4 parallel agents, each seeing others' candidates (as commits) and scores before each proposal. No direct communication, purely asynchronous, zero extra tokens.
Communication has two effects at different timescales:
Concrete example from the VLIW task: after forgetting, one agent tried a bold new approach (a new way of reading values from a tree). First attempt was slower (1409 cycles vs. starting point 1201), the second merely even. Working alone, it would have given up here. But the agent read a teammate's diff, borrowed a small trick to simplify its new code, and the combined version hit 1136 cycles — the round's biggest single improvement. The team ended the round at 1114 cycles.
Without forgetting, the agent wouldn't have attempted the bold idea (bound by historical inertia). Without communication, it would have quit after two failures (no teammate's diff to borrow from). Both mechanisms are essential.
The Numbers
Four tasks, three configurations (single agent / 4 parallel agents / 4-agent team + forgetting), three runs each:
| Task | Single agent | 4 parallel | Team + forgetting | |------|---------|--------|----------| | AHC014 (score ↑) | 795 | 964 (+21%) | 1103 (+39%) | | VLIW kernel (cycles ↓) | 1426 | 1220 (-14%) | 1097 (-23%) | | Frontier-CS Q171 (score ↑) | 64.0 | 70.2 (+10%) | 80.8 (+26%) | | nanochat-autoresearch (BPB ↓) | 0.980 | 0.980 | 0.961 (-2%) |
Team + forgetting was best on all four tasks: +10% on average over parallel agents, +22% over a single agent.
Marginal gains per forgetting event:
| Forgetting event | AHC014 gain | VLIW gain | |---------|-----------|----------| | 1st | +11.2% | -7.0% | | 2nd | +4.8% | -2.6% | | 3rd | +1.7% | -1.6% |
The first forgetting pays most, then diminishing returns as the candidate nears optimum. But 32 of 36 forgetting events produced a new best candidate in the next round — 89% of forgetting was effective.
A Cleaner Controlled Experiment
To rule out the confound that "forgetting is just cheaper because contexts are shorter," the authors ran a controlled experiment: from the same plateaued state, 30 subsequent proposals either continued the original session or reset via forgetting.
| Configuration | Continue | Forget | |------|------|------| | Single agent | +1.6% | +4.5% | | 4 parallel | +1.9% | +7.0% | | 4-agent team | +1.4% | +9.2% |
Forgetting won in all configurations, with team + forgetting gaining the most (+9.2%). Crucially, forgetting cost roughly half as much as continuing — shorter contexts mean less spend for more progress.
Engineering Takeaways
1. Your agent isn't out of ideas — it's trapped by history. If your agent produces empty proposals or micro-edits, don't rush to switch models or add budget. Try wiping the session first. 2. Forgetting granularity is "delete all or keep all." No selective forgetting was needed; wiping everything but the best candidate worked well. In iterative optimization, the "how progress was made" matters far less than "the progress itself." 3. Communication and forgetting are complementary, not substitutes. On a plateaued multi-agent system, adding either alone helps little; adding both works best. 4. "We've hit the limit" is almost always false. The agent that declared a limit at 1710 cycles was eventually beaten down to 1077. Agents' self-assessments are unreliable, especially when rooted in long failure histories. 5. Forgetting timing is an open question. The authors used fixed-interval resets (every 30 proposals); adaptive forgetting triggered by plateau detection is the natural next step.
Reflections
The memory–compute equivalence breaks down. Conventional wisdom: "memory = compressed computation" — remember results, avoid recomputing. This paper shows a counterexample: in open-ended discovery, memory can obstruct computation. What you remember isn't "the answer" but "why I believe there's no better answer" — and the latter is a self-fulfilling prophecy.
This matches human research intuition. Newcomers often make breakthroughs not because they know more, but because they don't know "what's impossible." A 20-year veteran of the same problem may be unable to see new angles.
Another case of "structure over content." The core finding isn't "forgetting works" but the structural effect of memory: memory isn't a neutral store — it's a conditioning prior that systematically narrows the search space. Deleting memory doesn't delete information; it deletes a search constraint.
For agent engineering: mainstream frameworks (LangChain, AutoGen, CrewAI, etc.) are all racing toward *more* memory — long-term, working, episodic, semantic. This paper poses the opposite question: are you sure your agent needs to remember this much? In some tasks, a periodically amnesiac agent may outperform an eidetic one by 39%.
Finally, the paper's title is its own best summary: Scaling Discovery Requires Forgetting. Not an engineering trick, but a deep insight into the relationship between memory and discovery — possibly applicable to humans too.
---
Paper: Scaling Discovery Requires Forgetting Authors: Shangyin Tan, Ben Zhou, Lakshya A Agrawal, Jialin Zhang, Yilin Chen, Qiuyang Mang, Donghyun Lee, Dennis Jacob, Koushik Sen, Alex Dimakis, Matei Zaharia Institutions: UC Berkeley, Stanford, Bespoke Labs arXiv: https://arxiv.org/abs/2610.20563 Code: No public repository provided