acceptodds
Under review as a conference paper at ICLR 2027

AgentDiscover: Autonomous Discovery with Minimal Search Scaffolding

Abstract

Frameworks that use large language models for scientific discovery typically rely on a fixed, human-designed algorithm that decides what the model sees at each step, leaving the model only the role of proposer. The model knows nothing of the search beyond what it is shown. As models grow more capable, a question arises: does a search strategy chosen by a human before the run scale better than promoting the model from proposer to planner and letting it own the search? *The Bitter Lesson* suggests that choosing the strategy in advance is the kind of hand-designed structure that general methods eventually outscale. We introduce AgentDiscover, in which a coding agent plans the search using its context as working memory, runs experiments, and records every attempt in a database of ideas, candidates, and their relations. This database serves as the agent's long-term memory and is structured so that the selection rules of classical algorithms such as MAP-Elites and Monte Carlo tree search each reduce to a single query, which the agent is free to use, combine, or replace. A server maintains the database and steers the agent after every submission, keeping it on course over long runs. In our experiments, AgentDiscover is more cost-efficient than existing frameworks, reaching better scores at lower cost. It achieves the best result among existing discovery frameworks on the kernel builder task, and on seven past AtCoder heuristic contests its programs would have placed first among human competitors in every contest. On eleven mathematical and systems optimization tasks, it matches or exceeds every baseline that uses the same model. Our code is available [here](https://anonymous.4open.science/r/AgentDiscover-D35C/).

Primary area:
foundation or frontier models, including LLMs
Keywords:
LLM agents, coding agents, scientific discovery, automated algorithm discovery, evolutionary search, self-improving systems, AI for science, agentic search, MAP-Elites, tree search, combinatorial optimization

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 3 reviews, above 27% of the others.
Reviewer_QANuOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper introduces AgentDiscover, a framework for autonomous discovery where a coding agent is responsible for both proposing candidates and directing the search process. Different from prior LLM-based evolutionary discovery frameworks that rely on fixed, human-designed search algorithms to select candidates or contexts for the LLM, AgentDiscover allows the agent to decide what information to retrieve, which experiments to run, and how to adapt the search strategy during optimization.

The framework consists of three main components: (1) a search agent that iteratively explores, experiments, and proposes candidates; (2) a graph-based long-term memory that stores candidates, ideas, lineage information, and lessons for structured retrieval; and (3) an optional meta-agent that analyzes previous search trajectories and produces reusable strategies or skills for future sessions. The authors argue that this design enables more efficient long-horizon search by avoiding excessively long contexts and allowing agents to reuse previous discoveries.

The paper evaluates AgentDiscover on a range of discovery and optimization tasks, including systems and mathematical optimization benchmarks, AtCoder heuristic contests, comparison with test-time reinforcement learning approaches, and Anthropic's kernel optimization task. The results show that AgentDiscover matches or outperforms existing discovery frameworks on the evaluated benchmarks, achieves competitive results on AtCoder tasks, and obtains strong cost-performance tradeoffs on the kernel optimization task.

Critical strengths
  1. The paper presents a carefully engineered framework for long-horizon autonomous discovery. In particular, the combination of agent-controlled search, graph-based persistent memory, and fresh-context sessions provides a practical solution to several challenges in long-running LLM-based optimization, such as context growth, information retrieval, and reuse of previous attempts. This system-level design is a meaningful contribution for building more capable discovery agents.

  2. The empirical evaluation is extensive and covers a diverse set of discovery problems, including systems optimization, mathematical optimization, heuristic programming contests, test-time optimization comparisons, and kernel optimization. The comparisons against several strong discovery frameworks under matched model settings and the reported cost-performance analysis provide substantial evidence that the proposed framework can be effective in practical discovery scenarios.

Critical weaknesses
  1. The novelty of AgentDiscover relative to recent autonomous discovery frameworks is not sufficiently established. In particular, CORAL already explores long-running agents that control retrieval and search direction through persistent state. Beyond this shared agentic search paradigm, the remaining design choices in AgentDiscover, such as graph-based memory and fresh-session execution, are not sufficiently distinguished from existing memory and agent orchestration approaches. The paper does not sufficiently demonstrate that these components provide fundamental advantages over existing memory and agent orchestration approaches, or isolate which design choices are responsible for the reported improvements.

  2. The contribution of individual components and the robustness of the reported improvements are not fully characterized. The main experimental results are mostly based on single runs, while LLM-based search procedures can have substantial stochastic variation. Moreover, the ablations do not isolate the effect of the central design choice—replacing fixed search policies with an autonomous search agent—from other factors such as graph memory, session restarting, and meta-agent guidance.

