The FERMIACC: Agents for Particle Theory

The paper introduces FERMIACC, a scaffolded reasoning model built on OpenAI agents that autonomously generates and quantitatively validates high-energy physics theory hypotheses at scale.

The Gist

Imagine you are a detective trying to solve a mystery. You walk into a crime scene (the Large Hadron Collider, or LHC) and find a strange clue: a tiny, unexpected bump in the data. Maybe it's a flash of light that shouldn't be there, or a pair of particles appearing more often than physics predicts.

In the past, human scientists would spend months or years brainstorming theories to explain this bump. They would write equations, draw diagrams, and run complex computer simulations to see if their ideas held up. It was slow, expensive, and often limited by how many theories a human could juggle at once.

Enter FERMIACC.

Think of FERMIACC not as a single super-intelligent "AI Einstein" who magically knows the answer, but rather as a highly organized, tireless team of AI interns working under a strict, rule-following manager. Its job is to act as an "AI Fermi"—a reasoning engine that can quickly test thousands of different theories to see which ones fit the clues.

Here is how the FERMIACC works, broken down into simple steps:

1. The "Proposer" (The Dreamer)

First, the system reads the scientific paper describing the mystery. It then sends a message to an AI agent we'll call the Proposer.

• The Analogy: Imagine the Proposer is a creative writer who loves sci-fi. It looks at the clue and says, "What if there's a new invisible particle? What if it's made of heavy quarks? What if it's a ghost?"
• The Twist: Unlike a human writer who might just daydream, this Proposer is forced to write its ideas in a very specific, structured format (like a strict fill-in-the-blank form). It can't just say "maybe a big particle"; it has to say "A particle with mass 750 GeV, spin 0, and these specific interactions."

2. The "Critic" (The Editor)

Before the idea goes anywhere, it gets passed to a Critic.

• The Analogy: Think of the Critic as a grumpy, hyper-organized editor. The Proposer hands over the draft, and the Critic immediately starts checking for errors.
  • "Does this make sense physically?"
  • "Is this idea too similar to something we already tried?"
  • "Did you explain why you chose these numbers?"
• If the idea is bad, the Critic sends it back with a list of corrections. The Proposer has to fix it and try again. This happens in a loop until the idea is solid.

3. The "Builder" (The Architect)

Once the Critic gives a "Pass," the idea goes to the Builder.

• The Analogy: The Builder is like a construction foreman who takes the architect's blueprints and tries to actually build the house. In physics, this means turning the text description into a computer model (using tools like FeynRules).
• The Guardrails: This is where the system gets strict. If the model tries to break the laws of physics (like creating a particle that violates energy conservation), the Builder immediately stops the process. It's a safety net to ensure the AI doesn't "hallucinate" impossible physics.

4. The "Simulator" (The Test Driver)

Now that the model is built, it goes to the Simulator.

• The Analogy: Imagine you built a new car design. Before you sell it, you have to crash-test it. The Simulator takes the new particle theory and runs a virtual collision inside a computer, mimicking what would happen if two protons smashed together at the LHC.
• It generates thousands of "fake" collisions and sees what the detectors would "see."

5. The "Analyzer" (The Judge)

Finally, the results go to the Analyzer.

• The Analogy: The Analyzer compares the "fake" data from the simulation with the real data from the LHC.
• "Does this new theory explain the bump we saw?"
• "Does it predict too many events? Too few?"
• If the theory matches the data well, it gets a gold star. If it fails, it's discarded.

Why is this a big deal?

Speed and Scale:
A human team might test one or two theories a month. FERMIACC can generate, build, simulate, and test hundreds of theories in a single run. It can explore a "universe" of possibilities that humans simply don't have time to check.

No "Magic" Answers:
The paper emphasizes that FERMIACC isn't trying to be a magic oracle. It's a scaffolded system. It uses AI for creativity (generating ideas) but relies on rigid, deterministic computer tools for the math and physics. This prevents the AI from making up nonsense. It's like giving a creative writer a strict calculator and a physics textbook to work with.

Real-World Examples:
The authors tested FERMIACC on famous historical mysteries, like the "750 GeV Excess" (a fake signal that turned out to be a statistical fluke).

• The system quickly generated dozens of theories to explain it.
• It successfully recreated the theories that human physicists had spent months writing.
• It also found new variations of theories that humans hadn't thought of yet.

The Bottom Line

FERMIACC is a scientific accelerator. It doesn't replace the human scientist; it replaces the boring, repetitive, and slow parts of the job. It acts as a tireless research assistant that can say, "I've tested 500 theories, and here are the top 3 that actually fit the data. Let's focus on those."

It turns the process of scientific discovery from a slow, manual search into a fast, automated exploration, helping us find the "needle in the haystack" of the universe much faster than before.

Technical Summary

1. Problem Statement

High Energy Physics (HEP) faces a fundamental challenge: the "inverse problem." While the Standard Model (SM) is well-tested, there are infinitely many Beyond-the-Standard-Model (BSM) theories consistent with current data at fixed precision due to decoupling. The challenge is not a lack of compatible theories, but an overabundance of them.

