<think>Planning faithful markdown translation</think>

AI Begins Using Search to Discover Physical Laws

ScienceDiscovery recently demonstrated a recursive scientific reasoning system driven by tree search: without training a new model or fine-tuning parameters, it can generate general-purpose integrators for physics problems within hours simply by searching through candidate reasoning paths and using execution feedback.

This is worth paying attention to not because a large model has written another piece of code, but because it pushes the task of “finding patterns in observational data” further—from prompt engineering toward program search and verifiable reasoning.

In the past, the typical way models handled scientific tasks was to read papers, summarize formulas, and write computational code according to the user’s requirements. ScienceDiscovery attempts to go further: given a set of physical systems, observational trajectories, or phenomena to be explained, it must propose candidate structures on its own, choose the next search direction, turn intermediate results into executable programs, and then use numerical experiments to check whether the results hold.

In other words, it does not ask the model to guess an answer in one shot. Instead, it asks the model to repeatedly trial and error within an ever-expanding “scientific hypothesis tree.”

No Model Training—Just Longer Reasoning Through Search

The aspect of ScienceDiscovery most likely to be misunderstood is that “recursive scientific reasoning” sounds like it involves training another specialized scientific model. Based on the information disclosed so far, however, its core does not lie in an additional round of pretraining, reinforcement learning, or parameter tuning. Instead, it places an existing large model within a more rigorous search framework.

The basic approach can be broken down into four steps:

1. Propose candidate hypotheses: Based on the problem description, existing variables, and previous search results, the model generates possible mathematical structures, physical relationships, or programmatic expressions.
2. Expand the reasoning tree: A candidate hypothesis is further decomposed into multiple subproblems, such as selecting state variables, determining conserved quantities, attempting coordinate transformations, or choosing a numerical approximation method.
3. Execute and verify: Intermediate results are converted into code and run in a sandbox, then scored using metrics such as numerical error, stability, and generalization.
4. Backtrack and continue searching: Failed paths are marked, better-performing nodes receive more computational budget, and the system continues expanding new combinations from those nodes.

This is fundamentally different from simply asking a model to “think for a few more steps.” Ordinary extended reasoning is often a linear chain: the model writes A, then B, and then C. Tree search allows it to retain multiple routes—A, B, and C—at the same time, then return to a branching point and choose again after receiving experimental feedback.

The analogy to Go is more intuitive: the model is not thinking only about the next move, but maintaining a tree of possible game states. Each path must compete for resources based on simulation results; weaker branches are gradually eliminated, while more promising ones receive additional opportunities for expansion. In ScienceDiscovery, however, the board is replaced by variables, formulas, programs, and experimental results.

Why “Recursive” Reasoning Matters for Scientific Discovery

Scientific laws are usually not isolated formulas, but sets of nested hypotheses.

Take a dynamics problem as an example. The system may first need to determine which variables describe the state of the observed object; whether those variables satisfy certain symmetries; whether the equations have conserved quantities; whether the model uses continuous or discrete time; and only then how to construct a stable, generalizable integrator.

If any judgment at one level is wrong, all subsequent derivations may be built on sand.

Traditional large-model generation usually jumps directly from the problem to the final answer, creating two common problems. First, a formula may appear reasonable on the surface but fail to satisfy basic physical constraints. Second, code may work on one test case but collapse when given a different set of initial conditions. Models are very good at “completing something that looks like an answer,” but scientific discovery requires structures that continue to hold under different conditions.

The significance of recursive search is that it can break a large problem down into multiple intermediate goals that can be tested. For example:

• First verify whether a candidate variable is sufficient to describe the system state;
• Then check whether the equation preserves known symmetries or conservation relationships;
• Next test whether a candidate discretization method remains stable at different step sizes;
• Finally evaluate whether it can transfer to systems that did not appear in the search samples.

The model no longer needs only to answer “What is this formula?” It must continually answer “Why follow this path?”, “Can this intermediate conclusion be verified by a program?”, and “If it fails, which hypothesis should we return to?”

Generating a General-Purpose Integrator Within Hours: Where the Real Difficulty Lies

“Writing a general-purpose integrator within hours” sounds like automated code generation, but an integrator itself is not merely a simple function wrapper.

In physical simulation, an integrator uses the current state and dynamical equations to infer the system’s state at the next point in time. The most basic Euler method is simple to implement but can produce significant numerical error. Higher-order Runge–Kutta methods offer greater accuracy, but their computational costs and applicable conditions also differ. For Hamiltonian systems, stiff systems, or long-term evolution problems, an algorithm must also preserve structures such as energy and momentum as much as possible; otherwise, the longer the simulation runs, the further the result may drift from the true trajectory.

A genuinely valuable “general-purpose integrator” cannot merely fit trajectories on a single dataset. It must face at least several challenges:

• Changes in initial conditions: Does the algorithm remain effective when given different positions, velocities, or energies?
• Changes in time scales: Accurate short-term prediction does not imply stable long-term evolution;
• Changes in system structure: Can it extend from simple pendulums and planetary orbits to more complex dynamical systems?
• The trade-off between error and stability: Does the result diverge rapidly when the step size increases?
• Interpretability: Can the generated structure be mapped to clear physical quantities and constraints?

