AutoMOOSE: An Agentic AI for Autonomous Phase-Field Simulation

Sukriti Manna; Henry Chan; Subramanian K. R. S. Sankaranarayanan

cs.AIMar 22, 2026

AutoMOOSE: An Agentic AI for Autonomous Phase-Field Simulation

Authors: Sukriti Manna, Henry Chan, Subramanian K. R. S. Sankaranarayanan

Organizations: Department of Mechanical and Industrial Engineering, University of Illinois Chicago, Chicago, IL 60607, USA · Center for Nanoscale Materials, Argonne National Laboratory, Lemont, IL 60439, USA

Abstract

Phase-field modeling links thermodynamics and kinetics to microstructural evolution, but multiphysics frameworks such as MOOSE require expertise to construct inputs, manage campaigns, diagnose failures, and validate results. We introduce AutoMOOSE, an open-source multi-agent framework that orchestrates the simulation lifecycle from a single natural-language prompt. Six specialized agents--Architect, Input Writer, Runner, Reviewer, Visualization, and a physics-grounded Skeptic--generate, execute, analyze, and adversarially test simulations against conservation laws, asymptotic limits, and scaling relations. We validate AutoMOOSE in two domains: non-conserved copper grain growth governed by Allen-Cahn dynamics and conserved Fe-Cr spinodal decomposition governed by Cahn-Hilliard dynamics. On a prospectively specified 25-task grain-growth benchmark spanning temperature, grain count, resolution, and model formulation, AutoMOOSE generates valid inputs for all 25 tasks, completes 19 simulations with measurable coarsening, and delivers 15 results that satisfy Burke-Turnbull kinetics ( $R^2 \geq 0.90$ ) and survive Skeptic falsification. The failures trace to two identifiable generator defects. An ensemble of 1000 simulations recovers the prescribed activation energy to within 1% after finite-size extrapolation ( $Q_\infty = 0.228$ eV versus $0.230$ eV). In the conserved domain, an agent-generated CALPHAD-based Fe-Cr simulation limits relative mass drift to $6.3 \times 10^{-6}$ , dissipates free energy to a stable plateau, and evolves toward the equilibrium tie-line. Controlled ablations show that the full pipeline converts stochastic raw generation--3-7 successful tasks out of 8 across repeated trials--into consistent success on all 8 tasks. AutoMOOSE therefore provides a practical route from natural-language specification to reproducible, physics-validated phase-field simulation campaigns.

Figures & tables

Figure 1: AutoMOOSE agentic pipeline. Six model-agnostic language-model agents ( $f_{1}$ – $f_{6}$ ), organized into a cognitive, an execution, and an epistemic layer, transform a natural-language prompt into a completed and physics-tested MOOSE phase-field simulation. In the cognitive layer , the Architect ( $f_{1}$ ) parses the user prompt into the structured simulation plan $\mathcal{P}$ (Eq. ( 9 )), encoding the physics model, mesh geometry, solver tolerances, and sweep parameters; the Input Writer ( $f_{2}$ ), a compound agent, then 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 2.9 ). In the execution layer , the Runner ( $f_{3}$ ) launches MOOSE and streams the solver log; the Reviewer ( $f_{4}$ ) screens each run for completion, distinguishing genuine solver breakdown from transient adaptive-timestep events (Section 2.6 ); and the Visualization agent ( $f_{5}$ ) extracts the coarsening kinetics and performs the Arrhenius analysis from CSV postprocessor output (Section 2.7 ). In the epistemic layer , the Skeptic ( $f_{6}$ ) adversarially tests each completed run against falsifiable physics invariants and classifies it as credible or falsified (Section 2.8 ); only credible runs enter campaign-level analysis. Recovery is triggered on two paths: a run that fails to complete is diagnosed from its solver-log signatures, and a completed run falsified for a correctable cause is diagnosed from the Skeptic’s verdict; either routes to the recovery module, which applies a bounded, logged correction (timestep, mesh, or integration window; at most three attempts) and re-enters the pipeline at the Input Writer (Section 3.7 ). Black arrows: forward path; green arrows: credible results; red arrows: recovery loop.

Backend	Weights	Hosting	Pipeline (end-to-end)
Claude Sonnet 4.6	Closed	Provider API	completes
Qwen2.5-32B-Instruct	Open	Self-hosted (Perlmutter, vLLM, 4 $\times$ A100)	completes