Current Large Language Models (LLMs) show promise in theoretical reasoning but suffer from "hallucinations," lack of long-horizon planning, and an inability to produce verifiable, executable scientific outputs. The paper argues that the field does not need an "AI Einstein" (a model that derives Nature's laws from scratch) but rather an "AI Fermi"—a reasoning model capable of navigating the vast space of viable theories, systematically generating hypotheses, and quantitatively validating them against experimental data.

2. Methodology: The FERMIACC Architecture

The authors present FERMIACC (Fast Engine for Reinterpretation: a Machine Intelligence ACCelerator), a scaffolded reasoning system built on the OpenAI Agents SDK. Unlike standard LLMs that generate text, FERMIACC generates structured, executable scientific workflows.

The system operates through a deterministic pipeline coupled with an adversarial agent loop, consisting of three primary modules:

A. Model Builder (Hypothesis Generation)

This module converts an experimental paper (PDF) into a structured BSM hypothesis.

• Adversarial Loop: It employs a Proposer-Critic-Patcher loop.
  • Proposer: Generates a hypothesis based on the paper's anomalies.
  • Critic: Evaluates the hypothesis on six axes: analysis grounding, novelty (checked against a database), physical consistency, specificity, UFO pipeline compatibility, and parameter justification.
  • Patcher: Iteratively refines the proposal if the Critic returns a "REFINE" decision.
• Structured Output: Hypotheses are not free text but typed JSON schemas (via Pydantic) containing field content, interaction terms, and benchmark parameters.
• Novelty Search: Uses a canonicalized retrieval system to compare new proposals against historical ones based on field signatures (spin, CP, gauge representations) rather than just model names.
• Justification: Every parameter (mass, coupling) must include an order-of-magnitude justification derived from phenomenological reasoning.

B. Event Generator (Simulation)

Once a hypothesis passes the Model Builder, it is converted into a collider benchmark.

• Translation: The JSON hypothesis is translated into FeynRules code to generate a UFO (Universal FeynRules Output) model.
• Guardrails: The system enforces strict constraints (e.g., working in the unbroken SM gauge basis, avoiding new gauge sectors or custom mixing) to ensure the model can be exported and run.
• Pipeline: The validated UFO is fed into MadGraph (hard process generation), Pythia (parton showering/hadronization), and Delphes (fast detector simulation).

C. Analyzer (Recasting & Validation)

This module re-implements the experimental analysis to test the simulated signal.

• Agentic Recasting: Agents extract selection logic, cutflows, and statistical inputs from the experimental paper.
• Code Generation: It generates executable MadAnalysis 5 C++ code based on a structured intermediate representation (AnalysisTemplate).
• Statistical Analysis: The simulated events are processed through the generated analysis to compute signal significance ($S/\sqrt{B}$) and exclusion limits.

3. Key Contributions

1. Scaffolded Reasoning: The paper demonstrates that coupling LLMs with deterministic scientific tools (FeynRules, MadGraph, MadAnalysis) creates a robust system that mitigates LLM hallucinations while leveraging their generative capabilities.
2. Adversarial Agent Loop: The introduction of a Proposer-Critic-Patcher loop allows for the iterative refinement of complex physical theories, ensuring physical consistency and novelty before simulation.
3. Executable Hypotheses: FERMIACC moves beyond text generation to producing executable scientific artifacts (UFO models, MadAnalysis code), making the hypothesis generation process reproducible and auditable.
4. Novelty Management: The system includes a canonicalized retrieval mechanism to ensure generated models are physically distinct from existing literature, not just textually different.

4. Results

The authors tested FERMIACC on several LHC anomalies, including the famous "750 GeV diphoton excess" and more recent dijet resonance searches.

• 750 GeV Excess (CMS & ATLAS): The system successfully generated viable BSM explanations (e.g., pseudoscalars coupled to vector-like quarks, hypercharge axions) that reproduced the observed excesses. It correctly identified that different experimental features (e.g., ATLAS's inclusive search vs. CMS's specific cuts) required different model topologies.
• CMS Paired Dijet Resonances: FERMIACC proposed novel models involving singlet and octet scalars/pseudoscalars to explain 4-jet excesses.
  • Limitation: In some cases, the initial "single-shot" runs chose overly conservative couplings (e.g., small gluon couplings to preserve branching ratios), resulting in insufficient signal cross-sections. The authors note that an iterative loop could resolve these trade-offs.
• ATLAS Dijet + Lepton: The system generated a novel octet scalar model with EFT couplings to explain a 2.8$\sigma$ excess, distinct from the four models proposed in the original paper.

Performance: While some single-shot proposals failed to perfectly match the observed rates due to parameter constraints, the system successfully demonstrated the ability to autonomously traverse the theory space, generate valid UFO models, and run full simulation chains without human intervention.

5. Significance

• Paradigm Shift: FERMIACC represents a shift from "AI as a chatbot" to "AI as a scientific agent." It automates the entire workflow from reading a paper to simulating a theory, drastically accelerating the hypothesis testing cycle.
• Scalability: By automating the reinterpretation of data, FERMIACC allows physicists to test innumerable hypotheses against existing datasets, maximizing the scientific return of current experiments (like the LHC) before new data is collected.
• Template for Scientific AI: The architecture (Adversarial Agents + Deterministic Tools + Structured Intermediates) provides a blueprint for applying AI to other complex scientific domains where hallucination is unacceptable and reproducibility is paramount.
• Future Outlook: The authors envision extending this to full experimental collaborations, integrating full detector simulations, and eventually deploying "AI Fermi" agents to explore the space of theories from quarks to cosmology.

In summary, the FERMIACC is a proof-of-concept for a new class of scientific software that augments human intuition with autonomous, verifiable, and scalable reasoning capabilities in high-energy physics.