AutoMOOSE: An Agentic AI for Autonomous Phase-Field Simulation

Abstract

Multiphysics simulation frameworks such as MOOSE provide rigorous engines for phase-field materials modeling, yet adoption is constrained by the expertise required to construct valid input files, coordinate parameter sweeps, diagnose failures, and extract quantitative results. We introduce AutoMOOSE, an open-source agentic framework that orchestrates the full simulation lifecycle from a single natural-language prompt. AutoMOOSE deploys a five-agent pipeline in which the Input Writer coordinates six sub-agents and the Reviewer autonomously corrects runtime failures without user intervention. A modular plugin architecture enables new phase-field formulations without modifying the core framework, and a Model Context Protocol (MCP) server exposes the workflow as ten structured tools for interoperability with any MCP-compatible client. Validated on a four-temperature copper grain growth benchmark, AutoMOOSE generates MOOSE input files with 6 of 12 structural blocks matching a human expert reference exactly and 4 functionally equivalent, executes all runs in parallel with a 1.8x speedup, and performs an end-to-end physical consistency check spanning intent, finite-element execution, and Arrhenius kinetics with no human verification. Grain coarsening kinetics are recovered with R^2 = 0.90-0.95 at T >= 600 K; the recovered activation energy Q_fit = 0.296 eV is consistent with a human-written reference (Q_fit = 0.267 eV) under identical parameters. Three runtime failure classes were diagnosed and resolved autonomously within a single correction cycle, and every run produces a provenance record satisfying FAIR data principles. These results show that the gap between knowing the physics and executing a validated simulation campaign can be bridged by a lightweight multi-agent orchestration layer, providing a pathway toward AI-driven materials discovery and self-driving laboratories.

Figures (9)

• Figure 1: AutoMOOSE agentic pipeline. Five claude-sonnet-4-20250514 agents ($f_1$--$f_5$) transform a natural-language prompt into a completed MOOSE phase-field simulation. Architect ($f_1$) parses the user prompt and constructs the structured simulation plan $\mathcal{P}$ (Eq. \ref{['eq:simplan']}), encoding the physics model, mesh geometry, solver tolerances, and sweep parameters. Input Writer ($f_2$) is a compound agent that coordinates six sub-agents in strict dependency order --- a Meshing, b Variables, c Kernels, d Materials, e Postprocessors, and f Executioner --- to render a validated MOOSE .i input file via the plugin registry (Section \ref{['sec:plugin']}). Runner ($f_3$) launches MOOSE and streams solver output to the live log panel; on convergence failure, the error log is routed to Reviewer ($f_4$), which diagnoses the failure class, proposes corrected parameters, and returns them to $f_2$ via the Retry arc (Section \ref{['sec:reviewer']}). On success, $f_3$ passes run output to Visualization ($f_5$) for quantitative kinetics analysis from CSV postprocessor output, including grain coarsening rate extraction and Arrhenius fitting (Section \ref{['sec:viz']}). Dashed border: compound Input Writer block ($f_2$); black arrows: nominal forward pipeline; red arrows: failure path; green arrows: success path.
• Figure 2: AutoMOOSE run directory structure. Each run directory is timestamped and self-contained, comprising: grain_growth.i (complete MOOSE input file), grain_growth.csv (tabulated grain count time series $N(t)$, Eq. \ref{['eq:Nt']}), run.log (full solver stdout), metadata.json (structured provenance record encoding all simulation parameters, executable path, hostname, MPI configuration, and wall-clock duration), and record.json (run status and parsed kinetics metrics). Any run can be exactly reproduced by executing the MOOSE command (Eq. \ref{['eq:mpi_cmd']}) from within this directory, satisfying FAIR data principles by construction wilkinson2016.
• Figure 3: Model Context Protocol server architecture of AutoMOOSE. The MCP server (port 8001, center) acts as the central orchestration hub between external LLM clients and the internal agent pipeline $\mathcal{S}$ (Eq. \ref{['eq:pipeline']}). Top: four supported client entry points --- Claude Desktop, Claude Code, custom scripts, and CI/CD pipelines --- all communicating via HTTP/SSE on port 8001. Left: the five AutoMOOSE agents ($f_1$--$f_5$) form the core intelligence layer; black arrows denote control flow (requests and commands) and red arrows denote data flow (JSON responses, .i file content, run identifiers, and corrected parameters). The feedback arc from Runner ($f_3$) through Reviewer ($f_4$) back to Input Writer ($f_2$) implements the autonomous correction loop (Section \ref{['sec:reviewer']}). Right: four backend resource endpoints --- Plugin Registry, Simulation Logs, Run Status, and Health Check --- each mapped to one or more of the ten registered MCP tools (Table \ref{['tab:mcp_tools']}). Bottom: the FastAPI backend (port 8000) comprises three internal modules --- Agent Pipeline, Plugin Registry, and MOOSE Engine --- accessed by the MCP server over HTTP REST.
• Figure 4: Input file fidelity: [UserObjects] block (✓ exact structural match). Human-written expert reference (left) and AutoMOOSE-generated file for $T = 450$ K (right). Both files declare identical [UserObjects] structure; the sole difference is grain_num (20 in the reference vs. 15 from the prompt, annotated in grey). The complete 12-block comparison is in Figure \ref{['fig:S_full_input_comparison']}.
• Figure 5: AutoMOOSE-generated microstructure evolution at $T = 450$ K. Panels (i)--(iv): phase-field grain structure at $t = 0$, $500$, $2000$, and $4000$ ns; grains colored by unique index (GrainTracker). The grain in the dashed circle shrinks from panel (i) and vanishes by panel (iv), consistent with the Gibbs--Thomson relation in the GBEvolution model. Grain count reduces from $N_0 = 15$ to $N_f = 13$ (Figure \ref{['fig:kinetics_arrhenius_comparison']}a). No user intervention was required.