Table 1: AutoMOOSE runs on interchangeable backends. The same agent pipeline drives a grain-growth task end-to-end under both a closed-weights frontier model and a self-hosted open-weights model; switching backends requires only a configuration change, so the framework does not depend on any single provider’s availability.

Sub-agent	MOOSE blocks	Key parameters set	Depends on
(a) Mesh	[Mesh]	$n_{x}$ / $n_{y}$ / $n_{z}$ , $L_{x}$ / $L_{y}$ / $L_{z}$ , elem_type (QUAD4 or HEX8), parallel_type ; enforces $h\leq w_{\mathrm{GB}}/4$	$\Omega$ , $h$ , dim from $\mathcal{P}$
(b) Variables	[GlobalParams] , [Variables] , [ICs] , [AuxVariables]	op_num , $\eta_{i}$ fields, Voronoi or Random IC; bound_value (LinearizedInterface)	$n_{x}$ , $n_{y}$ from (a)
(c) Kernels	[Kernels] , [AuxKernels]	GrainGrowth or GrainGrowthLinearizedInterface module [ 7 ] ; BndsCalcAux , FeatureFloodCountAux	op_num , $\eta_{i}$ from (b)
(d) Materials	[Materials] , [UserObjects]	$L$ , $\mu$ , $\kappa$ via Eq. ( 4 ) [ 5 ] ( GBEvolution ) or parsed $L$ / $\kappa$ / $\mu$ ( LinearizedInterface ); PolycrystalVoronoi , GrainTracker	$\{\sigma,w_{\mathrm{GB}},M_{0},Q\}$ from $\mathcal{M}$ ; mesh from (a)
(e) Postprocessors	[Postprocessors]	TimestepSize , NumDOFs , NumElements	Variables from (b) , UserObjects from (d)
(f) Executioner	[Executioner] , [BCs] , [Adaptivity] , [Outputs]	PJFNK [ 25 ] , bdf2 , IterationAdaptiveDT , $\epsilon_{\mathrm{nl}}$ , $\epsilon_{\mathrm{l}}$ , periodic BCs, AMR, CSV	$\boldsymbol{\theta}_{\mathrm{solver}}$ , $\boldsymbol{\theta}_{\mathrm{run}}$ from $\mathcal{P}$

Table 2: Input Writer sub-agents and MOOSE block responsibilities. The six sub-agents of

f_{2}

generate the MOOSE .i input file in the topological order of Eq. ( 10 ). The Depends on column lists upstream fields that must be available before each sub-agent executes.

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. ( 6 )), 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. ( 11 )) from within this directory, satisfying FAIR data principles by construction [ 1 ] .

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. ( 8 )). Top: four supported client entry points — Claude Desktop, Claude Code, custom scripts, and CI/CD pipelines — all communicating via HTTP and Server-Sent Events (SSE) on port 8001. Left: the AutoMOOSE agent pipeline forms 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 verification verdicts). Execution outcomes return through the verification stages (the Reviewer’s completion screen and the Skeptic’s falsification); on a recoverable divergence, the closed-loop recovery module re-enters the pipeline with a bounded correction (Section 3.7 ). 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 3 ). 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.

Tool	Class	Description
health_check	$\dagger$	Verify server and backend availability
list_plugins	$\dagger$	Enumerate registered plugins and their status
generate_input	$\dagger$	Render a MOOSE .i file via the plugin registry
run_simulation	$\ddagger$	Launch a single MOOSE job; return run identifier
run_sweep	$\ddagger$	Fan out a parametric sweep; return run identifiers
get_run_status	$\dagger$	Query the terminal or running state of a job

Table 3: MCP tools exposed by the AutoMOOSE server. Tools marked (

\dagger

) are available to all agents; tools marked (

\ddagger

) execute or modify simulation state and are accessible only to the Runner agent

f_{3}

under the orchestrator’s permission policy. Full argument schemas are given in Table S3 (Supplementary Information).

Agent	Stage	1 st -attempt	Key metric
$f_{1}$ Architect	Intent parsing	1/1	Correct sweep intent, formulation, BCs
$f_{2}$ Input Writer	.i file generation	4/4	6/12 blocks exact match (Section 3.4 )
$f_{3}$ Runner	Parallel execution	4/4	$T_{\mathrm{sweep}}\approx 22{,}820$ s ( $1.8\times$ vs. serial, scheduling only)
$f_{4}$ Reviewer	Completion screen	—	3/3 failed runs flagged (Section 3.7 )
$f_{5}$ Visualization	Kinetics extraction	4/4	$R^{2}=0.90$ – $0.95$ at $T\geq 600$ K (Section 3.5 )
End-to-end		4/4	Prompt $\to$ kinetics analysis: $\approx 380$ min

