HepScript: A Dual-Use DSL for Human-AI Collaborative Data Analysis Workflows in High-Energy Physics

This paper introduces HepScript, a dual-use Domain-Specific Language for High-Energy Physics that serves as a formal interface to abstract complex analysis logic, enabling human experts to write concise code while allowing AI agents to reliably generate executable specifications from literature, thereby significantly reducing manual effort and solving previously intractable automation challenges.

The Gist

The Big Picture: The "Translator" Problem

Imagine High-Energy Physics (HEP) as a massive, high-stakes cooking competition. Every year, the chefs (physicists) at the Beijing Spectrometer III (BESIII) experiment generate a mountain of ingredients (petabytes of data). To win, they need to cook specific dishes (analyze data) to discover new flavors (scientific discoveries).

However, there's a problem:

1. The Recipe is Complex: The "kitchen" (the computer software) is incredibly complicated. It uses a mix of old-school tools and modern gadgets. Writing a recipe that works in this kitchen requires deep, secret knowledge that only the head chefs have.
2. The AI Assistant is Smart but Clueless: We have a new AI assistant (Large Language Models) that can read any cookbook and write a recipe. But if you ask it to cook in this specific kitchen, it often fails. It doesn't know the secret tools, it gets confused by the complex machinery, and if it makes a tiny mistake, the whole dish burns.

The paper introduces HepScript, a solution to this problem.

The Solution: HepScript (The "Universal Translator")

The authors created a new language called HepScript. Think of it as a universal translator or a specialized menu that sits between the human chefs and the AI assistant.

Instead of asking the AI to write code directly in the complex kitchen language (which is like asking it to speak fluent French and German simultaneously while juggling), you ask it to write a HepScript order.

How it works:

1. For Humans: HepScript looks like a simple, clear list of instructions. "Select the red apples," "Mix with sugar," "Bake at 350 degrees." It hides all the scary, complex machinery underneath.
2. For AI: Because HepScript is a strict, limited language (a "Domain-Specific Language" or DSL), it gives the AI a small, safe playground. The AI doesn't have to guess how to use the kitchen; it just has to fill in the blanks on the menu.
3. The Magic Step: Once the HepScript menu is written, a special "processor" (a translator robot) reads it and automatically writes the complex, technical code needed to actually run the experiment in the real kitchen.

The "Dual-Use" Superpower

The paper calls HepScript "Dual-Use" because it works perfectly for two different people:

• The Human Expert: They can read the HepScript and understand the physics logic immediately without getting bogged down in technical details.
• The AI Agent: Because the language is strict and limited, the AI can generate it with very high accuracy. It's much easier for an AI to fill out a strict form than to write a novel.

The Results: What Happened in the Lab?

The team tested this system with real physics papers from the BESIII experiment. Here is what they found:

• Less Work for Humans: By using HepScript, the amount of code humans had to write dropped by 93%. It's like going from writing a 100-page manual to just filling out a 7-page checklist.
• AI Got Much Better: When they asked AI models to read a published physics paper and write the HepScript instructions for it:
  • On the first try, the AI got it right about 47% of the time.
  • But here is the trick: They let the AI try again if it made a mistake (using an "agentic loop"). The AI would see the error, fix it, and try again.
  • After just three tries, the AI succeeded 95% of the time.
• Proof it Works: They took the AI-generated instructions, ran them through the system, and the computer successfully recreated the exact graphs and results from the original physics papers.

The "Guardrails" Analogy

Why does this work so well?
Imagine the AI is a car.

• Without HepScript: The AI is driving on an open highway with no lanes, no signs, and no speed limits. It's easy to crash or get lost.
• With HepScript: The AI is driving on a monorail. The tracks (the grammar of HepScript) force the car to stay on the right path. It can't go off-road. It can't crash into the scenery. It just has to move forward along the track. This makes the journey safe and predictable.

Summary

The paper demonstrates that by creating a simple, strict "middle language" (HepScript), we can teach AI to do complex scientific work that it previously couldn't handle. It turns a chaotic, open-ended coding problem into a structured, solvable puzzle. This allows humans and AI to work together: the human provides the scientific intent, and the AI handles the heavy lifting of writing the code, all guided by the safe, structured rules of HepScript.

Technical Summary

1. Problem Statement

High-Energy Physics (HEP) faces a critical bottleneck in data analysis efficiency due to the exponential growth of data (petabytes to exabytes). While Large Language Models (LLMs) offer potential for automation, they struggle to autonomously manage complex scientific workflows for three main reasons:

