pdeflow-autonomous-agentic-pde-pipelines

name	pdeflow-autonomous-agentic-pde-pipelines
description	PDEFlow: an autonomous agentic framework that turns user-level ODE/PDE descriptions into solver-backed neural-operator pipelines. Links problem specification, data generation, operator training, and checkpoint-based inference via a stateful input graph and registry-based interface. Instantiated with multi-branch Bayesian DeepONet. Activation: PDEFlow, autonomous PDE solver, neural operator, agentic pipeline, DeepONet, FEniCSx, ODE PDE automation, scientific workflow, Bayesian DeepONet, operator learning.
version	1.0.0
metadata	{"hermes":{"tags":["multi-agent-rl","physics-math","agentic","neural-operator","pde","ode","scientific-computing","deep-operator-network","bayesian"],"source_paper":"PDEFlow: Autonomous Agentic PDE Pipelines for Neural Operator Learning and Solving (arXiv:2607.05134)","published":"2026-07-06","authors":"Akshat Jani, Prathamesh Gadekar, Sakhinana Sagar Srinivas, Venkataramana Runkana","arxiv_id":"2607.05134","utility":0.85}}

PDEFlow: Autonomous Agentic PDE Pipelines for Neural Operator Learning

Overview

PDEFlow is an autonomous agentic framework that converts user-level natural-language descriptions of ODEs and PDEs into complete solver-backed neural-operator pipelines. The workflow spans problem specification → data generation → operator training → checkpoint-based inference, minimizing manual intervention for repeatable scientific and engineering workflows.

Architecture

Four-Stage Agentic Pipeline

User NL Input → [Stateful Input Graph] → [Data Generation] → [Operator Training] → [Inference]
                      ↑                           ↑                  ↑                ↑
               Multi-turn edits           FEniCSx solver      Registry-based     Checkpoint
               + validation               + param sampling    operator interface  loading

1. Stateful Input Graph

Converts multi-turn natural-language input and user edits into validated problem specifications.

class StatefulInputGraph:
    """Maintains state across multi-turn PDE specification conversations."""
    def __init__(self):
        self.state = {
            "equation": None,      # e.g., "u_t = D * u_xx"
            "domain": None,        # e.g., {"x": [0, 1], "t": [0, 10]}
            "bc": None,            # boundary conditions
            "ic": None,            # initial conditions
            "params": None,        # physical parameters (e.g., D=0.01)
            "validated": False
        }
        self.edit_history = []

    def update_from_nl(self, user_input):
        """Parse natural language and update graph state."""
        parsed = self.parse_pde_description(user_input)
        for key, value in parsed.items():
            if value is not None:
                self.state[key] = value
                self.edit_history.append((key, value, user_input))

    def validate(self):
        """Validate that the specification is complete and consistent."""
        required = ["equation", "domain", , , ]
        .state[] = (.state[k]     k  required)
         .state[]

2. Data Generation Module

Samples parameters, solves the configured governing equation with FEniCSx finite-element backend, and stores solutions as operator-ready tensors.

import fenicsx  # FEniCSx backend

class DataGenerator:
    """Generate solver-backed training data for neural operators."""
    def __init__(self, spec, n_samples=1000):
        self.spec = spec
        self.n_samples = n_samples

    def generate(self):
        """Sample parameters, solve PDE, store as tensors."""
        dataset = []
        for _ in range(self.n_samples):
            params = self.sample_parameters()
            solution = self.solve_with_fenicsx(params)
            dataset.append({
                "params": params,
                "solution": solution.tensor(),
                "grid": solution.mesh()
            })
        return dataset

    def solve_with_fenicsx(self, params):
        """Solve PDE using FEniCSx finite element method."""
        mesh = self.create_mesh(self.spec["domain"])
        V = fenicsx.FunctionSpace(mesh, "P", 1)
        u = fenicsx.TrialFunction(V)
        v = fenicsx.TestFunction(V)
        # Set up variational problem from spec
        a, L = self.build_variational_form(u, v, params)
        # Apply BCs
        bcs = self.apply_boundary_conditions(V, self.spec["bc"])
        
        solution = fenicsx.Function(V)
        fenicsx.solve(a == L, solution, bcs)
         solution