Table 4: AutoMOOSE agent pipeline performance on the four-temperature grain growth benchmark (

T\in\{300,450,600,750\}

K). First-attempt success: correct output without Reviewer intervention. Timing on a MacBook Pro (Apple M-series, single core).

$T$ (K)	Timesteps	$N_{f}$	DOFs (peak)	Wall time (s)
300	31	15	260,124	509
450	85	13	261,862	4,165
600	306	6	261,086	13,768
750	602	3	260,832	22,820
Serial total				41,261
Concurrent (bounded by slowest run)				22,820

Table 5: Per-run execution statistics for the four-temperature grain growth sweep on a MacBook Pro (Apple M-series, single core per run). All runs dispatched concurrently via the run_sweep MCP tool.

N_{f}

: final grain count at

t=4000

ns; DOFs: peak degrees of freedom.

T=300

K shows no coarsening due to Arrhenius suppression (Section 3.5 ). The

1.8\times

reduction is a workflow-level scheduling effect — independent cases run concurrently, so wall-clock time is bounded by the slowest run — and not a solver-level acceleration of MOOSE.

Regime	$n$	G1	G2	G3	G4	G5	Valid & runs	Full
Core ( $T$ , $N$ sweep)	8	8	8	8	6	8	8/8	6/8
Resolution / domain	4	4	4	4	4	4	4/4	4/4
Formulation (Lin. Interface)	4	4	0	4	3	4	0/4	0/4
Robustness (seeds)	4	4	4	4	2	4	4/4	2/4
3D	2	2	0	0	0	1	0/2	0/2
High- $T$ stress	2	2	2	2	2	2	2/2	2/2

Table 6: AutoMOOSE performance across the

n{=}25

benchmark regimes (production integration length; each task on a dedicated Perlmutter node within a 12-hour allocation). G1: valid input generated; G2: ran to completion within the wall-clock window; G3: coarsened (

N_{f}<N_{0}

); G4: parabolic (Burke–Turnbull) kinetics (

R^{2}\geq 0.90

); G5: positive rate constant. Valid & runs counts G1–G3; Full counts all five gates.

Figure 4: Fe–Cr spinodal decomposition (500 ∘ C): composition evolution and Skeptic validation invariants. Top two rows: composition field $c(x,y)$ at increasing times, from the noisy initial condition through an interconnected spinodal pattern to grown, well-separated Cr-rich domains (each panel independently scaled to its composition range). Bottom row: (a) $S_{1}$ Cr-mass conservation, relative drift $6.28\times 10^{-6}$ , within the $10^{-5}$ tolerance; (b) $S_{2}$ free-energy dissipation, net decrease to a stable plateau (transient round-off increases within tolerance); (c) $S_{3}$ phase separation toward the equilibrium tie-line (Cr-rich $0.823$ , Fe-rich $0.236$ mol fraction).

Invariant	Value
Relative Cr-mass drift	$6.28\times 10^{-6}$
Free-energy decrease	0.4%
Energy monotone (transient increasing steps)	within tol. (15)
Final Cr range	$[0.239,\,0.826]$
Cr-rich precipitates (final)	1

Table 7: Fe–Cr spinodal-decomposition (Cahn–Hilliard) validation invariants from the AutoMOOSE run (500 ∘ C). Equilibrium target concentrations 23.6 / 82.3 mol% Cr; the Cr-mass drift is assessed against the Skeptic

S_{1}

