Skip to content

PDEFlow: Autonomous Agentic PDE Pipelines for Neural Operator Learning and Solver-Free Inference

🕒 Published (v1): 2026-07-06 14:18 UTC · Source: Arxiv · link

Why this paper was selected

Full autonomous pipeline from spec to trained neural operator; meta-harness for scientific AI

Ask a follow-up

Open an assistant pre-loaded with this paper's context.

💬 Ask ChatGPT✦ Ask Claude

TL;DR

PDEFlow is an autonomous agentic harness that converts multi-turn natural-language ODE/PDE descriptions into end-to-end solver-backed neural-operator pipelines without manual intervention. A stateful JSON-patch input graph maintains a valid problem specification across user edits, a FEniCSx finite-element backend generates training data, and a registry-based training module trains a Bayesian DeepONet for solver-free inference from saved checkpoints. The system achieves 81.43% specification accuracy on 70 scripted scenarios, outperforming ablated and single-shot baselines on structured multi-turn cases.

Problem

Neural operator learning presupposes two already-solved problems: a valid, executable PDE specification and a solver-backed dataset. Both are currently handled manually and are fragile — incremental user edits (adding boundary conditions, changing coefficients) can silently corrupt a specification when every update is treated as a fresh configuration. No existing system connects natural-language problem entry to the full chain of specification validation, simulation, operator training, and fast inference.

Method

Input Handling (stateful LLM agent graph, all nodes use gpt-o4-mini): - An Orchestrator classifies each user turn into five intent classes: conversation, specification, mixed input, assistant-generated specification, or no usable input. - Specification-bearing content is routed to an Extractor that emits JSON patch operations over the canonical specification (not full regeneration), so only changed fields are touched. - A Validator checks path validity, operation type, schema consistency, and completeness. Invalid patches are sent to a Repairer (up to two attempts); if both fail, an Interviewer requests clarification and no partial update is committed. - A Finalizer sets the problem status and schema version when the spec is complete.

Data Generation: - The validated JSON spec is parsed to extract governing equation, domain, coefficients \(K(x)\), \(\alpha(x)\), \(\gamma(x)\), forcing \(f(x,t)\), and boundary conditions (Dirichlet/Neumann/Robin per edge). - The general supported transient PDE is \(\partial_t u = \nabla \cdot (K(x)\nabla u) + \alpha(x)\cdot\nabla u + \gamma(x)u + f(x,t)\). - The FEniCSx solver is called per sampled configuration; seven time-integration schemes are supported. Solutions passing numerical validity checks are stored as tensors \(\mathcal{D} = \{X_f, X_s, Z, Y, M\}\) (conditioning fields, scalars, query coordinates, targets, metadata).

Operator Training and Inference: - A registry-based interface decouples the training orchestrator from the operator class (Bayesian DeepONet, FNO, deterministic DeepONet, or user-defined). - The active operator is a multi-branch Bayesian DeepONet: \(G_\phi: (X_f, X_s, z) \mapsto \hat{u}(z)\), trained by minimizing \(\|\hat{u} - u\|^2\) and returning predictive uncertainty \(\hat{u}(z) \sim \mathcal{N}(\mu_\phi(z), \sigma_\phi^2(z))\). - Inference restores checkpoint \(\phi^*\), rebuilds tensors from the new spec using saved metadata, and de-normalizes: \(\hat{u} = \hat{u}_n \sigma_y + \mu_y\), without calling the numerical solver.

Key Contributions

  • Stateful, multi-turn specification framework using incremental JSON patches with a validation–repair loop, preventing silent state corruption across user edits.
  • Five-class intent classifier that separates conversational from specification-bearing input, routing only the latter to spec update.
  • FEniCSx-backed data-generation pipeline supporting steady and transient 1D/2D problems with per-edge boundary condition types and seven time-integration schemes.
  • Registry-based neural-operator interface that decouples training orchestration from operator selection, enabling plug-and-play extension.
  • Multi-branch Bayesian DeepONet as the default operator, providing predictive uncertainty alongside point predictions.
  • End-to-end automation from natural-language input to solver-free inference with all intermediate artifacts persisted.

Results

  • Specification accuracy (70 scripted scenarios — 15 ODE, 30 PDE-1D, 25 PDE-2D):
  • Complete system: 81.43%
  • No Repairer: 65.71%
  • No Validator: 54.29% (largest drop; corrupts state on advanced-hard cases, dropping to 0.25)
  • Single-shot baseline: 74.29% (but reaches 0.95 on advanced-hard, outperforming the complete system there because it sees the full corrected dialogue at once)
  • By equation family (complete system): PDE (1D): 0.93, PDE (2D): 0.80, ODE: lower (single-shot stronger on ODE since specs are short).
  • Neural operator training MSE: Best-checkpoint MSEs across benchmark tasks range approximately 0.014–0.056 (from Figure 8); exact per-task numbers in appendix tables not fully reproduced in provided text.
  • Speedup of neural-operator inference over per-sample FEniCSx solve is reported in Appendix 6.4 (not in provided text).

Limitations

  • Specification accuracy caps at 81.43%; ~18.6% of multi-turn scenarios produce incorrect specifications even with validation and repair.
  • Maximum of two repair attempts; failure falls back to user clarification, breaking automation.
  • Single-shot baseline outperforms on advanced-hard cases, exposing a known weakness of the stateful patch approach when full dialogue context would be more informative.
  • Operator selection is entirely manual; no operator-recommendation agent exists yet.
  • Currently restricted to linear 1D/2D steady/transient problems; nonlinear or 3D PDEs are not supported.
  • Transport-dominated, strongly parametric, and high-dimensional transient cases exhibit the largest prediction errors and likely require larger datasets or better-matched architectures.
  • LLM backbone (gpt-o4-mini) is hardcoded; no discussion of cost, latency, or provider-agnostic design.

Relevance to Harnesses / Meta-Harnesses

PDEFlow is a domain-specific scientific computing harness that orchestrates a multi-agent pipeline — Orchestrator, Interviewer, Extractor, Validator, Repairer, Finalizer, FEniCSx backend, training orchestrator, inference engine — under a single stateful workflow with explicit state contracts (the canonical JSON specification). The JSON-patch-based incremental update mechanism with bounded repair loops is a concrete instance of the validated-state meta-harness pattern: the harness enforces correctness invariants on shared state rather than leaving validation to individual agents. The registry-based operator interface demonstrates how a harness can expose a stable orchestration surface while permitting internal module substitution — a key extensibility principle relevant to researchers building reusable meta-harnesses for scientific or ML pipelines.