Breaking the Bottleneck in Automated Research by LLM Agents: Forgetting Mechanism Boosts Discovery Efficiency by 39%

Automated research is becoming a key application area for LLM agents. Through iterative optimization and scoring verifiers, agents can discover new ideas across multiple domains. But a neglected problem is gradually coming to the surface: as agents accumulate longer and longer histories, their ability to innovate actually declines. Recent research points out that forgetting is the key to further scaling automated discovery.

All Three Scaling Strategies Hit Bottlenecks

The research team systematically examined three common paths for scaling automated research:

Single agent iterating for longer — letting one agent keep working for longer;

Multiple agents running in parallel — launching several agents simultaneously to explore independently;

Parallel agents communicating with each other — building on parallelism by letting agents exchange information and continue improving based on each other's candidates.

All three strategies yield gains early on, but as agents accumulate more history, they eventually stall. The core reason: each agent becomes "anchored" by its own past attempts. They tend to make smaller and smaller modifications to existing solutions rather than escaping local optima to explore entirely new directions. Once this stage is reached, adding more compute budget fails to bring substantive improvement.

This finding challenges the naive belief that "more compute equals better results." For open-ended discovery tasks, compute is not the only bottleneck.

Scoring verifier is a key component in the automated research pipeline. It is typically an independent model or program responsible for automatically scoring candidates produced by the agent to determine whether they meet the objective—such as whether code passes tests, whether a design meets performance targets, or whether a mathematical proof holds. In the iterative optimization loop, the agent adjusts its next search direction based on the score given by the verifier, so the quality of the verifier directly determines whether the discovery process can converge to a valid solution. If the verifier is biased or too lenient, the agent may be misled by erroneous signals and continue optimizing an invalid solution as if it were optimal.

Forgetting Mechanism: Periodically Clearing Search State

The solution proposed in the paper is straightforward: periodic forgetting.

Specifically, it periodically discards search state—including each agent's session records and full candidate history—and then restarts the search from the best candidate found so far. This operation appears to "waste" existing accumulation, but in fact it releases agents from being bound by their own history, allowing the same compute budget to push further.

The research team implemented the forgetting mechanism in a communicating team of agents and evaluated it on four types of tasks, covering heuristic programming, kernel optimization, and model training scenarios.

The results show:

• Compared with the parallel-agent approach, introducing the forgetting mechanism improves performance by up to 15%;
• Compared with the single-agent approach, the improvement is up to 39%.

These gains are achieved under the same compute budget, meaning the forgetting mechanism changes not "how much is invested," but "how effectively the investment is used."

Why Forgetting Is So Important for Open-Ended Discovery

The deeper insight of this research lies in redefining the value of agent memory.

In traditional software engineering, retaining a complete history is usually regarded as good practice—it provides traceability and context. But in open-ended discovery scenarios, a complete history instead becomes a burden. Agents tend to refer to their own historical decisions, causing search behavior to converge and the exploration space to shrink.

The core logic of the forgetting mechanism is: keep the best solution, discard path dependence. By restarting from the best candidate, the agent retains validated results while gaining the freedom to explore anew. It is no longer constrained by "what I tried before," but instead faces the open question of "where can I go from here."

The paper's authors therefore propose a more general conclusion: for open-ended discovery tasks, what an agent is allowed to remember is just as important as how much compute it is allocated. This view provides a new dimension for designing automated research systems—not only focusing on compute scaling and parallel architectures, but also seriously considering strategies for memory management.

Local optimum is a core concept in optimization and search theory, referring to a solution that is best within the neighborhood of the current position but not globally best. In automated discovery tasks, when an agent makes incremental modifications based on historical records, it is effectively searching only in small steps near the current solution, and is prone to getting stuck in a local optimum without being able to jump out. Common methods for escaping local optima include random restarts, high-temperature exploration in simulated annealing, and the forgetting mechanism proposed in this paper—by discarding history and restarting from the current best, it is equivalent to creating a "soft restart" while preserving results, giving the search a chance to cover a broader solution space.

Implications for the Development of Automated Research Tools

Most current mainstream LLM agent frameworks emphasize persistent memory and context accumulation, treating history length as a sign of capability. This research suggests a counterintuitive design principle: in exploratory tasks, timely "memory reset" may be more effective than continuous accumulation.

For teams building automated research tools, this means introducing controllable forgetting strategies into the architecture—determining when to discard state, from which checkpoint to restart, and how to strike a balance between forgetting and exploitation. These engineering decisions will directly affect whether agents can break through bottlenecks and achieve truly scalable discovery.

Persistent memory in LLM agent frameworks usually refers to conversation records, tool-call logs, and intermediate results retained across sessions, so that the agent does not lose context during multi-turn tasks. In contrast, working memory retains only short-term information relevant to the current task. The findings of this paper indicate that persistent memory may have negative effects in exploratory tasks: the longer the history, the more the agent tends to refer to old decisions, leading to convergent behavior. Therefore, in engineering practice, it is necessary to distinguish between tasks that "need long-term memory" (such as customer service and project management) and tasks that "need periodic forgetting" (such as open-ended search and creative generation), and to design state-discarding and checkpoint-restart mechanisms for the latter.

One-line Summary

The research finds that a forgetting mechanism can release agents from historical anchoring and significantly improve automated discovery performance.

Paragraph Summary

The article explores the scaling bottleneck of LLM agents in automated research: single-agent long iteration, multi-agent parallelism, and parallel communication all eventually stall due to accumulated history, because agents are anchored by past attempts and fall into local optima. The paper proposes a "forgetting mechanism"—periodically discarding search state and candidate history and restarting from the current best candidate, thereby removing path dependence. Across four task types including heuristic programming, kernel optimization, and model training, the forgetting mechanism improves performance by up to 15% over parallel agents and up to 39% over a single agent, without increasing compute budget. The article thus proposes that for open-ended discovery tasks, what an agent is allowed to remember is as important as how much compute is allocated, offering a new dimension for the design of automated research tools.