Questions for authors
  1. The paper's central motivation is that AgentDiscover allows agents to autonomously control and adapt search strategies rather than relying on fixed predefined algorithms. However, the paper states that it does not analyze which search strategies the agents actually use. Could the authors clarify why this analysis is omitted, given that understanding the agent's search behavior is important for validating the core claim of the paper?

  2. The paper emphasizes improved cost-performance tradeoffs, especially on the kernel optimization task. Could the authors provide an analysis of where these gains come from? For example, how much of the improvement is attributable to reduced model usage (tokens/calls), improved candidate quality per evaluation, graph-memory retrieval efficiency, or other orchestration choices such as session restarting and meta-agent guidance?

7 comments

Thank you for your review. We are glad you found AgentDiscover a carefully engineered framework for long-horizon discovery, and our evaluation extensive.

In the revision, we added ablations on session resets (Figure 4, p. 9), the graph memory (Table 5, p. 10) and the meta agent (Figure 5, p. 9). We also studied the search strategies the agent uses (Appendix B, p. 16) and added spend–performance curves as further evidence on cost (Appendix A, p. 15, Figures 6–8). Below, we also report averages over repeated runs for a selected group of tasks (W2), and address each point you raised.


W1: The novelty of AgentDiscover relative to recent autonomous discovery frameworks, in particular CORAL, is not sufficiently established.

Below, we list what is new in AgentDiscover and give an ablation or direct evidence for each part. In short, we show that:

  • Session resets lower cost and raise performance (Figure 4, p. 9).
  • Graph memory lowers cost (Table 5, p. 10) and makes planning easy, since each search rule is a single query (Appendix B, p. 16).
  • Meta-agent guidance raises performance (Figure 5, p. 9).
  • Steering messages keep the agent on course (Appendix E.3, p. 23) without wasting any LLM calls, whereas the heartbeat CORAL uses for the same purpose wastes about 10% of them.

1. Session resets (Figure 4, p. 9). Please see Figure 4, which we added in the revision.

  • Figure 4a: Without a reset, the cost of each LLM call keeps growing. A reset brings it back down.
  • Figure 4b: In a Cloudcast run, the search stalls repeatedly, and every new best comes right after a reset. After a reset, the agent explores the database again, which gives it a new perspective and makes new ideas more likely.
  • Figure 4c: Across all our runs, after the search stalls, a reset raises the chance of a new best from 21.2% to 25.0%.
  • Figure 4d: When a stalled search finds a new best, the gain over the previous best is 0.86% on average if it came after a reset, against 0.38% without a reset.

Two concurrent papers, posted after our submission deadline, reach the same idea as their main contribution:

  • Fork-and-Flush (arXiv:2610.07447)
  • Scaling Discovery Requires Forgetting (arXiv:2610.20563)

2. Graph database vs. plain files (Table 5, p. 10). Please see Table 5, which we added in the revision. We replayed eight sessions, with their entire history stored in a file system instead of the database. The file system uses the same structure as CORAL. We compared the two up to each session's first candidate. This is the exploration phase, where a fresh agent does most of its reading of the history (two thirds of its look-ups). In this phase, the database lets the agent use 26% fewer LLM calls, burn 22% fewer tokens and spend 20% less.

The database also lets the agent implement diverse search strategies simply, each as a single query, e.g., bandits, MAP-Elites, tree search and Pareto selection. Please see Appendix B (p. 16), which we added in the revision.


3. Meta agent (Figure 5, p. 9). Please see Figure 5, which we added in the revision.

  • Figure 5c compares the chance of finding a new best within n candidates, with and without meta guidance, for different n. For example, for n = 2, it rises from 33% to 73%.
  • Figure 5d compares the share of all proposed candidates, not only the best, that reach at least a given fitness, with and without meta guidance. For example, the median candidate's fitness rises from 0.801 to 0.832.

Figures 4c and 4d also show that combining a reset with a meta pass raises both the chance of a new best and the gain further (26.2% and 1.87%).


4. Steering messages vs. CORAL's heartbeat. Both keep a long-running agent on course, but CORAL's heartbeat wastes about 10% of its LLM calls, while our steering messages waste none.

  • CORAL: after submitting a candidate, the agent waits for its score, checking every 0.2 s, and resumes work as soon as the score arrives. CORAL's manager checks for new scores only every 5 s. Once it sees the score, it interrupts the agent (SIGINT) and restarts the same session with a steering prompt. In the gap between the two, the agent has usually already sent its next LLM call. The interrupt aborts this call while the provider is processing it: the tokens are billed, but the reply never reaches the restarted agent.
  • AgentDiscover: the steering message is simply the output of the MCP tool the agent calls to submit a candidate (Appendix E.3, p. 23). The agent is never interrupted, and no call is lost.

