Look-Ahead Mesh Refinement with Audited Rollback

Simulations of shocks, fronts and wakes spend most of their compute on a small, moving part of the domain. Adaptive mesh refinement (AMR) puts fine cells only where they are needed. Standard AMR is reactive, though: it refines where the error is large now. A fast feature therefore keeps running into coarse cells before the mesh catches up. Recent learned methods fix this by training policies that refine ahead of the feature. Those policies carry no guarantee: when they guess wrong, the error is silently baked into the rest of the run.

We propose to borrow a control structure from multi-agent LLM pipelines rather than any LLM itself. Those pipelines split the job three ways: a planner proposes, executors act, and an auditor checks and can send work back. Mapped onto mesh adaptation, a cheap coarse "scout" simulation runs a short time window ahead and plans where resolution will be needed. Local refiners build the fine mesh for that window. An auditor computes a standard error estimate on the result and either accepts the window or rolls it back for a local fix or a global replan. The bet is that look-ahead removes most of the waste of reactive AMR, while rollback recovers the accuracy guarantees that learned anticipatory policies give up.

Core Claim

On time-dependent nonlinear problems, a planner–refiner–auditor loop reaches a given verified error tolerance at lower total cost than tuned reactive AMR. "Verified" means the auditor's error estimate is below tolerance on every accepted window, and the result is confirmed afterward against a fine reference. The comparison counts every cost: the scout, all refinement, and all rollbacks.

The first new element is the combination itself: look-ahead refinement plus an accept-or-reject gate with dual-loop rollback inside a single running simulation. The second is a measured account of when the gate pays for itself. If $c_s$ is the cost of the scout per window, $c_p$ the cost of the planned fine solve, $r$ the average number of rollbacks per window, and $c_{re}$ the cost of reactive AMR over the same window at the same tolerance, the method wins exactly when

$$c_s + (1+r)\,c_p < c_{re}.$$

The point of the program is to measure $r$ and $c_p/c_{re}$ across problem classes, rather than assume they are favorable.

We expect the method to help most on hyperbolic conservation laws such as Burgers and the compressible Euler equations. For these, a coarse conservative scheme still moves shocks at roughly the right speed; this is the classical property that conservative schemes converge to solutions with correct shock speeds. A coarse scout is therefore a trustworthy planner there. We expect less benefit on flows where phase drifts on coarse grids, such as vortex shedding. In those cases the scout misplaces features, rollbacks become frequent, and the inequality may fail. Reporting that boundary is part of the contribution.

Relation to Prior Work

Three learned AMR systems motivate the anticipation half of the idea.

Multi-Agent Reinforcement Learning for Adaptive Mesh Refinement makes each mesh element an agent, trained on 2D linear advection in MFEM. It shows that anticipatory refinement beats greedy estimators by an efficiency ratio of up to 1.7x. That evidence is confined to a linear PDE and comes with no mechanism for catching a wrong anticipation.

Swarm Reinforcement Learning for Adaptive Mesh Refinement scales identical triangle-agents to tens of thousands of elements. It reports 100x savings over uniform refinement, but mostly on steady problems, and it needs a full PDE solve after every refinement step.

Learning Controllable Adaptive Simulation for Multi-resolution Physics couples a GNN surrogate with a refine/coarsen policy on 1D Burgers. It inherits the error growth that neural rollouts show elsewhere; CFDBench reports errors as high as 300% and 1,000x growth for neural operators.

All three put the forecast inside a learned policy and accept its output unconditionally. We instead obtain the forecast from a classical coarse solve, keep a classical solver as the numerical core, and gate every window with an estimator. Reinforcement Learning for Adaptive Mesh Refinement constrains the design. Its single centralized agent refines one element per step and cannot scale, so our refiners act in parallel per spatial patch.

The task-decomposition literature supplies the control structure. PDE-Agent uses a dual loop: local fixes at checkpoints, plus global plan revision when structural failures appear. Its ablation shows a 14% drop in success without this loop. Our inner loop (re-refine and recompute one flagged patch) and outer loop (rerun the scout at higher resolution or widen the plan) are the runtime-numerics analogue.

AutoNumerics separates coarse debugging runs from fine production runs and verifies results with residuals. It never adapts the grid inside a run, which is precisely what we do. The broader pattern of separating proposing from checking, seen in MACM and Self-collaboration Code Generation via ChatGPT, is the design principle we transfer. We deliberately keep LLMs out of the per-step loop. They are far too slow for decisions made every time window, and A survey on LLM-based multi-agent systems notes that such systems lack numerical guarantees.

The auditor reuses existing methods. These include recovery-type estimators of the kind analyzed by Cai et al.. Where a single target quantity matters, they also include goal-oriented estimates that weight local residuals by their influence on that target, following Wallwork et al..

Research Program

We will build the loop in PyMFEM for 1D and 2D problems on tree-based meshes, and in Firedrake for anisotropic metric-based meshes, using Anisotropic mesh adaptation in Firedrake with PETSc DMPlex. Each time window proceeds in four stages.

Scout. The scout advances a coarse solution over the window and records where error indicators and solution gradients will be large.

Plan. The planner converts that record into a target cell-size field for the window. We test two versions. One is a fixed rule: dilate the indicator region by the local wave speed times the window length. The other is a small learned model that corrects the coarse forecast's smearing, trained on pairs of scout and fine-reference runs.

