Language-model agents can now turn a plain-English description of a partial differential equation (PDE) into a working numerical solver. The best of these systems reach very small errors on current benchmarks. They check a solver's quality in only three ways: whether the code runs, whether the final error or equation residual is small, and whether shrinking the time step removes a blow-up. None of these checks asks how the error falls as the time step shrinks, or whether the solver quietly drains energy from a system that should conserve it. A first-order scheme such as Forward Euler (each step moves the state along its current slope) can pass every one of these checks while running ten or a hundred times more steps than needed. On long runs it also damps and phase-shifts waves in ways that a short-horizon error score never shows.
We propose to make that hidden property measurable and to use it as feedback. A small suite of deterministic numerical probes computes a diagnostic report for every candidate solver. The report gives the temporal order of accuracy actually observed, the drift in the discrete energy against the physical energy law, and the amplitude and phase error on a single test wave. This report replaces "it runs and the residual is small" as the gate in a multi-agent loop. When the observed order is 1 or the energy law is violated, the agent that designs the scheme must propose a structural change to the time integrator rather than a smaller step. The claim to test is that this measured contract, and not the multi-agent structure by itself, is what moves agent-built solvers off the Forward-Euler default. We also ask whether a language model redesigning the scheme adds anything beyond a fixed, scripted ladder of library integrators.
Core Claim
Existing agent pipelines treat time discretization as a knob to turn down, not a design object to verify. We claim that giving a verifier agent a numerical measurement of temporal behavior, instead of an opinion, will reduce the cost of reaching a target accuracy and the long-horizon error of agent-built solvers. The gains should be largest on problems where first-order or off-the-shelf integrators are known to be wrong: conservative waves, phase-field energy decay, and stiff or degenerate diffusion. On short-horizon benchmarks, accuracy is already saturated, so we expect the gain to show up as fewer steps at matched accuracy rather than lower error.
The central measurement is a self-convergence estimate of temporal order that needs no exact solution. The probe runs the candidate solver on a fixed spatial grid with steps $\Delta t$, $\Delta t/2$ and $\Delta t/4$, and computes
$$ \hat p = \log_2 \frac{\lVert u_{\Delta t} - u_{\Delta t/2}\rVert}{\lVert u_{\Delta t/2} - u_{\Delta t/4}\rVert}, $$
where $u_{\Delta t}$ is the solution at the final time computed with step $\Delta t$. Holding the spatial grid fixed makes the spatial error cancel in the differences, so $\hat p$ isolates the time integrator. This estimate follows from the leading error term scaling as $C\Delta t^p$. For systems with an energy law, the probe also reports the discrete violation $\max_n \big(E(u^{n+1}) - E(u^n)\big)$ for dissipative problems, or the relative drift $|E(u^N) - E(u^0)|/E(u^0)$ for conservative ones. For advective problems, it reports amplitude and phase error of a single Fourier mode after many periods.
Relation to Prior Work
Three systems motivate this proposal by showing both how far agents have come and where their checks stop.
AutoNumerics is the closest work. It splits solver construction into roles: one agent formulates the equation, another plans candidate schemes, others extract features, select and code the solver, and a final agent explains it. It runs solvers first on a coarse grid and then a fine one, and checks them by relative error or residual. When a fine-grid run fails, it shrinks $\Delta t$ or restarts. It never measures temporal order, and its explanation agent reasons about stability after the fact without running any measurement. Our proposal keeps its role structure but changes what the checking role consumes and what the repair step is allowed to do.
PDE-Agent coordinates external scientific tools through an inner repair loop and an outer re-planning loop. It treats the time integrator as a fixed property of the tool, and its loops detect crashes, not silent dissipation.
CodePDE is a single-model generate–debug–refine pipeline. It supplies the key motivating observation: conservative models default to Forward or Implicit Euler, and frontier models that attempt higher-order schemes often fail on subtle stability or stiffness details.
The multi-agent literature supplies the method, and here we deliberately change one ingredient. In MACM, a Thinker proposes intermediate conditions, a Judge checks them, and an Executor computes. In Self-collaboration Code Generation via ChatGPT, a Tester catches bugs that the Coder cannot see in its own output. In both, the Judge or Tester is itself a language model or runs unit tests. We replace the Judge with measurement, because the file documents "nuance blindness" about stability boundaries in exactly this domain (CodePDE). A model is a poor judge of whether a scheme is second order, and a refinement study is a good one.
The numerical-analysis literature constrains which repairs count as correct. Energy-Controllable Time Integration for Elastodynamic Contact shows that Implicit Euler and BDF2 (a two-step backward difference method) dissipate energy uncontrollably. This is why "switch to an off-the-shelf stiff solver" is not always the right repair. Unconditionally energy stable IEQ-FEMs for the Cahn-Hilliard equation and Allen-Cahn equation shows that phase-field problems need a reformulation (invariant energy quadratization, which rewrites the energy with an auxiliary variable so each step provably lowers it) rather than a higher-order Runge–Kutta method. Numerical artifacts in the Generalized Porous Medium Equation documents locking, lagging and oscillation in degenerate diffusion under standard time stepping. These papers define the "known right answers" against which we grade agent repairs.
We deliberately leave out low-rank manifold integrators (A robust second-order low-rank BUG integrator based on the midpoint rule). Asking agents to synthesize them is premature before the simpler question is answered.
Research Program
The first deliverable is an audit, which is useful whether or not the rest works. We will run the probe suite on solvers produced by an AutoNumerics-style pipeline and by CodePDE on the time-dependent problems of their own benchmarks. We will report three things: the distribution of observed temporal order, how often the order the agent claims in its explanation matches the measured $\hat p$, and how many time steps each solver spends relative to the fewest steps needed for the same error. If most shipped solvers turn out to be first order and heavily over-stepped, that motivates everything else. If they are mostly second order or higher and efficient, the proposal's premise is weak and we say so.
The second deliverable is the probe suite as a standalone, deterministic tool. It has three parts. The order probe uses the fixed-grid self-convergence estimate above, and also a manufactured-solution version when a forcing term can be added. The invariant probe uses an energy functional that the formulating agent writes down and that we check symbolically on the continuous equation before trusting it. The wave probe measures single-mode amplitude and phase error. Each probe returns numbers plus a short templated diagnosis, for example "observed order 1.0; energy decreases 4% per unit time in a conservative system; phase lag 0.3 rad after 20 periods."
The third deliverable is the agent loop. It keeps the formulate–plan–code roles of prior pipelines and adds a Scheme Designer role that receives the probe report. This role may change the integrator family, the splitting order (for example Lie–Trotter to Strang), the treatment of stiff terms, or the energy formulation. Shrinking $\Delta t$ is allowed only when the probe reports that the order already matches the target and only the error constant is too large. The loop stops when the probe contract is met: observed order at least the target order, invariant within tolerance, and target error reached. We will run it with one frontier model and one open-weight model under 13B parameters, since Self-collaboration Code Generation via ChatGPT reports that role adherence breaks down in smaller models.
Baselines
The naive reference point is the "do nothing" pipeline. This is an AutoNumerics-style pipeline with its original residual-based checking and $\Delta t$-shrinking repair, reimplemented with the same model, the same prompts for the shared roles, and the same token and wall-clock budget. On the CodePDE benchmark, AutoNumerics reports a geometric-mean normalized root-mean-square error (nRMSE) of 9.00 × 10⁻⁹, against 5.08 × 10⁻³ for CodePDE and 9.52 × 10⁻³ for a Fourier Neural Operator. Because error is essentially saturated there, beating this baseline does not mean lower nRMSE. It means matching its accuracy within a factor of two while using fewer time steps and less solver wall time, and doing clearly better on the long-horizon suite. No reported result was found on Lacuna for step counts or solver runtime of AutoNumerics-generated solvers, so we will measure these ourselves on our reimplementation. We will also run the released system if it is available.
The strongest competitor is a scripted integrator ladder with no language-model redesign. This is the same pipeline, but on probe failure it escalates through a fixed sequence: Forward Euler, then a second-order Runge–Kutta method, then classical fourth-order Runge–Kutta, then SciPy's adaptive RK45 and BDF, with Strang splitting substituted wherever the code uses Lie–Trotter. The ladder receives the same probe reports and the same compute. It is the strongest competitor because it is exactly what a skeptical numerical analyst would build, and it isolates whether the language model's redesign adds anything beyond the measurement. The agent beats the ladder only if it wins on problems where no rung of the ladder is structurally correct: conservative waves and contact, phase-field energy decay, and degenerate diffusion.
Two ablations isolate the key ingredient. In the first, the same Scheme Designer role receives only the scalar final error, not the order and invariant report. This tests whether structured measurement matters, or merely having a dedicated design role. In the second, the Judge is a language model asked to assess order and energy behavior by reading the code, with no probes. This tests whether measurement beats model judgment, the substitution our design rests on. All variants get an equal number of repair rounds, and each is run with three seeds per problem.
Why not just…?
Why not just prompt the coder to "use a high-order, energy-stable time integrator"? This is cheap, and it is the first thing we will test, as a prompt-only variant with no probes. The evidence against it being sufficient is that frontier models in CodePDE did attempt higher-order schemes and failed on stability and stiffness details. A request for high order therefore does not guarantee that high order is delivered. The audit's comparison of claimed versus measured order will show directly how often a prompted high-order solver is actually high order.
Why not just run a convergence test script and skip the agents entirely? This is a real threat, and the scripted ladder baseline is exactly this. If the ladder matches the agent loop across the suite, the honest conclusion is that the contribution is the probe suite and the audit, and that language-model redesign is unnecessary. We would report it that way. We expect the ladder to fall short where the right fix is a reformulation rather than a higher-order method. The IEQ result (Unconditionally energy stable IEQ-FEMs) and the BDF2 dissipation result (Energy-Controllable Time Integration for Elastodynamic Contact) say that such problems exist, but whether agents can find those reformulations is precisely what is uncertain.
Why not just keep shrinking $\Delta t$ with the simple scheme? For short horizons this works, which is why current benchmarks look solved. The cost is the problem. A first-order method needs about $\epsilon^{-1}$ steps to reach error $\epsilon$, against about $\epsilon^{-1/2}$ for a second-order method. Over long horizons, dissipation and phase lag also accumulate with time. The work-precision curves and the long-horizon phase and energy metrics measure this cost directly, and the stall-and-restart behavior reported for AutoNumerics suggests it is not only a matter of cost.
Proposed Experiments
We evaluate on three sets. The first is the five CodePDE problems (advection, Burgers, reaction–diffusion, compressible Navier–Stokes, and Darcy flow, which is steady and used only for the audit). The second is the time-dependent subset of the AutoNumerics 200-PDE suite. The third is a long-horizon extension we will build from those families plus problems named in the file: advection over many periods, a linear wave or one-dimensional Maxwell system with an exact energy, Allen–Cahn and Cahn–Hilliard with discrete energy decay, and the generalized porous medium equation. Metrics are nRMSE or relative $L_2$ error where references exist; PDEBench's spectral (fRMSE) and conservation (cRMSE) errors (PDEBench); observed order $\hat p$; energy violation or drift; phase error; and work-precision curves of error against steps and solver wall time. We also report tokens spent, because MACM flags inference cost as the main weakness of multi-agent loops.
Three results would settle the proposal. First, the audit must show that shipped solvers are frequently first order or over-stepped. Otherwise the premise fails. Second, the full loop must beat the scalar-error ablation on steps-at-matched-accuracy and on long-horizon energy and phase error. Otherwise structured measurement is not the active ingredient. Third, the full loop must beat the scripted ladder specifically on the phase-field, conservative-wave and degenerate-diffusion problems, while roughly tying on smooth non-stiff ones. A uniform tie with the ladder would mean we publish the probes and the audit, and drop the claim that language-model scheme redesign matters.
References
- AutoNumerics: An Autonomous, PDE-Agnostic Multi-Agent Pipeline for Scientific Computing
- PDE-Agent: A toolchain-augmented multi-agent framework for PDE solving
- CodePDE: An Inference Framework for LLM-driven PDE Solver Generation
- MACM: Utilizing a Multi-Agent System for Condition Mining in Solving Complex Mathematical Problems
- Self-Collaboration Code Generation via ChatGPT
- Energy-Controllable Time Integration for Elastodynamic Contact
- Unconditionally energy stable IEQ-FEMs for the Cahn-Hilliard equation and Allen-Cahn equation
- Numerical artifacts in the Generalized Porous Medium Equation: Why harmonic averaging itself is not to blame
- A robust second-order low-rank BUG integrator based on the midpoint rule
- PDEBench: An Extensive Benchmark for Scientific Machine Learning