In many of our CORAL runs, one call per candidate was aborted this way: 8–12% of all calls. Aborted calls leave no usage record, so the CORAL costs we report (Figures 1, 6 and 8, and Table 4) do not include them, although the provider bills them. CORAL's actual spend is therefore about 10% higher than reported.

Q1: Could the authors clarify why the analysis of which search strategies the agents actually use is omitted?

We added this analysis in the revision (Appendix B, p. 16).

We initially left it out because our main claim is that we no longer need to worry about the search algorithm: the agent takes care of it. Whatever strategy the agent uses, the results show that it works, since AgentDiscover outperforms frameworks built on hand-designed algorithms (Tables 1–4).

We agree, however, that a behavioral analysis is also useful and supports the claim directly. We therefore analyzed representative graph queries the agents wrote in our runs. The agents implement classical search strategies themselves, for example:

  • they look for ideas that were tried least, with the best score each reached, which is the information a bandit rule such as UCB uses;
  • they select the best candidate per idea, the MAP-Elites selection rule;
  • they follow lineage edges back from the best candidates to choose a parent, as in tree search;
  • they filter out the dominant family of ideas to judge whether another direction is worth trying, a form of diversity maintenance;
  • they query for Pareto-optimal candidates when the score combines two metrics, as in multi-objective evolution.

Appendix B gives the exact queries the agents wrote.


Q2: Could the authors provide an analysis of where the cost-performance gains come from, e.g., reduced model usage (tokens/calls), improved candidate quality per evaluation, graph-memory retrieval efficiency, or orchestration choices such as session restarting and meta-agent guidance?

First, the cost-performance gains are not limited to the kernel builder. Appendix A (p. 15, Figures 6–8) adds spend–performance curves for more benchmarks.

Gains over LLM-call frameworks (OpenEvolve, ShinkaEvolve, EvoX).

  • Cheaper tokens. A coding agent keeps its history in context, so each new call re-reads it as cached tokens, which cost one tenth of regular input tokens. These frameworks build a new prompt at every iteration, which is billed as regular input tokens.
  • Better candidates per evaluation. The agent writes and runs its own experiments before it submits, so each candidate is better informed. On the kernel builder for example, AgentDiscover used 15 candidates, against 128–166 for these frameworks (Figure 1).

Gains over CORAL, which is also agent-based:

  • Session resets reduce model usage, since each call carries fewer tokens, and also improve candidate quality (W1, point 1).
  • Graph memory improves retrieval efficiency: the agent needs fewer llm calls to read its long-term memory (W1, point 2).
  • Meta-agent guidance improves candidate quality per evaluation (W1, point 3).
  • Steering messages reduce model usage: unlike CORAL's heartbeat, they waste no calls (W1, point 4). The calls CORAL wastes are not even included in our reported cost.

W2: The main experimental results are mostly based on single runs, while LLM-based search procedures can have substantial stochastic variation.

Thank you for raising this. We agree that a single final number does not show how much of it is due to chance. The spend–performance curves (Figures 1, 6, 7 and 8) give a fuller picture: on most tasks, AgentDiscover leads over most of the budget, not only at its end, which a single lucky run would not explain.

Repeating every run is costly, since each seed must be run for every baseline. For example, one seed of the kernel builder costs about $120 per method, so $600 for the five methods. We therefore repeated the runs for a subset of tasks. If the reviewers find it necessary, we will report repeated runs for all tasks in the camera-ready version. Each cell below gives the mean, with the individual runs in parentheses.

TaskAgentDiscoverCORAL
Pancreas (search split) ↓0.1607 (0.1603, 0.1602, 0.1616)0.1685 (0.1676, 0.1724, 0.1654)
PBMC (held out) ↓0.1495 (0.1472, 0.1473, 0.1539)0.1555 (0.1559, 0.1571, 0.1534)
Tabula Muris lung (held out) ↓0.1323 (0.1320, 0.1308, 0.1342)0.1379 (0.1392, 0.1386, 0.1360)
AHC006 ↑2,319,175 (2,309,017, 2,323,655, 2,324,852)2,282,891 (2,317,352, 2,297,709, 2,233,612)
AHC012 ↑99,991,143 (99,997,290, 99,996,203, 99,979,937)99,936,491 (99,977,717, 99,847,640, 99,984,115)
AHC015 ↑167,284,540 (168,660,525, 165,531,643, 167,661,453)156,515,262.67 (156,230,796, 155,943,176, 157,371,816)

AHC006 was the only task in our paper where CORAL beat AgentDiscover (Table 2). Averaged over three runs, AgentDiscover leads on AHC006 as well.

TaskAgentDiscoverOpenEvolveShinkaEvolveEvoXCORAL
Kernel builder (cycles, $118) ↓985 (960, 1,010)1,182 (1,174, 1,190)1,404 (1,156, 1,652)1,118.5 (1,098, 1,139)1,149.5 (1,148, 1,151)
Txn Sched. ↑4622.7 (4651, 4566, 4651)3774380239844566
Cloudcast ↓618.0 (618.0, 618.0, 618.0)627.2627.8623.5618.4

