An End-to-end Architecture for Collider Physics and Beyond

This paper introduces ColliderAgent, the first language-driven, multi-agent system that autonomously executes end-to-end collider phenomenology workflows—from theoretical Lagrangians to detector-level analyses and exclusion limits—by leveraging a decoupled architecture and the Magnus execution backend to enable scalable, reproducible, and package-agnostic research in high-energy physics.

The Gist

Imagine you are a master chef who wants to create a complex, multi-course meal based on a vague idea: "Make me a dish that tastes like a star exploding in a galaxy, but with a hint of lemon."

In the world of High-Energy Physics (HEP), this is exactly what scientists do. They have a theoretical idea (the "recipe" written in complex math called a Lagrangian) and they want to know what it would look like if they actually cooked it up in a giant particle collider (like the Large Hadron Collider, or LHC).

For decades, doing this has been like trying to cook that meal using five different kitchens, each with its own language, its own set of knives, and its own rules. You have to manually translate the recipe from "Mathematica" to "FeynRules," then to "MadGraph," then to "Pythia," and finally to "Delphes." If you make a tiny typo in one step, the whole meal burns, and you have to start over. It's slow, frustrating, and prone to human error.

Enter "ColliderAgent": The Ultimate Kitchen Robot.

The paper you shared introduces ColliderAgent, the first "robot chef" that can take your natural language instructions (like "Simulate a particle collision with a leptoquark") and execute the entire cooking process from start to finish without you touching a single pot.

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

1. The Brain vs. The Hands (Decoupled Architecture)

Think of the system as having two distinct parts:

• The Brain (Cognitive Reasoning Engine): This is the "Project Manager." It listens to your request, breaks it down into steps, and decides which tool to use. It doesn't do the heavy lifting; it just plans.
• The Hands (Magnus Backend): This is the "Kitchen Crew." It's a powerful, pre-built environment that actually runs the heavy software (the tools physicists use). The Brain tells the Hands what to do, and the Hands do the work.

This separation is crucial. If the "Hands" get updated or changed, the "Brain" doesn't need to relearn how to think. It just keeps giving orders.

2. The Specialized Sous-Chefs (Multi-Agent System)

The "Brain" doesn't try to do everything itself. Instead, it hires a team of specialized Sub-Agents, each an expert in one specific tool:

• The Model Generator: Translates your math recipe into a file the computer understands.
• The Validator: Tastes the dish before serving. It checks for errors (like "Did you forget to add the salt?" or "Is this math Hermitian?"). If something is wrong, it fixes it automatically and tries again.
• The Simulator: Actually runs the collision simulation, smashing particles together virtually.
• The Analyzer: Looks at the results, counts the particles, and draws the graphs.

These agents talk to each other using a standardized "language" (a Command Line Interface), passing notes back and forth so no information is lost.

3. The "Self-Correction" Loop

One of the coolest features is that the robot chef can fix its own mistakes.
Imagine the robot tries to cook a dish and realizes the oven temperature is wrong. Instead of calling you for help, it reads the error message, realizes the mistake, adjusts the temperature, and tries again. In the paper, they showed the agent catching errors in the code, fixing the physics model, and re-running the simulation until it got it right.

4. The Proof: Can It Actually Cook?

To prove this robot isn't just a toy, the scientists gave it four very difficult "recipes" from famous scientific papers and asked it to recreate the results:

1. The Leptoquark: A rare particle that is half-lepton, half-quark. The robot had to handle a tricky technical workaround (swapping leptons for photons) that even humans find confusing. Result: It got the graph right.
2. The Axion-Like Particle: A ghostly particle that interacts with light. The robot had to handle complex math involving "Effective Field Theory." Result: It reproduced the exact energy distribution curve.
3. The Z' Boson Scan: A massive search for a new force carrier across a huge range of possibilities. This usually takes humans weeks of scripting. Result: The robot did the whole scan in hours and found the exact same "exclusion limits" (where the particle doesn't exist) as the original paper.
4. The Mono-Tau Search: A detector-level analysis looking for a specific "missing energy" signature. This involves simulating the entire detector. Result: It matched the real-world data perfectly.

Why Does This Matter?

Think of this as the difference between hand-crafting every single brick of a house versus using a 3D printer that can build the whole structure from a blueprint.

• Speed: Tasks that took weeks of manual coding and debugging now take hours.
• Reproducibility: Since the robot follows a strict, automated path, anyone can run the same "recipe" and get the exact same result. No more "it worked on my computer" excuses.
• Accessibility: You don't need to be a coding wizard to run these simulations. You just need to know the physics and speak English (or write a prompt).

The Big Picture

The authors are saying: "We have built the first robot that can take a theoretical idea about the universe, run the most complex simulations known to science, and give you the answer, all by itself."

This isn't just about saving time; it's about opening the door to autonomous discovery. In the future, scientists could ask the AI, "What happens if we combine these two theories?" and the AI could run thousands of simulations to tell them if it's worth building a new, multi-billion dollar collider to find out. It's a giant leap toward a future where AI helps us uncover the secrets of the cosmos.

Technical Summary

1. Problem Statement

High-Energy Physics (HEP) phenomenology involves translating theoretical concepts (encoded in Quantum Field Theory Lagrangians) into physical observables to confront experimental data. While a mature software ecosystem exists (e.g., FeynRules, MadGraph, Pythia, Delphes, MadAnalysis), orchestrating these heterogeneous tools remains a major bottleneck.

• Fragmentation: Tools differ significantly in syntax, usage conventions, and dependencies.
• Manual Orchestration: Researchers must manually write scripts to chain these tools together, a process prone to human error and difficult to scale.
• Limitations of Existing Automation: Current automation frameworks are often restricted to specific stages of the workflow or specific classes of problems. Recent agent-based studies have addressed isolated components but have not achieved a fully autonomous, end-to-end pipeline from a theoretical Lagrangian to final exclusion limits.

