⚛️ high-energy experiments

HEPTAPOD: Orchestrating High Energy Physics Workflows Towards Autonomous Agency

This paper introduces HEPTAPOD, an orchestration framework that integrates large language models into high-energy physics workflows to enable autonomous, multi-step task execution across theoretical calculations, simulations, and data analysis while maintaining transparency, reproducibility, and human oversight.

Original authors: Tony Menzo, Alexander Roman, Sergei Gleyzer, Konstantin Matchev, George T. Fleming, Stefan Höche, Stephen Mrenna, Prasanth Shyamsundar

Published 2026-07-21

📖 4 min read🧠 Deep dive

CC BY 4.0

Original authors: Tony Menzo, Alexander Roman, Sergei Gleyzer, Konstantin Matchev, George T. Fleming, Stefan Höche, Stephen Mrenna, Prasanth Shyamsundar

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine the universe is a giant, invisible puzzle made of tiny, invisible pieces. Scientists who study these pieces are called high-energy physicists, and they work in a field known as High-Energy Physics (HEP). To solve the puzzle, they don't just look at rocks or stars; they smash particles together at nearly the speed of light using massive machines called colliders. But since they can't see the pieces directly, they have to build giant, complex computer simulations to guess what happens when these particles crash. These simulations are like a digital recipe book: you mix specific ingredients (theoretical models), cook them in a specific way (mathematical calculations), and see what dish you get (the data).

The problem is that cooking these digital meals is incredibly hard. It requires a long chain of different computer programs, each speaking a slightly different language. A scientist has to manually tell the first program to make a model, then copy the results to the second program to simulate the crash, then move those results to a third program to see what the particles look like after the crash, and so on. If one step goes wrong, the whole chain breaks, and the scientist has to start over. Recently, a new kind of computer brain called a Large Language Model (LLM) has become very good at reading and writing code. People started wondering: "Can we teach these AI brains to be the head chef, automatically managing this whole cooking chain for us?" This is the big question the paper tackles.

The paper introduces a new system called HEPTAPOD (which stands for the HEP Toolkit for Agentic Planning, Orchestration, and Deployment). Think of HEPTAPOD as a super-smart, highly organized sous-chef that sits between the human scientist and the messy kitchen of computer programs. Instead of letting the AI just guess what to type (which often leads to mistakes), HEPTAPOD gives the AI a set of strict, pre-approved "tools." Each tool is like a specialized kitchen gadget with a clear label: "This gadget mixes ingredients," "This gadget chops vegetables," "This gadget checks the temperature." The AI can't just wave its hands and hope for the best; it has to pick the right gadget, use it correctly, and then report back exactly what it did.

In their experiments, the researchers tested this system with a specific cooking challenge: simulating a hypothetical particle called a "leptoquark" (a made-up particle that might exist beyond our current understanding of physics). They asked the AI to run a simulation where it tested three different "masses" (weights) for this particle: 1.0, 1.5, and 2.0 TeV. Without the special HEPTAPOD tools, the AI tried to do the job by writing its own computer code from scratch. It failed miserably, crashing the simulation or producing empty results every single time. It was like asking a robot to build a car by inventing its own wrenches and hammers on the fly; it got confused and dropped the parts.

However, when the researchers gave the AI the HEPTAPOD toolkit, the story changed completely. The AI successfully navigated the entire chain: it built the model, ran the collision simulation, processed the results, and even fixed its own mistakes when it accidentally skipped a step. In 7 out of 10 tries, the AI successfully reconstructed the "signature" of the leptoquark, finding the correct peaks in the data that matched the weights they were looking for. The system didn't just guess; it kept a detailed log of every move, allowing the human scientist to check its work and ensure nothing was faked.

The paper suggests that this approach is a promising way forward. It shows that by wrapping complex scientific software in simple, reliable tools, we can turn AI from a chaotic code-generator into a disciplined scientific assistant. The system doesn't replace the human scientist; instead, it acts as a transparent, auditable partner that handles the boring, repetitive, and error-prone parts of the workflow, letting the human focus on the big ideas. While this specific test was a simulation, the results indicate that with the right structure, AI agents can reliably orchestrate the complex, multi-step workflows that modern physics requires.

Technical Summary: HEPTAPOD – Orchestrating High Energy Physics Workflows Towards Autonomous Agency

Problem Statement

High-energy physics (HEP) research relies on complex, multi-stage computational pipelines involving symbolic algebra, matrix-element generation, parton showering, hadronization, detector simulation, and numerical analysis. While individual software components (e.g., FeynRules, MadGraph5_aMC@NLO, Pythia, FastJet) are mature and robust, the coordination of these tools remains largely manual. Researchers must manually construct run cards, manage intermediate file paths, ensure parameter consistency across tools, and debug failures at any stage. This manual orchestration is time-intensive, error-prone, and difficult to scale across parameter scans or large model spaces.

Although Large Language Models (LLMs) have evolved into general-purpose computational interfaces capable of planning and executing multi-step workflows, their application in HEP has been limited. Early applications focused on code generation or documentation. Existing agentic frameworks in HEP (e.g., ArgoLOOM, Agents of Discovery, LLM4HEP) have begun to emerge, but they often lack a structured mechanism to ensure reproducibility, transparency, and human oversight when integrating external scientific codes. The core challenge is enabling LLMs to coordinate these workflows reliably without generating unstructured, unverified code or losing track of state across long execution chains.

Methodology