• Domain Knowledge Gap: LLMs lack the deep, tacit knowledge required to structure complex, multi-step physics workflows (e.g., particle reconstruction, kinematic fitting).
• Semantic Gap: There is a disconnect between high-level analysis goals (e.g., "measure a branching fraction") and the low-level, framework-specific code (e.g., C++ for BOSS, ROOT scripts) required to execute them.
• Unbounded Action Space: Open-ended code generation by LLMs often leads to hallucinations, logical incoherence, or code that fails to compile in production environments because the space of possible code variations is too vast.

2. Methodology: HepScript

The authors propose HepScript, a Dual-Use Domain-Specific Language (DSL) designed to serve as a shared formal interface between human experts and AI agents.

• Core Concept: HepScript abstracts HEP analysis logic into a constrained, high-level syntax. It acts as a "grounding mechanism" that transforms open-ended code generation into a tractable sequence prediction task.
• Architecture:
  • Embedded DSL: Implemented as a Ruby-embedded DSL to leverage Ruby's readability, meta-programming capabilities, and fluent interfaces.
  • Code Generation Pipeline: HepScript does not execute directly. A dedicated DSL Processor translates HepScript specifications into target code for the BESIII software stack:
    • BOSS (C++): For simulation, reconstruction, and basic selection.
    • ROOT (C++/Python): For advanced selection, visualization, and statistical inference.
    • Auxiliary Scripts: Bash/Python for job configuration.
  • Hybrid Translation Strategy: The processor uses three methods:
    1. Templated Generation: For static structures.
    2. Translator-Based Generation: For complex syntax via custom Ruby classes.
    3. LLM-Assisted Generation: Used specifically for ambiguous tasks like cascade decay logic (mapping particles to resonances) and generating specific ROOT scripts.
• Design Principles:
  • Readability: Intuitive for physicists.
  • Modularity: Discrete blocks for analysis stages (Dataset Prep, Base Selection, Advanced Selection, Visualization, Statistical Analysis).
  • Constrained Grammar: Limits the LLM's action space to ensure generated code is logically coherent and executable.

3. Key Contributions

1. Theoretical Insight: Demonstrates that a well-designed DSL can collapse the unbounded action space of framework-specific code, making LLM generation reliable and verifiable.
2. HepScript Instantiation: A concrete, Ruby-embedded DSL co-designed with LLM assistance, specifically tailored for the BESIII (Beijing Spectrometer III) experiment.
3. Empirical Validation:
   • Human Efficiency: Reduced human-written code volume by 93% by eliminating boilerplate and repetitive routines.
   • AI Autonomy: Enabled LLMs to autonomously generate correct, executable HepScript specifications from published literature with a 95% success rate after iterative agentic retries.
4. Generalizable Framework: Provides a methodology for DSL design, implementation, and evaluation that can be adapted to other data-intensive scientific domains.

4. Evaluation Results

The system was evaluated on 45 BESIII papers (filtered from the first 50 on arXiv) covering dataset preparation and base selection.

• LLM Performance:
  • Initial success rates for LLM-generated specifications ranged from 43% to 47% (depending on the model, e.g., GLM-4.7 vs. DeepSeek-R1).
  • Failures were primarily due to syntax errors (76%) and physics misinterpretations (24%).
  • Agentic Loop: By implementing an iterative loop where the LLM receives error feedback from the compiler/processor, the success rate jumped to ~95% after three retries.
• Code Execution:
  • Generated BOSS code compiled without errors in 100% of human-written cases.
  • Generated ROOT scripts successfully reproduced figures from original papers (e.g., invariant mass distributions) in case studies, validating the end-to-end pipeline.
• Efficiency: The abstraction reduced the character count of required code by an average of 93%, significantly lowering the barrier for both human prototyping and AI task definition.

5. Significance and Future Work

• Paradigm Shift: HepScript shifts the automation bottleneck from "how to execute an analysis" (coding) to "what to specify" (intent), enabling a scalable human-AI collaborative system.
• Trust & Safety: The DSL acts as a guardrail, ensuring that AI agents operate within a verified, constrained environment, which is crucial for scientific rigor.
• Future Directions:
  • Self-Evolutionary Mechanism: Developing a system where the DSL grammar autonomously extends based on new domain literature and usage gaps.
  • Structure-Aware Retrieval: Moving beyond semantic text similarity (RAG) to retrieval based on the formal topology of particle decay chains to improve LLM grounding.
  • Agentic Memory: Creating a dynamic knowledge base where successful workflows are stored as "skills" for future agents.

Conclusion:
The paper establishes that a dual-use DSL is a viable and powerful strategy for automating complex scientific workflows. By bridging the gap between human expertise, AI generation, and production software, HepScript demonstrates that high-energy physics analysis can be effectively automated, paving the way for AI to become an autonomous research collaborator.