2. Methodology: The ColliderAgent Architecture

The authors propose ColliderAgent, a decoupled, domain-agnostic architecture for autonomous HEP phenomenology. The system separates cognitive reasoning from analytical/numerical execution.

A. Core Architecture

The framework consists of three main layers (illustrated in Fig. 1 of the paper):

1. User Layer: Accepts natural-language prompts supplemented with standard physics notation (e.g., LaTeX expressions for Lagrangians) and numerical inputs.
2. Cognitive Reasoning Engine (Hierarchical Multi-Agent):
   • Master Orchestrator: Decomposes high-level user requests into a workflow of sub-tasks.
   • Specialized Sub-agents: Each sub-agent is equipped with Agent Skills (portable, task-specific instruction modules based on official software documentation).
     • Model-Generator: Translates Lagrangians to FeynRules (.fr) files, validates them (checking Hermiticity, syntax), and converts them to UFO format.
     • Collider-Simulator: Generates MadGraph scripts, handles parton showering (Pythia), and detector simulation (Delphes).
     • Event-Analyzer: Performs event selection, cutflow construction, and histogram extraction using MadAnalysis.
     • Pheno-Analyzer: Performs statistical inference (profile-likelihood), parameter scans, and visualization.
   • Context Management: Sub-agents communicate via structured intermediate progress records (Markdown summaries) to maintain physical context without carrying full history overhead.
3. Execution Backend (Magnus):
   • A unified execution backend that hosts the heterogeneous HEP toolchain (Mathematica, FeynRules, MadGraph, Pythia, Delphes, MadAnalysis).
   • Provides a pre-configured, containerized environment (Docker/Slurm) to ensure reproducibility and handle complex dependencies.
   • Accessed via a standardized Command Line Interface (CLI), allowing the reasoning layer to remain independent of the underlying hardware.

B. Validation and Self-Correction

To ensure robustness, the system employs a validation-and-repair loop:

• Before large-scale simulations, the model-generator invokes a validator to check for syntax errors, consistency (e.g., Hermiticity), and successful loading of the UFO model in MadGraph.
• If a check fails, the agent parses diagnostic output, revises the model, and re-runs the validation, minimizing manual debugging.

3. Key Contributions

• First End-to-End Language-Driven Agent: ColliderAgent is the first system capable of executing a complete collider phenomenology workflow—from a theoretical Lagrangian to final phenomenological outputs (distributions, exclusion limits)—without requiring package-specific code from the user.
• Decoupled, Domain-Agnostic Design: By separating reasoning from execution and using a unified backend (Magnus), the architecture is scalable and can be applied to future colliders (CEPC, FCC, Muon Collider) and broader physics domains.
• Skill-Based Modularity: The use of "Agent Skills" allows the system to adapt to new tools or updates in existing software without rewriting the entire agent logic.
• Autonomous Error Correction: The system can detect and fix common model-construction errors (e.g., missing conjugate terms) autonomously.

4. Results and Benchmarks

The authors validated ColliderAgent on four representative literature reproductions spanning different physics scenarios and analysis levels:

1. Resonant Leptoquark Production (Parton/Detector Level):

   • Task: Reproduced the $m_{ej}$ distribution for $pp \to LQ \to ej$ at the LHC.
   • Challenge: Required using the non-standard LUXlep PDF (leptons inside the proton) and a technical workaround for Pythia (replacing initial-state leptons with photons).
   • Outcome: Successfully handled the complex workflow and reproduced the resonance peak (Fig. 2a).

2. Axion-Like Particle (ALP) EFT (Parton Level):

   • Task: Reproduced the normalized missing transverse energy ($E_T^{miss}$) distribution for $pp \to aW^\pm\gamma$ with $W^\pm \to \ell^\pm\nu$.
   • Challenge: Required generating correct EFT model files for higher-dimensional operators and reconstructing invisible kinematics.
   • Outcome: Faithfully reproduced the hard tail induced by the $A\tilde{W}$ operator (Fig. 2b).

3. Large-Scale Parameter Scan (Statistical Inference):

   • Task: Performed a 2D parameter-space scan for a $U(1)'$ extension of the SM to derive LHC constraints on gauge couplings.
   • Outcome: Compressed weeks of manual scripting and job orchestration into an autonomous workflow completed in hours, reproducing 95% CL exclusion contours (Fig. 2c).

4. Detector-Level Mono-$\tau$ Search (Full Pipeline):

   • Task: Reproduced the $U_1$ vector-leptoquark exclusion contour from a mono-$\tau$ search.
   • Challenge: Required a full detector-level analysis including event generation, showering, ATLAS/CMS detector simulation, experiment-specific cuts, and profile-likelihood analysis against published data.
   • Outcome: Successfully coordinated the entire heterogeneous toolchain without human intervention, reproducing the 2$\sigma$ exclusion contour (Fig. 2d).

Additional benchmarks in the Supplemental Material confirmed performance on heavy Majorana neutrinos, general $Z'$ models, and Kaluza-Klein gravitons at lepton colliders.

5. Significance

• Reproducibility and Scalability: The framework drastically reduces the barrier to entry for complex phenomenological studies, making research more reproducible and scalable.
• Future-Proofing: The architecture is designed to support future collider programs (e.g., Muon Collider, FCC) where manual toolchain orchestration would be even more prohibitive.
• Paradigm Shift: This work demonstrates that language-driven AI agents can perform technically demanding scientific tasks while remaining grounded in established, rigorous physics toolchains. It suggests a future where AI acts as a collaborative partner in scientific discovery, capable of autonomous hypothesis testing and data analysis across collider physics, cosmology, and beyond.