WorksComputer Science
ExpEvolve: Structuring and Reusing Experience for Open-Ended Discovery
Abstract
Evolutionary coding agents such as AlphaEvolve are one of the notable successes in using Large Language Models (LLMs) to build AI Scientists. These agents tackle open-ended scientific problems by iteratively improving and evolving programs, leveraging the prior knowledge and reasoning capabilities of LLMs. Despite their success, mutations over programs are mostly low-level upon surface heuristics, without a persistent unit of control. In contrast, science compounds through ideas. In this work, we propose ExpEvolve, which injects idea-level extraction and control into evolution: it discovers and leverages the high-level factors from programs that explain scoring differences among different programs. We characterize theoretical conditions on when discovery with idea factors improves sample efficiency. We also build a practical framework to show that the extracted high-level idea factors are helpful for guiding exploitation from experience and exploration when discovery comes to a plateau. Across 11 open-ended mathematical tasks, ExpEvolve significantly improves the final performance and sample efficiency up to 5.0x. The improvements also transfer to 4 other LLMs and to 6 machine learning tasks from MLS-Bench. Analysis shows that ExpEvolve can discover idea-level factors to provide better exploration and exploitation for evolutionary discovery.
Introduction
Large language models (LLMs) are now widely used to build agents that operate on increasingly long-horizon tasks (Plaat et al., 2025). One of the most ambitious applications is AI scientist agents (Zheng et al., 2025a), in which LLMs automate the scientific discovery process, including literature surveys (Asai et al., [3]), hypothesis generation (Wang et al., 2024; Yang et al., 2024), data-driven analysis (Majumder et al., 2025), experiment design (Li et al., 2025a), or even the whole discovery workflow (Gottweis et al., [24]; Lu et al., 2024; Mitchener et al., 2025; Yamada et al., 2025). LLM-driven discovery has shown strong results in a variety of domains, such as mathematics (OpenAI, 2026b,c), de novo protein design (Anthropic, [2]), algorithm discovery (Lange et al., [37]; Novikov et al., 2025), and the research that develops LLMs themselves, an early form of recursive self-improvement (RSI) (Favaro and Clark, [16]; Karpathy, [33]; Lyu et al., 2026a; OpenAI, 2026a). At the heart of the discovery loop is the iteration over scientific hypotheses, where scientific ideas compound throughout the evaluation of promising hypotheses (Wallace et al., 2026). Therefore, it is essential to reuse the discovery experience to generate high-quality hypotheses, e.g., avoiding getting stuck in repetitive mistakes or suboptimal solutions and encoding promising exploratory proposals.
In this work, we study experience reuse in open-ended discovery with evolutionary coding agents, where hypotheses are represented as solution programs to the underlying scientific problem, and experiences are accumulated as evaluated programs and their scores given by an explicit evaluator (Novikov et al., 2025). Typically, existing evolutionary coding agents such as ShinkaEvolve directly incorporate successful programs or rely on LLMs to summarize reusable insights and incorporate them as
*This paper is an extended version of CausalEvolve (arXiv:2603.14575). memory for future mutations with LLMs ([22, 33, 37]). However, program mutation contains an open-ended search space including low-level details such as hyperparameters and high-level insights such as optimization strategies. LLM-driven guidance is prone to focusing on low-level details ([33] (Pelleriti et al. 2026)), which may not bring genuine new scientific discoveries. In contrast, human scientists tend to recognize the high-level contrasts among programs, accumulate and exploit scientific ideas from experience ([15, 36]). The gap raises a challenging research question:
How can we reuse experience for evolutionary discovery like human scientists?
To tackle the question, we formulate evolutionary discovery as a Partially Observable Markov Decision Process (POMDP) ([32]) (§ 3). In each turn, the agent needs to propose meaningful solutions to uncover the underlying causal mechanism for solving the scientific problem, i.e., maximizing the evaluation score ((Glymour; Wallace, 1981)). Under the formulation, we introduce the notion of ideas as high-level mechanistic properties of the programs that determine the evaluation scores, e.g., the construction family or the optimization strategy (Def. 3.2). Without uncovering the ideas, the agent has to treat programs as unrelated and cannot tell whether a revision changes an idea or only a low-level detail, so discovery degenerates into exhaustive search (Thm. 3.1). Meanwhile, the identification of ideas also requires sufficient exploration to contrast programs with and without each idea (Thm. 3.3). Hence, an effective discovery agent needs to extract ideas from experience, and keep exploring programs where the ideas vary.
Motivated by the analysis, we propose ExpEvolve, which recognizes, structures, and leverages the high-level idea factors from discovery experience (Figure 1). Specifically, ExpEvolve realizes the discovery of ideas via identifying high-level factors that help explain the program scoring differences. Built upon COAT ([47]), the discovered idea factors are expected to predict which program performs better given any pair of programs in the experience. Then, the admitted idea factors will be incorporated as an action of a multi-armed bandit that controls the exploration and exploitation of different ideas during discovery. To enable sufficient exploration, ExpEvolve also allocates slots for random exploration ([22]), and idea-guided exploration when the evolution comes to a plateau. The idea-guided exploration enforces LLMs to explore diverse ideas other than those widely used in top-scoring programs. The idea-based control in ExpEvolve allows efficient exploitation of promising ideas while continuing to explore programs with varied ideas.
Figure 1. Comparison between experience reuse at program-level and idea-level. All programs solve the same grid task. Left: Experience reuse at program-level is prone to low-level edits. Program-level evolution derives new programs from a high-scoring parent, such as changing the heuristic weight or bounding the search loop. Both edited programs score lower. Right: Experience reuse at idea-level compares structurally different programs through a shared procedure-level factor, lp = refine_lp(lp). Programs that contain the factor score higher than the program that omits it. This contrast singles out the factor, which is then inserted into new programs of different structures.
We evaluate ExpEvolve on 11 open-ended mathematical discovery tasks with a budget of 200 evaluated programs, using SCS as the backbone and the main baseline (§ 5). Under two configurations that split the budget into 20 generations of 10 programs and 10 generations of 20 programs, ExpEvolve improves the final performance over SCS and ShinkaEvolve in most settings with smaller budgets up to 5.0×. Further analyses show that the discovered idea factors order the archived programs better than their code length on all 11 tasks. We further integrate ExpEvolve into OpenRSI ((Yang et al., 2026b)) on six tasks from MLS-Bench ((Lyu et al., 2026a)), where it improves the mean final best-so-far score of OpenRSI on all six tasks.
Related Work
In this section, we discuss the closest related works and defer a more detailed one in Appendix § 8.
AI Scientist agents. With the significant advancement in LLM capacity and the development of agentic systems, building LLM-based AI scientists has gained increasing attention ((Zhou et al., 2025)). One research line automates part or the whole of the pipelines in scientific activities through agentic workflows ([18, 21, 24] (Lu et al. 2026; Lyu et al. 2026b; Mitchener et al. 2025; Yamada et al. 2025)). Evolutionary coding agents are one of the most representative AI scientist agents that integrate LLMs into evolutionary search over programs scored by an explicit evaluator ((Novikov et al., 2025; Romera-Paredes et al., 2024)). AI scientist agents, including evolutionary coding agents, have made impact in a variety of domains, such as mathematics ((OpenAI, 2026b)), materials science ([20]), biology ([2]), and the development of LLMs themselves, e.g., accelerating LLM training and research toward recursive self-improvement ([16, 33] (Lyu et al. 2026a; OpenAI 2026a; Zhang et al. 2026)). As generation scales up, validating the generated hypotheses becomes the main cost ((Wallace et al., 2026)), and ideas that look promising often degrade once executed ((Si et al., 2026)). The expanding paradigm of LLM-driven scientific discovery makes the reuse of experience increasingly more essential, which is central to our work.
Experience reuse in evolutionary coding agents. Existing evolutionary coding agents typically reuse experience via conditioning on evaluated programs ([22] (Novikov et al. 2025)) or summarizing textual insights from programs into memory for future mutations ([37] (Liu et al. 2024; Volkov et al. 2026; Ye et al. 2024)). The useful experience can also be exploited for future search control, e.g., selection inspirations across diverse strategy clusters ([37] (Luo et al. 2026)). Different from existing works that concentrate on the unit of experience as texts or programs, ExpEvolve discovers and exploits high-level idea factors to guide program mutations.
Theoretical Formulation of Evolutionary Discovery
In this section, we formalize evolutionary discovery and introduce the notion of ideas.
Evolutionary Discovery as a POMDP
Scientific discovery aims to uncover the causal mechanisms underlying a problem through interactions with the world ([36]). In evolutionary discovery, the agent interacts with the problem through an evaluator. We denote by the hidden mechanism of the problem, which is fixed during the search and unknown to the agent. At turn , the agent proposes a program and observes a score with , where is the objective, e.g., the value of a mathematical construction, the efficiency of a kernel, or the performance of a trained model (Novikov et al., 2025). The goal is to uncover by optimizing for the evaluation score.
POMDP. As shown in Figure 2B, the interaction forms a Partially Observable Markov Decision Process (POMDP) [32] with a static hidden state , actions , observations , an identity transition kernel, and the observation kernel . Given a budget of evaluations, the agent chooses to find a program with high .

