AutoMOOSE: An Agentic AI for Autonomous Phase-Field Simulation

AutoMOOSE is an open-source agentic AI framework that autonomously orchestrates the entire phase-field simulation lifecycle—from generating input files and executing parallel runs to diagnosing and correcting runtime failures—enabling non-experts to conduct validated materials modeling campaigns with high accuracy and efficiency.

The Gist

Imagine you want to bake a complex, multi-layered cake that predicts how metal grains grow inside a new alloy. In the old days, you'd need to be a master baker (a materials scientist) who also knows how to write code in a strange, ancient language (MOOSE input files) just to tell the oven what to do. If you made a tiny typo, the whole cake would burn, and you'd have to start over, often not knowing why it failed.

AutoMOOSE is like hiring a team of five highly specialized, super-smart robot chefs who work together to bake that cake for you, just by listening to your simple request.

Here is how it works, broken down into everyday concepts:

1. The Problem: The "Forbidden Language" Barrier

Currently, running advanced physics simulations is like trying to order a custom meal at a restaurant where the menu is written in a secret code. You have to know exactly how to write the code (the input file), set the oven temperature, and monitor the cooking process. If the oven crashes, you have to be a detective to figure out if it was the gas, the electricity, or the recipe. This stops many brilliant scientists from doing great work because they spend months learning the code instead of doing the science.

2. The Solution: A Team of Robot Chefs (The Agents)

The authors created AutoMOOSE, which uses Artificial Intelligence (specifically "Agentic AI") to act as a bridge between your simple English request and the complex computer code. Instead of one robot trying to do everything, they built a pipeline of five specialized robots, each with a specific job:

• The Architect (The Planner): You tell it, "I want to simulate grain growth in copper at four different temperatures." The Architect listens, understands your goal, and writes a detailed, step-by-step recipe (a simulation plan) that the other robots can follow.
• The Input Writer (The Scribe): This robot takes the recipe and writes the actual "secret code" (the MOOSE input file). It doesn't just copy-paste; it has six little sub-robots that build the file piece by piece, ensuring the math and physics are correct.
• The Runner (The Cook): This robot puts the file into the computer "oven" and starts the simulation. It watches the clock and the temperature, running four different simulations at the same time to save time.
• The Reviewer (The Firefighter): This is the magic part. If the oven starts smoking (the simulation crashes or fails), the Runner doesn't panic. It calls the Reviewer. The Reviewer reads the error message, figures out exactly what went wrong (e.g., "The temperature was too high" or "A typo in the ingredients"), fixes the recipe, and sends it back to the Scribe to try again. You don't have to do anything.
• The Visualization (The Food Critic): Once the cake is baked, this robot tastes it. It analyzes the results, draws graphs showing how the metal grains grew, and writes a plain-English summary explaining what happened, just like a food critic reviewing a dish.

3. The "Self-Healing" Superpower

The most impressive feature is the Reviewer. In traditional science, if a simulation crashes, the human has to stop, read a confusing error log, guess the fix, and start over.
In AutoMOOSE, if the simulation fails, the system automatically diagnoses the problem and fixes it.

• Analogy: Imagine you are driving a car, and the engine stalls. Instead of calling a mechanic and waiting hours, the car's computer instantly figures out the fuel pump is clogged, clears it, and restarts the engine while you keep driving. AutoMOOSE does this for complex physics simulations.

4. The Results: Did the Cake Taste Good?

The team tested this system by asking it to simulate how copper grains grow at four different temperatures.

• Speed: It ran four simulations in parallel, finishing 1.8 times faster than if they were done one by one.
• Accuracy: The results were almost identical to what a human expert would get. The system correctly predicted how fast the grains would grow and calculated the "activation energy" (a measure of how hard it is for the grains to move) with high precision.
• Self-Documentation: Every time the system runs, it creates a "digital receipt" (a folder with all the files, settings, and logs) so that anyone can look at it later and say, "Yes, this is exactly how we made this result." This makes the science transparent and reproducible.

5. Why This Matters

Before AutoMOOSE, you needed to be a "Code Wizard" to do this kind of science. Now, you just need to be a scientist with a question.

• The Gap is Closed: The paper shows that we can finally bridge the gap between "knowing the physics" (understanding the science) and "doing the physics" (running the complex simulation).
• The Future: This is a step toward "Self-Driving Laboratories." Imagine a future where a scientist says, "Find the best metal alloy for a jet engine," and the AI runs thousands of simulations, fixes its own mistakes, analyzes the data, and tells the scientist the answer—all without the scientist ever writing a line of code.

In short: AutoMOOSE is a team of AI specialists that turns your simple English sentence into a complex, validated scientific experiment, fixes its own mistakes along the way, and hands you the results on a silver platter.

Technical Summary

1. Problem Statement

While multiphysics simulation frameworks like MOOSE (Multiphysics Object-Oriented Simulation Environment) are powerful tools for modeling microstructure evolution (e.g., grain growth, spinodal decomposition), their practical adoption is hindered by a steep barrier to entry.

• Complexity: Constructing valid MOOSE input files requires deep expertise in physics, numerical solvers, and specific syntax. A single grain growth simulation often involves over 100 lines of tightly coupled syntax.
• Manual Effort: Researchers must manually coordinate parameter sweeps, diagnose convergence failures, and extract quantitative results.
• Reproducibility: Small variations in mesh resolution, solver tolerances, or undocumented parameter choices lead to non-reproducible results, impeding the creation of standardized processing–microstructure–property databases.
• Gap: Existing AI agents have addressed atomistic scales (DFT, molecular dynamics) but have not yet automated the full lifecycle of mesoscale phase-field simulations, which sit at the intersection of thermodynamic theory and numerical methods.

