Structured Scaling of AI Discovery Across Diverse Scientific Domains — part 1/12
Cleaned-text code points [0, 15628). Bibliography omitted here; source.md includes it.
Structured Scaling of AI Discovery Across Diverse Scientific Domains
Wizard Intelligence Learning Lab, Stanford University Peking University, Tsinghua University The Hong Kong University of Science and Technology (Guangzhou)
Homepage
Abstract
Scientific discovery often requires many cycles of proposing, testing, and refining candidate solutions. Language models can increasingly participate in these loops, but simply generating more attempts does not ensure progress: parallel searches may duplicate one another and iterative refinement may become trapped in poor directions. The central challenge is therefore not only to scale AI-driven discovery, but to structure that scaling so that evaluation signals compound over time. Here we introduce SimpleTES ( Simple T est-time E valuation-driven S caling), a framework that focuses on the structured scaling of AI discovery loops, organizing evaluator queries across independent trajectories, iterative refinement, local candidate selection, and the selective reuse of evaluated histories. Drawing on structural features of scientific communities, SimpleTES uses a single open-source GPT-OSS model to establish new state-of-the-art solutions across 28 open-ended problems in diverse scientific domains ranging from quantum physics and astronomy to biology, AI, and mathematics. These include a 24.5% reduction in quantum circuit compilation overhead, up to 23% lower propulsive cost for deep-space trajectories, a 2.17 × 2.17\times faster lasso-path solver, an 8.5% lower-error whole-brain neural-activity predictor, the fastest reported TriMul kernel, and new mathematical constructions beyond prior human or AI records. We further post-train the model for long-horizon discovery by assigning each attempt the final outcome of the trajectory it helped produce. This improves performance on both training and held-out mathematics problems, further advancing the frontier. Together, these results establish structured scaling as a general mechanism for advancing AI scientific discovery.
Contents
### Introduction
Over the past decade, the role of AI in scientific discovery has changed significantly. Early successes in AI for science came largely from specialized models that served as predictors or optimizers for well-defined scientific objects, such as protein structures, quantum wavefunctions, or molecular potentials [ 65 , 21 , 107 , 151 , 169 ] . More recently, language models have been treated as researchers, generating candidate solutions, writing and revising the programs that implement them, and carrying a line of inquiry across many steps in response to evaluator feedback [ 17 , 48 , 85 , 100 ] . For instance, recent systems build the loop around evolutionary search procedures, as exemplified by AlphaEvolve and related approaches [ 100 , 114 , 6 , 73 ] , or around tree search [ 9 ] , while other works adapt the model through test-time reinforcement learning on a single problem [ 155 , 165 ] . Despite differences in domains, models, and search heuristics, these systems share a common building block: the propose-evaluate-refine discovery loop that drives new discovery results [ 114 , 43 , 123 , 165 ] .
More broadly, the human research community advances science collectively by scaling this loop in a complex, decentralized manner: researchers around the world pursue candidate solutions in parallel, driven by different inspirations, test them against the current baselines, and use the resulting feedback to shape the next attempts [ 74 ] . With LLMs taking the role of individual researchers in the loop, the entire scaling can be designed completely differently: an organized, structured way to drive scientific breakthroughs more efficiently and effectively. We name this new scaling dimension evaluation-driven scaling , because it is primarily driven by evaluation signals from empirical measurements, simulations, formal checks, or performance profiles, which later on become inspirations of next proposals. Different from standard model scaling that scales up parameters and training data [ 67 , 56 ] , or classical test-time scaling that scales through longer reasoning traces or additional agent turns [ 129 , 158 , 96 , 174 , 83 , 69 ] , evaluation-driven scaling targets challenging, open-ended problems that fundamentally require explorations, and a larger number of loops does not automatically imply better results. While showing promise in making discoveries, existing systems leave unexamined how the loop itself should be organized in a structured way. This leads to a central question: How can AI-driven discovery loops be scaled in a structured way to accelerate scientific breakthroughs?
This paper introduces SimpleTES ( Simple T est-time E valuation-driven S caling), a framework for scaling AI-driven discovery by structuring how evaluator queries are allocated and how evaluated histories are grown, filtered, and reused. The central challenge is to determine how early attempts and their evaluation signals should guide later proposals, and which search structures allow progress to compound on open-ended problems. SimpleTES draws on structural features of scientific communities: locally, individual researchers test a few variants and carry forward the best; over time, researchers selectively learn from prior results based on relevance, performance, and reputation; collectively, researchers build on one another’s ideas to refine and propose new solutions; and in parallel, multiple lines of inquiry develop and compete. SimpleTES operationalizes these features through a compact and structured design tuple ( C , L , K , Φ ) (C,L,K,\Phi) . Global width C C maintains independent trajectories, refinement depth L L lets feedback accumulate within each trajectory, local sample size K K filters candidate variants before they shape future refinement, and the proposal constructor Φ \Phi selects and compresses useful prior solutions, failures, and feedback into the next prompt. This reframes discovery-loop scaling as a problem of managing evaluated histories, so that additional evaluations compound into stronger trajectories rather than merely producing more attempts. The key distinction between SimpleTES and existing AI discovery systems such as AlphaEvolve lies in the focus. Existing systems typically seek to maximize discovery performance through customized agentic search procedures. SimpleTES instead asks how the discovery loop itself should be organized and scaled. By isolating this structure, SimpleTES becomes a simple, structured, and highly parallelizable system that scales efficiently to tens of thousands of evaluator queries, yielding better results using smaller open-source models compared to prior systems that used larger proprietary LLMs. A comprehensive comparison can be found in Supplementary B.1 .
We apply SimpleTES on 28 open-ended problems across diverse scientific domains, spanning quantum circuit compilations, astrodynamics trajectory designs, GPU kernel implementation, LLM scaling law designs, biological and time-series algorithms optimization, and mathematical constructions. On all problems, SimpleTES discovers the state-of-the-art solutions using a single open-source GPT-OSS model, surpasses both human experts and other AI discovery systems that use an order of magnitude larger proprietary models. To illustrate, SimpleTES improves the best-known bound for the Erdős minimum-overlap problem, open in extremal combinatorics since 1955, ahead of every prior human and machine record [ 100 ] . It discovers quantum compilation policies that reduce expensive qubit-swap gates by over 20% relative to the widely used LightSABRE baseline [ 176 ] . It improves the fuel efficiency of Solar System exploration mission trajectories, reducing propulsive costs by up to 23% relative to references constructed from historical encounter sequences under the same orbital-dynamics evaluator [ 148 , 121 ] . It implements the fastest TriMul kernel, the triangle multiplicative update central to AlphaFold3 [ 66 , 1 ] , and a lasso path solver 2.17 × 2.17\times faster than the widely used glmnet [ 39 ] . In neuroscience, it also discovers a state-of-the-art whole-brain neural-activity predictor, reducing error by 8.5 % 8.5\% on the long-horizon time-series forecasting task in ZAPBench [ 88 ] relative to the proprietary-model-driven algorithm discovery result [ 9 ] . More than any single record, what matters is that one unchanged procedure produces all of them, from abstract mathematical constructions to executable scientific programs, showing that SimpleTES can serve as a general mechanism for discovery.
The above results come from the fixed, off-the-shelf GPT-OSS model, which is not specifically optimized for the long-horizon discovery that SimpleTES performs: standard post-training tends to reward outputs that score well immediately, whereas discovery often turns on unconventional attempts that score poorly on their own yet lead to much stronger solutions. This raises a natural question: how can the LLM itself be deliberately trained for long-horizon discovery? We address this by post-training the model on its own successful trajectories, crediting each attempt by the final outcome of its trajectory rather than its immediate score. The improved model then drives the same search, now less myopic and more willing to build on early failures in pursuit of a stronger eventual solution. We study training primarily in mathematics, across a range of related open-ended problems. Post-training improves the entire outcome distribution, raising both the average score across independent trajectories and the best score on problems where the off-the-shelf GPT-OSS model scores poorly, and it transfers to held-out mathematical problems. These results suggest the trained model learns to search for strong eventual solutions rather than optimizing for immediate scores.
In summary, SimpleTES takes the scaling of the loop as its object of study, and asks how a fixed budget of evaluator queries should be structured. By formalizing this structured scaling with the design tuple ( C , L , K , Φ ) (C,L,K,\Phi) , SimpleTES shows superior performance using the open-source model, surpassing existing systems that uses larger proprietary models. SimpleTES uses a single configuration to handle all five domains and discover 28 SOTA results, with only the evaluator changing between problems. A summary of SimpleTES result with the open-sourced model can be found in Table 1 .
### Overview of SimpleTES
SimpleTES is a test-time framework for scientific discovery on problems that have a verifiable evaluation protocol , which we call an evaluator . An evaluator is the system’s interface to the scientific objective: given a candidate solution, it returns a numerical score together with auxiliary feedback such as verifier messages, error traces, or runtime statistics. Depending on the task, it may compute the objective exactly (an exact verifier), estimate it empirically (a measurement), or approximate it (a heuristic proxy). The objective is to find the highest-scoring candidate under the evaluator.
Formally, a problem is specified by an instruction x 0 x_{0} , and the goal is a solution y y that maximizes the score r r output by an evaluator V V . To search for such a solution, an LLM G G plays the role of a researcher, drawing candidates y ∼ G ( x ) y\sim G(x) from a proposal x x built from the instruction x 0 x_{0} together with the accumulated history of previously evaluated solutions, their scores, and the evaluator’s feedback. SimpleTES runs this as a propose–evaluate–refine loop: G G proposes a candidate, V V evaluates it, and its score and feedback are folded into the history that shapes the next proposal.
SimpleTES organizes this loop through a compact design tuple ( C , L , K , Φ ) , \displaystyle(C,L,K,\Phi), (1) where C C is the number of parallel trajectories, L L the number of refinement steps per trajectory, K K the number of candidates drawn per step, and Φ \Phi the proposal constructor that assembles each new proposal from a trajectory’s history. SimpleTES launches C C independent trajectories and advances each for L L refinement steps. At each step, Φ \Phi builds a proposal x x from the history so far, G G draws K K candidate solutions from x x , V V scores them, and the highest-scoring one is appended to the trajectory. Once every trajectory has completed, SimpleTES returns the best solution across all of them, having spent N = C × L × K N=C\times L\times K evaluator queries.
This decomposition is what gives SimpleTES its structure: each of the three dimensions targets a distinct, independent way an undirected search fails, so together they form a small and non-redundant set of controls on the search, which we analyse and ablate in the Methods. Refinement depth L L lets feedback accumulate, so later attempts build on earlier ones, but a single deep trajectory is not enough, since once early attempts bias the search toward a narrow direction, further refinement tends to reinforce that basin rather than escape it. Global width C C counters this by running independent trajectories in parallel, so competing directions mature without influencing one another early on. Local sample size K K addresses noise in the LLM’s output: drawing several candidates at each step and committing only the highest-scoring one keeps a weak or non-executable candidate from corrupting every later refinement built on it. Because the three act on different failure modes, they can be adjusted independently, and the budget N N has a clear meaning as the way that scaling is allocated.
In practice, the allocation of the evaluator-query budget across C C , L L , and K K depends on the task. Problems whose progress depends on discovering qualitatively different approaches, such as mathematical construction problems, benefit from larger C C , whereas problems dominated by incremental engineering refinement, such as GPU kernel optimization, benefit from larger L L . The local sample size K K should remain moderate: increasing it makes each committed step more reliable, but leaves fewer refinement steps under the same budget. Unless otherwise stated, we use C = 32 C=32 , L = 100 L=100 , and K = 16 K=16 as a default configuration.
While C C , L L , and K K govern how evaluated histories grow, the proposal constructor Φ \Phi governs which parts of that history are reused, since a trajectory’s history soon becomes too long and noisy to feed back in full. Because each proposal can build on several prior attempts rather than only the last, the history forms a directed graph rather than a chain. Φ \Phi selects which attempts to reuse through a graph-based variant of the PUCT rule [ 115 , 127 , 126 ] , favoring attempts that scored well or led to strong later attempts, while still giving promising but rarely used ones a chance to be revisited. It also folds in a running summary of recurring failures, such as compilation errors, verifier failures, or timeouts, to steer G G away from unproductive directions. In Methods, a Pólya-urn analysis together with ablations on C C , L L , and K K shows why these dimensions form a compact design space for scaling the loop, and Φ \Phi ’s construction and selection strategy are specified and ablated in full. We next turn to the discoveries SimpleTES makes across scientific domains, and then to how a language model can be trained for SimpleTES -based discovery.
### SimpleTES discovers effective algorithms to reduce quantum compilation overhead