💻 computer science

Structured Scaling of AI Discovery Across Diverse Scientific Domains

The paper introduces SIMPLETES, a framework that structures AI-driven scientific discovery by organizing evaluation signals across iterative trajectories and selectively reusing histories, enabling a single open-source model to achieve state-of-the-art results across 28 diverse scientific domains and further improve through outcome-based post-training.

Original authors: James Zou

Published 2026-08-28

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: James Zou

Original paper licensed under CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Science has long relied on a cycle of trial and error. A researcher proposes an idea, tests it against the laws of nature or the constraints of a problem, and then uses the result to refine the next attempt. For decades, artificial intelligence has joined this loop, but often as a specialized tool that predicts outcomes or optimizes known variables. Recently, language models have begun to act more like researchers themselves, generating candidate solutions, writing the code to test them, and revising their work based on feedback. However, simply asking a computer to try more ideas does not guarantee better discoveries. If a system generates thousands of attempts without a clear structure, many will be duplicates, or the process may get stuck refining a dead end. The central challenge is not just to scale up the number of attempts, but to organize that scaling so that every test builds on the last, allowing progress to compound over time.

A researcher has introduced a new framework called SIMPLETES to solve this problem. Rather than relying on a single, massive artificial intelligence model or complex, custom-built search engines, they focused on how to structure the search process itself. They treated the discovery loop like a scientific community: running many independent lines of inquiry in parallel, letting each line refine its best ideas over time, and carefully selecting which failures and successes to share with the next round of attempts. Using a single, open-source language model, this system tackled twenty-eight different open-ended problems across fields as diverse as quantum physics, deep-space travel, and pure mathematics. In every case, the system found solutions that were better than the best known results from human experts or other advanced AI systems, often using significantly less computing power.

The researcher demonstrated that the way a search is organized matters more than the size of the model running it. They tested their framework on tasks ranging from designing fuel-efficient trajectories for spacecraft to optimizing the code that runs on the fastest computer chips. In the realm of space travel, the system redesigned flight paths for missions to Jupiter and other planets, finding routes that reduced fuel costs by up to twenty-three percent compared to historical records. In quantum computing, it discovered new ways to arrange data on chips, cutting down the extra operations needed to move information by nearly twenty-five percent. It also wrote new computer code for mathematical problems that had remained unsolved for decades, including a problem about overlapping sets that had been open since 1955. The system found a solution that improved the best-known record, and it did so without any human intervention or specialized training for those specific tasks.

One of the most significant findings was that the system could learn from its own search process to become even better. The researcher took the successful paths the system had discovered and used them to train the language model further. Instead of rewarding the model for getting a good score on a single attempt, they taught it to value the final outcome of an entire search journey. This allowed the model to learn that a seemingly poor early attempt might be a necessary step toward a breakthrough later on. When tested on new mathematical problems, this trained model found solutions that were even more advanced than the original system, pushing the boundaries of what was previously thought possible.

The success of this approach suggests that the organization of the search is a powerful tool in its own right. By structuring the evaluation process to encourage diverse exploration and iterative refinement, the researcher showed that a single, relatively modest open-source model could outperform systems built with much larger, proprietary models. The framework did not just find one good answer; it established a general method for discovery that works across vastly different scientific domains. From designing better algorithms for analyzing brain activity to creating faster software for artificial intelligence, the system proved that a structured, evaluation-driven approach can accelerate scientific progress. The results indicate that the future of AI-driven discovery may depend less on building bigger brains and more on designing smarter ways for those brains to explore the unknown.

Technical Summary: Structured Scaling of AI Discovery Across Diverse Scientific Domains

Problem Statement

Scientific discovery often requires iterative cycles of proposing, testing, and refining candidate solutions. While Large Language Models (LLMs) can participate in these loops, simply scaling the number of attempts (e.g., through longer reasoning traces or more parallel sampling) does not guarantee progress. Parallel searches may duplicate efforts, and iterative refinement can become trapped in suboptimal directions. The central challenge identified by the author is not merely to scale AI-driven discovery, but to structure that scaling so that evaluation signals compound over time. The paper asks: How can AI-driven discovery loops be scaled in a structured way to accelerate scientific breakthroughs?

Methodology: SIMPLETES

The author introduces SIMPLETES (Simple Test-time Evaluation-driven Scaling), a framework designed to organize the allocation of evaluator queries and the reuse of evaluated histories. Unlike systems that rely on complex agentic coordination or multi-model ensembles, SIMPLETES isolates the structure of the discovery loop itself.

Core Design Tuple $(C, L, K, \Phi)$

SIMPLETES organizes the search process through four key dimensions:

Global Width ( $C$ ): Runs $C$ independent trajectories in parallel. This prevents the "lock-in" effect where early choices bias a single deep trajectory, allowing diverse lines of inquiry to mature without influencing one another prematurely.
Refinement Depth ( $L$ ): Each trajectory advances through $L$ refinement steps. Feedback accumulates within a trajectory, allowing later attempts to build on earlier ones.
Local Sample Size ( $K$ ): At each step, the model generates $K$ candidate solutions. Only the highest-scoring candidate is committed to the trajectory history. This mitigates the noise inherent in LLM outputs, preventing weak or non-executable candidates from corrupting subsequent refinements.
Proposal Constructor ( $\Phi$ ): A mechanism that selects and compresses useful prior solutions, failures, and feedback into the next prompt. $\Phi$ uses a graph-based variant of the PUCT rule to select historical nodes that scored well or led to strong descendants, while also summarizing recurring failures (e.g., compilation errors) to steer the model away from unproductive directions.