Figure 2. Evolutionary discovery as a POMDP. (A) In each iteration, an evolutionary coding agent builds the proposal context from its memory, e.g., parent and inspiration programs or summarized insights, and generates candidate programs with an LLM . The evaluator scores every program, whose outcome depends on the hidden mechanism , and the scored programs enter the archive and update the memory. (B) The corresponding temporal graphical model. The memory guides the next program , and the score depends on both and the static but unknown mechanism , which in turn updates .
Evaluation as intervention. can be parameterized as a structural causal model over variables of interest (Spirtes et al., 2000), in which a program specifies a configuration of design variables . Each evaluation can be considered as the expected outcome of the intervention:
In this work, we leverage the causal view to provide a more in-depth understanding, while neither the analysis nor the method requires recovering the causal graph. A full discussion on the relations with causality can be found in Appendix § 9.
Experience-driven discovery. We define as the agent’s Bayesian belief after accumulating experience , which is essentially a probability distribution on , for . In the ideal Bayesian formalism, the belief is a sufficient statistic for decision-making [32]. In practice, the AI Scientist maintains an internal belief within LLMs, or an external one realized as memory for some (possibly learnable) summarization function [37], to represent the approximate representation of its knowledge about and the landscape of . Each evaluation step thus updates , which in turn updates the agent’s belief about and determines the next action .
Reusing Experience with Ideas
Reusing Experience with Ideas
If the evaluator fully reveals and the evaluation budget is unlimited, then enumerating every possible program can directly lead to discovery. However, in reality, the evaluation score only reveals partial information about and evaluations can be expensive, e.g., training a model or running a physical experiment, so the agent can afford only a limited number of them (Wallace et al., 2026). Therefore, it is essential to reuse experience from past evaluations.
Without properly reusing experience, a single evaluation cannot reveal further insights about other unseen programs, and the agent then has to evaluate every candidate program to find the best one. Reusing experience requires some structure shared across programs, so that the evaluation of one program also informs the others. We formalize the contrast as follows.
Theorem 3.1 (Structured experience reuse, informal). Let , and let each evaluation return with i.i.d.
(a) With reuse. If each program has a known representation with and for an unknown , then under a coverage condition on the representation, there exists a policy that, with probability at least , outputs a program within of the optimal value after evaluations.
(b) Without reuse. If programs are unrelated, i.e., for an arbitrary , then any policy with the same guarantee for every needs evaluations.
The formal statement and proof are given in Appendix § 11. Theorem 3.1 implies that reusing experience at the high-level design choices can significantly improve sample efficiency from to , where . In evolutionary discovery, counts the candidate program space, which grow combinatorially with the high-level design choices and further with the ways of implementing each choice, while is determined by the design choices that affect the score. Most existing agents retain experience at the level of programs [37] (Novikov et al. 2025), which ignores the high-level design choices. In contrast, human scientists recognize and record what they learn from experiments in terms of reusable concepts, e.g., a construction or an optimization technique, which carry over to later experiments. We are hence inspired to introduce the notion of ideas.
Definition 3.2 (Idea). An idea is an interpretable mapping from programs to a binary or categorical value. It describes a high-level mechanistic property that can be shared by syntactically different programs, such as the construction family, initialization, or optimization procedure. A set of ideas defines the idea representation .
A program realizes a set of ideas together with low-level details. We call an idea representation faithful if the score depends on a program only through its ideas, i.e., for some function determined by . Under a faithful idea representation, the hidden mechanism acts on a program only through its ideas, and Theorem 3.1 applies with being the one-hot encoding of , whose dimension is determined by the number of ideas.
Identifiability of ideas. However, the agent does not know in advance which representation is faithful, and the ideas have to be identified from the evaluated programs, while which programs are evaluated is decided by the search itself. When the search stops varying the candidate ideas, the exploration of ideas degenerates, as formalized below.
Theorem 3.3 (Degenerated exploration of ideas). Consider two candidate ideas and , and two mechanisms and under which the score depends on and , respectively, i.e., for a common representation and function , with the same observation noise. Suppose
the optimal programs under and are different and unique with a margin . Then for any policy that only evaluates programs on which and agree, there exists such that for every budget , the output satisfies
The formal statement and proof are given in Appendix § 12. Theorem 3.3 can be considered as a consequence of the partial observability of , since the scores reveal only through the evaluated programs. If two candidate ideas agree on all explored programs, the two mechanisms produce the same observations, and one cannot distinguish which idea determines the score. This situation is common in evolutionary search: as the search concentrates around its current best programs, the ideas shared by these programs stop varying. Identifying ideas thus requires sufficient exploration to contrast programs with and without each idea, to isolate contributions of ideas in the program space.
ExpEvolve: Discovering and Exploiting Ideas from Experience
Theoretical analysis in § 3 suggests that a discovery agent should extract ideas from its experience, and keep exploring programs where the ideas vary. We realize the theoretical principles in ExpEvolve. The full procedure and implementation details are given in Alg. 1 and Appendix § 14.
Discovering Ideas from Experience
We leverage the discovery loop of the COAT framework [47] to find idea factors according to their theoretical properties.
Figure 3. Illustration of idea factor discovery.
Idea memory. During the discovery, ExpEvolve maintains an idea memory which is a set of idea factors. Each idea factor is stored with a name, a description of its code pattern, a type, i.e., binary or categorical, and a value set . For each program in the experience archive, the values of idea factors are annotated by an annotator LLM, which instantiates the idea representation .
Explainability of idea factors. A faithful idea representation is expected to be able to predict the score of a program, i.e., (§ 3.3). However, predicting the exact scores from ideas is difficult, since the scores of different tasks lie on different scales, the unknown function can be highly nonlinear, and the archive only contains a limited number of noisy evaluations. Therefore, we define the explainability of an idea representation by its pairwise predictability, i.e., whether and predict which of two programs and is better. The ranking is already informative for optimizing the objective, invariant to the scale of the scores, and more robust to noise than the scores.
Discovering idea factors from unexplained pairs. The idea discovery process in ExpEvolve is an iterative loop: each time the discovery is triggered, ExpEvolve fits a pairwise ranker on the annotated idea factors, and selects the pairs of archived programs with a large score gap that the current idea factors fail to explain. The unexplained pairs suggest the existence of missing idea factors that separate the programs in each pair. For the selected pairs, a separate proposer LLM reads the programs to propose candidate idea factors that distinguish them. Each candidate is then annotated on the whole archive, and is admitted into the idea memory if each of its values is supported by enough programs and its values separate the scores.
Figure 4. Illustration of two-level exploration-exploitation with discovered idea factors.
Exploiting Idea Factors for Discovery
We build a two-level exploration and exploitation framework with a multi-armed bandit (MAB) to fully exploit discovered idea factors while exploring varying design spaces.
Exploration and MAB exploitation. In each generation, ExpEvolve keeps at least a fraction of the slots for random exploration that follows SCS ([22]) with randomly sampled example programs, which explores programs beyond the current ideas and provides new material for discovery. The remaining slots are allocated to idea-guided actions by MAB.
Figure 5. Illustration of idea-guided exploration at plateaus.
Idea factors as MAB actions. To exploit an idea factor , ExpEvolve compiles it into edit actions, e.g., ADD() and REMOVE() for a binary idea factor. An action adds to the context an instruction that describes , together with demonstration programs in the target state, to ask the mutator LLM to realize the action in the new program. The MAB selects the action for each idea-guided slot. The reward of an action is the score of the program generated under the action relative to the random exploration in the same generation, i.e., , where is the score of the generated program, and and are the mean and the standard deviation of the scores of random exploration in the same generation. The normalization removes the drift of scores across generations and the differences of score scales across tasks. The MAB selects the actions with an upper confidence bound (UCB) rule on the maximum reward of each action (Appendix § 14.§ 3).
Exploration at plateaus. Oftentimes, evolutionary discovery can concentrate around its best programs and a single strategy. Consequently, the ideas widely used in top-scoring programs stop varying, and their roles cannot be identified from the archive (Thm. 3.3). When the best score does not improve for generations, ExpEvolve switches to idea-guided exploration, which enforces the mutator LLM to explore diverse ideas other than those widely used in top-scoring programs. Specifically, a separate LLM probes the properties shared by the top-scoring programs as background idea factors, and an LLM judge determines which idea factors in the memory depend on the background. ExpEvolve then masks the actions of the dependent idea factors, instructs the mutator LLM to avoid them, and assigns more slots to random exploration with diversified demonstrations.
Experiments
We evaluate ExpEvolve on 11 open-ended mathematical discovery tasks and further integrate it into an evolutionary agent for Machine Learning Engineering (MLE) tasks.
Experimental Setup
Tasks. We evaluate on 11 open-ended mathematical discovery tasks. Nine tasks are the problems studied by SCS ([22]), which are taken from AlphaEvolve ((Novikov et al., 2025)), including the first and second autocorrelation inequalities, the uncertainty inequality, the Erdős minimum overlap problem, sums and differences of sets, the max–min distance ratio, the Heilbronn problem for triangles, the kissing number in 11 dimensions, and circle packing. The other two tasks are the Hadamard matrix problem ((Wang et al., 2026)) and a variant of circle packing that recovers the radii by linear programming. We report the best score at the end of the budget, as the mean and standard deviation over seeds, and the best seed. Full details of the tasks are given in Appendix § 15.§ 1.
Budget. Each run evaluates 200 programs. We consider two configurations with the same budget, i.e., 10 generations of 20 programs as in SCS ([22]) and 20 generations of 10 programs, which presents more challenges to accumulating reusable knowledge from experience.
Implementation. We compare ExpEvolve with SCS ([22]), which is the backbone of ExpEvolve and shows competitive results against more elaborate evolutionary coding agents. We further compare with ShinkaEvolve ([37]), which maintains an island-based archive and summarizes the insights of recent programs with a meta-summary. Details are given in Appendix § 15.§ 2. We use DeepSeek-V4-Flash by default, and each setting is run with 3 seeds. ExpEvolve uses a random-exploration fraction for 20-gen. and for 10-gen. to keep a similar number of random-exploration slots, i.e., 6 and 8. We do not tune other hyperparameters.
Main Results
ExpEvolve consistently improves the final performance. Table 1 shows the final performance at the budget of 200 programs. ExpEvolve improves the mean and best final performances across most settings over SCS and ShinkaEvolve. Moreover, the improvements are robust to how the budget is parallelized. From 10 generations of 20 programs to 20 generations of 10 programs, the mean final score of SCS can drop dramatically because of limited capability in experience reuse, while ExpEvolve still maintains competitive performance. More details are given in Appendix § 16.
| Task | 20 generations 10 programs ExpEvolve Mean | 20 generations 10 programs ExpEvolve Best | 20 generations 10 programs SCS Mean | 20 generations 10 programs SCS Best | 10 generations 20 programs ExpEvolve Mean | 10 generations 20 programs ExpEvolve Best | 10 generations 20 programs SCS Mean | 10 generations 20 programs SCS Best | ShinkaEvolve Mean | ShinkaEvolve Best |
| Hadamard | 0.9211 ± 0.000 | 0.9211 | 0.6641 ± 0.169 | 0.8596 | 0.9259 ± 0.008 | 0.9357 | 0.8349 ± 0.101 | 0.9211 | 0.6467 ± 0.139 | 0.8066 |
| Pack | 2.63542 ± 0.001 | 2.63598 | 2.61697 ± 0.028 | 2.63572 | 2.63499 ± 0.002 | 2.63598 | 2.6305 ± 0.011 | 2.63104 | 2.58201 ± 0.037 | 2.61408 |
| Linprog | 2.63542 ± 0.001 | 2.63598 | 2.63542 ± 0.001 | 2.63598 | 2.63542 ± 0.001 | 2.63598 | 2.55161 ± 0.006 | 2.55608 | 2.51434 ± 0.026 | 2.54142 |
| SumDiff | 1.11609 ± 0.006 | 1.11937 | 1.11087 ± 0.001 | 1.11143 | 1.12224 ± 0.001 | 1.12281 | 1.11608 ± 0.005 | 1.12006 | 1.10954 ± 0.000 | 1.10954 |
| Heilbronn | 0.0353 ± 0.001 | 0.0359 | 0.0313 ± 0.003 | 0.0340 | 0.0358 ± 0.001 | 0.0365 | 0.0336 ± 0.001 | 0.0343 | 0.0303 ± 0.002 | 0.0324 |
| Min overlap | 0.3810 ± 0.000 | 0.3810 | 0.3816 ± 0.001 | 0.3810 | 0.3810 ± 0.000 | 0.3810 | 0.3810 ± 0.000 | 0.3810 | 0.3824 ± 0.000 | 0.3824 |
| Kissing | 526 ± 97 | 582 | 413 ± 23 | 438 | 582 ± 0 | 582 | 582 ± 0 | 582 | 462 ± 90 | 566 |
| Second autocorr. | 0.8825 ± 0.000 | 0.8825 | 0.8398 ± 0.016 | 0.8499 | 0.8825 ± 0.000 | 0.8825 | 0.8825 ± 0.000 | 0.8825 | 0.8745 ± 0.008 | 0.8825 |
| First autocorr. | 1.5113 ± 0.002 | 1.5098 | 1.5235 ± 0.011 | 1.5151 | 1.5195 ± 0.006 | 1.5151 | 1.5508 ± 0.011 | 1.5378 | 1.5540 ± 0.029 | 1.5203 |
| Max–min ratio | 12.9262 ± 0.064 | 12.8892 | 12.9338 ± 0.077 | 12.8892 | 12.8892 ± 0.000 | 12.8892 | 12.9808 ± 0.033 | 12.9425 | 13.0000 ± 0.000 | 13.0000 |
| Hermite | 0.35473 ± 0.003 | 0.35263 | 0.39431 ± 0.059 | 0.35945 | 0.35089 ± 0.002 | 0.34820 | 0.35956 ± 0.005 | 0.35394 | 4.72779 ± 3.788 | 0.35429 |
Table 1. Final performance at the budget of 200 evaluated programs. Mean reports the seed mean ± seed standard deviation over 3 seeds, and Best reports the best seed.
ExpEvolve improves sample efficiency. Figure 6 shows the best-so-far scores along the budget on Hadamard, Sums and differences, Heilbronn, and Minimum overlap. On these four tasks, ExpEvolve needs 1.7× to 26.2× fewer evaluations than SCS under both configurations.
Figure 6. Best-so-far scores along the budget of 200 evaluated programs.
The improvements transfer to other LLMs. Figure 7 (a) shows that the advantages of ExpEvolve over SCS transfers to other LLMs such as DeepSeek-v4-pro, GLM-5.2 and Gemini-3.7-Flash.
Figure 7. (a) Best-so-far scores of SCS and ExpEvolve with other LLMs. (b) Best-so-far scores of SCS, SCS+meta, and ExpEvolve.
Summarizing experience as memory helps the early search but saturates. ShinkaEvolve and SCS+meta retain the experience as a textual summary of recent programs, which provides additional context to the mutator LLM without controlling which ideas are evaluated. Figure 7 (b) shows that SCS+meta improves over SCS in the early stage. However, its improvement slows down afterwards while ExpEvolve keep improving. It again verifies the advantages of idea-guided evolution.
The discovered idea factors explain the order of archived programs. Following the definition of explainability in § 4.1, we measure the fraction of archived program pairs that discovered factors can order correctly. As shown in Figure 8(a), the discovered idea factors reach an accuracy of 0.79 to 0.99. Figure 8(b) shows the idea factor with the largest weight on each task.
Figure 8. Quality of discovered idea factors. (a) Pairwise accuracy of the discovered idea factors. (b) The idea factor with the largest weight. (c) Illustration of usage of factors in sumdiff task.
In an example run, idea-guided actions produce about half of the new best programs. Figure 8(c) shows a run on Sums and differences with 10 generations of 20 programs. 6 of the 11 new best programs come from idea-guided slots. The 92 idea-guided slots of the run select 7 distinct actions, and all the new best programs from idea-guided slots come from 2 of them.
Additional Experiments on Machine Learning Engineering Tasks
We further study whether the effectiveness of ExpEvolve transfers to MLE by integrating it into OpenRSI (Yang et al., 2026b) and evaluating it on 6 tasks from MLS-Bench (Lyu et al., 2026a): Online bandit, Anomaly detection, Clustering, Multi-objective optimization, Subgroup calibration shift, and Evolution strategy. Search leverages the scores and execution feedback from each task.
Experimental setup. We use the evolutionary harness from OpenRSI, which organizes search through DRAFT, IMPROVE, DEBUG, and CROSSOVER operators. For each task, we retain a fixed history containing 20 completed search slots from an earlier OpenRSI run. The OpenRSI baseline and OpenRSI equipped with ExpEvolve continue from this same history for 50 additional evaluator calls, with 3 seeds. Both methods use 5 search slots per generation. All program generation uses Qwen3.6-35B-A3B. The same checkpoint performs factor discovery and annotation in ExpEvolve.
For each task and method, we average the final best-so-far (BSF) scores over three seeds.
Idea-guided evolution transfers to MLE tasks. Figure 9(a) compares OpenRSI with OpenRSI+ ExpEvolve across the six tasks, where ExpEvolve shows superior performance on all six tasks, with the largest gains on Online bandit and Anomaly detection.

