🤖 AI

AutoPDE: Reliable Agentic PDE Solving via Explicitly Represented Solver Strategies

AutoPDE is an agentic system that improves the reliability of partial differential equation (PDE) solving by explicitly representing and iteratively refining numerical solver strategies as independent objects before code generation, achieving a 54.5% pass rate on the PDE Agent Bench.

Original authors: Huanshuo Dong, Keyao Zhang, Hong Wang, Zhezheng Hao, Zhiwei Zhuang, Ziyan Liu, Jiacong Wang, Gengyuan Liu, Xin Jin

Published 2026-06-10

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Huanshuo Dong, Keyao Zhang, Hong Wang, Zhezheng Hao, Zhiwei Zhuang, Ziyan Liu, Jiacong Wang, Gengyuan Liu, Xin Jin

Original paper licensed under CC BY 4.0 (http://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

Imagine you are trying to bake a very complex cake (solving a Partial Differential Equation, or PDE). In the world of science and engineering, these "cakes" represent real-world problems like how heat spreads through a metal plate, how air flows over a wing, or how water moves in a pipe.

For a long time, getting this right required a human expert chef who knew exactly which ingredients to mix, what temperature to use, and how long to bake it. If the cake burned, the chef had to rethink the recipe, not just fix a typo in the instructions.

Recently, AI coding assistants (LLMs) started trying to bake these cakes for us. They are great at writing the instructions (code), but they often have a blind spot: they treat the recipe as a secret hidden inside the code.

The Problem: "Fixing the Code" vs. "Fixing the Strategy"

The paper argues that current AI agents work like a nervous apprentice who, when the cake fails, immediately starts rewriting the instructions line-by-line without ever asking, "Wait, did I use the wrong oven temperature to begin with?"

The Old Way (Traditional Human Expert): The chef writes down a clear plan first: "This is a convection problem, so I need a special stabilizing ingredient (SUPG) and a specific mesh size." If it fails, they look at the plan, realize the temperature was wrong, and change the plan.
The Current AI Way: The AI jumps straight to writing the code. If the cake fails, it tries to patch the code. It doesn't realize the fundamental strategy (the recipe) was flawed. It's like trying to fix a burnt cake by changing the font on the recipe card.

The Solution: AutoPDE

The authors introduce AutoPDE, a new AI agent that changes the workflow. Instead of jumping straight to writing code, AutoPDE acts like a project manager who insists on a blueprint first.

Here is how AutoPDE works, broken down into three simple steps:

The Diagnosis (The "What is this?" Phase):
Before writing a single line of code, AutoPDE analyzes the problem. It asks: "Is this a heat problem? A wave problem? Is it unstable?" It creates a digital "Diagnosis Card" that explicitly states the nature of the problem. This is like a chef reading the ingredients and saying, "Ah, this is a soufflé; it needs a very specific technique, not a standard cake method."
The Strategy Selection (The "How do we do it?" Phase):
Using a library of "skills" (like a cookbook of proven techniques), AutoPDE picks the right tools based on the Diagnosis Card. It decides on the math method, the grid size, and the solver. Crucially, this strategy is saved as a separate, visible object. It's not hidden inside the code yet. It's a standalone document that says, "We are using Method X because the problem is Type Y."
The Pilot Run (The "Test Kitchen" Phase):
Before committing to the final, expensive run, AutoPDE runs a tiny, cheap test (a "pilot solve"). It checks: "Did we get the right result? Did it take too long?"
- If the error is too high, it doesn't just tweak the code; it goes back to the Strategy Document and says, "We need a finer grid."
- If it's too slow, it says, "We need a simpler solver."
- It revises the plan based on the test results, then updates the code to match the new plan.

Why This Matters (The Results)

The authors tested AutoPDE on a benchmark called PDE Agent Bench, which contains 191 different math problems ranging from simple heat flow to complex fluid dynamics.

The Score: AutoPDE solved 54.5% of the problems successfully.
The Comparison: The best previous AI agent (CodePDE) only solved about 40.3% (on the same powerful AI model). AutoPDE improved the success rate by 14.2 percentage points.

The paper highlights that this improvement is most dramatic in "tricky" problems (like convection-diffusion), where a wrong strategy makes the problem impossible to solve, no matter how much you refine the code. AutoPDE succeeds because it fixes the strategy first, ensuring the code is built on solid ground.

The Takeaway

Think of AutoPDE as the difference between a coder who just types furiously hoping to get it right, and a master engineer who draws a blueprint, checks the physics, runs a small scale model, and then builds the bridge. By making the "solver strategy" an explicit, visible, and revisable object, AutoPDE stops AI from blindly patching code and starts it thinking like a mathematician.

Technical Summary: AutoPDE

Problem Statement

Numerical solvers for partial differential equations (PDEs) are fundamental to scientific computing, yet building reliable solvers requires more than generating executable code; it demands a coherent numerical solver strategy. This strategy encompasses critical decisions regarding discretization, stabilization, solver configuration, and resolution control, which must align with the specific algebraic and physical structure of the PDE.

Recent Large Language Model (LLM) based coding agents (e.g., SWE-agent, OpenHands, CodePDE) have reduced the programming burden by generating and debugging solver implementations. However, these systems operate in a program-centric manner. They move directly from a PDE specification to code, leaving the solver strategy implicit within the generated implementation details. Consequently, when a solve fails, feedback is routed to code edits (patches) rather than to the underlying numerical decisions. This makes it difficult to inspect numerical choices before code generation and hard to revise them using numerical evidence when failures occur. For instance, applying a Conjugate Gradient solver to an indefinite Helmholtz system or omitting stabilization for convection-dominated problems represents a strategy-level mismatch that local code patching often fails to resolve.

Methodology: AutoPDE

To address these limitations, the authors propose AutoPDE, an agentic PDE solver that maintains the solver strategy as an explicitly represented object throughout the solving process. Unlike traditional agents that generate code immediately, AutoPDE constructs a strategy artifact before writing code, allowing it to be inspected and revised using numerical evidence.

The AutoPDE workflow consists of three distinct stages, all drawing from a library of reusable PDE-solving skills:

PDE Analysis:
The agent inspects the PDE specification (equation type, domain, boundary conditions, dominant mechanisms) to generate a DIAGNOSIS card. This card identifies the equation family (e.g., Helmholtz, Stokes, Convection-Diffusion) and its algebraic structure (e.g., symmetric positive-definite vs. symmetric indefinite). This step determines which reusable skills are applicable.
Numerical Method Selection:
Based on the DIAGNOSIS card, the agent retrieves a structured, plain-text PDE skill from a library covering ten equation families (Poisson, Heat, Stokes, Navier-Stokes, Helmholtz, Convection-Diffusion, Biharmonic, Darcy, Linear Elasticity, Reaction-Diffusion). The agent then writes a METHOD card, committing to specific choices for:
- Variational formulation
- Finite element space (discretization)
- Stabilization techniques (e.g., SUPG for advection-dominated flows)
- Algebraic solver and preconditioner (e.g., MINRES for indefinite systems, avoiding CG)
Adaptive Tuning:
After generating an initial executable solver (solver.py), AutoPDE performs adaptive tuning using low-cost pilot solves. It measures empirical error and wall-clock time against prescribed accuracy and runtime budgets. A rule-based profiling guide directs self-correction:
- If error is too high: Refine mesh ( $h$ ) or increase polynomial degree ( $p$ ).
- If runtime is too high: Simplify the solver or loosen tolerances.
- If execution crashes: Debug the traceback.
  The solver strategy record is updated iteratively until the targets are met or no further local repairs are possible.

Key Contributions

Strategy-First Agent Design: AutoPDE introduces a paradigm where the solver strategy is an explicit, auditable object maintained alongside the code. This makes numerical decisions visible, checkable, and revisable, contrasting with the implicit strategies of current LLM coding agents.
Reusable Skills for Strategy Construction: The system utilizes a library of structured, non-executable PDE-solving skills. This allows the agent to compose complex strategies (formulation, discretization, stabilization, solver selection) based on the specific PDE family identified during analysis.
Adaptive Tuning via Numerical Evidence: The agent employs a pilot-solve mechanism to calibrate resolution and solver tolerances based on empirical performance data, ensuring the final solver meets both accuracy and runtime constraints.

Experimental Results

The authors evaluated AutoPDE on the PDE Agent Bench, a benchmark comprising 191 cases across eight equation families.

Overall Performance: AutoPDE achieved an overall pass rate of 54.5% on both the Claude Opus 4.6 and GPT 5.1 backbones. This represents a 14.2 percentage point improvement over the strongest baseline (OpenHands on GPT 5.1 at 40.3%) and a 22.6 point improvement over the best Claude-based baseline (CodePDE at 31.9%).
Robustness Across Backbones: AutoPDE demonstrated minimal dependence on the underlying LLM backbone (0.0% gap between Claude and GPT results), whereas other agent families showed gaps of 15–21 percentage points. This suggests that explicit strategy reasoning allows weaker code-writing backbones to achieve high-quality results.
Per-Family Performance: AutoPDE was the only method to maintain non-trivial pass rates across all eight equation families. It particularly excelled in complex regimes requiring non-trivial numerical decisions, such as Convection-Diffusion (59.5% on GPT 5.1) and Helmholtz (78.9% on GPT 5.1), where other agents often collapsed to near-zero pass rates.
Ablation Studies: Removing any of the three stages (DIAGNOSIS, PDE Skills, or Adaptive Tuning) resulted in significant performance drops. The removal of PDE Skills caused the largest decline (34.6 percentage points), highlighting the importance of the structured skill library.

Significance and Claims

The paper claims that the primary bottleneck in automated PDE solving is not code generation capability, but the implicit representation of numerical strategy. By decoupling the strategy from the code and making it an explicit, revisable artifact, AutoPDE recovers the feedback loop typical of human numerical experts: analyzing the problem, selecting a method, and refining based on evidence, rather than merely patching code.

The authors emphasize that AutoPDE does not rely on novel LLM architectures but rather on a scaffolding innovation that structures the agent's reasoning process. The results suggest that explicit strategy representation is crucial for solving PDEs in delicate regimes (e.g., convection-dominated transport, indefinite operators) where a "wrong" numerical choice cannot be fixed by simple mesh refinement or code patching. The system successfully automates the "human expert" loop of strategy derivation and revision, achieving state-of-the-art performance on a diverse set of PDE problems.