GRACE: an Agentic AI for Particle Physics Experiment Design and Simulation

This paper introduces GRACE, an agentic AI system that autonomously designs and optimizes particle physics experiments by extracting structured representations from natural language or papers, constructing simulations, and iteratively proposing and evaluating detector modifications using first-principles Monte Carlo methods to improve physics performance under physical and budgetary constraints.

The Gist

Imagine you are an architect trying to design the ultimate skyscraper. Usually, you'd spend years drawing blueprints, running computer models, and arguing with engineers about whether the building will stand up in a hurricane.

Now, imagine you have a super-intelligent, tireless apprentice named GRACE.

GRACE isn't just a calculator; it's a "simulation-native agent." Here is what that means in plain English, using some everyday analogies:

1. The Problem: The "Human Bottleneck"

Designing particle physics experiments (like giant machines that smash atoms to find new secrets) is incredibly hard. It involves complex math, massive computers, and thousands of variables.

• The Old Way: Human scientists spend years manually tweaking designs, running simulations, and hoping they don't miss a better option. It's slow, expensive, and limited by how many hours a human can stay awake.
• The New Way: GRACE takes the wheel. It doesn't just follow orders; it thinks about the design itself.

2. How GRACE Works: The "Virtual Architect"

Think of GRACE as a master architect who lives entirely inside a video game engine.

• The Input (The Brief): You can talk to GRACE in plain English ("Design a detector to catch dark matter") or hand it a scientific paper.
• The Brain (The Agent): GRACE reads your request, figures out the rules of physics (like gravity or how light travels), and starts sketching. It doesn't just guess; it builds a toy version of the experiment in a computer.
• The Loop (The Trial and Error):
  1. Observe: GRACE looks at the current design.
  2. Plan: It says, "Hmm, if I make this wall thicker, maybe we catch more particles."
  3. Execute: It runs a super-fast simulation (like a flight simulator for atoms).
  4. Verify: It checks the results against the laws of physics. "Wait, that design breaks the laws of nature! Let's try again."
  5. Iterate: It repeats this thousands of times, getting smarter with every try.

3. The "Budget" Analogy: Fast vs. Slow Simulations

Running a perfect simulation of a particle smashing into a detector is like running a high-end video game on a supercomputer—it takes forever and costs a lot of money.

• GRACE's Trick: It starts with a cheap, fast sketch (like a rough pencil drawing) to test 100 different ideas quickly.
• Escalation: If an idea looks promising, GRACE says, "Okay, this one is worth the cost," and switches to a high-definition, expensive simulation (like a photorealistic 3D render) to get the final answer. This saves time and money by not wasting resources on bad ideas.

4. What Did GRACE Actually Do? (The Test Drive)

The authors tested GRACE on real-world physics problems to see if it could think like a human expert.

• Test 1: The Electron Catcher (Calorimeter):
  • The Task: Design a machine to measure electron energy perfectly.
  • GRACE's Move: It tried different shapes and materials. It realized that arranging crystals in a specific "tower" shape (like a honeycomb) was much better than a solid block. It found a solution that matched what real-world experts (like the CMS experiment at CERN) had discovered, but GRACE found it on its own just by simulating physics.
• Test 2: The Muon Filter:
  • The Task: Build a shield to stop unwanted particles while letting muons (a type of subatomic particle) pass through.
  • GRACE's Move: It figured out that making the iron walls thicker was the key to stopping the bad particles, even though it made the machine slightly heavier. It quantified the trade-off: "If we add 10% more iron, we stop 7 times more bad particles."
• Test 3: Reading a Paper (DarkSide-50):
  • The Task: GRACE was given a published paper about a dark matter detector. It was told: "Read the design, but do not look at the results in the paper. Build your own simulation and tell us how it should work."
  • GRACE's Move: It built a virtual version of the detector from scratch. It correctly predicted that adding more light sensors would make the detector much better at seeing dark matter. This proved GRACE could learn from a blueprint and improve it without "cheating" by looking at the answer key.

5. Why This Matters

GRACE isn't trying to replace scientists. Think of it as a super-powered research assistant.

• It doesn't get tired: It can run 1,000 simulations overnight.
• It doesn't get biased: It doesn't have "gut feelings" that might be wrong; it only trusts the math.
• It keeps a diary: Every step, every change, and every reason for a decision is recorded perfectly. You can replay the whole experiment later to see exactly how GRACE got there.

The Bottom Line

GRACE is a new kind of AI that treats scientific discovery like a video game level. It reads the rules, tries millions of strategies, and finds the winning move faster than any human team could. It's a step toward a future where computers don't just crunch numbers, but actually help us design the next great discoveries in physics.

Technical Summary

1. Problem Statement

Modern experimental physics, particularly in high-energy and nuclear physics, relies on complex software stacks (e.g., Geant4, ROOT) for design, optimization, and interpretation. However, the experimental design phase remains a bottleneck due to:

• Human Limitations: Design decisions rely on human intuition and limited parameter scans within a vast design space.
• Existing AI Gaps: Current agentic AI systems focus on executing predefined procedures (e.g., accelerator tuning, data analysis) or operational control. They do not address the upstream problem of autonomous experimental design—proposing non-obvious modifications to detector geometry, materials, and configurations to improve physics performance under physical constraints.
• Simulation Complexity: The computational cost of high-fidelity simulations (Monte Carlo) makes exhaustive exploration infeasible without intelligent guidance.

2. Methodology: The GRACE Framework

GRACE (Generative Reasoning Agentic Control Environment) is a simulation-native agent designed to treat experimental design as a constrained search problem under physical law.

Core Architecture

GRACE operates in a closed-loop cycle mirroring the scientific method: Observe → Plan → Execute → Verify → Update → Iterate.

