- 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
-
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.
-
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
-
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.
-
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
-
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?
-
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
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.
| Task | AgentDiscover | CORAL |
|---|---|---|
| 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.
| Task | AgentDiscover | OpenEvolve | ShinkaEvolve | EvoX | CORAL |
|---|---|---|---|---|---|
| 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) | 3774 | 3802 | 3984 | 4566 |
| Cloudcast ↓ | 618.0 (618.0, 618.0, 618.0) | 627.2 | 627.8 | 623.5 | 618.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.
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.
Below, we list what is new in AgentDiscover and give an ablation or direct evidence for each part. In short, we show that:
1. Session resets (Figure 4, p. 9). Please see Figure 4, which we added in the revision.
Two concurrent papers, posted after our submission deadline, reach the same idea as their main contribution:
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.
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.
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.