Figure 9. Results on MLS-Bench. (a) Mean final scores. (b,c) Trajectories on two example tasks.
Idea-guided actions produce better exploration and exploitation on MLE tasks. Figure 9(b) and Figure 9(c) show two concrete trajectories in the tasks of multi-objective optimization and evolution strategy, respectively. We can find that ExpEvolve can effectively discover useful ideas such as removing running ideal-point tracking (A1), removing reference-vector adaptation (A2), and adding hybrid differential-evolution variation (A3) to effectively boost the performance. When the evolution gets stuck at plateaus, exploiting useful strategies proposed by ExpEvolve in multi-objective optimization, or exploration guided by idea factors in ExpEvolve can effectively break the plateaus and lead to improvements. More details about the implementation can be found in Appendix § 17.§ 1.
Conclusions
We introduced ExpEvolve, which structures the experience of evolutionary discovery into idea factors and reuses them to guide the search. ExpEvolve discovers idea factors from the pairs of programs that the current idea factors fail to explain, exploits them as the actions of a multi-armed bandit, and keeps exploring programs where the ideas vary, through random exploration and idea-guided exploration at plateaus. Our analysis shows that reusing a faithful idea representation reduces the number of evaluations from to , and that identifying ideas requires exploring programs where the ideas vary. On 11 mathematical discovery tasks and 6 tasks from MLS-Bench, ExpEvolve improves the final performance and the sample efficiency of evolutionary discovery under the same evaluation budget.
Limitations and Future directions
Due to the resource constraints, the tasks studied in this work remain limited to small-scale verification and are relatively simple. There remains a broader scope of scientific problems to be explored where verification signals can be expensive, such as biology, medicine, etc.. Meanwhile, the factor discovery can also be guided with additional background knowledge of the task.
Related Work
In this section, we present more detailed discussions of related works in the literature.
AI Scientist agents. With the significant advancement in LLM capacity and the development of agentic systems, a rising number of works develop agents to help scientific discovery (Tie et al., 2025; Zheng et al., 2025a; Zhou et al., 2025). Some systems automate the whole research workflow, from idea generation to experimentation and paper writing [18, 21, 24] (Lu et al. 2026; Lyu et al. 2026b; Mitchener et al. 2025; Yamada et al. 2025). One research line automates specific scientific activities, including literature review and deep research [3, 29], hypothesis generation (Li et al., 2025c; Wang et al., 2024; Yang et al., 2024, 2025), hypothesis verification [28] (Li et al. 2024), and feedback on scientific papers [46]. Another line targets data-driven discovery and machine learning engineering [10, 31, 41] (Majumder et al. 2025), as well as embodied agents in self-driving laboratories that conduct real-world experiments (Mandal et al., 2025; Roch et al., 2020; Tom et al., 2024; Zhang et al., 2025; Zhu et al., 2022). A growing set of benchmarks evaluates the research abilities of these agents, e.g., replicating and conducting AI research (Lyu et al., 2026a; Starace et al., 2025; Wu et al., 2026), generating hypotheses from inspirations (Liu et al., 2026), discovering scientific laws and equations (Shojaee et al., 2025b; Zheng et al., 2026), and conducting research tasks in biology [38], together with broader evaluations of research abilities (Wan et al., 2026). These lines of work have made impact in mathematics (Bubeck et al., 2025; OpenAI, 2026b,c; Woodruff et al., 2026), chemistry [5] (Yang et al. 2026a), materials science [20], earth science [17], biology [2, 41] (Swanson et al. 2025; Truhn et al. 2026), and the development of LLMs themselves [16, 33] (OpenAI 2026a). As generation scales up, validating the generated hypotheses becomes the main cost (Wallace et al., 2026), and ideas that look promising often degrade once executed (Si et al., 2026), which motivates us to study how to reuse experience to reduce the evaluations needed in evolutionary discovery.
Evolutionary coding agents. FunSearch (Romera-Paredes et al., 2024) pairs an LLM with an evaluator and a program database to discover new constructions in extremal combinatorics, and AlphaEvolve (Novikov et al., 2025) extends the loop to full codebases with an ensemble of LLMs, with applications to a large set of mathematical problems [19]. Follow-up frameworks improve the search process: OpenEvolve provides an open-source implementation (Sharma, 2025); ShinkaEvolve improves sample efficiency with parent sampling, novelty rejection, bandit-based LLM selection, and a meta-scratchpad that summarizes insights of recent programs [37]; CodeEvolve and GigaEvo maintain diversity with island models and quality-diversity archives [4, 35]; MCTS-AHD organizes heuristics in a Monte Carlo search tree (Zheng et al., 2025b); and AdaEvolve adapts search intensity and resource allocation from the history of improvements [8]. The paradigm has also been applied to equation discovery (Shojaee et al., 2025a) and systems research [12]. SCS shows that simply conditioning on previous solutions is competitive with more elaborate pipelines [22], which we adopt as the backbone and main baseline. Classical evolutionary computation also reuses experience through credit assignment over predefined units: adaptive operator selection allocates budget across operators with multi-armed bandits [13], quality-diversity methods maintain elites across behavior niches (Mouret and Clune, 2015) or search for novelty alone [39], and MuEvo revises the priorities of heuristic components with short-budget probing (Lv et al., 2026). In ExpEvolve, the units receiving credit are ideas discovered during the search, and plateau handling targets the ideas shared by top programs.
Learned mutators and self-improving agents. Another line trains the LLM mutator with reinforcement learning, either during evolution (Šurina et al., 2025) or at test time on a single problem (Wang et al., 2026; Yuksekgonul et al., 2026), where experience is stored in model weights. Self-improving agents such as the Darwin Gödel Machine and the Huxley-Gödel Machine evolve the code of the agent itself [41] (Zhang et al. 2026), SATLUTION evolves a solver repository together with its own rulebase (Yu et al., 2025a), and AlphaResearch alternates between idea proposal and program verification (Yu et al., 2025b). These directions are orthogonal to ours, which uses a fixed LLM and a fixed harness.
Causality for scientific discovery. There is a long history of discussions on how to understand the world through observations [25] (Pearl 2009; Spirtes et al. 2000). One research line is causal discovery, which learns the causal structure among variables from observational data under assumptions such as conditional independence or constrained functional forms [26] (Shimizu et al. 2006; Spirtes et al. 1995), from interventional data and data of multiple domains [6, 27] (Mooij et al. 2020; Perry et al. 2022; Yang et al. 2018), and in the presence of latent variables (Li and Liu, 2025; Li et al., 2025d), while experiment design selects the interventions that make the causal structure identifiable [30] (Li et al. 2025a). Recently, LLMs have been used to construct structured variables out of unstructured data [47] (Li et al. 2025b), to estimate treatment effects from unstructured data [14], and to propose instrumental variables (Sheth et al., 2025). Compared with these works, the variables in ExpEvolve, i.e., ideas, are constructed from unstructured programs, and are evaluated through interventions that the search itself chooses adaptively; § 3.3 characterizes what such an archive can identify.
A Causal View of the Formulation
In this section, we present a more detailed discussion of the causal view of evolutionary discovery in § 3.1.
Formulation of Scientific Discovery
Scientific discovery aims to uncover the underlying scientific knowledge or the causal mechanisms from interactions with the world [36], which can be formulated as a Partially Observed Markov Decision Process (POMDP) [32] (Figure 10).