The key to ScienceDiscovery is not having the model invent a seemingly sophisticated integration algorithm out of thin air. It is the formation of a closed loop in which algorithms are generated, executed, evaluated, and corrected. The model proposes candidate programs, the programs return actual errors, and the searcher then decides which structures are worth retaining.

This is also what distinguishes it from an ordinary coding agent. A coding agent primarily optimizes for “whether the code passes the tests.” A scientific discovery system must also ask “Why did it pass?”, “Does it capture a pattern that transfers across scenarios?”, and “Does it satisfy the prior constraints of the field?”

How Tree Search Controls Large-Model Rambling

Tree search does not automatically eliminate hallucinations in large models, but it changes the cost structure of errors.

In one-shot generation, after the model generates an incorrect formula, that erroneous path may continue to be treated as correct unless the user actively points out the problem. Tree search, by contrast, treats each intermediate result as a scorable node. As long as a candidate program can be executed, the system can use objective feedback to weaken incorrect branches.

For scientific tasks, the reward function does not necessarily need to come from human annotations. It can also be a combination of multiple computable metrics, such as:

• The error between predicted trajectories and observational data;
• Stability under different initial conditions;
• The degree of drift in energy or other conserved quantities;
• Whether the code can execute successfully in a sandbox;
• Formula complexity and the number of parameters;
• Whether performance is maintained on previously unseen test systems.

This type of feedback is like equipping the model with “laboratory instruments.” The large model proposes possible explanations, while the execution environment tells it whether the results actually hold.

The influence of Monte Carlo Tree Search (MCTS) can also be seen here. MCTS typically balances “exploration” and “exploitation”: on the one hand, it continues trying untested paths; on the other, it allocates more computational resources to branches that have already performed well. Applied to scientific reasoning, this means the system must neither repeatedly reproduce the current best formula nor endlessly try completely random hypotheses.

That said, ScienceDiscovery’s value does not necessarily lie in mechanically reproducing game-oriented MCTS. Search nodes in scientific problems are usually not discrete actions; they may instead be combinations of variable selection, symbolic transformations, program fragments, and experimental setups. It is more like combining language models, program synthesis, numerical experiments, and heuristic tree search into a search system designed for scientific problems.

It Is Not the Same as “Letting the Model Think for a While Longer”

Over the past two years, search-based reasoning has gradually become an important direction for improving the ability of large models to handle complex tasks. Mathematical theorem proving, code repair, and robot planning have all experimented with generating multiple candidate paths and then using verifiers to select more reliable answers.

Scientific discovery, however, has an additional challenge: correctness often cannot be determined from a simple final answer.

Mathematical problems usually have a clear result, and coding problems can be evaluated using a test set. Scientific laws, by contrast, must satisfy data fitting, theoretical constraints, and generalization across conditions at the same time. Even if a formula explains the current data, it may merely be overfitting; even if a program has very low short-term error, it may become unstable during long-term simulation.

ScienceDiscovery is therefore closer to “searching for a program that can withstand experimental testing” than to “searching for text that looks more like a human answer.”

This also explains why it may not necessarily need to train a specialized process reward model. A process reward model can certainly evaluate the quality of each reasoning step, but it is expensive to train, difficult to transfer across domains, and intermediate steps in scientific problems often lack uniform labels. By contrast, directly invoking execution results, numerical error, and domain constraints, while imperfect, is closer to the actual validation methods used in scientific work.

Where the Cost Advantages Come From

If every scientific problem required training a new model, automated discovery would be extremely expensive: it would require datasets, reward design, training cycles, and extensive human filtering. ScienceDiscovery instead places more of the cost on inference-time search, allowing it to switch rapidly between problems with the help of a general-purpose model.

This approach has three advantages.

First, faster transfer. When facing a new physical system, there is no need to retrain the entire model. It is only necessary to change the problem description, tool library, verifier, and search budget.

Second, a traceable process. The system retains candidate hypotheses, execution results, and reasons for elimination, allowing researchers to see why it chose a particular structure rather than receiving only a final formula.

Third, reusable failures. Although a search branch may ultimately fail to produce a usable integrator, its variable transformations, numerical techniques, or failure conditions may still become prior knowledge for subsequent searches.

Of course, inference-time search is not free. The more branches the tree has, the more often the model and programs must be called and executed. Each simulation in scientific computing may also be far more expensive than an ordinary code test. The approach merely shifts costs from the training stage to the search stage. Whether that is worthwhile depends on verifier efficiency, search-pruning capabilities, and the inference price of the underlying model.

The Biggest Bottleneck Is Not the Model, but the Verifier

The most important point to be cautious about with this approach is clear: without a reliable verifier, tree search may simply search for incorrect answers in greater complexity.

If the scoring function considers only short-term trajectory error, the system may generate a highly overfitted expression. If it looks only at whether the code can run, the program may fail under boundary conditions. If it penalizes complexity too heavily, it may miss patterns that genuinely require the introduction of new variables or structures.

“Correctness” in scientific discovery is usually multi-layered:

