# Structured Scaling of AI Discovery Across Diverse Scientific Domains > SimpleTES uses one open-source model to achieve state-of-the-art results across 28 scientific problems by structuring evaluation-driven search through parallel trajectories, iterative refinement, and selective history reuse. - **Source:** [arXiv](https://arxiv.org/abs/2604.19341) - **Published:** 2026-08-17 - **Permalink:** https://picx.dev/p/twKveT - **Whiteboard:** https://picx.dev/p/twKveT/image ## Summary # Structured Scaling of AI Discovery Across Diverse Scientific Domains ## Summary (Overview) - **SimpleTES (Simple Test-time Evaluation-driven Scaling)** is a framework that structures AI-driven scientific discovery loops through a compact design tuple $(C, L, K, \Phi)$, where $C$ is the global width (parallel trajectories), $L$ is the refinement depth, $K$ is the local sample size, and $\Phi$ is the proposal constructor that selectively reuses evaluated histories. - Using a **single open-source GPT-OSS model**, SimpleTES achieves **state-of-the-art results across 28 open-ended problems** in quantum physics, astronomy, biology, AI, and mathematics—surpassing systems that use larger proprietary models. - Key breakthroughs include a **24.5% reduction in quantum circuit compilation overhead**, up to **23% lower propulsive cost for deep-space trajectories**, a **2.17× 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. - The paper introduces **trajectory-level post-training**, which credits each attempt by the final outcome of its trajectory rather than its immediate score, improving performance on both training and held-out mathematics problems. - SimpleTES 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. ## Introduction and Theoretical Foundation ### Background and Motivation Scientific discovery fundamentally requires **many cycles of proposing, testing, and refining** candidate solutions. While language models can increasingly participate in these loops, the central challenge is not merely scaling AI-driven discovery but **structuring that scaling so that evaluation signals compound over time**. Parallel searches may duplicate one another, and iterative refinement may become trapped in poor directions. The paper draws an analogy to human research communities, which advance science collectively through: - **Local refinement**: individual researchers test a few variants and carry forward the best - **Selective learning**: researchers selectively learn from prior results based on relevance and performance - **Collective building**: researchers build on one another's ideas - **Parallel competition**: multiple lines of inquiry develop and compete ### Theoretical Foundation: Evaluation-Driven Scaling The authors distinguish evaluation-driven scaling from: - **Standard model scaling**: scaling parameters and training data - **Classical test-time scaling**: scaling through longer reasoning traces or additional agent turns Evaluation-driven scaling targets **open-ended problems that fundamentally require exploration**, where a larger number of loops does not automatically imply better results. ### Problem Formulation Formally, a problem is specified by an instruction $x$, and the goal is to find a solution $y$ that maximizes a score $r$ output by an evaluator $V$. An LLM $G$ plays the role of a researcher, drawing candidates $y \sim G(\Phi)$ from a proposal built from the instruction plus accumulated history of previously evaluated solutions. ## Methodology ### The SimpleTES Design Tuple SimpleTES organizes the discovery loop through the compact design tuple: $$(C, L, K, \Phi) \tag{1}$$ where: - **$C$** = number of parallel trajectories (global width) — counters the tendency of single deep trajectories to become trapped in narrow basins - **$L$** = refinement steps per trajectory — lets feedback accumulate so later attempts build on earlier ones - **$K$** = candidates drawn per step (local sample size) — addresses noise in LLM output by committing only the highest-scoring candidate - **$\Phi$** = proposal constructor — selects which parts of evaluated history to reuse via a graph-based PUCT rule, favoring attempts that scored well or led to strong later attempts The total evaluator-query budget is $N = C \times L \times K$. ### Proposal Constructor Φ Because each trajectory's history becomes too long and noisy to feed back in full, Φ: - Selects attempts through a **graph-based PUCT rule** (favoring high-scoring attempts while allowing promising rarely-used ones to be revisited) - Folds in a **running summary of recurring failures** (compilation errors, verifier failures, timeouts) to steer the model away from unproductive directions ### Post-Training for Long-Horizon Discovery The model is post-trained on its own successful trajectories, crediting each attempt by the trajectory's final outcome rather than its immediate score: $$\mathcal{L} = -\mathbb{E}_{(x, \hat{y}, w) \sim \mathcal{D}}\left[w \cdot \sum_{i=1}^{|\hat{y}|} \log \pi_\theta(\hat{y}_i \mid x, \hat{y}_{