Figure 10. The iterative scientific discovery loop. Left: Conceptual flow of the agent. The agent maintains a scratchpad memory (), proposes a program (), and observes the outcome () which is constrained by the unknown world state (). The outcome feeds back into the memory for the next step. Right: The diagram illustrates how the AI Scientist probes the unknown world state . By proposing a candidate program , the agent triggers an experiment yielding outcome . This observation provides evidence about , which is integrated into the agent’s scratchpad memory . Over time steps , this recurrent process allows the agent to navigate the performance landscape and converge towards optimal programs despite the static but unknown nature of .
Scientific knowledge. The primary objective of an AI Scientist is to uncover the underlying scientific knowledge about the task-world, represented by a latent variable , where may encode causal structure, mechanisms, inductive biases, constraints, etc. Specifically, can be parameterized as a Structural Causal Model (SCM) (Spirtes et al., 2000), where is a directed graph whose nodes represent variables of interest and whose edges encode direct causal dependencies; is a collection of structural equations , where denotes the parents of in and is an exogenous noise variable; is a distribution over the exogenous variables .
Evaluation as intervention on SCM. Given the SCM parametrization of , we can consider that a program is encoded as a particular configuration of design variables . Then, can be implemented as
i.e., the expected outcome under the intervention in the true causal model . Typical implementations of can be the objective value of a combinatorial optimization problem, the efficiency of a kernel program, or the performance of a machine learning model (Novikov et al., 2025).
Belief as revealed knowledge. As in § 3.1, the AI Scientist maintains a memory as an approximate belief about . Each evaluation step thus updates , which in turn updates the agent’s effective belief about . In this sense, each step reveals part of the underlying scientific knowledge, which in turn determines the next action .
Ideas and Causal Representation Learning
Ideas as high-level causal variables. In the SCM view above, a program specifies a configuration of design variables , which are low-level and high-dimensional, e.g., every line of the code. An idea (Definition 3.2) is a function of the program, and hence of , that summarizes the design variables at a higher level. A faithful idea representation (§ 3.3) requires that depends on only through , i.e., interventions on the design variables that keep all ideas fixed leave the expected outcome unchanged. Hence, an intervention on the ideas is well defined at the level of expected outcomes. This condition is related to causal feature learning (Chalupka et al., [9]), which constructs macro-level causal variables by grouping the micro-level states that induce the same outcome distribution under intervention, and to causal abstraction (Rubenstein et al., 2017), which studies when a high-level causal model is consistent with a low-level one. Faithfulness is a mean-level version of these conditions, restricted to the score of interest.
Relation to causal representation learning. Causal representation learning (CRL) aims to recover high-level causal variables from low-level observations (Schölkopf et al., 2021), where identifiability usually relies on additional information such as interventions on the latent variables (Ahuja et al., [1]). Ideas can be viewed as the high-level causal variables of programs, and the two settings differ in three aspects. (i) In CRL, the representation is usually an encoder learned from the observations, while an idea is an interpretable function of the program that an LLM can annotate, similar to how LLMs construct high-level variables from unstructured data (Li et al., (2025b); Liu et al. [47]). (ii) CRL usually aims to recover all latent variables, while ideas only need to be faithful to the score. (iii) The agent decides which programs to evaluate, and an edit that changes one idea and keeps the others fixed acts as an intervention on that idea, although an LLM edit may also change other ideas. Theorem 3.3 shows that when the evaluated programs do not vary the candidate ideas, the ideas that matter cannot be identified from the scores.
Essentiality of Causal Knowledge for AI Scientists
If the evaluation revealed the scientific knowledge completely, then with more experiment turns, the agent’s revealed scientific knowledge would converge to . However, the observation from the evaluation is usually only a proxy of the scientific knowledge : each evaluation returns a scalar score of the program that the agent chooses to evaluate. Different hypotheses about , e.g., ones under which different ideas determine the score, can produce the same scores on all evaluated programs. For example, if all evaluated programs in circle packing share the same initialization and the same refinement, the scores cannot tell which of the two accounts for the performance. Therefore, the causal knowledge often cannot be identified from the scores of the programs explored so far, and it is essential for an AI Scientist to explore sufficiently, i.e., to evaluate programs that distinguish the competing hypotheses. We denote by the environment in which the evaluation is conducted.
Definition C.1 (Causal AI Scientist). A Causal AI Scientist is an agent specified by: (i) a policy selecting , (ii) a counterfactual / explanatory operator CF, that answer interventional queries via as an “explanation” of predicted performance, where is the knowledge revealed at turn .
Without the revealing of the causal knowledge, the discovery process suffers from significant inefficiency and suboptimality issues. We discuss the two issues more concretely below.
Evolutionary efficiency of Causal AI Scientist. The efficiency issue is characterized by Theorem 3.1. In the linear setting of Theorem 3.1, a Causal AI Scientist can be implemented via estimating the and optimizing for from the history, while the black-box baseline does not consider the interactions between the historical observations. Theorem 3.1 shows that, when , which is usually the case as the space for all programs is significantly larger than the underlying SCM, encoding (correct) causal structure, e.g., a faithful idea representation, yields an exponential (or at least multiplicative) gain in sample efficiency under finite budgets. For example, if grows exponentially with , e.g., , the upper bound in Theorem 3.1 grows polynomially in , as , while the lower bound for the black-box baseline grows exponentially in , as .
Sufficient exploration of Causal AI Scientist. The suboptimality issue is characterized by Theorem 3.3. Let be the set of programs evaluated by the agent. Two hypotheses and can be distinguished from the history only if their observation models differ on some program in ; otherwise, the history has the same distribution under both hypotheses. Under the idea-level mechanisms in Theorem 3.3, i.e., for , the two hypotheses agree on every program where and agree, so only the programs where the two ideas differ can distinguish them. Intuitively, Theorem 3.3 implies that if the evaluated programs do not distinguish the corresponding among , then the solution incurs an expected regret of at least under one of them, regardless of the budget. This situation is common in evolutionary search: as the search concentrates around its current best programs, the ideas shared by these programs stop varying among the evaluated programs, and the scores cannot tell whether these ideas are the ones that matter. Hence, a Causal AI Scientist needs to explore the programs in which the competing ideas differ, so that the scores can distinguish the hypotheses. This barrier can be removed by exploration within the same evaluator, which differs from the transfer across environments discussed below.
Transfer of Scientific Knowledge across Environments
Beyond a single evaluator, the revealed scientific knowledge is also expected to transfer to other environments. If the objective function is static universally, then with more experiment turns, the optimized solution and the agent’s revealed scientific knowledge can also be applied universally. However, the evaluation is usually conducted at some specific environment , which only gives a proxy knowledge about the scientific knowledge . For example, the performance of a machine learning model is usually assessed on finite samples from the test distribution, and there also exist distribution shifts from the test distribution when deploying the model in the real world (Quinonero-Candela et al., 2008). Different from that characterizes the complete causal structure about the scientific problem, optimization under environment may introduce some spurious correlations that maximize the objective value [11]. Therefore, to retain the optimality of beyond the source environment to some target , it is essential to reveal the causal knowledge and answer causal questions for an AI Scientist, e.g., through the operator CF in Definition C.1. Let denote the observation model of the evaluator in environment , with mean . We have the following:
Theorem C.2. Consider and such that for all , and the optimal programs in under and are different and unique, each better than all other programs by at least . Then for any policy that can interact only with , there exists such that for every budget , .
The formal description and the proof are given in Appendix § 13. Intuitively, Theorem C.2 implies that if the source environment does not distinguish the corresponding among , then the solution solved given source environment is suboptimal in the target environment under one of them, no matter how many evaluations are made in the source environment. In the real world, it is usually the case that two machine learning models will have similar performances under the public test benchmarks, but exhibit significantly different behaviors when generalizing to distributions from other environments. Different from Theorem 3.3, this barrier cannot be removed by more exploration in the source environment, since the two hypotheses agree on every program there. We leave a full study of the transfer of scientific knowledge across environments to future work.
Additional Technical Details
Notation
| Symbol | Meaning |
| Program / pipeline / model space (candidate designs) | |
| Number of candidate programs, (finite in Theorem 3.1) | |
| A program to evaluate (action) | |
| Design-variable space (encoding of programs) | |
| Encoding of program (e.g., design variables ) | |
| , | An idea and the idea representation of program (Definition 3.2) |
| Number of ideas in an idea representation | |
| Known representation of program in Theorem 3.1, e.g., the one-hot encoding of | |
| Dimension of the representation, e.g., the number of value combinations of the ideas | |
| Hypothesis space of scientific knowledge (e.g., SCMs / mechanisms) | |
| Latent RV taking values in (Bayesian view) | |
| True (fixed but unknown) scientific knowledge instance (realization) | |
| Prior over (i.e., ) | |
| Environment / protocol index set (evaluation regimes, deployments) | |
| Environment index; source, target | |
| True performance in env (scalar objective) | |
| Observation model (likelihood) for evaluator output in env | |
| Observed evaluator outcome at round | |
| History | |
| Bayesian belief/posterior over : | |
| Evaluation budget / horizon (number of program evaluations) |
Table 2. Notation used in the formulation and theorems.
Random variable, space, and realization (to avoid notation confusion)
We use the following (standard) convention.
(i) Hypothesis space. is a set that contains all candidate scientific-knowledge hypotheses.
(ii) True but unknown instance. The real world is governed by a fixed but unknown .
(iii) Bayesian view (optional but convenient). A Bayesian agent models uncertainty by treating as a realization of a latent random variable with prior , i.e. and is one draw from it. The belief is simply the posterior distribution of after seeing history .
(iv) Does scientific knowledge change across environments? In our formulation, the underlying scientific knowledge is static across rounds. Different environments represent different evaluation/deployment protocols (distribution shifts, constraint changes, measurement noise, private vs public tests, etc.). Formally, environments affect either the true performance map and/or the observation kernel , while itself remains the same hidden instance.
Evaluator as an observation model (covers deterministic and stochastic evaluators)
Fix an environment . When the agent evaluates program , it receives an observation drawn from
where is a conditional distribution on .
Deterministic evaluator. A deterministic evaluator is the special case where there exists a function such that
In many program-evolution settings, the evaluator is designed to deterministically check validity and compute an objective score (e.g., via a verifier and a scoring routine).
Stochastic/noisy evaluator. A common instantiation is additive noise:
but only the proof of Theorem 3.1 relies on the Gaussian form; the other results hold for any noise distribution shared by the hypotheses.
Belief and Bayes update: kernel form and undergraduate-friendly special cases
Let be the history. The Bayesian belief (posterior) is
General Bayes update (kernel form). After choosing and observing in , the posterior is
Finite hypothesis space (sum form). If is finite and the likelihood has a pmf , then
Continuous hypothesis space (density form). If has a density , then
Deterministic evaluator (indicator/filter form). If deterministically, then the update becomes
i.e. the posterior is the prior restricted to hypotheses consistent with the observed outcome.
Proof of Theorem 3.1 (Structured experience reuse)
Throughout this section we fix a single static environment (drop from notation), and assume is finite.
Protocol and performance criterion
Experiment–then–commit protocol. A policy interacts for rounds. At each round it selects a program (possibly randomized) based on the past history , then observes . After evaluations it outputs a final recommendation .
Simple regret. Let denote the true mean performance of program in this environment. Define the (random) simple regret
(, )-correctness (uniform). Fix and . We say a policy is -correct uniformly on a hypothesis class if for every instance in ,
“Uniformly” means the guarantee must hold for all instances in the class, not only on average.
Two hypothesis classes
(1) Structured class. Each program has a known representation with , e.g., a faithful linear idea representation (§ 3.3). The unknown instance is a weight vector and
Observations follow a Gaussian noise model
Coverage condition. Assume there exist basis programs whose representations are the standard basis:
(2) Unstructured black-box class (baseline). The unknown instance is an arbitrary vector of means
and observations are
where is the index of the chosen program . Crucially, there is no assumed relation between and for .
Formal statement and proof
Theorem E.1 (Formal version of Theorem 3.1). Fix and .
(Upper bound under the structured linear class). Under equation (4)–equation (6) and equation (5), there exists a policy such that
(Lower bound for the unstructured black-box class). For the black-box class equation (7), any policy that is -correct uniformly for all must satisfy
Replacing with in part (1) gives the informal statement in Theorem 3.1.
Proof. We prove the two parts separately.
Part (1): constructive upper bound (estimate then commit). Evaluate each basis program exactly times (total ). Let be the observations for basis , and define
By equation (4)–equation 6, . By equation (5), and these coordinates are independent.
Define for any program :
Then
so since ,
Union bound over programs gives
Choose
so that with probability at least we have .
Now output . Let . On the above high-probability event,
Thus for as stated.
Part (2): lower bound for the black-box class. We construct hard instances and lower bound any uniformly -correct policy.
Let the programs be . Define a base instance :
For each , define an alternative instance :
Under , the unique best program is , and choosing any with incurs regret . Under , the unique best program is , and choosing incurs regret .
Let be the distribution of the full transcript under , and the analogous distribution under . Uniform -correctness implies
Step 1: a KL lower bound from an event. For any event and distributions , one has
Apply it with , , . Let and . For this yields
Step 2: compute via number of pulls of arm . Under and , the policy is identical; only observations when playing differ:
For Gaussians with equal variance, , so each pull of contributes
Let be the (random) number of times is evaluated in rounds. Additivity of log-likelihood ratios over independent Gaussian samples yields
Step 3: conclude the lower bound on . Combine equation (8) and equation (9):
Summing over gives
This completes the proof. □
Remark (deterministic evaluator). If , the structured linear class can recover exactly from basis evaluations and achieve , while in the unstructured black-box class a uniform worst-case guarantee requires evaluating all programs at least once.
Relation to best-arm identification. The lower bound follows the standard change-of-measure argument for best-arm identification in -armed Gaussian bandits [34], and the upper bound is a simple instance of best-arm identification in linear bandits (Soare et al., 2014).
Proof of Theorem 3.3 (Degenerated exploration of ideas)
Formal statement and proof
For a policy that interacts for rounds and outputs , define the simple regret under mechanism as .
Theorem F.1 (Formal version of Theorem 3.3). Let be two ideas, and let be the set of programs on which they agree. Assume there exist such that:
(i) (Idea-level mechanisms) for all and , for a common representation and function , and each evaluation returns with the same noise distribution under and ;
(ii) (Optimal program flips with margin ) there exist and such that for all and .
Then for any policy that only evaluates programs in , there exists such that for every budget ,
Moreover, at least one of and lies outside .
Proof. For every , gives . Together with the common noise distribution in (i), the observation model is identical under and for every .
Let be the distribution of the transcript when the true mechanism is . Since the policy only evaluates programs in , for any history and any chosen , the conditional distribution of is identical under and , and the policy chooses and with the same randomization given the same history. By induction on , . In particular, the output has the same distribution on under both mechanisms.
By (ii), any output incurs regret at least under , so
Since , , so at least one of the two probabilities is at most , and the corresponding expected regret is at least .
For the last claim, suppose both . Then , which contradicts the optimality of under .
The theorem holds for any budget, since the barrier comes from the programs that the policy evaluates. To identify which of and matters, the policy has to evaluate a program outside , i.e., a program on which the two ideas differ. In ExpEvolve, this is the role of plateau-aware revision, which changes the proposal distribution to evaluate programs where the ideas shared by the leading programs differ.
Proof of Theorem C.2 (Non-identifiability under environment shifts)
Setup: source interaction, target evaluation, and target regret
The agent can only interact with the source environment :
After rounds it outputs a final program . Performance is judged in a target environment via . Define the target (simple) regret:
Formal statement and proof
Theorem G.1 (Non-identifiability barrier under shifts). Fix . Assume there exist two hypotheses such that:
Then for any policy that can interact only with , there exists such that for every budget ,
This impossibility holds whether the evaluator is stochastic or deterministic, since equation (10) is stated at the level of the full observation model .
Proof. Let be the distribution over the full transcript
when the true hypothesis is and interaction is only with .
By equation (10), for any history and any chosen action , the conditional distribution of is identical under and . By induction on , the entire transcript distribution is identical:
In particular, the marginal distribution of the final output is the same under and . Let this common distribution be denoted by on . Now consider the expected target regret under : by equation (12), any output incurs regret at least under :
Taking expectation w.r.t. yields
Similarly,
Since , at least one of these probabilities is at most , so at least one of the two expected regrets is at least :
This proves the claim. □
Concrete examples satisfying the conditions
We give two illustrative examples where source data cannot distinguish two hypotheses, yet the target-optimal decision differs.
Example 1: public test vs private (distribution shift / shortcut feature). Let encode which feature is truly stable/causal. Programs correspond to two model families: uses a stable causal feature; uses a shortcut feature. In the source environment (public benchmark), the shortcut feature is perfectly correlated with labels, so both hypotheses yield the same evaluator distribution for every program, satisfying equation (10). In the target environment (deployment/private), the shortcut correlation breaks: under , is uniquely optimal; under , is uniquely optimal, with margin , satisfying equation (12). No amount of interaction with can identify which world holds.
Example 2: relaxed verification (slack) vs exact verification (constraint shift). In combinatorial optimization, it is common to evaluate candidate programs using a relaxed verifier (e.g., allowing numerical slack), then validate with an exact verifier. For instance, in circle packing, one may verify non-overlap with a numerical slack such as , and later validate with an exact checker; converting a relaxed-feasible solution into an exact-feasible one may require tiny but nonzero modifications, and rankings can change when switching verifiers. This is explicitly discussed in the context of circle packing verification with slack vs exact validation. The source environment can correspond to the relaxed evaluator, while the target environment corresponds to the exact evaluator. Then two hypotheses can be constructed so that they are indistinguishable under the relaxed evaluator for all queried programs, yet the exact evaluator reverses which program is truly best (with gap ), matching Theorem G.1.
Implementation Details of ExpEvolve
This section describes the implementation of ExpEvolve used in our experiments. Alg. 1 summarizes the search loop, and Alg. 2 details the discovery of idea factors. We implement ExpEvolve on the backbone of SCS ([22]). In each generation, ExpEvolve generates programs in parallel slots. The prompt of each slot contains the task instruction, an optional strategy instruction
Algorithm 1 ExpEvolve
Require: initial archive $\mathcal{A}_0$ of the task; mutator LLM $G$; generations $N$; batch size $B$; random-exploration fraction $\rho$; plateau window $\kappa$
1: $\mathcal{M}_0 \leftarrow \varnothing$
2: for $t = 0, \ldots, N - 1$ do
Exploit idea factors ({xref}`Sec. 4.2`)
3: $(u_{t,1}, \ldots, u_{t,B}) \leftarrow \operatorname{Allocate}(\mathcal{M}_t, B, \rho)$ $\{\perp$: random exploration$\}$
4: for $b = 1, \ldots, B$ do
5: $p_{t,b} \sim G(\cdot \mid \operatorname{BuildContext}(u_{t,b}, \mathcal{A}_t, \mathcal{M}_t));\ y_{t,b} \leftarrow \operatorname{Evaluate}(p_{t,b})$
6: end for
Discover ideas from experience ({xref}`Sec. 4.1`)
7: $\mathcal{A}_{t+1} \leftarrow \mathcal{A}_t \cup \{(p_{t,b}, y_{t,b}, u_{t,b})\}_{b=1}^{B}$
8: $\mathcal{M}_{t+1} \leftarrow \operatorname{UpdateMemory}(\mathcal{M}_t, \mathcal{A}_{t+1})$ {annotate; merge; update rewards}
9: if $\operatorname{DiscoverScheduled}(t)$ then
10: $\mathcal{M}_{t+1} \leftarrow \operatorname{DiscoverIdeas}(\mathcal{A}_{t+1}, \mathcal{M}_{t+1})$ \{Alg. 2\}
11: end if
Revise at plateaus ({xref}`Sec. 4.2`)
12: if $\operatorname{EntersPlateau}(\mathcal{A}_{t+1}, \kappa)$ then
13: $\mathcal{M}_{t+1} \leftarrow \operatorname{ReviseAtPlateau}(\mathcal{A}_{t+1}, \mathcal{M}_{t+1})$ {probe; judge; mask}
14: end if
15: end for
16: return $\underset{(p,y,\cdot)\in\mathcal{A}_N}{\arg\max}\ y$ and $\mathcal{M}_N$
from an idea-guided action, a summary of the idea memory, and a few example programs, and the mutator LLM writes a new program from the prompt. All LLM calls use DeepSeek-V4-Flash, and the hyperparameters are listed in Table 3. Each generated program is evaluated once. A program is treated as failed if the evaluation fails or returns a non-finite objective, and failed programs are neither repaired nor retried. The LLM calls for generation are not retried in our experiments either, so a failed call, e.g., due to rate limits, yields a failed program that still counts toward the evaluation budget.
| Hyperparameter | , | , |
| Fraction of random exploration | 0.6 | 0.4 |
| Discovery interval (generations) | 2 | 1 |
| Plateau window (generations) | 4 | 2 |
| Warm-up generations | 2 | 1 |
| Action rotation (generations) | 6 | 3 |
| Shared by both configurations | ||
| Minimum archive size for discovery | 15 | |
| Maximum number of idea factors | 12 | |
| Score gap of candidate pairs | ||
| Pair budget | 6 | |
| Weight of same-generation pairs | 1.5 | |
| Permutations for the null accuracy | 500 | |
| Permutations and quantile of the action gate | 200, 0.95 | |
| Candidates per discovery round | 8 | |
| Minimum support | 5 | |
| Admission threshold | ||
| Actions in the action set | and a baseline action | |
| Example programs per prompt | 3 | |
| UCB coefficient | 1 | |
| Top programs in the background probe | 8 | |
| Reassignment probability at plateaus | 0.9, then 0.3 | |
| Bandit exploration window (generations) | 2 | |
| LLM of all calls | DeepSeek-V4-Flash | |
| Temperature of proposer / annotator / judge | 0.7 / 0.2 / 0.3 |
Table 3. Hyperparameters of ExpEvolve in the main experiments. The budget of 200 evaluations is run with two configurations of generations and batch size . Both configurations are run on all 11 tasks, each with 3 seeds.
Idea Memory and Annotation
Idea factors. Each idea factor in the idea memory is stored with a name, a description of its code pattern, a type, i.e., binary or categorical, and a value set . The description is also used by the annotator LLM to recognize the idea factor from the source code. The annotator LLM labels each program with , where the label is unknown if the idea factor cannot be recognized. The annotation of a program is a separate LLM call, independent of the proposal of idea factors, with the source code truncated to 4000 characters.
Score contrast. For a binary idea factor, the score contrast is the difference of the mean scores between the successful programs labeled true and those labeled false. For a categorical idea factor, the score contrast is the difference of the mean scores between the value with the highest mean score and the value with the lowest mean score. Programs labeled unknown are excluded from the score contrast.
Updating the memory. After each generation, labels the new programs with all existing idea factors, recomputes the score contrasts, and merges two idea factors if the Pearson correlation of their labels on the archive exceeds 0.85 (Alg. 1, line 8). Degenerate evaluations, whose scores collapse to extreme values, are excluded from the statistics. It also updates the statistics of the actions (Appendix § 14.§ 3).
Algorithm 2 DiscoverIdeas
Require: archive ; idea memory ; pair budget ; minimum support ; admission threshold
Ensure: updated idea memory
Select unexplained contrasts
1: if then 2: 3: else 4: {pairwise ranker on } 5: end if
Propose candidate ideas
6: {name, description, type, values}
Annotate, test, and admit
7: for each do 8: for all {in } 9: if and and not then 10: 11: end if 12: end for 13: return
Memory summary in the prompt. Every slot, including random exploration, receives a summary of the idea memory (line 5). The summary lists the six idea factors with the largest absolute score contrasts, each with its name, description, direction of effect, numbers of programs with and without it, and score contrast, and gives the mean score of each value for categorical idea factors. It also contains the outlier programs that the current idea factors fail to explain, i.e., one program with a large positive residual and one with a large negative residual (), with their source code truncated to 1500 characters.
Idea Discovery
Trigger. Discovery is triggered every generations after the first generation, when the archive contains at least 15 successful programs and the idea memory contains fewer than 12 idea factors, excluding the background idea factors (Alg. 1, line 9).
Pairwise ranker. Let be the standard deviation of the scores of the successful programs in the archive. ExpEvolve builds all pairs of successful programs with , and labels each pair by . The feature of a pair is the difference of the binary encodings of the idea factors, where a factor is encoded as 1 if it is labeled true and 0 otherwise, together with the standardized difference of the code lengths as a covariate. The ranker is a ridge least-squares model without intercept (), refit in each discovery round.
Selecting unexplained pairs. ExpEvolve selects the pairs that the ranker orders incorrectly (Alg. 2, line 4), and excludes the pairs on which the current idea factors take identical values. The selected pairs are ranked by , where if the two programs come from the same generation and 1 otherwise. The null accuracy is the fraction of 500 random permutations of the scores over programs, under which a ranker refit on the permuted labels still predicts the true order of the pair. A pair with a high null accuracy is easy to order from the idea factors, so that its misranking indicates a missing idea factor. The null accuracy uses the differences of the idea factors without the code-length covariate. Up to pairs are used, with each program appearing in at most two pairs. If fewer than 3 pairs are available, the discovery round is skipped. When the idea memory is empty, ExpEvolve selects the pairs with the largest score gaps under the same constraints (lines 1–2).
Proposing candidates. For each selected pair, the prompt of the proposer LLM contains the score gap in raw units and in units of , the scores, the predicted scores and the residuals of both programs, the order predicted by the ranker, the idea factors on which the two programs differ, and the source code of both programs truncated to 1500 characters each. The proposer LLM is asked to explain the unexpected order, and proposes 8 candidates in each round, each with a name, a description, a type, a value set, and a predicted direction (line 6).
Annotation and admission. Each candidate is annotated on the whole archive (line 8). ExpEvolve admits a candidate if the two values compared by its score contrast are each taken by at least programs, the absolute score contrast is at least , and the candidate does not duplicate an idea factor in the memory, an idea factor removed before, or another selected candidate (line 9). Two idea factors are considered duplicates if their names are identical, the token Jaccard similarity of their names is at least 0.6, or the token overlap of their descriptions is at least 0.45. Since the archive is collected adaptively by the search, the score contrast is an association within the archive and does not identify the effect of the idea factor. Admission therefore makes an idea factor available for testing, and the search examines it through the actions (Appendix § 14.§ 3).
Idea-Guided Actions
Actions. Allocate compiles the idea factors into actions, i.e., ADD() and REMOVE() for a binary idea factor, and SET() for each value of a categorical idea factor (Alg. 1, line 3). The action set is rebuilt in every generation, and keeps at most three actions of the idea factors with the largest absolute score contrasts, together with a baseline action without instruction. An action that has stayed in the action set for consecutive generations is rotated out to give way to other actions, and its records are kept for when it enters the action set again. Before an admitted idea factor is compiled into actions, its absolute score contrast must exceed the 95th percentile of a null distribution obtained from 200 permutations of the scores, and a threshold on the absolute score contrast is used instead when the permutation test cannot be run. Background idea factors (Appendix § 14.§ 4) are not compiled into actions, until they satisfy the admission conditions of Appendix § 14.§ 2 and are promoted to regular idea factors.
Prompt of an action. An idea-guided slot differs from random exploration in two parts of the prompt (line 5). First, a strategy instruction asks the mutator LLM to use or avoid the pattern of , or to set to , with the description of and its estimated effect. Second, the example programs consist of the best program in the archive as an anchor, followed by the best programs in the target state of the action, where ties between programs with similar scores are broken in favor of programs with rare combinations of idea factors, and example programs are used in total. There is no explicit parent program, since SCS conditions the mutator LLM on a set of example programs.
Random exploration. A random exploration slot uses the prompt of SCS without strategy instruction, with 3 example programs sampled uniformly at random from the successful programs, and the summary of the idea memory.
Diversification in the warm-up. In the warm-up generations, the slots of the baseline action in the second half of each generation receive a diversification instruction, which asks the mutator LLM to first list three to five distinct families of well-established approaches to the task as code comments, and to note which families the example programs use.
Allocating slots. In each generation, ALLOCATE assigns slots to random exploration, and the remaining slots to idea-guided actions, where denotes the action of slot and denotes random exploration (line 3). An idea-guided slot falls back to random exploration if no action is available, e.g., before any idea factor is admitted, or if the actions have reached the limit of slots per generation. The fraction of random exploration is thus at least .
Bandit. The bandit selects the actions of idea-guided slots with a soft UCB rule,
where is the number of times that has been selected, , and . Actions that have not been selected are tried first. The value is the maximum reward of , minus a bootstrap estimate of the expected maximum of rewards drawn from all actions, which corrects the growth of the maximum with the number of samples. The reward of a program generated under an action follows the normalized reward in § 4.2, where the standard deviation is lower bounded as
(line 8). If fewer than two random exploration programs are available in the generation, the adjacent generations are included. A failed program receives a penalty score below the worst successful program.
Idea-Guided Exploration at Plateaus
Entering and leaving a plateau. ExpEvolve records the best-so-far score at the end of each generation, and the search is in a plateau if the best-so-far scores of the last generations are equal up to a relative tolerance of , after the warm-up generations. When the search enters a plateau, ReviseAtPlateau runs the background probe and the dependency judge below (Alg. 1, lines 12–13). The plateau ends as soon as the best-so-far score improves, and all the changes during the plateau are reverted in the same generation. Each time the search enters a plateau again, the probe and the judge are run again, since the background of a new plateau can differ from the previous one.
Background probe. An LLM reads the 8 successful programs with the highest scores, with the source code truncated to 1500 characters and the names of the current idea factors, and proposes 2 to 4 binary properties that these programs share. Each property is annotated on the archive, and is recorded as a background idea factor if at least 5 of the 8 top programs are annotated and at least 80% of them realize the property. A background idea factor stays in the memory after the plateau, and is promoted to a regular idea factor once enough programs without it appear in the archive and its score contrast passes the admission threshold.
Dependency judge. The background is described by the three idea factors with the largest absolute score contrasts. For each idea factor in the memory, and for each value of a categorical idea factor, an LLM judge decides, with three calls, whether it depends on the background, i.e., loses its meaning or reverses its effect once the defining property of the background no longer holds.
Changes during a plateau. While the search is in a plateau, ExpEvolve applies the following changes.
Reversing and masking actions. For a binary idea factor judged dependent, ADD() is replaced by REMOVE() in the action set, with the same description and score contrast, so that the bandit can only move away from . For a categorical idea factor, the actions of the values judged dependent are masked, while the other values are kept as escape actions. The dependent idea factors are also removed from the summary of the idea memory. After the plateau, the original actions are restored, and the records of the reversed and masked actions are kept.
Stall note. A note on the current state is prepended to the prompt of every slot. The note reports the best score and the number of generations without improvement, lists the dependent idea factors with their names and shortened descriptions, states that the search has stalled on this combination, and asks whether other constructions or combinations can reach a higher score.
More random exploration. Each idea-guided slot is reassigned to random exploration with probability 0.9. Since the judge runs at the end of the first plateau generation, the probability is lowered to 0.3 from the next generation.
Diversified demonstrations. Random exploration uses the best program of the background as the first example, and fills the other examples with programs outside the background, which are selected greedily to diversify their idea factors. A program is considered in the background if it realizes any dependent idea factor.
Exploration of the bandit. In the first 2 generations of a plateau, the bandit selects the actions by the exploration bonus only.
Experimental Details
Tasks
Table 4 summarizes the 11 tasks. Nine tasks are the mathematical problems studied by SCS (Gideoni et al., [22]), which are taken from AlphaEvolve (Novikov et al., 2025), and we report their reference values as collected by Gideoni et al. [22]. All methods use the same evaluator for each task, and each evaluation is limited to 60 seconds, except the uncertainty inequality with 300 seconds.
| Task | Direction | Previous best | AlphaEvolve |
| First autocorrelation inequality | ↓ | 1.5098 | 1.5053 |
| Second autocorrelation inequality | ↑ | 0.88922 | 0.8962 |
| Uncertainty inequality | ↓ | 0.3523 | 0.3521 |
| Erdős minimum overlap | ↓ | 0.380927 | 0.380924 |
| Sums and differences of sets | ↑ | 1.14465 | 1.1584 |
| Max–min distance ratio (16 points) | ↓ | 12.890 | 12.88927 |
| Heilbronn for triangles () | ↑ | 0.036 | 0.0365 |
| Kissing number (11 dimensions) | ↑ | 592 | 593 |
| Circle packing (26 circles) | ↑ | 2.634 | 2.63586 |
| Circle packing via LP (26 circles) | ↑ | – | – |
| Hadamard matrix () | ↑ | 0.9357 | – |
Table 4. Tasks, optimization directions, and reference values. The previous best values and the values of AlphaEvolve are collected by Gideoni et al. [22]. For the uncertainty inequality, all methods in Gideoni et al. [22] reach 0.3482 under their reformulated parameterization, which we use in our experiments. For the Hadamard matrix, the previous best is the normalized score of the best-known construction.
First autocorrelation inequality. Let be the largest constant such that for all non-negative functions supported on , where is the autoconvolution. A non-negative step function gives an upper bound , which the task minimizes. The number of steps is chosen by the program, and for a step function with steps and values , the score is computed as , which is invariant to the scale of .
Second autocorrelation inequality. Let be the smallest constant such that for all non-negative functions . A non-negative step function gives a lower bound , which the task maximizes. The evaluator rejects step functions with more than steps.
Uncertainty inequality. For a function , let . For even functions with and , the task minimizes , which upper bounds the largest constant such that . Following the reformulation of Gideoni et al. [22], is a Hermite–Gaussian expansion over the monic (probabilist’s) Hermite polynomials with 7 free coefficients, which represents a larger class of functions than the original formulation over with 3 free coefficients. The sign conditions are checked on a grid of points in , which is refined to points with extended precision when the score is below 0.6, and each evaluation is limited to 300 seconds. Since the reformulation enlarges the search space, the resulting values are not comparable with the values of the original formulation in Table 4. In the implementation, the score is , where is the largest root at which changes sign.
Erdős minimum overlap problem. For a partition of into two sets and of equal size, let . The task constructs a step function with values in , whose number of steps is chosen by the program, and minimizes the upper bound on given by twice the maximum correlation between and divided by the number of steps.
Sums and differences of sets. Following the framework of Gyarmati, Hennecart, and Ruzsa, the task constructs a set with $0 \in U\theta(U) = 1 + \log(|U-U|/|U+U|)/\log(2\max(U) + 1), which lower bounds the largest exponent such that for arbitrarily large sets , with .
Max–min distance ratio. The task places 16 points in the plane to minimize the squared ratio between the maximum and the minimum pairwise distances. For example, the squared ratios 12.889 and 13.0 in Table 1 correspond to the ratios 3.5902 and 3.6056.
Heilbronn problem for triangles. The task places 11 points in the equilateral triangle with vertices , , and to maximize the smallest area of the triangles formed by any three of the points, normalized by the area of the equilateral triangle.
Kissing number in 11 dimensions. A set of points with and over yields a kissing configuration of unit spheres. The task constructs such a set, and the score is the number of points . The distances and norms are only used to check the validity of the configuration, and a configuration with more points than the known upper bound 868 is rejected.
Circle packing. The task places 26 non-overlapping circles in the unit square to maximize the sum of their radii. The evaluator checks the non-overlap and the containment of all circles, including that every radius is at most 0.5 and every center lies in the unit square, and checks that the sum of radii reported by the program agrees with the radii up to a relative and absolute tolerance of .
Circle packing via linear programming. A variant of circle packing where the program proposes only the 26 centers , and the radii are recovered by a linear program that maximizes subject to and . The variant isolates the layout of the circles from the assignment of the radii. The starting code in the prompt solves the linear program with the HiGHS solver of SciPy.
Hadamard matrix. The task constructs a matrix that maximizes . Following the convention of Wang et al. (2026), the best-known construction with scores .
Baselines
SCS. We use the implementation of SCS (Gideoni et al. [22]), which generates each program from a prompt containing the task instruction and 3 example programs sampled uniformly at random without replacement from the archive. SCS does not maintain an idea memory, and its prompt does not contain the summary of the idea memory used by ExpEvolve.
SCS+meta. SCS+meta adds the meta-summary of ShinkaEvolve to the prompt of SCS, i.e., a textual summary of the insights of recent programs with at most 5 recommendations, which is rewritten by DeepSeek-V4-Flash at temperature 0 after every generation, without the idea memory, the idea-guided actions, and the exploration at plateaus of ExpEvolve. It is run on First autocorrelation, Heilbronn, and Kissing with 10 generations of 20 programs, and on Uncertainty inequality with 20 generations of 10 programs.
ShinkaEvolve. We run ShinkaEvolve (Lange et al. [37]) with 5 islands and migration every 10 generations, weighted parent sampling, an archive of 40 programs, a meta-summary every 10 generations with 5 recommendations, and both diff-based and full rewrites. ShinkaEvolve generates one program per generation, and does not distinguish the two configurations of ExpEvolve and SCS.
Budget and Resources
Budget and Resources
All methods evaluate each generated program once, and a failed program consumes the budget. The LLM calls of ExpEvolve for proposing, annotating, probing, and judging idea factors do not evaluate programs and do not consume the budget. Each run of ShinkaEvolve starts from 5 copies of the initial program, one for each island, and then generates 199 programs, so its final performance is reported at 199 generated programs. The evaluations of ExpEvolve and SCS are not limited in CPUs, while the runs of ShinkaEvolve on First autocorrelation, Second autocorrelation, Kissing, and Max–min distance ratio evaluate each program with at most 8 CPUs. The LLM is accessed either through the official API of DeepSeek or through OpenRouter, depending on the time of the run.
Additional Results
Per-seed results. Table 5 and Table 6 report the final best score of each seed for the cells of Table 1, and Table 7 and Table 8 report the best-so-far scores along the budget.
| Task | Method | Config. | Seed 1 | Seed 2 | Seed 3 | Mean |
| Hadamard | ExpEvolve | 0.9211 | 0.9357 | 0.9211 | ||
| Hadamard | ExpEvolve | 0.9211 | 0.9211 | 0.9211 | ||
| Hadamard | SCS | 0.8596 | 0.9211 | 0.7240 | ||
| Hadamard | SCS | 0.8596 | 0.5665 | 0.5662 | ||
| Hadamard | ShinkaEvolve | – | 0.5603 | 0.5733 | 0.8066 | |
| Pack | ExpEvolve | 2.63304 | 2.63598 | 2.63595 | ||
| Pack | ExpEvolve | 2.63598 | 2.63429 | 2.63598 | ||
| Pack | SCS | 2.62760 | 2.63104 | 2.61050 | ||
| Pack | SCS | 2.63017 | 2.63572 | 2.58501 | ||
| Pack | ShinkaEvolve | – | 2.61408 | 2.54142 | 2.59052 | |
| Linprog | ExpEvolve | 2.63598 | 2.63429 | 2.63598 | ||
| Linprog | ExpEvolve | 2.63429 | 2.63598 | 2.63598 | ||
| Linprog | SCS | 2.55342 | 2.54533 | 2.55608 | ||
| Linprog | SCS | 2.63598 | 2.63429 | 2.63598 | ||
| Linprog | ShinkaEvolve | – | 2.51192 | 2.54142 | 2.48969 | |
| SumDiff | ExpEvolve | 1.12281 | 1.12142 | 1.12250 | ||
| SumDiff | ExpEvolve | 1.11937 | 1.10954 | 1.11937 | ||
| SumDiff | SCS | 1.11033 | 1.12006 | 1.11786 | ||
| SumDiff | SCS | 1.11143 | 1.11123 | 1.10995 | ||
| SumDiff | ShinkaEvolve | – | 1.10954 | 1.10954 | 1.10954 | |
| Heilbronn | ExpEvolve | 0.0359 | 0.0365 | 0.0351 | ||
| Heilbronn | ExpEvolve | 0.0357 | 0.0359 | 0.0342 | ||
| Heilbronn | SCS | 0.0343 | 0.0333 | 0.0331 | ||
| Heilbronn | SCS | 0.0340 | 0.0288 | 0.0312 | ||
| Heilbronn | ShinkaEvolve | – | 0.0303 | 0.0324 | 0.0283 | |
| Min overlap | ExpEvolve | 0.38096 | 0.38102 | 0.38095 | ||
| Min overlap | ExpEvolve | 0.38096 | 0.38095 | 0.38100 | ||
| Min overlap | SCS | 0.38130 | 0.38094 | 0.38097 | ||
| Min overlap | SCS | 0.38104 | 0.38210 | 0.38154 | ||
| Min overlap | ShinkaEvolve | – | 0.38239 | 0.38243 | 0.38246 |
Table 5. Final best score of each seed at the budget of 200, and the mean standard deviation over seeds.
| Task | Method | Config. | Seed 1 | Seed 2 | Seed 3 | Mean |
| Kissing | ExpEvolve | 10 20 | 582 | 582 | 582 | 582 0 |
| ExpEvolve | 20 10 | 414 | 582 | 582 | 526 97 | |
| SCS | 10 20 | 582 | 582 | 582 | 582 0 | |
| SCS | 20 10 | 406 | 438 | 394 | 413 23 | |
| ShinkaEvolve | – | 414 | 406 | 566 | 462 90 | |
| Second autocorr. | ExpEvolve | 10 20 | 0.8825 | 0.8825 | 0.8825 | 0.8825 0.0000 |
| ExpEvolve | 20 10 | 0.8825 | 0.8825 | 0.8825 | 0.8825 0.0000 | |
| SCS | 10 20 | 0.8825 | 0.8825 | 0.8825 | 0.8825 0.0000 | |
| SCS | 20 10 | 0.8499 | 0.8485 | 0.8210 | 0.8398 0.0163 | |
| ShinkaEvolve | – | 0.8739 | 0.8825 | 0.8671 | 0.8745 0.0077 | |
| First autocorr. | ExpEvolve | 10 20 | 1.5151 | 1.5176 | 1.5257 | 1.5195 0.0055 |
| ExpEvolve | 20 10 | 1.5104 | 1.5098 | 1.5137 | 1.5113 0.0021 | |
| SCS | 10 20 | 1.5587 | 1.5560 | 1.5378 | 1.5508 0.0113 | |
| SCS | 20 10 | 1.5151 | 1.5354 | 1.5202 | 1.5235 0.0106 | |
| ShinkaEvolve | – | 1.5203 | 1.5708 | 1.5708 | 1.5540 0.0292 | |
| Max–min ratio | ExpEvolve | 10 20 | 12.8892 | 12.8892 | 12.8892 | 12.8892 0.0000 |
| ExpEvolve | 20 10 | 13.0000 | 12.8892 | 12.8892 | 12.9262 0.0640 | |
| SCS | 10 20 | 12.9425 | 13.0000 | 13.0000 | 12.9808 0.0332 | |
| SCS | 20 10 | 13.0229 | 12.8892 | 12.8892 | 12.9338 0.0772 | |
| ShinkaEvolve | – | 13.0000 | 13.0000 | 13.0000 | 13.0000 0.0000 | |
| Hermite | ExpEvolve | 10 20 | 0.34820 | 0.35172 | 0.35274 | 0.35089 0.00238 |
| ExpEvolve | 20 10 | 0.35321 | 0.35263 | 0.35834 | 0.35473 0.00314 | |
| SCS | 10 20 | 0.35394 | 0.36109 | 0.36365 | 0.35956 0.00503 | |
| SCS | 20 10 | 0.46232 | 0.35945 | 0.36116 | 0.39431 0.05890 | |
| ShinkaEvolve | – | 6.91428 | 0.35429 | 6.91480 | 4.72779 3.78756 |
Table 6. Final best score of each seed (continued) at the budget of 200 evaluated programs (199 for ShinkaEvolve), and the mean standard deviation over seeds.
| Task | Method | Config. | 40 | 80 | 120 | 160 | 200 |
| Hadamard ↑ | ExpEvolve | 10 × 20 | 0.8801 ± 0.0355 | 0.9211 ± 0.0000 | 0.9259 ± 0.0084 | 0.9259 ± 0.0084 | 0.9259 ± 0.0084 |
| Hadamard ↑ | ExpEvolve | 20 × 10 | 0.9006 ± 0.0355 | 0.9006 ± 0.0355 | 0.9211 ± 0.0000 | 0.9211 ± 0.0000 | 0.9211 ± 0.0000 |
| Hadamard ↑ | SCS | 10 × 20 | 0.5047 ± 0.0113 | 0.6446 ± 0.1866 | 0.6494 ± 0.1828 | 0.7144 ± 0.1502 | 0.8349 ± 0.1008 |
| Hadamard ↑ | SCS | 20 × 10 | 0.6506 ± 0.1821 | 0.6506 ± 0.1821 | 0.6556 ± 0.1771 | 0.6641 ± 0.1693 | 0.6641 ± 0.1693 |
| Hadamard ↑ | ShinkaEvolve | – | 0.4909 ± 0.0171 | 0.5093 ± 0.0093 | 0.5297 ± 0.0258 | 0.5588 ± 0.0131 | 0.6467 ± 0.1386 |
| Pack ↑ | ExpEvolve | 10 × 20 | 2.62275 ± 0.00820 | 2.62721 ± 0.00567 | 2.63201 ± 0.00090 | 2.63499 ± 0.00169 | 2.63499 ± 0.00169 |
| Pack ↑ | ExpEvolve | 20 × 10 | 2.63046 ± 0.00347 | 2.63289 ± 0.00397 | 2.63326 ± 0.00336 | 2.63485 ± 0.00098 | 2.63542 ± 0.00098 |
| Pack ↑ | SCS | 10 × 20 | 2.60036 ± 0.03729 | 2.60307 ± 0.03920 | 2.60423 ± 0.04016 | 2.61452 ± 0.02569 | 2.62305 ± 0.01100 |
| Pack ↑ | SCS | 20 × 10 | 2.60046 ± 0.02223 | 2.61200 ± 0.02384 | 2.61383 ± 0.02605 | 2.61697 ± 0.02781 | 2.61697 ± 0.02781 |
| Pack ↑ | ShinkaEvolve | – | 2.51452 ± 0.04659 | 2.53382 ± 0.01316 | 2.56349 ± 0.03437 | 2.57166 ± 0.03783 | 2.58201 ± 0.03707 |
| Linprog ↑ | ExpEvolve | 10 × 20 | 2.63043 ± 0.00962 | 2.63435 ± 0.00282 | 2.63542 ± 0.00098 | 2.63542 ± 0.00098 | 2.63542 ± 0.00098 |
| Linprog ↑ | ExpEvolve | 20 × 10 | 2.63165 ± 0.00241 | 2.63444 ± 0.00148 | 2.63542 ± 0.00098 | 2.63542 ± 0.00098 | 2.63542 ± 0.00098 |
| Linprog ↑ | SCS | 10 × 20 | 2.52974 ± 0.01579 | 2.54272 ± 0.00225 | 2.54672 ± 0.00612 | 2.55161 ± 0.00560 | 2.55161 ± 0.00560 |
| Linprog ↑ | SCS | 20 × 10 | 2.63328 ± 0.00332 | 2.63486 ± 0.00098 | 2.63486 ± 0.00098 | 2.63542 ± 0.00098 | 2.63542 ± 0.00098 |
| Linprog ↑ | ShinkaEvolve | – | 2.46507 ± 0.09226 | 2.48623 ± 0.06618 | 2.48853 ± 0.06724 | 2.51167 ± 0.02988 | 2.51434 ± 0.02595 |
| SumDiff ↑ | ExpEvolve | 10 × 20 | 1.11026 ± 0.00102 | 1.11364 ± 0.00470 | 1.11948 ± 0.00220 | 1.12089 ± 0.00065 | 1.12224 ± 0.00073 |
| SumDiff ↑ | ExpEvolve | 20 × 10 | 1.10968 ± 0.00023 | 1.10968 ± 0.00023 | 1.11413 ± 0.00480 | 1.11473 ± 0.00484 | 1.11609 ± 0.00567 |
| SumDiff ↑ | SCS | 10 × 20 | 1.10981 ± 0.00023 | 1.10990 ± 0.00009 | 1.11387 ± 0.00473 | 1.11564 ± 0.00497 | 1.11608 ± 0.00510 |
| SumDiff ↑ | SCS | 20 × 10 | 1.10968 ± 0.00023 | 1.11031 ± 0.00099 | 1.11031 ± 0.00099 | 1.11031 ± 0.00099 | 1.11087 ± 0.00080 |
| SumDiff ↑ | ShinkaEvolve | – | 1.10954 ± 0.00000 | 1.10954 ± 0.00000 | 1.10954 ± 0.00000 | 1.10954 ± 0.00000 | 1.10954 ± 0.00000 |
| Heilbronn ↑ | ExpEvolve | 10 × 20 | 0.0315 ± 0.0008 | 0.0349 ± 0.0012 | 0.0350 ± 0.0014 | 0.0354 ± 0.0014 | 0.0358 ± 0.0007 |
| Heilbronn ↑ | ExpEvolve | 20 × 10 | 0.0336 ± 0.0016 | 0.0339 ± 0.0013 | 0.0342 ± 0.0013 | 0.0349 ± 0.0010 | 0.0353 ± 0.0009 |
| Heilbronn ↑ | SCS | 10 × 20 | 0.0310 ± 0.0025 | 0.0325 ± 0.0003 | 0.0326 ± 0.0005 | 0.0331 ± 0.0002 | 0.0336 ± 0.0006 |
| Heilbronn ↑ | SCS | 20 × 10 | 0.0294 ± 0.0021 | 0.0309 ± 0.0025 | 0.0309 ± 0.0025 | 0.0311 ± 0.0022 | 0.0313 ± 0.0026 |
| Heilbronn ↑ | ShinkaEvolve | – | 0.0261 ± 0.0007 | 0.0268 ± 0.0012 | 0.0290 ± 0.0024 | 0.0297 ± 0.0024 | 0.0303 ± 0.0021 |
| Min overlap ↓ | ExpEvolve | 10 × 20 | 0.38109 ± 0.00012 | 0.38107 ± 0.00010 | 0.38101 ± 0.00007 | 0.38098 ± 0.00004 | 0.38098 ± 0.00004 |
| Min overlap ↓ | ExpEvolve | 20 × 10 | 0.38121 ± 0.00009 | 0.38116 ± 0.00016 | 0.38106 ± 0.00014 | 0.38105 ± 0.00013 | 0.38097 ± 0.00003 |
| Min overlap ↓ | SCS | 10 × 20 | 0.38141 ± 0.00029 | 0.38114 ± 0.00017 | 0.38108 ± 0.00019 | 0.38107 ± 0.00020 | 0.38107 ± 0.00020 |
| Min overlap ↓ | SCS | 20 × 10 | 0.38351 ± 0.00015 | 0.38344 ± 0.00323 | 0.38344 ± 0.00323 | 0.38156 ± 0.00053 | 0.38156 ± 0.00053 |
| Min overlap ↓ | ShinkaEvolve | – | 0.38285 ± 0.00065 | 0.38242 ± 0.00003 | 0.38242 ± 0.00003 | 0.38242 ± 0.00003 | 0.38242 ± 0.00003 |
Table 7. Best-so-far scores along the budget, as the mean ± standard deviation over 3 seeds after 40, 80, 120, 160, and 200 evaluated programs.
| Task | Method | Config. | 40 | 80 | 120 | 160 | 200 |
| Kissing ↑ | ExpEvolve | 10 × 20 | 578 ± 6 | 582 ± 0 | 582 ± 0 | 582 ± 0 | 582 ± 0 |
| Kissing ↑ | ExpEvolve | 20 × 10 | 348 ± 0 | 453 ± 113 | 523 ± 103 | 523 ± 103 | 526 ± 97 |
| Kissing ↑ | SCS | 10 × 20 | 564 ± 3 | 582 ± 0 | 582 ± 0 | 582 ± 0 | 582 ± 0 |
| Kissing ↑ | SCS | 20 × 10 | 394 ± 38 | 394 ± 38 | 402 ± 34 | 402 ± 33 | 413 ± 23 |
| Kissing ↑ | ShinkaEvolve | – | 426 ± 68 | 459 ± 92 | 459 ± 92 | 461 ± 91 | 462 ± 90 |
| Second autocorr. ↑ | ExpEvolve | 10 × 20 | 0.8825 ± 0.0000 | 0.8825 ± 0.0000 | 0.8825 ± 0.0000 | 0.8825 ± 0.0000 | 0.8825 ± 0.0000 |
| Second autocorr. ↑ | ExpEvolve | 20 × 10 | 0.8649 ± 0.0154 | 0.8823 ± 0.0004 | 0.8824 ± 0.0002 | 0.8825 ± 0.0000 | 0.8825 ± 0.0000 |
| Second autocorr. ↑ | SCS | 10 × 20 | 0.8825 ± 0.0000 | 0.8825 ± 0.0000 | 0.8825 ± 0.0000 | 0.8825 ± 0.0000 | 0.8825 ± 0.0000 |
| Second autocorr. ↑ | SCS | 20 × 10 | 0.8492 ± 0.0010 | 0.8398 ± 0.0163 | 0.8398 ± 0.0163 | 0.8398 ± 0.0163 | 0.8398 ± 0.0163 |
| Second autocorr. ↑ | ShinkaEvolve | – | 0.8577 ± 0.0215 | 0.8650 ± 0.0172 | 0.8732 ± 0.0096 | 0.8732 ± 0.0096 | 0.8745 ± 0.0077 |
| First autocorr. ↓ | ExpEvolve | 10 × 20 | 1.5528 ± 0.0113 | 1.5316 ± 0.0233 | 1.5217 ± 0.0093 | 1.5216 ± 0.0091 | 1.5195 ± 0.0055 |
| First autocorr. ↓ | ExpEvolve | 20 × 10 | 1.5196 ± 0.0021 | 1.5169 ± 0.0053 | 1.5124 ± 0.0023 | 1.5119 ± 0.0019 | 1.5113 ± 0.0021 |
| First autocorr. ↓ | SCS | 10 × 20 | 1.5674 ± 0.0056 | 1.5626 ± 0.0076 | 1.5549 ± 0.0165 | 1.5508 ± 0.0113 | 1.5508 ± 0.0113 |
| First autocorr. ↓ | SCS | 20 × 10 | 1.5482 ± 0.0284 | 1.5262 ± 0.0143 | 1.5262 ± 0.0143 | 1.5235 ± 0.0106 | 1.5235 ± 0.0106 |
| First autocorr. ↓ | ShinkaEvolve | – | 1.5664 ± 0.0076 | 1.5664 ± 0.0076 | 1.5622 ± 0.0149 | 1.5554 ± 0.0268 | 1.5540 ± 0.0292 |
| Max–min ratio ↓ | ExpEvolve | 10 × 20 | 12.8892 ± 0.0000 | 12.8892 ± 0.0000 | 12.8892 ± 0.0000 | 12.8892 ± 0.0000 | 12.8892 ± 0.0000 |
| Max–min ratio ↓ | ExpEvolve | 20 × 10 | 12.9266 ± 0.0636 | 12.9262 ± 0.0640 | 12.9262 ± 0.0640 | 12.9262 ± 0.0640 | 12.9262 ± 0.0640 |
| Max–min ratio ↓ | SCS | 10 × 20 | 14.8410 ± 1.5646 | 13.8205 ± 1.4212 | 13.0557 ± 0.0965 | 12.9808 ± 0.0332 | 12.9808 ± 0.0332 |
| Max–min ratio ↓ | SCS | 20 × 10 | 13.4169 ± 0.9139 | 13.2822 ± 0.6807 | 13.2420 ± 0.6110 | 12.9629 ± 0.1277 | 12.9338 ± 0.0772 |
| Max–min ratio ↓ | ShinkaEvolve | – | 13.0000 ± 0.0000 | 13.0000 ± 0.0000 | 13.0000 ± 0.0000 | 13.0000 ± 0.0000 | 13.0000 ± 0.0000 |
| Hermite ↓ | ExpEvolve | 10 × 20 | 0.39730 ± 0.06957 | 0.35841 ± 0.00503 | 0.35738 ± 0.00659 | 0.35117 ± 0.00203 | 0.35089 ± 0.00238 |
| Hermite ↓ | ExpEvolve | 20 × 10 | 2.81478 ± 2.14897 | 1.51139 ± 1.88727 | 0.40779 ± 0.06331 | 0.35505 ± 0.00285 | 0.35473 ± 0.00314 |
| Hermite ↓ | SCS | 10 × 20 | 1.14201 ± 1.25089 | 0.35956 ± 0.00503 | 0.35956 ± 0.00503 | 0.35956 ± 0.00503 | 0.35956 ± 0.00503 |
| Hermite ↓ | SCS | 20 × 10 | 2.42124 ± 2.13014 | 0.96193 ± 0.95033 | 0.39580 ± 0.05769 | 0.39431 ± 0.05890 | 0.39431 ± 0.05890 |
| Hermite ↓ | ShinkaEvolve | – | 4.72792 ± 3.78744 | 4.72791 ± 3.78744 | 4.72788 ± 3.78741 | 4.72783 ± 3.78749 | 4.72779 ± 3.78756 |
Table 8. Best-so-far scores along the budget (continued), as the mean ± standard deviation over 3 seeds after 40, 80, 120, 160, and 200 evaluated programs. For ShinkaEvolve, the last column reports 199 programs.
Sample efficiency. For each setting, is the first number of evaluated programs at which the best-so-far score of ExpEvolve, averaged over the seeds that have produced a successful program, reaches the final best score of SCS averaged over seeds, and is the first number of evaluated programs at which the best-so-far score of SCS, averaged in the same way, reaches its final value. The programs within a generation are ordered by their slots. Table 9 reports the four tasks in Figure 6.
| Task | Config. | Final of SCS | |||
| Hadamard | 0.8349 | 186 | 10 | 18.6 | |
| Hadamard | 0.6641 | 131 | 5 | 26.2 | |
| SumDiff | 1.11608 | 180 | 81 | 2.2 | |
| SumDiff | 1.11087 | 181 | 97 | 1.9 | |
| Heilbronn | 0.0336 | 199 | 52 | 3.8 | |
| Heilbronn | 0.0313 | 169 | 27 | 6.3 | |
| Min overlap | 0.38107 | 141 | 84 | 1.7 | |
| Min overlap | 0.38156 | 144 | 13 | 11.1 |
Table 9. Numbers of evaluated programs that ExpEvolve and SCS need to reach the final best score of SCS, averaged over 3 seeds.
Prompts
Prompt of a slot. The prompt of each slot is assembled as follows, where the strategy instruction is present only for idea-guided slots, and the summary of the idea memory is present for all slots.
```` {base_instruction}
Strategy for this attempt
{directive}
{causal_info_block}
Successful examples (to improve on):
Solution {i+1} ({metric} = {value}):
{code}
Please now provide your new, better implementation of the required function (exact signature from the task statement above). Address the strategy above and avoid the failure patterns shown. ````
Strategy instructions. The strategy instruction of an action on a binary idea factor and on a categorical idea factor are as follows, with lines wrapped for display.
STRATEGY (this batch is targeting a discovered code factor): {USE|AVOID} the ‘{feature_name}‘ pattern{ ({desc})}. Past data on this run estimates its effect on {conf_metric_name} at ATE={+}{ate:.3f}. The first example below is the highest-Y program (anchor, regardless of this pattern); subsequent examples {USE this pattern|DO NOT use this pattern}. Keep the pattern direction while improving on the anchor’s overall quality.
STRATEGY (this batch is targeting a categorical code factor): SET the
‘{feature_name}‘ factor to value ‘{level}‘{ ({desc})}. Past data shows
programs with this exact level gain {+}{ate:.3f} {conf_metric_name} vs
other levels of the factor. The first example below is the highest-Y
program (anchor); the other examples USE this exact level. Adopt the
‘{level}‘ setting and improve on the anchor.
Stall note. At plateaus, the following note is prepended to the prompt of every slot, where {blur} lists the dependent idea factors as their names followed by the first 90 characters of their descriptions, separated by semicolons, and {stall} is “best has stayed at {best} for {streak} generations”.
CURRENT-STATE NOTE (read first): the most common combination among the
current top programs is: {blur}. Progress with this combination has
stalled — {stall}. Consider: are there OTHER constructions or
combinations, or variants of the current one, that could reach higher?
If you know one, this attempt is a good moment to try it.
Annotator. The annotator LLM labels the idea factors of a program with the following prompt, where the descriptions are truncated to 200 characters and the source code to 4000 characters.
[system]
You annotate program code for the presence of specific algorithmic
factors. Output STRICT JSON only with key ’assignments’.
[user]
Factors to annotate:
- <name> (binary): <description>
- <name> (categorical, values: [...]): <description>
Program code:
```python
<code>
Output JSON: { "assignments": { "<factor_name>": <value>, ... } } For binary factors, value should be true or false. For categorical, value should be one of the listed values. Use null only if unknown.
**Background probe.** At the entry of a plateau, the background probe reads the 8 successful programs with the highest scores, with the source code truncated to 1500 characters, and the names of the current idea factors.
These are the TOP-SCORING programs of a search that has plateaued -
they are the stuck family.
## Program {i} ({metric}={score}):
{code}
...
Factors already tracked (do NOT repeat these or trivial rephrasings):
- {name}
...
Name the structural / algorithmic properties that these top programs
SHARE — especially the construction or representation they all rely
on. These will be used to describe the stuck family so the search can
deliberately depart from it. Binary properties only.
Return ONLY a JSON array: [{"name":"<snake_case>","description":
"<one sentence, concrete>"}] (2 to 4 entries)
More Details of Experiments on Machine Learning Engineering
We further study whether the effectiveness of ExpEvolve transfers to machine learning engineering (MLE). We integrate its idea discovery and search control into OpenRSI (Yang et al., 2026b) and evaluate the resulting agent on MLS-Bench (Lyu et al., 2026a). This setting examines the use of idea factors within a harness that supports evolution on ML algorithms towards a specific task objective.
Tasks and data. MLS-Bench evaluates agents on improving components of ML algorithms under fixed task interfaces and evaluation protocols. Here we consider 6 tasks: Online bandit, Anomaly detection, Clustering, Multi-objective optimization, Subgroup calibration shift, and Evolution strategy. Search leverages the scores and execution feedback exposed by each task.
Backbone and budget. We use the evolutionary harness from OpenRSI, which organizes search through DRAFT, IMPROVE, DEBUG, and CROSSOVER operators. For each task, we retain a fixed history containing 20 completed search slots from an earlier OpenRSI run. The OpenRSI baseline and OpenRSI equipped with ExpEvolve continue from this same history for 50 additional evaluator calls, with 3 seeds. Both methods use 5 search slots per generation. All program generation uses Qwen3.6-35B-A3B. The same checkpoint performs factor discovery and annotation in ExpEvolve.
Integrating idea factors with OpenRSI. ExpEvolve initializes its idea memory from the shared history and updates it with newly evaluated programs. Consistent with § 4, Discovery examines program pairs whose score differences are insufficiently explained by the current factors. The LLM reads their source and proposes reusable mechanisms. Factors enter the action catalog when both states have sufficient support and exhibit a score contrast in the archive. Each generation reserves two slots for OPEN exploration and schedules three for GUIDED search. Specifically, a guided slot first selects an action, such as ADD() or REMOVE(), and then the harness selects a high-scoring parent compatible with that change. We use improvement over the best selected parent as action feedback, adapting the reward reference to OpenRSI’s parent–child structure. When the cumulative best score remains unchanged within relative tolerance across three generation boundaries, ExpEvolve switches to idea-guided exploration at plateaus, aligning with § 4.2.
Evaluation and results. We evaluate search performance using the best-so-far (BSF) score. For each task and method, we average the final BSF score over three seeds, starting from the same 20-slot history and continuing for 50 additional evaluations. Figure 9(a) compares OpenRSI with OpenRSI+ExpEvolve across the six tasks. The reported configurations improve the mean final BSF score on all six tasks, with the largest gains on Online bandit and Anomaly detection.
Ethics Statement
This work studies evolutionary coding agents on open-ended mathematical discovery tasks and on machine learning tasks from MLS-Bench. It does not involve human subjects or personally identifiable information, and all tasks come from public benchmarks or prior work.
Reproducibility Statement
The full procedure of ExpEvolve is given in Alg. 1 and Alg. 2, and its implementation details and hyperparameters are given in Appendix H and Table 3. The tasks, evaluators, and reference values are described in Appendix I.1, the configurations of the baselines in Appendix I.2, the budget and resources in Appendix I.3, the setting of MLS-Bench in Appendix K.1, and all prompts in Appendix K. The per-seed results are given in Appendix J. The formal statements and proofs of the theoretical results are given in Appendix E and Appendix F. All experiments on mathematical discovery use DeepSeek-V4-Flash unless stated otherwise, and each setting is run with 3 seeds.
AI Use Statement
We used LLM assistance to revise the manuscript’s organization and wording, identify and check related references, and examine the interpretation of reported experiments. The proposed framework itself uses LLMs to generate programs, propose idea factors, and assess program properties.
References
- [1]K. Ahuja, D. Mahajan, Y. Wang, and Y. Bengio. Interventional causal representation learning. In International Conference on Machine Learning (ICML), 2023. (Cited on page 23)arxiv.org/abs/2209.11924
- [2]Anthropic. Claude accelerates protein design and analytical chemistry. https://www.anthropic.com/research/claude-accelerates-protein-design, Aug. 2026. 354 binders against 14 of 15 targets from 1,320 designs, produced and tested independently by Adaptvy Bio and Twist Bioscience. (Cited on pages 1, 3 and 20)
- [3]A. Asai, J. He, R. Shao, W. Shi, A. Singh, J. C. Chang, K. Lo, L. Soldaini, S. Feldman, et al. Synthesizing scientific literature with retrieval-augmented language models. Nature, 2026. doi: 10.1038/s41586-025-100724. (Cited on pages 1 and 20)
- [4]H. Assumpção, D. Ferreira, L. Campos, and F. Murai. CodeEvolve: an open source evolutionary coding agent for algorithm discovery and optimization. arXiv preprint arXiv:2510.14150, 2025. (Cited on page 20)arxiv.org/abs/2510.14150
- [5]D. A. Boiko, R. MacKnight, B. Kline, and G. Gomes. Autonomous chemical research with large language models. Nature, 624(7992):570–578, 2023. (Cited on page 20)DOI
- [6]P. Brouillard, S. Lachapelle, A. Lacoste, S. Lacoste-Julien, and A. Drouin. Differentiable causal discovery from interventional data. Advances in Neural Information Processing Systems, 33:21865–21877, 2020. (Cited on page 21)arxiv.org/abs/2007.01754
- [8]M. Cemri et al. AdaEvolve: Adaptive LLM driven zeroth-order optimization. arXiv preprint arXiv:2602.20133, 2026. (Cited on page 20)arxiv.org/abs/2602.20133
- [9]K. Chalupka, P. Perona, and F. Eberhardt. Visual causal feature learning. In Proceedings of the Thirty-First Conference on Uncertainty in Artificial Intelligence, 2015. (Cited on page 23)arxiv.org/abs/1412.2309
- [10]J. S. Chan, N. Chowdhury, O. Jaffe, J. Aung, D. Sherburn, E. Mays, G. Starace, K. Liu, L. Maksin, T. Patwardhan, A. Madry, and L. Weng. MLE-bench: Evaluating machine learning agents on machine learning engineering. In ICLR, 2025. arXiv:2410.07095. (Cited on page 20)arxiv.org/abs/2410.07095
- [11]Y. Chen, W. Huang, K. Zhou, Y. Bian, B. Han, and J. Cheng. Understanding and improving feature learning for out-of-distribution generalization. In Advances in Neural Information Processing Systems, 2023. (Cited on page 24)arxiv.org/abs/2304.11327
- [12]A. Cheng, S. Liu, M. Z. Pan, Z. Li, B. Wang, A. Krentsel, T. Xia, M. Cemri, J. Park, S. Yang, J. Chen, L. A. Agrawal, A. Desai, J. Xing, K. Sen, M. Zaharia, and I. Stoica. Barbarians at the gate: How ai is upending systems research. ArXiv, abs/2510.06189, 2025. (Cited on page 20)arxiv.org/abs/2510.06189
- [13]L. Da Costa, Á. Fialho, M. Schoenauer, and M. Sebag. Adaptive operator selection with dynamic multi-armed bandits. In Proceedings of the Genetic and Evolutionary Computation Conference (GECCO), pages 913–920, 2008. (Cited on page 21)
- [14]N. Dhawan, L. Cotta, K. Ullrich, R. G. Krishnan, and C. J. Maddison. End-to-end causal effect estimation from unstructured natural language data. Advances in Neural Information Processing Systems, 37:77165–77199, 2024. (Cited on page 21)arxiv.org/abs/2407.07018
- [15]I. Douven. Abduction. In E. N. Zalta and U. Nodelman, editors, The Stanford Encyclopedia of Philosophy. Metaphysics Research Lab, Stanford University, Winter 2025 edition, 2025. (Cited on page 2)
- [16]M. Favaro and J. Clark. When AI builds itself: Our progress toward recursive self-improvement and its implications. Anthropic Institute, https://www.anthropic.com/institute/recursive-self-improvement, June 2026. (Cited on pages 1, 3 and 20)
- [17]P. Feng, Z. Lv, J. Ye, X. Wang, X. Huo, J. Yu, W. Xu, W. Zhang, L. Bai, C. He, and W. Li. Earth-Agent: Unlocking the full landscape of earth observation with agents. In ICLR, 2026a. arXiv:2509.23141. (Cited on page 20)arxiv.org/abs/2509.23141
- [18]S. Feng, R. Ma, X. Yan, et al. InternAgent-1.5: A unified agentic framework for long-horizon autonomous scientific discovery. arXiv preprint arXiv:2602.08990, 2026b. (Cited on pages 3 and 20)arxiv.org/abs/2602.08990
- [19]B. Georgiev, J. Gómez-Serrano, T. Tao, and A. Z. Wagner. Mathematical exploration and discovery at scale. ArXiv, abs/2511.02864, 2025. (Cited on page 20)arxiv.org/abs/2511.02864
- [20]A. Ghafarollahi and M. J. Buehler. Sciagents: automating scientific discovery through bioinspired multi-agent intelligent graph reasoning. Advanced Materials, 37(22):2413523, 2025. (Cited on pages 3 and 20)
- [21]A. E. Ghareeb et al. A multi-agent system for automating scientific discovery. Nature, 655(8122):497–505, 2026. doi: 10.1038/s41586-026-10652-y. (Cited on pages 3 and 20)DOI
- [22]Y. Gideoni, S. Risi, and Y. Gal. Simple baselines are competitive with code evolution. In ICLR 2026 Workshop on AI with Recursive Self-Improvement, 2026. arXiv:2602.16805. (Cited on pages 2, 3, 7, 8, 20, 32, 37, 38 and 39)arxiv.org/abs/2602.16805
- [24]J. Gottweis et al. Accelerating scientific discovery with co-scientist. Nature, 655(8122):487–496, 2026. doi: 10.1038/s41586-026-10644-y. (Cited on pages 1, 3 and 20)DOI
- [25]S. Greenland, J. Pearl, and J. M. Robins. Causal diagrams for epidemiologic research. Epidemiology, 10(1):37–48, 1999. (Cited on page 21)pubmed.ncbi.nlm.nih.gov/9888278
- [26]P. Hoyer, D. Janzing, J. M. Mooij, J. Peters, and B. Schölkopf. Nonlinear causal discovery with additive noise models. Advances in neural information processing systems, 21, 2008. (Cited on page 21)
- [27]B. Huang, K. Zhang, J. Zhang, J. Ramsey, R. Sanchez-Romero, C. Glymour, and B. Schölkopf. Causal discovery from heterogeneous/nonstationary data. Journal of Machine Learning Research, 21(89):1–53, 2020. (Cited on page 21)
- [28]K. Huang, Y. Jin, R. Li, M. Y. Li, E. Candes, and J. Leskovec. Automated hypothesis validation with agentic sequential falsifications. In ICML, 2025a. (Cited on page 20)
- [29]Y. Huang, Y. Chen, H. Zhang, K. Li, H. Zhou, M. Fang, L. Yang, X. Li, L. Shang, S. Xu, et al. Deep research agents: A systematic examination and roadmap. arXiv preprint arXiv:2506.18096, 2025b. (Cited on page 20)
- [30]A. Hyttinen, F. Eberhardt, and P. O. Hoyer. Experiment selection for causal discovery. The Journal of Machine Learning Research, 14(1):3041–3071, 2013. (Cited on page 21)DOI
- [31]L. Jing, Z. Huang, X. Wang, W. Yao, W. Yu, K. Ma, H. Zhang, X. Du, and D. Yu. DSBench: How far are data science agents from becoming data science experts? In ICLR, 2025. arXiv:2409.07703. (Cited on page 20)
- [32]L. P. Kaelbling, M. L. Littman, and A. R. Cassandra. Planning and acting in partially observable stochastic domains. Artificial intelligence, 101(1-2):99–134, 1998. (Cited on pages 2, 4 and 21)DOI
- [33]A. Karpathy. autoresearch: session reports of an autonomous single-GPU training-loop agent. GitHub discussions #32 and #43, https://github.com/karpathy/autoresearch/discussions/32, https://github.com/karpathy/autoresearch/discussions/43, 2026. Discussion #43 is the 126-experiment log classified in the paper; discussion #32 (8 March 2026) is an 89-experiment log with the same format. (Cited on pages 1, 2, 3 and 20)
- [34]E. Kaufmann, O. Cappé, and A. Garivier. On the complexity of best-arm identification in multi-armed bandit models. Journal of Machine Learning Research, 17(1):1–42, 2016. (Cited on page 30)
- [35]V. Khrulkov, A. V. Galichin, et al. GigaEvo: An open source optimization framework powered by LLMs and evolution algorithms. arXiv preprint arXiv:2511.17592, 2025. (Cited on page 20)arxiv.org/abs/2511.17592
- [36]T. S. Kuhn and D. Hawkins. The structure of scientific revolutions. American Journal of Physics, 31: 554–555, 1963. (Cited on pages 2, 3 and 21)
- [37]R. T. Lange, Y. Imajuku, and E. Cetin. ShinkaEvolve: Towards open-ended and sample-efficient program evolution. In ICLR, 2026. arXiv:2509.19349. (Cited on pages 1, 2, 3, 4, 5, 8, 20 and 39)arxiv.org/abs/2509.19349
- [38]J. M. Laurent, J. D. Janizek, M. Ruzo, M. M. Hinks, M. J. Hammerling, S. Narayanan, M. Ponnapati, A. D. White, and S. G. Rodrigues. Lab-bench: Measuring capabilities of language models for biology research. arXiv preprint arXiv:2407.10362, 2024. (Cited on page 20)arxiv.org/abs/2407.10362
- [39]J. Lehman and K. O. Stanley. Abandoning objectives: Evolution through the search for novelty alone. Evolutionary Computation, 19(2):189–223, 2011. (Cited on page 21)DOI
- [41]J. Li, S. Wang, Q. Zhang, F. Liu, T. Liu, L. Cao, S. Yu, and F. Chen. Revealing multimodal causality with large language models. In The Thirty-ninth Annual Conference on Neural Information Processing Systems, 2025b. (Cited on pages 21 and 23)arxiv.org/abs/2509.17784
- [46]W. Liang, Y. Zhang, H. Cao, B. Wang, D. Y. Ding, X. Yang, K. Vodrahalli, S. He, D. S. Smith, Y. Yin, et al. Can large language models provide useful feedback on research papers? a large-scale empirical analysis. NEJM AI, 1(8):AIoa2400196, 2024. (Cited on page 20)
- [47]C. Liu, Y. Chen, T. Liu, M. Gong, J. Cheng, B. Han, and K. Zhang. Discovering and reasoning of causality in the hidden world with large language models, 2025. URL https://arxiv.org/abs/2402.03941. (Cited on page 2, 6, 21 and 23)