1. Can it explain existing observations?
2. Can it make predictions on unseen data?
3. Does it satisfy known physical constraints?
4. Is its expression sufficiently simple and stable?
5. Can it be reproduced by other experiments or simulations?

Compressing these metrics into a single reward score is itself a scientific modeling task. No matter how advanced the search algorithm is, it cannot replace domain experts’ judgment about how a problem should be formulated and how its results should be verified.

In addition, a model may repeatedly exploit loopholes in the verifier during the search process. For example, it may discover a numerical trick that makes the test metrics look good without actually capturing the underlying physical law. This is similar to “gaming the tests” in software engineering: a program’s passing the tests does not mean that it implements the correct requirements.

Therefore, ScienceDiscovery is better understood as an automated discovery tool for researchers rather than an unattended “AI scientist.” It can substantially expand the hypothesis space and accelerate experimental iteration, but humans are still needed to confirm the physical meaning and experimental value of the discovered patterns.

What This Means for Developers

For developers, the insight offered by ScienceDiscovery may be more important than the result of a “general-purpose integrator within hours”: in the future, the competitive focus of scientific AI systems will shift from model capability alone to the combined capabilities of models, searchers, tools, and verifiers.

A deployable system will typically require the following layers:

• Foundation model: Understands the problem, proposes hypotheses, and generates formulas and code;
• Search controller: Manages tree nodes, branch expansion, pruning, backtracking, and budget allocation;
• Execution sandbox: Runs candidate code while isolating resources and potential risks;
• Scientific toolchain: Provides symbolic computation, automatic differentiation, numerical integration, data analysis, and visualization;
• Verifier: Scores results based on error, stability, conservation, and generalization;
• Result compression layer: Organizes extensive search trajectories into readable formulas, code, and experimental reports.

The searcher and verifier do not necessarily need to be large models. In many cases, deterministic numerical checks, symbolic simplification, and domain rules are more reliable. Large models are well suited to open-ended hypothesis generation, while programs and mathematical tools are better suited to precise verification.

This is a typical “models diverge, tools converge” architecture: the model expands the range of possibilities, while tools rapidly eliminate possibilities that do not hold.

For teams building AI agents, this also means that not every task should be stuffed into one extremely long prompt. A more reasonable approach is to break complex tasks into observable nodes, each with clear inputs, outputs, and evaluation criteria, and then use search or planning mechanisms to orchestrate them.

From Automatically Writing Code to Automatically Proposing Testable Laws

The significance of ScienceDiscovery ultimately does not lie in whether it has already replaced scientists, but in the fact that it has pushed the boundaries of AI’s participation in scientific research one step further.

The first stage of AI scientific tools focused mainly on retrieval and summarization: helping researchers find papers, organize variables, and explain concepts. The second stage involved code generation: writing simulation programs, data-processing scripts, and experimental pipelines based on formulas. Now, systems driven by tree search are beginning to participate in work further upstream—proposing multiple candidate laws and filtering them through programmatic experiments.

This represents a shift from “answering questions” to “organizing experiments.”

Of course, truly autonomous discovery of new physics remains a long way off. The public information currently indicates that the system can efficiently generate general-purpose integrators for specific tasks and verification environments. This does not mean that it has independently discovered a new law confirmed by the physics community. Hour-scale results also depend heavily on problem size, model-calling costs, tool libraries, and test design, and cannot simply be extrapolated to all scientific fields.

But the direction is already clear: when large models are no longer confined to one-shot text generation and are instead placed in an environment where they can execute, score, backtrack, and continue exploring, the boundaries of their capabilities change.

For scientific computing, what is truly worth anticipating is not whether a model can write down a formula, but whether it can find, among vast numbers of candidate structures, those programmatic laws that are simple, stable, reproducible, and continue to hold under new conditions. The tree-search approach adopted by ScienceDiscovery at least provides a low-training-cost, verification-oriented path toward that goal.

OpenAI Hub Observations

These systems also show that scientific reasoning does not necessarily depend on a single specialized model. A more realistic engineering solution may combine models according to different stages: using a powerful reasoning model to propose and decompose hypotheses, a model with stronger coding capabilities to generate executable programs, and local numerical tools and custom verifiers to complete the loop.

For developers, the model itself is merely an expansion operator for nodes in the search tree. What truly determines the system’s upper limit is often how you define the state, design the feedback, control the budget, and identify results that “appear effective but are actually exploiting the system.”

This is ScienceDiscovery’s most valuable signal: the next competition in AI-driven scientific discovery will not be merely a competition in parameter scale, but a competition over who can turn reasoning into an executable, verifiable, and reproducible search system.

References

• Zhihu: ReST-MCTS*: LLM Self-Training Through Process-Rewards-Guided Tree Search — Introduces methods combining tree search with large-model reasoning, and can help explain concepts such as process rewards, reasoning trajectories, and search expansion.
• Public reports: ScienceDiscovery Implements Tree-Search-Driven Recursive Scientific Reasoning — The primary basis for this article’s information about the ScienceDiscovery system, its generation of general-purpose integrators within hours, and its “no model training, no parameter tuning” approach. Due to restrictions on the linked domain, no inaccessible source link is included in the article.