For Txn Sched. and Cloudcast, the OpenEvolve, ShinkaEvolve, EvoX and CORAL numbers are taken from the CORAL paper, where they are already averaged over multiple runs.

Regarding isolating the central design choice: we do not claim that our gains come from a better search algorithm. We believe LLM-based discovery works because of the growing power of LLMs, not because of the particular search algorithm around them. Much prior work replaces one fixed search algorithm with another, which we argue targets the wrong part. Letting the agent control the search means no search algorithm needs to be designed, since the agent can handle it itself (Q1). The gains come from the components that let the agent work efficiently over a long horizon, and W1 ablates each of them: session resets, graph memory, meta-agent guidance and steering messages.

Reviewer_RfsKOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper presents AgentDiscover, an LLM-driven discovery framework in which a coding agent both plans the search and proposes candidate programs, rather than operating under a fixed evolutionary search policy. The system stores candidates, ideas, lineage, and session-level lessons in a graph database that the agent can query as long-term memory; a server evaluates submissions and returns steering feedback, while an optional meta-agent produces reusable guidance for later sessions.

Critical strengths

The database-centered design is intuitive and potentially useful. In particular, representing ideas, candidates, lineage, sessions, and lessons explicitly could make long-horizon search more inspectable and allow agents to retrieve focused context instead of repeatedly reading raw experiment logs.

Critical weaknesses
  1. The central causal claim is under-supported. AgentDiscover changes many factors simultaneously: an agentic planner, a graph memory, server steering, session resets, persistent tools, optional meta-agent guidance, and possibly substantial task-specific prompting/infrastructure. The paper does not yet isolate how much of the gain comes from each component. The existing parallel-agent and meta-agent experiments are useful, but they do not establish that agent-selected search strategy, rather than better context/memory management, is the primary driver.
Questions for authors

For each main benchmark, what is held exactly constant across AgentDiscover and every baseline beyond model family and dollar spend: evaluator, candidate count, wall-clock budget, prompt/context budget, tool access, initialization, and hardware?

4 comments

Thank you for your review, and for finding our graph database, which stores ideas, candidates and their relations as long-term memory, an intuitive and useful design.

In the revision, we added an ablation or direct evidence for each part of the design, and raised the number of benchmarks to 24, across systems, mathematics, AtCoder heuristic contests, kernel engineering and biology. Below, we address each point you raised.


W1: AgentDiscover changes many factors simultaneously. The paper does not yet isolate how much of the gain comes from each component.

In short:

  • Session resets: lower cost and raise performance (Figure 4, p. 9).
  • Graph memory: lowers cost (Table 5, p. 10) and makes planning easy, since each search rule is a single query (Appendix B, p. 16).
  • Meta-agent guidance: raises performance (Figure 5, p. 9).
  • Agentic planner: the agent is indeed able to plan the search itself, so no fixed, human-designed algorithm is needed (Appendix B, p. 16).
  • Server steering: keeps the agent on course over a long horizon (Appendix E.3, p. 23).
  • Persistent tools: save cost, since the agent does not rewrite the same tools in every session.
  • Task-specific prompting/infrastructure: there is none (Appendix E, p. 22).

1. Session resets (Figure 4, p. 9). Please see Figure 4, which we added in the revision.

  • Figure 4a: Without a reset, the cost of each LLM call keeps growing. A reset brings it back down.
  • Figure 4b: In a Cloudcast run, the search stalls repeatedly, and every new best comes right after a reset. After a reset, the agent explores the database again, which gives it a new perspective and makes new ideas more likely.
  • Figure 4c: Across all our runs, after the search stalls, a reset raises the chance of a new best from 21.2% to 25.0%.
  • Figure 4d: When a stalled search finds a new best, the gain over the previous best is 0.86% on average if it came after a reset, against 0.38% without a reset.

Two concurrent papers, posted after our submission deadline, reach the same idea as their main contribution:

  • Fork-and-Flush (arXiv:2610.07447)
  • Scaling Discovery Requires Forgetting (arXiv:2610.20563)

2. Graph database vs. plain files (Table 5, p. 10). Please see Table 5, which we added in the revision. We replayed eight sessions, with their entire history stored in a file system instead of the database. The file system uses the same structure as CORAL. We compared the two up to each session's first candidate. This is the exploration phase, where a fresh agent does most of its reading of the history (two thirds of its look-ups). In this phase, the database lets the agent use 26% fewer LLM calls, burn 22% fewer tokens and spend 20% less.

The database also lets the agent implement diverse search strategies simply, each as a single query (Appendix B, p. 16), e.g., bandits, MAP-Elites, tree search and Pareto selection.