The total budget of evaluator queries is $N = C \times L \times K$ . The framework treats the allocation of this budget as the primary lever for scaling, rather than increasing model parameters or training data.

Trajectory-Level Post-Training

To address the limitation of standard post-training (which rewards immediate scores and may discourage exploratory "failures" that lead to breakthroughs), the author proposes trajectory-level post-training.

Credit Assignment: Instead of rewarding individual steps based on their immediate score, the model is trained on the final outcome of the entire trajectory.
Mechanism: Trajectories that achieve a score in the top $R\%$ are assigned a weight of $w=1$ , while others are $w=0$ . The model is fine-tuned to maximize the likelihood of generating the reasoning and solutions that led to these high-scoring final outcomes.
Goal: This trains the model to optimize for long-horizon breakthroughs rather than myopic, immediate gains, effectively learning to "search for strong eventual solutions."

Key Contributions and Results

The author applied SIMPLETES to 28 open-ended discovery problems across five diverse scientific domains using a single, fixed, open-source model (gpt-oss-120b). The framework achieved State-of-the-Art (SOTA) results in all domains, often surpassing systems that use proprietary models an order of magnitude larger.

1. Quantum Circuit Compilation

Task: Optimizing qubit routing for superconducting and zoned neutral-atom devices to minimize overhead (SWAP gates) and execution time.
Results:
- Superconducting: Reduced added SWAP overhead by 21.7% vs. SABRE and 14.9% vs. LightSABRE on average. On specific benchmarks (Q20), reductions reached 24.5%.
- Neutral-Atom: Reduced total execution time by 33.2% (geometric mean) compared to ZAC-style baselines.

2. Astrodynamics Trajectory Design

Task: Designing fuel-efficient deep-space trajectories using gravity assists and deep-space maneuvers (DSMs).
Results: Evolved optimizers reduced propulsive costs by 2.1% to 23.1% across five historical mission windows (Mariner 10, Voyager 2, Galileo, Cassini, Rosetta) compared to references constructed from historical encounter sequences.
Discovery: Synthesized a feasible Earth–Venus–Earth–Earth–Jupiter trajectory for a 2028–2030 launch window with no intermediate DSMs.

3. Scientific Algorithms

Lasso Path Solver: Discovered a geometry-aware solver that is 2.17× faster than the expert-engineered glmnet and 14.08× faster than sklearn on real-world datasets, while maintaining strict correctness guarantees. The solver dynamically switches between LARS homotopy and coordinate descent based on problem geometry.
Whole-Brain Neural Activity: Discovered a forecaster for ZAPBench (zebrafish neural activity) that reduced Mean Absolute Error (MAE) by 8.5% at a 32-step horizon compared to the previous SOTA (ERA), outperforming both proprietary-model-driven results and volumetric U-Net baselines.
Single-Cell RNA-seq Denoising: Achieved a denoising score of 0.74 on the held-out Tabula Muris Senis Lung dataset, surpassing TTT-Discover (0.73).

4. AI Foundations

GPU Kernel Optimization: Discovered the fastest reported TriMul kernel (central to AlphaFold3) with a latency of 1.122 ms on H100, surpassing expert Triton submissions (1.140 ms) and AI baselines. The implementation generalized across A100, H100, and MI300 without re-tuning.
Scaling Law Discovery: On the SLDBench, SIMPLETES achieved the highest average extrapolation $R^2$ (0.674), outperforming SLDAgent with GPT-5 (0.572). It notably succeeded on difficult extrapolation tasks (e.g., U-shape scaling) where other agents failed (negative $R^2$ ).

5. Mathematical Discovery

Results: Established new SOTA bounds on four classical problems:
- Erdős Minimum-Overlap: Improved bound from 0.380871 to 0.380868.
- Second Autocorrelation Inequality: Improved bound from 0.961206 to 0.962694.
- Third Autocorrelation Inequality: Improved bound from 1.454555 to 1.453675.
- Sum–Difference Problem: Improved ratio from 1.121936 to 1.143975.
Post-Training Impact: With trajectory-level post-training, the model reached a new SOTA of 1.144887 on the held-out Sum–Difference problem, a solution the untrained search could not find under the same budget.

Significance and Claims

The paper posits that structured scaling is a general mechanism for advancing AI scientific discovery. The author claims:

Structure over Complexity: A single, open-source model with a structured evaluation loop can match or surpass systems built on much larger proprietary models and complex agentic machinery. The organization of the evaluation loop itself is a primary source of capability.
Evaluation-Driven Scaling: The key to progress is not just more compute, but how evaluator queries are distributed (across width, depth, and local selection) and how feedback is reused.
Long-Horizon Learning: Post-training on trajectory-level outcomes, rather than immediate rewards, allows models to learn the "topology" of discovery, enabling them to pursue unconventional paths that lead to breakthroughs.
Generality: The same fixed procedure and configuration successfully handled problems ranging from exact mathematical verification and physical simulation to empirical hardware timing and biological prediction, demonstrating the framework's versatility.

The author emphasizes that these results were achieved without multi-agent coordination, model ensembles, or online parameter updates during the search (except for the specific post-training phase), highlighting the power of the structured loop itself. They acknowledge limitations regarding evaluator fidelity (reward hacking) and the need for cheap, automated feedback, but argue that the framework provides a scalable path for discovery in domains where such evaluators exist.