3. Training Stage — Registry-Based Operator Interface

A registry-based interface allows different neural operators to be trained and deployed without changing the surrounding pipeline.

class OperatorRegistry:
    """Registry for pluggable neural operators."""
    _operators = {}

    @classmethod
    def register(cls, name):
        def decorator(op_class):
            cls._operators[name] = op_class
            return op_class
        return decorator

    @classmethod
    def get(cls, name):
        return cls._operators.get(name)

@OperatorRegistry.register("bayesian-deeponet")
class BayesianDeepONet:
    """Multi-branch Bayesian DeepONet with uncertainty quantification."""
    def __init__(self, branch_input_dim, trunk_input_dim, hidden_dim=128):
        self.branch = BayesianMLP(branch_input_dim, hidden_dim)
        self.trunk = BayesianMLP(trunk_input_dim, hidden_dim)

    def forward(self, branch_input, trunk_input):
        b = self.branch(branch_input)  # (batch, hidden)
        t = self.trunk(trunk_input)    # (batch, hidden)
        return torch.einsum("bi,bi->b", b, t)  # dot product

    def predict_with_uncertainty(self, branch_input, trunk_input, n_samples=10):
        
        preds = [.forward(branch_input, trunk_input)  _  (n_samples)]
        mean = torch.stack(preds).mean(dim=)
        std = torch.stack(preds).std(dim=)
         mean, std

4. Inference Stage — Checkpoint-Based

Loads saved checkpoints for solver-free predictions from new inputs.

class InferenceEngine:
    """Solver-free prediction from trained neural operator checkpoints."""
    def __init__(self, checkpoint_path, operator_name="bayesian-deeponet"):
        self.operator = OperatorRegistry.get(operator_name)
        self.operator.load_state_dict(torch.load(checkpoint_path))

    def predict(self, input_params, query_points):
        """Predict solution at query points without running solver."""
        with torch.no_grad():
            branch_input = self.encode_params(input_params)
            trunk_input = self.encode_points(query_points)
            prediction, uncertainty = self.operator.predict_with_uncertainty(
                branch_input, trunk_input
            )
        return prediction, uncertainty

Key Features

• Multi-turn specification: Stateful input graph handles iterative PDE description refinement
• Solver-backed data: FEniCSx finite-element solver generates ground-truth solutions
• Pluggable operators: Registry pattern allows swapping neural operators (DeepONet, FNO, etc.) without pipeline changes
• Bayesian uncertainty: Multi-branch Bayesian DeepONet provides epistemic uncertainty on predictions
• Checkpoint persistence: Trained operators saved/loaded for repeatable inference

Experimental Validation

• Benchmark ODE and PDE tasks (steady-state and transient)
• PDEFlow successfully: constructs valid specifications → generates solver-backed datasets → trains neural operators → provides solver-free predictions from checkpoints
• Designed for repeatable scientific/engineering workflows where many related physics configurations must be specified, simulated, learned, and queried

Use Cases

• Scientific computing automation — automate the PDE solve-train-deploy loop
• Engineering design exploration — rapidly test variations of a PDE configuration
• Neural operator research — benchmark different operators within a unified pipeline
• Physics-informed ML pipelines — as a reference architecture for agentic scientific workflows
• Digital twin construction — learn surrogate models from solver data with uncertainty

Activation Keywords

PDEFlow, autonomous PDE pipeline, agentic scientific workflow, neural operator, DeepONet, Bayesian DeepONet, FEniCSx, PDE automation, ODE solving, operator learning, stateful input graph, registry-based operator, solver-free prediction, checkpoint inference, scientific computing agentic