2. Methodology: The AutoMOOSE Framework

AutoMOOSE is an open-source, agentic AI framework that orchestrates the entire MOOSE simulation lifecycle from a single natural-language prompt. It employs a five-agent pipeline and a modular plugin architecture.

A. The Five-Agent Pipeline

The system uses specialized instances of the claude-sonnet-4-20250514 model, organized sequentially:

1. Architect Agent ($f_1$): Parses the user's natural-language intent into a structured JSON simulation plan ($P$). It identifies physics models, spatial dimensions, boundary conditions, and sweep parameters.
2. Input Writer Agent ($f_2$): A compound agent coordinating six sub-agents (Mesh, Variables, Kernels, Materials, Postprocessors, Executioner) to generate a syntactically valid MOOSE .i input file.
   • Key Feature: It uses a plugin contract to translate physical parameters (e.g., grain boundary energy $\sigma$, mobility $M_{GB}$) into MOOSE coefficients ($L, \mu, \kappa$) analytically, eliminating manual calculation errors.
3. Runner Agent ($f_3$): Launches MOOSE simulations (supporting parallel execution for parameter sweeps), streams solver output in real-time, and manages file I/O.
4. Reviewer Agent ($f_4$): Monitors for convergence failures. If a run fails, it parses the error log, classifies the failure (e.g., timestep too large, mesh resolution issues), proposes corrected parameters, and triggers a retry loop with the Input Writer. This occurs autonomously without user intervention.
5. Visualization Agent ($f_5$): Extracts quantitative kinetics (grain count $N(t)$), fits the data to physical laws (e.g., grain coarsening laws), performs Arrhenius regression, and generates a natural-language scientific interpretation of the results.

B. Architecture & Interoperability

• Plugin Architecture: Physics-specific logic is decoupled from the orchestration layer via a two-function contract (generate_input and parse_results). This allows new physics models (e.g., ferroelectric switching) to be added without modifying the core agents.
• Model Context Protocol (MCP): The entire workflow is exposed as an MCP server with 10 structured tools. This enables:
  • Headless operation: Integration with CI/CD pipelines, custom scripts, or external optimization loops.
  • Composability: AutoMOOSE tools can be chained with other AI agents (e.g., querying thermodynamic databases).
• Provenance & FAIR Data: Every run generates a self-documenting directory containing the input file, raw logs, parsed metrics, and a metadata.json file encoding all execution parameters, ensuring full reproducibility.

3. Key Contributions

1. Full Autonomous Lifecycle: First framework to close the loop from natural-language intent to quantitative, publication-ready analysis for phase-field simulations without human intervention.
2. Autonomous Failure Recovery: The Reviewer agent successfully diagnoses and corrects runtime convergence failures (e.g., adjusting timesteps, fixing duplicate declarations) in a single correction cycle.
3. Quantitative Self-Verification: The system performs an end-to-end consistency check by recovering the Arrhenius activation energy from simulation results and comparing it against the user-specified input value.
4. MCP Integration: Provides a standardized interface for integrating complex simulation workflows into broader AI-driven materials discovery pipelines.

4. Results

The system was validated on a four-temperature copper polycrystalline grain growth benchmark ($T = 300, 450, 600, 750$ K).

• Input File Fidelity:
  • Generated input files achieved 6/12 exact structural matches and 4/12 functional equivalences against an expert-written reference.
  • The generated files executed successfully on the first attempt after plugin validation.
• Kinetics & Physics Recovery:
  • Grain Coarsening: The system recovered grain coarsening kinetics with $R^2 = 0.90–0.95$ for $T \ge 600$ K.
  • Arrhenius Consistency: The system extracted an activation energy $Q_{fit} = 0.296$ eV from the simulation data, compared to the user-specified input $Q = 0.23$ eV. The discrepancy (28.7%) was attributed to finite-size effects in the 15-grain system, consistent with a human-written reference run ($Q_{fit} = 0.267$ eV).
• Autonomous Failure Correction:
  • During development, three distinct classes of runtime failures (duplicate object declarations, duplicate solver keys, unused parameters) were encountered.
  • The Reviewer agent diagnosed and resolved 100% of these failures autonomously within a single retry cycle.
• Performance:
  • Parallel execution of the 4-temperature sweep achieved a 1.8$\times$ wall-clock speedup over serial execution.
  • Total end-to-end time (prompt to analysis) was $\approx$ 380 minutes, dominated by compute time, with zero manual file editing.

5. Significance

• Bridging the Gap: AutoMOOSE bridges the gap between "knowing the physics" and "executing the simulation," lowering the barrier for non-experts to perform rigorous mesoscale modeling.
• Self-Driving Laboratories: By automating error recovery and quantitative analysis, it provides a pathway toward self-driving computational laboratories where AI agents can autonomously explore parameter spaces and optimize material properties.
• Reproducibility: The framework enforces FAIR (Findable, Accessible, Interoperable, Reusable) data principles by construction, ensuring that every simulation result is fully reproducible from its metadata.
• Scalability: The modular plugin design and MCP interface allow the framework to scale to new physics models and integrate seamlessly with high-throughput screening and Bayesian optimization workflows.

In conclusion, AutoMOOSE demonstrates that lightweight multi-agent orchestration can effectively manage the complexity of multiphysics simulations, transforming them from manual, expert-only tasks into automated, verifiable scientific workflows.