3. Meta agent (Figure 5, p. 9). Please see Figure 5, which we added in the revision.

  • Figure 5c compares the chance of finding a new best within n candidates, with and without meta guidance, for different n. For example, for n = 2, it rises from 33% to 73%.
  • Figure 5d compares the share of all proposed candidates, not only the best, that reach at least a given fitness, with and without meta guidance. For example, the median candidate's fitness rises from 0.801 to 0.832.

Figures 4c and 4d also show that combining a reset with a meta pass raises both the chance of a new best and the gain further (26.2% and 1.87%).


4. Agentic planner (Appendix B, p. 16). To clarify our claim about agentic planner: most prior work replaces one fixed search algorithm with another. We argue that this targets the wrong part, for two reasons:

  • No search algorithm is best across all problems (Wolpert & Macready, 1997; Gupta et al., 2026), so no algorithm fixed in advance suits every task.
  • Coding agents already know classical search algorithms from their training.

LLM-based discovery works because of the growing power of LLMs, not because of the particular search algorithm around it. Our claim is therefore that no fixed algorithm is needed: once strategies are easy to implement, as single database queries (point 2), the agent picks and adapts them itself, as it needs. This also means that agent-selected search and memory are not competing explanations: the agent plans through the memory. We show in two ways that no fixed algorithm is needed:

  • Quantitatively: with no fixed algorithm, AgentDiscover outperforms frameworks built on hand-designed algorithms (Tables 1–4).
  • Behaviorally: Appendix B shows that the agent can indeed do this. It implements classical search strategies itself and balances exploration and exploitation. For example, it searches for under-explored ideas (bandits), the best candidate per idea (MAP-Elites), strong parents along a lineage (tree search) and Pareto-optimal candidates (multi-objective evolution).

5. Server-side steering. Steering messages keep the agent on course over a long horizon; they are not meant to raise scores directly or to dictate what the agent does. In each session, the agent should propose candidates in a loop and finally record a lesson. No code runs this loop (there is no for or while): the agent runs it itself. Steering messages help the agent know where it stands in this loop, simply through the output of the MCP tool it calls to submit a candidate (Section 3; Appendix E.3, p. 23). After each submission, the message reports:

  • how many candidates the agent has submitted, so the agent knows how far into its session it is;
  • the scores of its previous five candidates, so it knows whether it is stuck;
  • its context length, so it knows whether it is cheaper to stop and leave the work to a new session.

The logs show that steering messages help with this. For example, agents stop right after 43% of the replies that show a fresh session would now be cheaper, against 9.4% of other replies, and they cite this reply when they stop.

In Appendix C (Table 6, p. 19), we ran a local model as a coding agent alone, with no component to keep it on course, such as steering messages or session resets. Compared to AgentDiscover with the same model and coding agent, it does much worse on every task, simply because it doesn't perform the loop and stops too early. This shows how important it is to keep the agent on course.


6. Persistent tools. To clarify, the only tools we give the agent are general bash tools. No task-specific tool is provided. The agent uses bash to write its own tools and to run experiments with them.

  • Turning tools off would reduce the agent to single LLM calls. With no tools, the model cannot act and can only reason in its chain of thought. We already compare against three optimized methods built on LLM calls: OpenEvolve, ShinkaEvolve and EvoX.
  • The agent writes the tools it needs as bash or Python scripts in a tools/ folder. We simply keep this folder across sessions, so later sessions inherit the tools earlier ones wrote. Otherwise, each session would burn tokens writing them again. In our logs, 41% of the tools a session writes are run again by a later session.

7. Task-specific prompting or infrastructure. We use no task-specific prompts or infrastructure (Appendix E, p. 22). Each problem has only its own problem description and evaluator, the same ones every baseline gets.


Q1: What is held exactly constant across AgentDiscover and every baseline?

Our main results are Table 2 and 3, Figure 1 and Table 1. The protocol is in Section 4 (p. 7) and Appendix G (p. 26).

General rule (Tables 2 and 3, Figure 1). We ran all baselines ourselves, and every method gets:

  • the exact same seed solution,
  • exactly the same evaluator,
  • the same information in the problem description, with no task-specific guidance,
  • zero tools at the start,
  • the same model and the same dollar budget.

Each method runs until it has used its whole budget. Wall-clock time and the number of candidates are therefore not fixed: they depend on how many candidates each framework submits, and how long it runs, within the budget. Each framework needs its own instructions, so the instructions are not verbatim, but none of them contains task-specific guidance. TTT-Discover's numbers in Table 3 are taken from its paper.

