FERMIACC: Agent-Based AI in Particle Theory

• FERMIACC is a scaffolded, agent-based AI system that automates the generation and exploration of viable particle theory hypotheses for high-energy collider data.
• It employs a modular workflow that transforms experimental analyses into executable benchmarks through hypothesis refinement, simulation, and quantitative validation.
• The system uniquely couples language-model–driven hypothesis proposals with deterministic tools like FeynRules/UFO, MadGraph, Pythia, and Delphes for collider recasting.

FERMIACC is a scaffolded, agent-based AI system for particle theory designed to autonomously generate and quantitatively validate theory hypotheses for high-energy physics data at scale. Built on the OpenAI Agents SDK and coupled to deterministic phenomenology software, it is intended not as a conversational assistant for beyond-the-Standard-Model physics, but as an end-to-end workflow that reads experimental analyses, proposes executable Standard Model extensions, simulates their collider signatures, applies analysis cuts, and evaluates whether they can plausibly explain a target feature in the data (Agrawal et al., 23 Mar 2026).

1. Scientific role and conceptual framing

FERMIACC addresses a specific problem in collider phenomenology: the difficulty is often not deriving a unique theory from existing data, but navigating a very large space of viable theories that remain compatible with current measurements at fixed precision. In the formulation given for the system, effective field theory decoupling implies that there can be infinitely many UV-consistent explanations for the same low-energy signal. FERMIACC is designed to explore that space systematically by proposing, refining, simulating, and discriminating among plausible hypotheses (Agrawal et al., 23 Mar 2026).

The system is explicitly framed as an “AI Fermi” rather than an “AI Einstein.” The intended function is therefore not to infer a unique fundamental theory from incomplete evidence, but to automate the theorist’s practical workflow: reading an experimental paper, extracting the relevant signal structure, proposing candidate BSM explanations, encoding them as executable models, and pushing them through a deterministic collider-recasting pipeline. In this formulation, the central bottleneck in high-energy theory is human attention rather than a lack of formal calculational tools.

This framing also distinguishes FERMIACC from unrestricted large-language-model use. The architecture treats plain LLMs as insufficient because they are probabilistic, can hallucinate, and are weak at long-horizon verified reasoning. FERMIACC responds with scaffolding: typed intermediate artifacts, retrieval, adversarial critique, deterministic checks, and standard collider simulation software. Its significance lies in this coupling of language-model hypothesis generation to executable phenomenology rather than in free-form text generation alone (Agrawal et al., 23 Mar 2026).

2. System architecture and end-to-end workflow

FERMIACC is organized into three principal modules—Model Builder, Event Generator, and Analyzer—with agent modules represented as blue boxes and deterministic software components as green boxes in the architecture described by the paper. Its top-level workflow consists of six stages: proposing and refining field-theoretic hypotheses; encoding those hypotheses in FeynRules while checking gauge and Lorentz consistency; generating signal events in MadGraph; running Pythia for decay, showering, and hadronization and Delphes for fast detector simulation; implementing the analysis in MadAnalysis and computing rudimentary statistical summaries; and storing summaries of hypothesis generation, simulation, and significance in a database for future runs (Agrawal et al., 23 Mar 2026).

The primary input is an experimental analysis PDF. Depending on stage, FERMIACC also consumes selected hypothesis summaries, proposal-database entries from prior runs, HEPData and digitized plot information, Delphes-level event samples, and optional user mappings. Its outputs span several levels: structured BSM hypothesis objects in typed JSON, proposal traces containing critiques and patches, FeynRules and UFO artifacts, MadGraph process files, simulated event samples, generated MadAnalysis code, cutflows and exclusion-related summaries, and archived manifests for reuse and reproducibility (Agrawal et al., 23 Mar 2026).

Operationally, an end-to-end run begins by identifying a target feature or signal region in a collider analysis, generating multiple candidate explanations, retrieving similar prior proposals, critiquing and patching those proposals, translating an approved model into an executable benchmark, validating it through symbolic and Monte Carlo checks, generating events, reconstructing the analysis logic in MadAnalysis, and then comparing the simulated signal to the experimental feature. This structure makes FERMIACC a machine-accelerated reinterpretation framework rather than a static model catalog.

3. Structured hypothesis generation and scaffolded reasoning

A defining feature of FERMIACC is that it requires proposals to be returned in a typed JSON schema enforced with Pydantic rather than as free-form prose. The appendix defines each hypothesis as

$H = (s, a, F, K, I, C, J, r, U, T, P),$