tolerance (

10^{-5}

Figure 5: Matched-cell parity between AutoMOOSE-generated and human-reference runs. Across 14 matched grain-count/temperature cells, the agent-generated and human kinetic outputs agree closely (slope $1.023$ , Pearson $r=0.9887$ , median absolute deviation $3.4\%$ ), confirming that structural fidelity carries through to functionally equivalent simulation output.

Structural completeness (all 12 blocks present & valid)
Set	$n$	blocks present	blocks valid
AutoMOOSE-generated	1000	12/12	12/12
Human reference	100	12/12	12/12
Content agreement, 100 matched pairs (per block, over 100 pairs)
Block	exact	approx	differs
Mesh, UserObjects, ICs, Modules	100	0	0

Table 8: Input-file fidelity. Top: structural completeness — fraction of inputs in which each block is present and well-formed — across 1000 AutoMOOSE-generated inputs and 100 human reference inputs. Bottom: block-by-block content agreement across 100 matched human–agent pairs (same grain count, temperature, seed), scored over non-prompt parameters only: “exact” = zero mismatched parameters, “approx” = exactly one (functionally equivalent), “differs” = two or more (physically valid alternative); see Section 3.4 for the full criteria.

Block	Key parameter / setting	Human	AutoMOOSE
[Mesh]	nx/ny = 44 vs. 12 ; uniform_refine	✓	$\times$
[GlobalParams]	op_num = 8 vs. 15 ; var_name_base	✓	$\approx$
[UserObjects]	PolycrystalVoronoi + GrainTracker	✓	✓
[ICs]	PolycrystalColoringIC	✓	✓
[Modules]	GrainGrowth phase-field module	✓	✓
[AuxVariables]	bnds , unique_grains , var_indices	✓	✓

Table 9: Block-by-block input file comparison between the expert reference [ 2 ] and the AutoMOOSE-generated file (

T=450

K, 15 Voronoi grains,

12\times 12

mesh). ✓: exact match;

\approx

: functionally equivalent, minor difference;

\times

: differs from reference (physically valid; see text). Full annotated listing: Figure S11 .

Figure 7: 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 8 a). No user intervention was required.

Figure 8: Grain growth kinetics and Arrhenius analysis: AutoMOOSE vs. human-written reference. (a) AutoMOOSE $N(t)$ ( rand_seed $=42$ ); circles, dashed lines: $1/N$ linear fit (Eq. ( 6 )). (b) Human-written $N(t)$ ( rand_seed $\in\{10,30\}$ ); squares. (c) AutoMOOSE Arrhenius plot; $Q_{\mathrm{fit}}=0.296$ eV, $R^{2}=0.994$ . (d) Human-written Arrhenius plot; $Q_{\mathrm{fit}}=0.267$ eV, $R^{2}=0.996$ . Both sets: $12\times 12$ mesh, $N_{0}=15$ , refinement level 3, copper GBEvolution parameters ( $Q=0.23$ eV [ 3 ] ). Colors: $T=300$ K (navy), $450$ K (vivid blue), $600$ K (deep orange), $750$ K (amber).

	AutoMOOSE			Human-written
$T$ (K)	$N_{f}$	$\tilde{k}$ ( $\times 10^{-6}$ ns -1 )	$R^{2}$	$N_{f}$	$\tilde{k}$ ( $\times 10^{-6}$ ns -1 )	$R^{2}$
300	15	suppressed		15	suppressed
450	13	$2.863$	$0.749$	13	$2.850$	$0.750$
600	6	$23.51$	$0.898$	7	$18.40$	$0.804$
750	3	$58.67$	$0.951$	4	$43.46$	$0.922$

Table 10: Grain coarsening fit parameters from linear regression of

N^{-1}(t)

(Eq. ( 6 )).

N_{f}

: final grain count at

t=4000

ns.

T=300