One exception (Table 1). The baseline numbers come from CORAL's paper, which does not report dollar spend. Where we corrected an evaluator (signal processing), we reran all baselines ourselves. So for this table we use the number of candidates as the budget: the baselines used 100, and so did we. Even so, AgentDiscover often needs far fewer. For example, it matches the best baseline, and reaches its own number in Table 1, within 1 candidate on PRISM and MMD-16-2, 2 on circle packing, 4 on MMD-14-3 and 6 on transaction scheduling. Several benchmarks in Table 1 are saturated, which is why we also evaluate on the AtCoder contests of Table 2 and added the less saturated tasks of Table 3. Everything else is the same as above.

Hardware. The search only makes API calls and runs on CPUs, and the CPU type does not affect results in any meaningful way. For the GPU kernel tasks, CORAL and AgentDiscover are evaluated on the same GPU (TriMul on A100, MLA-Decode on H200).

AuthorsOpenReview ↗

A gentle reminder

Thank you for your time and feedback on our paper. This is a gentle reminder to take a look at our responses above.

In our responses and revised manuscript, we:

  • Clarified the contribution of each component to performance and cost-efficiency.
  • Added an ablation comparing the graph database with plain-file memory.
  • Analyzed the effects of context resets.
  • Added an ablation of the meta-agent.
  • Added an analysis of the agent’s search strategies and clarified how search planning and memory work together.
  • Clarified the role of server-side steering and added supporting evidence.
  • Explained how agents create and reuse tools across sessions.
  • Clarified that we provide no task-specific tools or prompts and explained how we keep comparisons with baselines fair.
  • Expanded the evaluation to 24 benchmarks.

Considering that there are less than 24 hours left until the end of the discussion period, we wanted to post this as a follow-up. We would appreciate your feedback while there is still time to discuss any remaining concerns.

Reviewer_v96vOpenReview ↗
Rating
2
Confidence
2
Informativeness
3
Presentation
3
Soundness
2
Read review
Paper summary

This paper investigates the problem of automatic scientific research. The authors propose AgentDiscovery, a novel framework that replaces the fixed evolutionary search algorithms many pipelines adopt with a coding agent to direct the search. The framework is evaluated on 11 tasks and is reported to have the best published results.

Critical strengths
  1. The paper is generally well-written. I have found it easy to follow and understand.

  2. A comprehensive list of autoresearch papers are engaged in the related work section.

  3. The authors have drafted elaborate diagrams for the presentation of their methodology and workflow.

Critical weaknesses
  1. The related work section have unclear taxonomy, autonomous research agents and LLM-based evolutionary search appear to have clear intersections.

  2. Critically, the core methodology to use another agent to guide searching is already proposed by many previous works, including EvoX: Meta-Evolution for Automated Discovery, Meta-Harness: End-to-End Optimization of Model Harnesses and CORAL: Towards Autonomous Multi-Agent Evolution for Open-Ended Discovery. This paper has very doubtable novelty over these existing approaches.

  3. The experimental results shown in the paper only demonstrate marginal performance gains compared with previous research, making the effectiveness of this paper doubtable.

  4. Many of the references are arXiv preprints. It is worth check if published versions are available and if so the references should be changed accordingly.

Questions for authors
  1. What mechanism proposed in this AgentDiscover framework is completely new and not introduced in prior works?

  2. The framework simultaneously introduces agent-controlled search, a graph database, context resets, server-side steering, and meta-agent guidance. What actually causes the performance improvement?

5 comments

Thank you for your review, and for finding the paper well-written and the diagrams of our workflow elaborate.

In the revision, we increased the number of benchmarks to 24 and added ablation studies on context resets, the graph database and the meta agent. Below, we address each point you raised.


W1: The experimental results shown in the paper only demonstrate marginal performance gains.

We believe the gains are significant, for five reasons.

1. Several gains in the submission are large. Our five largest gains over the best baseline are:

  • AHC025: 26.0% (25,923,844 → 19,173,103 absolute score)
  • Kernel builder: 12.6% (1,098 → 960 cycles)
  • AHC015: 8.0% (156,230,796 → 168,660,525)
  • EPLB: 2.7% (0.149 → 0.153)
  • Signal processing: 2.0% (0.7790 → 0.7948)

These come from Tables 1, 2 and 4 (pp. 7–8) and Table 13 (p. 28).

2. We added six new, less saturated benchmarks. AgentDiscover is best on all six. Gains over the previous best:

  • MLA-Decode: 6.8% (1,582 → 1,474 µs)
  • TriMul: 5.4% (2,198 → 2,080 µs)
  • PBMC denoising: 4.5% (0.154 → 0.147 MSE)
  • Pancreas denoising: 3.1% (0.1655 → 0.1603 MSE)
  • Tabula lung denoising: 2.9% (0.136 → 0.132 MSE)
  • AC2: 0.4% (0.9591 → 0.96275)

These come from Table 3 (p. 8).

