Autoresearch Agents Plateau Because They Remember Too Much

Autoresearch agents stop improving because they remember too much. In Scaling Discovery Requires Forgetting (PDF), Shangyin Tan, Ben Zhou, Lakshya A Agrawal, and colleagues at UC Berkeley, Stanford, and Bespoke Labs show that longer runs, parallel agents, and even parallel agents that share candidates all plateau for the same reason: accumulated session and search history makes the agents conservative. Periodically discarding that history, keeping only the best candidate, and restarting from empty context unblocks progress under the same budget.

The abstract puts the claim cleanly: "the key to scaling discovery further is to forget." On four tasks, a team of four with communication plus three forgets beats parallel agents by up to about 15% and a single agent by up to about 39%.

Three scaling knobs, one wall

The paper studies the autoresearch loop: an agent edits a candidate, a scorer grades it, and the agent keeps going. You can give one agent more turns, run several agents in parallel, or let those agents see one another's candidates. All three eventually flatten.

The mechanism is visible in the trajectories. Early proposals change around 100 lines of code. Later ones shrink to a few lines. Reasoning tokens fall to about a third of their early level. On Anthropic's VLIW kernel take-home, across three single-agent replicates inside a $40 budget, 532 of 763 completed turns produce no candidate at all. That is 66% of model spend. In 531 of those empty turns the agent reads at most one file, makes no edit, and declares a plateau. One agent, stuck at 1,710 cycles after 34 turns, writes that it has "reached the practical limit of this machine configuration." The team with forgetting later reaches 1,077 cycles on the same task.

History anchors the search. The agent stays polite to its own past attempts and stops taking the large edits that still move the score.

What forgetting actually deletes

Forgetting here is aggressive. At each reset the harness discards every agent's session and the candidate history. It keeps only the best candidate and its score. A new empty-context agent then starts from that file, with the same instructions as the first round.

That is stronger than wiping chat alone. Concurrent work on Stateless Language Agents and Fork-and-Flush also resets proposer context; this paper clears workspace state too and retains only the best candidate. The team still communicates inside each round. There is no separate orchestrator.

The main setup is a team of four, forgetting three times (four rounds), running DeepSeek V4.1 Flash through the Pi agent, with three replicates per configuration and matched total token cost.

Table 1, same budget

On AtCoder Heuristic Contest 014 (higher score better), mean best scores are 795k for one agent, 964k for four parallel agents (+21%), and 1,103k for the team with forgetting (+39% vs one agent). Best run for the forgetting team hits 1,145k.

On the VLIW kernel (cycles, lower better), means are 1,426 / 1,220 / 1,097. Best for forgetting is 1,077.

On Frontier-CS Q171, means are 64.0 / 70.2 / 80.8. On nanochat-autoresearch validation bits-per-byte, 0.980 / 0.980 / 0.961. Parallel agents add nothing on nanochat; forgetting still moves the mean.

Across the four tasks the forgetting team is best on average and in its best run. Gains shrink after later forgets as solutions approach the task ceiling, but 32 of 36 forget events still produce a new best candidate in the next round.

Continue vs forget from the same plateau

The cleanest control starts from a plateaued AHC014 state and spends 30 more proposals per agent either continuing the long sessions or forgetting. Continue gains about 1.6% for one agent, 1.9% for parallel, and 1.4% for a team. Forget gains 4.5%, 7.0%, and 9.2% at little more than half the dollar cost, because contexts are shorter.

After a forget, the first ten proposals per agent look different: median edits about 40 lines versus 6 under continuation, and median reasoning about 9.4k tokens versus 2.9k. The renewed search narrows again inside a fresh phase, which is why the paper resets more than once.

Communication matters after the wipe. In one VLIW team run, a fresh agent tries a large tree-read change, fails twice, then borrows a small trick from a peer's diff and lands a jump from the round's starting point down to 1,136 cycles. A long session would likely have kept that agent in small-edit mode; a solo run would have dropped the idea after the two failures.

What I'd take from it

For open-ended discovery harnesses, memory policy is a first-class knob next to model choice and dollar budget. Keeping every failed attempt in context feels like continuity. In practice it breeds conservatism. If your single agent or parallel swarm has gone quiet while the score is still far from any known optimum, try discarding sessions and search state, keeping only the best candidate, and restarting from empty context before you buy another parallel replica.

The paper is short, the four tasks are concrete (heuristic programming, kernel cycles, a grid routing problem, and a training-script edit loop), and the continue-versus-forget table is the part I would re-run first on another model or another scorer.