The authors introduce HEPTAPOD (HEP Toolkit for Agentic Planning, Orchestration, and Deployment), an orchestration framework designed to integrate LLMs into HEP theory pipelines. The framework is built upon the Orchestral AI engine, a provider-agnostic agent-orchestration harness, but is specifically configured for scientific tools rather than general software engineering.

The methodology relies on four key architectural pillars:

Schema-Validated Tools:
Instead of relying on free-form code generation for every operation, HEPTAPOD exposes scientific capabilities as Python classes with structured JSON schemas. These tools define strict input and output types (using RuntimeField for user-provided arguments and StateField for injected environment data).
- Validation: Arguments are validated against the schema before execution.
- Error Handling: Tools return structured error messages (rather than raw logs) upon failure, allowing the agent to interpret and recover from errors deterministically.
- Docstrings: Each tool includes a detailed natural-language docstring explaining its scientific purpose and semantics, which is injected into the LLM's context to guide decision-making.
LLM-Compatible Event Data Structures (evtjsonl):
Traditional HEP formats (ROOT, HepMC, LHE) are opaque to LLMs. HEPTAPOD introduces a text-based, line-delimited JSON format (evtjsonl) for intermediate event data. This format encodes particle four-vectors, IDs, and status codes in a self-contained record that the agent can inspect directly within the conversation context. This enables the agent to perform semantic validation (e.g., checking for implausible multiplicities) without needing external deserialization tools.
Run-Card-Driven Orchestration:
The framework uses human-readable run cards (e.g., .mg5, .cmnd) as the canonical interface between the agent and external codes.
- Placeholders: The system supports template-based run cards where placeholders (e.g., [[UFO_PATH]]) are automatically substituted with actual file paths at execution time.
- Auditability: Every configuration decision is captured in a persistent, versionable artifact, allowing for human approval checkpoints before execution.
Stateful Context Propagation:
The orchestration layer maintains a structured conversation state. When a tool detects a parameter scan (e.g., multiple mass points), it returns structured metadata associating each run ID with its specific parameters and file paths. This metadata is propagated to subsequent steps (e.g., from MadGraph to Pythia) without requiring the agent to parse directory names or recall filenames.

Key Contributions

The paper presents the following specific contributions:

The HEPTAPOD Framework: A complete orchestration infrastructure that bridges LLM reasoning with domain-specific HEP software. It abstracts theory tasks into modular, schema-validated tools.
A Representative Case Study: A full end-to-end demonstration of a Beyond the Standard Model (BSM) scalar leptoquark ( $S_1$ $S_{1}$ ) analysis. The workflow spans:
1. Model generation (FeynRules $\to$ UFO).
2. Parton-level event generation with a parameter scan (MadGraph).
3. Showering and hadronization (Pythia).
4. Jet clustering (FastJet/SlowJet).
5. Object selection and resonance reconstruction.
6. Visualization of the reconstructed leptoquark mass distribution ( $m_{LQ}^{min}$ ).
Quantitative Benchmarking: A comparison of the framework's performance against a "core-only" baseline (where the agent has only shell/Python capabilities without domain tools).
- Tool-Assisted: The agent successfully completed the full pipeline in 7 out of 10 attempts ($pass@1 = 0.70$) and reached 100% success within a few attempts.
- Core-Only: The agent failed to complete the workflow in any of the 10 attempts ($pass@1 = 0$). Failures were primarily due to JSON serialization errors when generating large scripts and incorrect reconstruction of physics observables.
Error Recovery Mechanism: The framework demonstrates the agent's ability to detect structured errors (e.g., missing jet clustering for a specific scan point), re-invoke the necessary tool, and resume the workflow without human intervention.

Results

The benchmark results highlight the critical role of the orchestration layer:

Reliability: The schema-validated tools reduced the serialization burden on the LLM. Without tools, the model frequently failed to serialize complex payloads (entire scripts/run cards) as valid JSON, leading to fatal crashes.
Physics Correctness: With domain tools, the agent correctly reconstructed the resonance peaks at the injected mass points (1.0, 1.5, and 2.0 TeV). Without tools, even when the pipeline executed, the resulting mass distributions were empty or collapsed to zero, indicating a failure to correctly implement the physics logic.
Efficiency: The tool-assisted agent required fewer tokens and tool calls to achieve success compared to the core-only variant, which often terminated early or required excessive retries.

Significance and Claims

The authors position HEPTAPOD not as a fully autonomous system replacing human researchers, but as a human-in-the-loop system that augments scientific reasoning.

Foundation for Reproducibility: By enforcing schema validation and run-card-driven configuration, HEPTAPOD establishes a foundation for transparent, auditable, and reproducible AI-assisted research.
Safety and Oversight: The framework ensures that LLMs operate within established computational workflows, preserving human oversight at critical decision points (e.g., run card approval).
Scalability: The modular nature of the tool suite allows for the easy addition of new capabilities (e.g., new generators or analysis techniques) by implementing a single BaseTool subclass, which the orchestration layer then coordinates automatically.
Future Outlook: The paper suggests that this infrastructure enables future applications such as automated background modeling, generator tuning, and iterative model refinement where multiple agents could collaborate on theoretical extensions and phenomenological viability.

The paper concludes that HEPTAPOD provides the necessary infrastructure to transition HEP workflows from manual, error-prone scripting to reliable, adaptive, and interpretable agent-assisted pipelines, bridging the gap between symbolic theory inputs and measurable data.