3. Final scores hide how fast each method gets there. Figure 1 and Table 4 show this on kernel builder. We added spend–performance figures for eight more tasks in Appendix A (p. 15, Figures 6–8), which show a visible gap as well.

4. Small gains on math tasks are still meaningful. Math tasks are already close to their bounds, so all methods score close to each other. However, the scores come from an exact (oracle) evaluator. Even a gain in the fourth decimal is a genuine new construction, and it shows the bound can still be improved. This is unlike other domains in AI, where such small gains can be noise.

Prior work reports gains of the same size on these problems:

  • AlphaEvolve improved the Erdős bound over the best human result by 0.0008% (0.380927 → 0.380924).
  • ThetaEvolve improved AC1 over AlphaEvolve V2 by 0.002% (1.50317 → 1.50314).
  • TTT-Discover improved AC1 over ThetaEvolve by 0.018% (1.50314 → 1.50287).

Our gains over the best baseline are similar: 0.03% on Erdős (0.38089 → 0.38077) and 0.005% on AC1 (1.50282 → 1.50274).

5. Relative scores compress the gap. AHC025's official score is relative to other entrants: 98.76 vs. 98.50 for CORAL, a 0.3% difference. On the fixed absolute score, the gap is 26% (Table 13, Appendix H.1, p. 28).


W2: Many of the references are arXiv preprints.

Thank you for pointing this out. Nine of the cited preprints have since been published, at COLM, ICML, ICLR, NeurIPS and in Nature. We replaced their references with the published versions, marked in blue. The papers are CORAL, EvoX, Meta-Harness, TTT-Discover, ThetaEvolve, MCTS-AHD, GEPA, SkillOpt and Paper2Agent.

Q1: What mechanism in AgentDiscover is completely new and not introduced in prior works?

We list our contributions here. In our answer to Q2, we give the ablations and evidence for the usefulness of each one.

1. No fixed search algorithm is needed. In LLM-based scientific discovery, most papers before us replaced one fixed search algorithm with another. We argued that this targets the wrong part, for two reasons:

  • No search algorithm is best across all problems (Wolpert & Macready, 1997; Gupta et al., 2026).
  • Coding agents already know classical search algorithms from pretraining.

Knowing them is not enough, however; the agent must also be able to implement them easily. We made this feasible with a graph database, where each search strategy is a single query (Appendix B, p. 16).

We then showed that our argument holds:

  • Quantitatively, AgentDiscover outperforms the baselines in our main results (Tables 1–4).
  • Behaviorally, Appendix B studies the search strategies the agent uses (see Q2).

2. Context resets. AgentDiscover resets the agent's context when the agent stalls or when its long context becomes too costly. This keeps the cost per call from growing and helps the agent find new ideas (Figure 4, Section 4.2, p. 9). Two concurrent papers, posted after our submission deadline, reach the same idea as their main contribution:

  • Fork-and-Flush (arXiv:2610.07447)
  • Scaling Discovery Requires Forgetting (arXiv:2610.20563)

3. A graph database as memory. AgentDiscover stores ideas and candidate lineage in a graph database. This helps in two ways. First, classical search algorithms become easy to implement, because each selection rule is a single query (Appendix B, p. 16). Second, the archive is queryable. After a context reset, the agent reads the history faster and more cheaply than from plain files (Table 5, p. 10).

4. Steering messages vs. CORAL's heartbeat. Both keep a long-running agent on course, but CORAL's heartbeat wastes about 10% of its LLM calls, while our steering messages waste none.

  • CORAL: after submitting a candidate, the agent waits for its score, checking every 0.2 s, and resumes work as soon as the score arrives. CORAL's manager checks for new scores only every 5 s. Once it sees the score, it interrupts the agent (SIGINT) and restarts the same session with a steering prompt. In the gap between the two, the agent has usually already sent its next LLM call. The interrupt aborts this call while the provider is processing it: the tokens are billed, but the reply never reaches the restarted agent.
  • AgentDiscover: the steering message is simply the output of the MCP tool the agent calls to submit a candidate (Appendix E.3, p. 23). The agent is never interrupted, and no call is lost.

Q2: What actually causes the performance improvement?

We added an ablation or direct evidence for each component.

1. Context resets (Figure 4, p. 9).

  • Figure 4a: Without a reset, the cost of each LLM call keeps growing. A reset brings it back down.
  • Figure 4b: In a Cloudcast run, the search stalls repeatedly, and every new best comes right after a reset. After a reset, the agent explores the database again, which gives it a new perspective and makes new ideas more likely.
  • Figure 4c: Across all our runs, after the search stalls, a reset raises the chance of a new best from 21.2% to 25.0%.
  • Figure 4d: When a stalled search finds a new best, the gain over the previous best is 0.86% on average if it came after a reset, against 0.38% without a reset.