• State Representation: The agent maintains a 5-tuple state $S = (H, E, R, A, P)$ representing Hypothesis, Experiment configuration, Run artifacts, Analysis results, and Provenance metadata. This ensures full reproducibility.
• LLM-Driven Reasoning: The system is LLM-agnostic (supporting Claude, GPT, Ollama models) and uses Large Language Models for task classification, workflow planning, and error recovery rather than hardcoded taxonomies.
• Knowledge Graph (KG) & Physics Verifier: Unlike standard code validators, GRACE uses a Physics Verifier that checks outputs against domain-specific Knowledge Graphs (e.g., material properties, interaction physics). It detects physically unreasonable results even if the code executes successfully.
• Fair-Date Constraint: When analyzing published papers, the agent enforces a "fair-date" knowledge cutoff, extracting only design specifications and avoiding published performance data. This prevents the agent from "cheating" by looking up answers; it must discover performance via simulation.

Fidelity Tiers and Budgeted Escalation

To balance speed and accuracy, GRACE employs a tiered simulation system:

• T0: Fast parametric models (Pythia8 → Delphes).
• T1: Heavy reconstruction.
• T2: Full Geant4 simulation.
• T3: Full chain with optical physics (scintillation, Rayleigh scattering).
  The agent autonomously selects the fidelity tier based on task requirements and auto-escalates (e.g., from T0 to T2) when detailed physics (like optical photon transport) is required or when verification fails.

Tool Registry

The agent dispatches tasks to a registry of physics tools, including:

• Geometry: Generates GDML files for Geant4 (supporting box, cylinder, and projective tower topologies).
• Simulation: Geant4 (with Opticks GPU backend for optical photons) and Pythia8.
• Analysis: ROOT, FastJet, and Python scripts.
• Ingestion: LLM-based parsing of PDFs to extract design parameters.

3. Key Contributions

1. Shift from Execution to Design: GRACE is the first agentic system to autonomously propose and evaluate new detector geometries and material configurations, rather than just optimizing existing workflows.
2. Simulation-Native Reasoning: It treats simulation not as a passive evaluator but as an active epistemic tool for hypothesis generation and counterfactual reasoning.
3. Provenance and Reproducibility: The system maintains strict provenance tracking (container digests, git commits, RNG seeds) and generates structured scientific memory, ensuring every design iteration is auditable.
4. Novel Benchmarking: The authors introduce a benchmark suite involving natural language prompts and published papers (DarkSide-50, ProtoDUNE) to test autonomous design capabilities.

4. Results and Benchmarks

The framework was tested on four scenarios: two natural language prompts and two published papers.

A. Natural Language Prompts

1. Electromagnetic Calorimeter Design:
   • Task: Design a calorimeter for 0.5–10 GeV electrons.
   • Outcome: The agent autonomously selected PbWO4 crystals in a projective tower geometry. It identified a 38.7% improvement in energy resolution compared to a single-block design, aligning with real-world CMS detector choices. It correctly parameterized resolution ($\sigma_E/E = a/\sqrt{E} \oplus b$) and identified trade-offs between stochastic and constant terms.
2. Muon Spectrometer Design:
   • Task: Design a spectrometer to identify muons (5–100 GeV) and reject pions.
   • Outcome: The agent compared planar, cylindrical, and thick-absorber designs. It quantified a 7.4× improvement in pion rejection by increasing iron thickness, correctly identifying the trade-off with muon energy resolution.

B. Paper-Based Optimization (DarkSide-50 & ProtoDUNE)

1. DarkSide-50 (Dark Matter Detector):
   • Task: Extract design from the paper, simulate, and propose optimizations without using measured performance data.
   • Outcome: The agent simulated the detector, calculated light yield (~1479 PE/MeV), and characterized nuclear recoil discrimination. It autonomously proposed increasing PMT count from 75 to 100, predicting a 204% increase in light yield at 5 MeV. This aligns with the actual DarkSide-20k upgrade path (moving to high-coverage SiPMs).
2. ProtoDUNE (Neutrino Detector):
   • Task: Optimize the photon detection system for a liquid argon TPC.
   • Outcome: The agent proposed two strategies: Enhanced Coverage (increasing PMTs to 100, predicting 33% light yield gain) and Enhanced Uniformity. It correctly diagnosed that the baseline was limited by photon detection area rather than transport efficiency.

Performance Metrics

• Execution Reliability: Achieved 100% success rate across 42 tool executions in prompt-based tasks and 16/16 steps in DarkSide-50.
• Autonomy: No replanning was required for the prompt-based tasks; the agent successfully decomposed complex goals into multi-step workflows.
• Alignment: The agent's optimization directions (increasing photosensor coverage, optimizing geometry) consistently aligned with known upgrade priorities in the respective collaborations.

5. Significance and Future Work

• Scientific Impact: GRACE demonstrates that AI can act as an "exploratory partner" in experimental physics, surfacing non-obvious design modifications and providing reproducible rationales. It bridges the gap between agentic AI and the simulation-driven nature of modern physics.
• Epistemic Shift: The work reframes simulation from a passive scoring tool to an active component of the scientific reasoning loop.
• Limitations & Future Directions:
  • Current simulations are idealized (e.g., 100% detection efficiency in ProtoDUNE runs) and lack some real-world noise factors.
  • The agent does not yet autonomously diagnose why an anomaly occurred (e.g., unexpected position resolution trends) without human intervention.
  • Future Development: The authors plan to implement a multi-agent "Hypothesis Evolution" system where competing agents advocate for different designs, with Monte Carlo simulation acting as the objective arbiter to select the best hypotheses.

In conclusion, GRACE establishes a new paradigm for autonomous scientific reasoning, proving that simulation-driven agents can effectively navigate the complex design spaces of particle physics experiments to propose physically meaningful optimizations.