where $s$ is analysis_signature, $a$ is paper_anchors, $F$ is new_fields, $K$ is new_kinetic_terms, $I$ is new_interaction_terms, $C$ is new_couplings, $J$ is parameter_justifications, $r$ is new_model_reasoning, $U$ is ufo_contract, $s$0 is bsm_topology, and $s$1 is process_cfg. A hard validation rule requires exactly one parameter justification for every field mass and every coupling (Agrawal et al., 23 Mar 2026).

Hypothesis generation is ensemble-based. For a given analysis, FERMIACC launches proposal runs at different temperatures, with temperature $s$2 interpreted as controlling sampling stochasticity: low temperature biases toward high-likelihood completions, whereas higher temperature is used to explore more novel completions. The system complements this with retrieval against a structured proposal database. Each new field is mapped to a canonical signature

$s$3

and multi-field proposals are represented by multisets of these signatures, enabling coarse retrieval of structurally similar prior proposals (Agrawal et al., 23 Mar 2026).

FERMIACC’s most characteristic reasoning loop is adversarial. A proposal is generated from the analysis PDF, compared to retrieved prior proposals, and then critiqued along six axes: analysis grounding, novelty with respect to the paper and prior proposals, physical consistency, specificity, compatibility with the UFO pipeline, and parameter estimation quality. Each axis receives one of PASS, REFINE, or FAIL; the overall decision is the most severe label. If the decision is REFINE, only the minimal requested patch is applied before the cycle repeats. This creates an explicit propose–critique–patch loop rather than leaving all reasoning implicit inside a single model invocation (Agrawal et al., 23 Mar 2026).

Another important architectural distinction is between the full theory narrative and the executable collider benchmark. Because the present FeynRules/UFO path supports only a restricted class of pre-EWSB gauge-basis Standard Model extensions, each proposal includes a ufo_contract specifying the fields and couplings that must survive into the runnable benchmark, optional couplings, and unsupported UV features that are acknowledged but intentionally omitted. This makes the truncation from conceptual model to executable proxy explicit.

4. Executable model construction and event simulation

The Event Generator translates an approved hypothesis into a runnable benchmark. Handoff artifacts include run_card_settings.json, param_map.json, ufo_scope.json, build_status.json, attempt-specific FeynRules extension snapshots, ufo_package.json, process_config.json, parameter_point.json, and proc.mg5. A helper infers a minimal MadGraph run card from the analysis PDF and selected hypothesis, extracting beam type, beam energy, event count, and simple object-level cuts when clearly stated in the paper (Agrawal et al., 23 Mar 2026).

The FeynRules/UFO construction stage is deliberately conservative. FERMIACC rejects broken-phase electroweak fields such as $s$4, $s$5, and $s$6 written directly in the extension; explicit Higgs vev insertions or electroweak mixing-angle substitutions; new gauge sectors; custom mixing and diagonalization machinery; malformed Higgs bilinears; problematic SU(2) field-strength operators; and non-covariant kinetic terms. If these guardrails are satisfied, the build sequence writes BSMExtension.fr, loads the base Standard Model plus extension, runs LoadModel, runs CheckHermiticity, runs WriteUFO, sanitizes the UFO, verifies that required couplings survive the export, and performs a minimal MadGraph generate test to ensure that at least one diagram exists (Agrawal et al., 23 Mar 2026).

If any step fails, FERMIACC enters a repair loop in which diagnostics are fed back into a rewrite of the executable model text without changing the approved proposal itself. Parameter values are then injected into MadGraph using commands of the form

$s$7

so that event generation uses the same masses and couplings that passed symbolic validation. The default deterministic stack is MadGraph for hard-process generation, Pythia8 for showering and hadronization, Delphes for detector simulation, and MadAnalysis 5 for reinterpretation. The infrastructure also supports parameter scans by reading proposal-specified scan ranges, building a Cartesian grid, rescaling point counts to satisfy a global cap, and launching one MadGraph run per retained point (Agrawal et al., 23 Mar 2026).

This stage is central to the system’s identity. FERMIACC is not limited to suggesting a model idea; it attempts to produce an executable benchmark and a collider event sample. A plausible implication is that the architecture treats symbolic consistency and simulation readiness as first-class constraints rather than as post hoc checks.

5. Analysis reconstruction and quantitative validation

The Analyzer turns an experimental paper into an executable recast. It performs four tasks: extracting the analysis logic, resolving numerical ingredients for validation and statistics, generating executable analysis code, and running the analysis to compute exclusions. Before code generation, FERMIACC creates a normalized AnalysisTemplate containing signal regions, control and validation regions, cutflow structure, observables, and statistical inputs. This template functions as the contract between semantic interpretation of the paper and production of MadAnalysis 5 code (Agrawal et al., 23 Mar 2026).