K excluded: Arrhenius-suppressed (

N=\mathrm{const}

Figure 9: Ensemble Arrhenius analysis over the 1000 AutoMOOSE / 100 human-written runs. Per-temperature ensemble-mean rate constants

\tilde{k}(T)

(mean

\pm

standard error over admissible seeds) for the converged grain-count ensembles, with the standard-error-weighted Arrhenius fit of

\ln\tilde{k}

against

1/T

. The fit recovers the input activation energy within statistical uncertainty.

Figure 10: Finite-size dependence of the recovered activation energy.

Q_{\mathrm{fit}}

as a function of initial grain count

N_{0}

: the recovered value decreases from the finite-size-inflated small-system estimate toward a plateau at large

N_{0}

. An inverse-variance fit over the converged sizes (

N_{0}\leq 200

) gives

Q_{\infty}=0.228

eV against the input

Q=0.230

eV;

N_{0}=500

is resolution-limited (6.5 cells per grain) and excluded from the fit.

Quantity	AutoMOOSE	Human-written
Slope $(-Q_{\mathrm{fit}}/k_{\mathrm{B}})$ (K)	$-3{,}436$	$-3{,}095$
$Q_{\mathrm{fit}}$ (eV)	$0.296$	$0.267$
Input $Q$ (eV)	$0.230$
$R^{2}$	$0.994$	$0.996$

Table 11: Arrhenius fit summary.

Q_{\mathrm{fit}}

from the slope of

\ln\tilde{k}

vs.

T^{-1}

(Eq. ( 20 ));

T=450

600

750

K only. Input:

Q=0.23

eV [ 3 ] .

Class	Error	Root cause	Correction
I	Duplicate object name in registry	GrainTracker declared in both [UserObjects] and [Postprocessors]	Remove [Postprocessors] entry
II	Duplicate key in [Executioner]	solve_type = PJFNK emitted twice by Executioner sub-agent	Deduplicate output template
III	Unused parameter abort	interval not recognised in [Outputs/exodus]	Remove interval parameter

Table 12: Input-level defects caught by the execution screen during GrainGrowth plugin development. Each defect produces an unambiguous MOOSE error signature, and each correction is a single re-generation plus re-execution.

Condition	G1 strict	G1 lenient
Raw entries: mean (min–max) over 3 independent runs.
AutoMOOSE plugin	8/8	8/8
raw Opus 4.8 (claude-opus-4-8)	5.0 (3–7)/8	5.3 (3–8)/8
raw Sonnet 4.6 (claude-sonnet-4-6)	0.3 (0–1)/8	2.0 (1–3)/8
raw GPT-4o (gpt-4o)	0/8	0/8

Table 13: Ablation and baseline comparison on

n{=}8

core grain-growth tasks, scored on G1 (input validity via --check-input ). AutoMOOSE is the deterministic plugin (identical output on every invocation); raw conditions prompt the bare model directly with the same task and no plugin scaffolding, repeated across independent runs to characterize stochasticity (ranges shown). Strict requires a clean parse; lenient ( --allow-unused ) ignores deprecated-but-harmless parameters, matching the checking applied to AutoMOOSE’s own benchmark runs. The frontier models the reviewer named were used (Claude Opus 4.8, exceeding the requested Opus 4.7+); GPT-5.x was not API-accessible at the time of testing, so GPT-4o is reported.

File	Lines	Language	Role
plugin.py	655	Python	GrainGrowth plugin: implements generate_input(**params) $\to$ str and parse_results(csv) $\to$ dict . Replace to add new physics.
server.py	375	Python	FastAPI backend: agent orchestration, sweep threading, Server-Sent Events (SSE) log streaming, record.json writer, Model Context Protocol (MCP) server (ports 8000 and 8001).
App.jsx	1,143	React	Browser frontend: Chat, Configure, Input File, Live Log, Results, and Run Sidebar panels (Vite/Tailwind build).
mcp_server.py	210	Python	Standalone MCP server exposing 10 tools (Table S15 ); supports stdio and SSE transports.
plugin_registry.py	48	Python	Dynamic plugin loader; scans plugins/ and registers generate_input / parse_results contracts at startup.
skeptic.py	—	Python	Skeptic agent ( $f_{6}$ ): physics-grounded falsification battery (grain-growth invariants $T_{1}$ – $T_{5}$ , conserved-dynamics invariants $S_{1}$ – $S_{3}$ ); dispatches the invariant set appropriate to the governing equations and emits a credible/falsified verdict with diagnosis.

Table S14: AutoMOOSE v2 codebase structure. Upper block: user-facing files requiring configuration. Lower block: infrastructure modules.

Tool	Stage	Description and key arguments
health_check	—	Server status, MOOSE executable path, API key validity.
list_plugins	—	Registered plugins with status and supported formulations.
generate_input	$f_{2}$	Renders .i file from parameter dict. Args: params: dict , plugin: str .
run_simulation	$f_{3}$	Launches single MOOSE run. Args: input_file , n_mpi , run_id .
run_sweep	$f_{3}$	Dispatches parallel sweep; returns run_id list. Args: sweep_param , values , base_params .
get_run_status	$f_{3}$	Real-time status (queued/running/done/failed). Args: run_id .

Table S15: AutoMOOSE MCP server tool index.

Eq.	Expression	Component (SP)	Role
( 8 )	$\mathcal{S}=f_{5}\circ\cdots\circ f_{1}(\mathcal{U})$	All agents	Pipeline abstraction
( 9 )	$\mathcal{P}=(\Omega,h,\mathcal{M},\mathcal{B},\boldsymbol{\theta}_{\mathrm{s}},\boldsymbol{\theta}_{\mathrm{r}},\mathcal{O})$	All agents (SP S1.1 )	Shared simulation plan
( 10 )	DAG block order	$f_{2}$ (SP S1.2 , rule 1)	Dependency-consistent block generation
( 11 )	mpiexec -n $N_{\mathrm{MPI}}$	$f_{3}$ (SP S1.3 )	Execution command
( 12 )	$T_{\mathrm{sweep}}=\max_{i}T_{i}$	$f_{3}$ + Sweep Orchestrator	Parallel sweep wall-clock bound
( 13 )	$\\|\mathbf{R}^{(k)}\\|_{2}<\epsilon_{\mathrm{nl}}$	$f_{4}$ (SP S1.4 )	Nonlinear convergence criterion

Table S16: Equation index for AutoMOOSE. Cross-reference of the main-text equations to the pipeline component that uses each and its role. SP = system prompt in Section S1 .

Prov.	N 0	T	valid/tot	yield	cells/grain	$\tilde{k}\pm$ SE ( $\times 10^{-6}$ )	Gate
auto	20	350	0/40	0.00	32.3	–	fail
auto	20	400	0/40	0.00	32.3	–	fail
auto	20	450	8/40	0.20	32.3	6.670 $\pm$ 0.771	fail
auto	20	500	20/40	0.50	32.3	9.973 $\pm$ 0.637	fail
auto	20	550	29/40	0.72	32.3	15.326 $\pm$ 0.960	pass
auto	50	350	0/40	0.00	20.4	–	fail

Table S17: Per-cell seed yield and resolution for the ensemble campaign. A cell enters the Arrhenius/finite-size fits only if yield

\geq 0.60

and

\geq 5

valid seeds. “Res.” marks resolution-limited cells (

<8

cells per grain).

ID	Regime	$N_{0}\!\to\!N_{f}$	$R^{2}$	G1	G2	G3	G4	G5	Verdict
GG01	Core	20 $\to$ 16	0.83	✓	✓	✓	✗	✓	near
GG02	Core	20 $\to$ 15	0.85	✓	✓	✓	✗	✓	near
GG03	Core	30 $\to$ 13	0.97	✓	✓	✓	✓	✓	cred.
GG04	Core	30 $\to$ 12	0.96	✓	✓	✓	✓	✓	cred.
GG05	Core	30 $\to$ 12	0.95	✓	✓	✓	✓	✓	cred.
GG06	Core	30 $\to$ 13	0.97	✓	✓	✓	✓	✓	cred.

Table S18: Per-task outcomes for the 25-task evaluation set, at production integration length.

N_{0}\!\to\!N_{f}

: initial and final grain count;

R^{2}

: the parabolic Burke–Turnbull kinetics fit. Gates G1–G5 as defined in the main text (Section 2.13 ). Verdict: cred. = credible (all five gates pass and the Skeptic admits the run); near = near-miss (coarsens but parabolic

R^{2}<0.90

); fals. = falsified by the Skeptic or failed a hard gate. Prompts are listed verbatim in Section S7.1 .

Computational Materials Science

Computational materials science uses computation and data-driven models to predict, explain, and design materials and their properties.

See all 141 papers

Aug 16, 2026

Deploying Frontier Agentic Technology in MOOSEnger, a Multiphysics-Capable AI Assistant

The Multiphysics Object-Oriented Simulation Environment (MOOSE) is an open-source finite-element framework for building multiphysics simulation applications. Using a multiphysics environment effectively demands specialized expertise, creating a barrier for many domain scientists and engineers. MOOSEnger, developed at Idaho National Laboratory (INL), is a domain-specific, tool-enabled AI agent built for the MOOSE Framework. This work extends MOOSEnger with a harness focused on locally-hosted models. The harness gives the agent a full pipeline: it retrieves contextual knowledge from the MOOSE repository, validates and diagnoses the resulting input through interaction with the simulation executable environment, and extracts and stores lessons in a persistent memory. The resulting framework is demonstrated on an engineering problem from the National Reactor Innovation Center Virtual Test Bed (VTB), illustrating its potential to support realistic multiphysics simulation workflows. Additionally, the agent performance is evaluated on different categories including diffusion, Navier--Stokes, phase field, plasticity, porous media flow, solid mechanics, transient heat transfer, and reactor mesh generation. Each category consists of 25 prompts/cases. We compare MOOSEnger-Gemma4 against MOOSEnger-GPT-5.2, alongside baseline Gemma4 and GPT-5.2 without agentic capabilities. MOOSEnger-GPT-5.2 shows a slight edge, achieving a 90% success rate versus 76.5% for MOOSEnger-Gemma4. The baseline models perform far worse, at just 5% (GPT-5.2) and 0% (Gemma4), underscoring the impact of the agentic harness.

Zaid Abulawi, Mengnan Li, Guillaume Giudicelli +2

Department of Nuclear Engineering, Texas A&M University (TAMU), TX, USA · Idaho National Laboratory (INL), ID, USA

Tool-Augmented Language Model Agents LLM Agent Harnesses AI Agents for Scientific Discovery Agentic RAG Multiphysics Simulation Memory-Augmented Agents

Ask PDF

Mar 5, 2026

MOOSEnger: A Simulation-Aware AI Agent Framework for the MOOSE Ecosystem

MOOSEnger is a modeling and simulation AI agent framework for the Multiphysics Object-Oriented Simulation Environment (MOOSE) ecosystem, built around a simulation-aware harness that combines an interchangeable reasoning model with grounded domain knowledge, revised simulation artifacts, MOOSE-specific validation, and executable solver feedback. This surrounding system addresses a central limitation of one-shot large language model generation: small syntax, schema, reference, or solver-configuration errors can prevent a plausible input from executing, while successful execution alone does not establish scientific correctness. MOOSEnger's simulation-aware harness integrates MOOSE knowledge retrieval, Hierarchical Input Text (HIT)-aware parsing, syntax metadata, language-server diagnostics, revision-controlled authoring, and local or MCP-backed validation and execution in a generate-check-repair-run workflow that binds evidence to each input revision and guides bounded repair before acceptance. Across 200 prompts spanning eight simulation families, the MOOSEnger harness increases executable success from 10/200 (5%) to 179/200 (89.5%) with GPT 5.2 API and from 0/200 to 153/200 (76.5%) with Gemma 4 31B. A complementary ten-case Method of Manufactured Solutions benchmark moves beyond executability: all ten generated inputs satisfy the semantic-alignment criterion, and eight execute successfully while meeting the prescribed single-mesh numerical-accuracy criterion. These results show that executable reliability depends on the complete agent system rather than on the reasoning model alone, and that simulation-aware harnessing provides a path toward physics-informed verification and future full application-level and engineering verification and validation implementation.

Mengnan Li, Jason Miller, Zaid Abulawi +7

Idaho National Laboratory, 995 MK Simpson Blvd, Idaho Falls, 83401, ID, USA

AI Agent Reliability Agentic Code Generation LLM Agent Reliability

Ask PDF

Mar 31, 2026

SimMOF: AI agent for Automated MOF Simulations

Metal-organic frameworks (MOFs) offer a vast design space, and as such, computational simulations play a critical role in predicting their structural and physicochemical properties. However, MOF simulations remain difficult to access because reliable analysis require expert decisions for workflow construction, parameter selection, tool interoperability, and the preparation of computational ready structures. Here, we introduce SimMOF, a large language model based multi agent framework that automates end-to-end MOF simulation workflows from natural language queries. SimMOF translates user requests into dependency aware plans, generates runnable inputs, orchestrates multiple agents to execute simulations, and summarizes results with analysis aligned to the user query. Through representative case studies, we show that SimMOF enables adaptive and cognitively autonomous workflows that reflect the iterative and decision driven behavior of human researchers and as such provides a scalable foundation for data driven MOF research.

Jaewoong Lee, Taeun Bae, Jihan Kim

Department of chemical and Biomolecular Engineering, Korea Advanced Institute of Science and Technology (KAIST), 291 Daehak-ro, Yuseong-gu, Daejeon 34141, Republic of Korea

Scientific Workflow Automation Materials Science Computational Materials Science Multi-Agent LLM Systems

Ask PDF

Abstract

Computational Materials Science

Explore similar work

Deploying Frontier Agentic Technology in MOOSEnger, a Multiphysics-Capable AI Assistant

MOOSEnger: A Simulation-Aware AI Agent Framework for the MOOSE Ecosystem

SimMOF: AI agent for Automated MOF Simulations