Refine. Per-patch refiners realize the size field under a degrees-of-freedom budget. The solver's built-in conformity rules handle mesh grading.

Audit. The fine solver advances the window, and the auditor computes per-patch error estimates. Patches over tolerance trigger the inner loop. If the inner loop fails twice, or a flagged feature lies outside the planned region, the outer loop triggers.

Two analyses accompany the build. First, we will log $c_s$, $c_p$, $r$ and $c_{re}$ per window to test the break-even inequality directly. Second, we will vary the window length. Short windows mean cheap rollbacks but frequent scouting. Long windows mean more scout drift.

Baselines

Naive references. Uniform fine refinement at the resolution needed to reach the tolerance gives the upper cost bound. Reactive AMR without buffers gives the floor of standard practice.

Strongest classical competitor. This is reactive AMR in MFEM or Firedrake with a Zienkiewicz–Zhu or Kelly estimator, regridding every step, plus a buffer of extra refined cells around flagged regions. Buffer width and refinement threshold will be tuned per problem by grid search, with the same tuning budget we give our own window length and tolerance. This is the real threat: a wide enough buffer is itself a crude form of anticipation. No reported result was found on Lacuna for buffered reactive AMR on transient Burgers or Euler problems, so we will establish it ourselves. To beat it, our method must reach the same verified tolerance at lower total wall-clock time and lower total degrees of freedom summed over time steps, on most of the test instances.

Strongest learned competitor. This is the value-decomposition graph policy (VDGN) from Multi-Agent Reinforcement Learning for Adaptive Mesh Refinement. Its reported result is an efficiency ratio of up to 1.7x over the best heuristic baselines on 2D linear advection. We will reimplement it in PyMFEM, train it on the same problem distributions, and give it matched training compute. On its home benchmark we aim to match its efficiency. On nonlinear transient problems we aim to exceed it, and in particular to never violate the tolerance, whereas we expect VDGN's unaudited runs to do so occasionally. For 1D Burgers we will also report LAMP. Its published 33.7% reduction in long-term error versus MP-PDE and FNO is a surrogate-error figure and is not directly comparable to verified-tolerance cost, so we use it only qualitatively.

Ablations. These isolate the key ingredients. Scout plus planner with no auditor isolates the value of rollback. Auditor with reactive planning, which rejects and re-solves windows but has no look-ahead, isolates the value of the scout. Fixed-rule versus learned planner isolates whether learning is needed at all.

Why not just…?

Why not just use reactive AMR with a wide buffer? It is cheap, standard and has no rollback cost. It may well win on slow features, and that is a legitimate result. The buffer must, however, be sized for the fastest feature everywhere and at all times, so it over-refines in proportion to the speed contrast across the domain. We will build test cases with features of mixed speed, such as interacting shocks of different strengths, where a single buffer width must be either wasteful or too thin. The tuned-buffer baseline settles the question directly.

Why not just use a learned anticipatory policy like VDGN or swarm RL? These policies do anticipate. The VDGN evidence for anticipation comes from linear advection, however, and nothing stops a wrong forecast from contaminating later steps. The swarm approach also needs a global solve per refinement step. The no-auditor ablation applied to VDGN measures how often unaudited anticipation violates tolerance on Burgers and Euler problems. If it never does, the auditor is overhead and we will say so.

Why not just run a coarse preview with a fixed dilation rule and skip everything else? This is the scout with the fixed-rule planner and no auditor, and it may capture most of the savings. That is why it appears as an ablation rather than being dismissed. Our claim rests on the auditor making the method safe where coarse forecasts drift. The vortex-shedding cases are designed to expose exactly that.

Why not have an LLM pipeline like AutoNumerics or PDE-Agent write a solver that calls MFEM's adaptive loop? Those pipelines produce a solver once. Our decisions are made every window, inside the run, at millisecond-to-second timescales. Our system is complementary: it is a tool such a pipeline could invoke, not a competitor to it.

Proposed Experiments

Benchmarks. We cover four problem classes. The first is 2D linear advection with Gaussian and ring features, following the VDGN benchmark, for direct comparability. The second is the 1D viscous and inviscid Burgers family, following LAMP and the reinforcement-learning AMR paper. The third is 2D compressible flow initialized from PDEBench compressible Navier–Stokes conditions and from the Shockwave setting of AMR-Transformer. The fourth is the cylinder wake configuration from CFDBench as the deliberate stress case. For the steady-state comparison, we include non-stationary heat diffusion from the ASMR suite.

Ground truth and metrics. Fine uniform-grid solutions serve as ground truth. The metrics are relative $L_2$ error against reference at each accepted window, the fraction of windows exceeding tolerance after acceptance, total degrees of freedom summed over time steps, wall-clock time including scout and rollbacks, and the measured rollback rate $r$.

Decisive checks. There are three.

First, on Burgers and compressible shocks, does the full loop beat the tuned buffered reactive baseline in verified cost at equal tolerance? If not, the idea fails where it should be strongest.

Second, does the no-auditor ablation, or VDGN, violate tolerance on a measurable fraction of windows? If neither ever does, the audit layer is unjustified.

Third, does the measured break-even inequality predict where the method wins and loses? We expect wins on shocks and losses or ties on vortex shedding. If the inequality predicts correctly, the result is a usable rule for practitioners even where the method itself does not win.