The analyzer is itself decomposed into specialized agents. The Analysis planner reconstructs semantic structure, object definitions, region logic, and hierarchy. The Data-source agent retrieves numerical ingredients such as observed counts, background predictions, and uncertainties from HEPData, extracted tables, official pages, digitized plots, or user-provided mappings. The Code-generation agent emits a MadAnalysis 5 implementation with cuts, regions, and metadata. This decomposition mirrors the broader scaffolded-reasoning philosophy: semantic planning, numerical grounding, and executable synthesis are separated rather than entangled in one prompt (Agrawal et al., 23 Mar 2026).

The generated MadAnalysis package is compiled in expert mode and run on Delphes-level event samples. FERMIACC then uses native MadAnalysis 5 statistics where supported, computing efficiencies, best-region summaries, and CL$s$8-related outputs. The paper does not provide explicit likelihood equations, p-value formulas, or a full uncertainty-propagation formalism, and it also identifies a missing future feature: a dedicated physics-validation layer that would reproduce efficiencies for a known model from the paper and compare them against the published efficiencies, potentially enabling reweighting of the fast simulation (Agrawal et al., 23 Mar 2026).

In this sense, FERMIACC’s quantitative validation is strong at the level of an executable recasting workflow, but less fully formalized than a mature statistical reinterpretation framework. The system computes exclusions and significance-related summaries, yet the paper emphasizes architecture and workflow rather than a new statistical formalism.

6. Demonstrations, limitations, and projected development

FERMIACC is evaluated primarily through case studies rather than through a benchmark suite with aggregate metrics. The paper reports end-to-end demonstrations on several LHC analyses with mild excesses or statistically suggestive structures, including the CMS and ATLAS $s$9 GeV diphoton excesses, CMS paired dijet resonances, and an ATLAS dijet resonance plus lepton signature (Agrawal et al., 23 Mar 2026).

Analysis	Proposal ID	Summary
CMS $a$0 GeV diphoton	544c3421	$a$1 GeV singlet pseudoscalar $a$2 with $a$3 TeV vector-like quarks $a$4
ATLAS $a$5 GeV diphoton	5e41fd9e	hypercharge-axion interpretation
ATLAS $a$6 GeV diphoton	7a3fb5a1	scalar $a$7 with EFT couplings $a$8 and $a$9
CMS paired dijets	449ba23a	$F$0 TeV singlet scalar $F$1 plus $F$2 TeV color-octet scalar $F$3
CMS paired dijets	896abfa5	$F$4 TeV scalar $F$5 plus $F$6 TeV octet pseudoscalar $F$7
ATLAS dijet + lepton	f597e791	$F$8 TeV color-octet scalar $F$9 with electroweak-symmetric EFT couplings

These studies are used to show several capabilities. FERMIACC can recover much of the known explanation space for the historic $K$0 GeV anomaly, generate distinct interpretations for newer analyses, estimate order-of-magnitude parameters, convert proposals into executable benchmarks, and produce analysis-level histograms after a full simulation chain. At the same time, several examples illustrate failure modes: in particular, some otherwise viable models underproduce the observed rate because FERMIACC selects gluon couplings that are too small in an attempt to preserve branching ratios (Agrawal et al., 23 Mar 2026).

The paper is explicit about limitations. The current executable-model class is restricted to pre-EWSB gauge-basis Standard Model extensions and does not support new gauge sectors, additional vevs, explicit broken-phase operators, or custom mass-diagonalization machinery. The system does not yet automatically verify the mapping from a full UV theory to the executable benchmark, lacks a full recast-validation layer against published efficiencies, and is evaluated through case studies rather than formal ablations or large-scale benchmark statistics. The architecture is therefore best understood as an early systems realization of agentic particle-theory automation rather than a finished general-purpose theorem-proving framework (Agrawal et al., 23 Mar 2026).

Future directions identified in the paper include iterative reruns that feed simulation outcomes back into hypothesis generation, a validation agent for recasting accuracy and fast-simulation reweighting, testing proposals against related analyses and complementary constraints, extending the framework beyond LHC collider data, deploying it inside experimental collaborations where full simulation and correlations are available, strengthening deterministic topology construction and backend emission, and integrating tools such as SARAH for more faithful UV-to-benchmark mapping. Within that trajectory, FERMIACC is presented as an “AI Fermi”: a system for systematic exploration and quantitative testing of large spaces of viable theory explanations rather than a mechanism for uniquely inferring fundamental law from sparse evidence (Agrawal et al., 23 Mar 2026).