2. Graph database vs. plain files (Table 5, p. 10). We replayed eight sessions with the same history stored in plain files, laid out as in CORAL. With the database, the agent uses 26% fewer LLM calls, burns 22% fewer tokens and spends 20% less.

3. Meta agent (Figure 5, p. 9).

  • Figure 5c compares the chance of finding a new best within n candidates, with and without meta guidance, for different n. For example, for n = 2, it rises from 33% to 73%.
  • Figure 5d compares the share of all proposed candidates, not only the best, that reach at least a given fitness, with and without meta guidance, for different fitness levels. For example, the median candidate's fitness rises from 0.801 to 0.832.

Figures 4c and 4d also show that combining a reset with a meta pass raises both the chance of a new best and the gain further (26.2% and 1.87%).

4. Agent-controlled search (Appendix B, p. 16). In Q1, we argued that the search strategy should not be fixed: no fixed strategy is best across problems, and the agent can plan the search itself. We added a new appendix showing that the agent can indeed do this. It implements classical search strategies itself and balances exploration and exploitation. For example, it searches for:

  • under-explored ideas (bandits),
  • the best candidate per idea (MAP-Elites),
  • strong parents along a lineage (tree search),
  • Pareto-optimal candidates (multi-objective evolution).

5. Server-side steering. Steering messages keep the agent on course over a long horizon; they are not meant to raise scores directly or to dictate what the agent does. In each session, the agent should propose candidates in a loop and finally record a lesson. No code runs this loop (there is no for or while): the agent runs it itself. Steering messages help the agent know where it stands in this loop, simply through the output of the MCP tool it calls to submit a candidate (Section 3; Appendix E.3, p. 23). After each submission, the message reports:

  • how many candidates the agent has submitted, so the agent knows how far into its session it is;
  • the scores of its previous five candidates, so it knows whether it is stuck;
  • its context length, so it knows whether it is cheaper to stop and leave the work to a new session.

The logs show that steering messages help with this. For example, agents stop right after 43% of the replies that show a fresh session would now be cheaper, against 9.4% of other replies, and they cite this reply when they stop.

In Appendix C (Table 6, p. 19), we ran a local model as a coding agent alone, with no component to keep it on course, such as steering messages or session resets. Compared to AgentDiscover with the same model and coding agent, it does much worse on every task, simply because it doesn't performe the loop and stops too early. This shows how important it is to keep the agent on course.


W3: The core methodology to use another agent to guide searching is already proposed by many previous works, including EvoX, Meta-Harness and CORAL.

We would like to kindly clarify that, as stated in Section 2 (p. 4) and Section 3.2 (p. 5), the meta agent is optional and is not our main contribution: we believe that, as agents become more capable, the search agent alone will be enough. Our main contributions are listed in Q1. Moreover, none of these three works uses another agent to guide the search the way ours does:

  • Meta-Harness works in a different domain. It uses a coding agent to optimize the harness around a model. This agent does the job of our search agent: our search agent optimizes solutions to a scientific discovery problem, and theirs optimizes a harness. Our meta agent is a second agent that reflects on what the search agent is doing. Meta-Harness has nothing equivalent.
  • CORAL has no meta agent. Its multi-agent setting runs several search agents in parallel.
  • EvoX is the closest in its meta level, but overall it is a very different approach:
    • In EvoX, both the meta level and the candidate generator are single LLM calls, not agents. The meta call fixes a search algorithm, and EvoX later replaces it with another fixed algorithm.
    • In AgentDiscover, both are coding agents with tools, and no algorithm is fixed.
    • Because of these differences, EvoX is not close to AgentDiscover in performance. Over EvoX, AgentDiscover improves by 50.9% on AHC025 (absolute score), 16.7% on transaction scheduling, 12.6% on kernel builder, 11.1% on AHC015, 9.1% on signal processing, 6.7% on MMD-14-3 and 6.4% on the third autocorrelation inequality (Tables 1, 2, 4 and 13). The gap holds for cost too (Figure 1, Table 4, Figures 6 and 8).

W4: The related work section have unclear taxonomy, autonomous research agents and LLM-based evolutionary search appear to have clear intersections.

We agree. These terms are still loose in the community, and the boundary between them can be blurry. In our paper:

  • LLM-based evolutionary search means an LLM proposes candidate programs inside a human-designed search loop, and an automatic evaluator scores each candidate (e.g., FunSearch, AlphaEvolve, OpenEvolve).
  • Autonomous research agents means agents that run the research process themselves, from ideas to experiments, and whose results are judged by humans or real-world experiments rather than a fixed evaluator (e.g., AI Scientist, AI co-scientist).

AgentDiscover sits at their intersection: an autonomous agent owns the search, and an evaluator scores its candidates (Section 2, p. 4).

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.