⚛️ phenomenology

Large Language Model-Assisted Framework for BSM Model Building

The paper introduces \texttt{bsm_agent}, an open-source framework that integrates a deterministic Python backend for symbolic physics calculations with a large language model interface to automate the construction, validation, and analysis of Beyond the Standard Model theories through natural language interaction.

Original authors: Shaikh Saad

Published 2026-06-23

📖 4 min read🧠 Deep dive

CC BY 4.0

Original authors: Shaikh Saad

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 you are an architect trying to design a new type of building. In the world of particle physics, this "building" is a theoretical model that explains how the universe works beyond what we already know (the Standard Model).

Usually, building these models is like trying to construct a skyscraper using only a hammer and a chisel. You have to manually calculate every single brick, beam, and bolt, checking if they fit together without the whole thing collapsing. If you make one tiny math error, the whole building is unsafe. This process is slow, tedious, and prone to mistakes.

Enter bsm_agent: The AI Architect's Assistant.

This paper introduces a new tool called bsm_agent. Think of it as a smart construction foreman who speaks your language. You don't need to know how to mix the concrete or calculate the load-bearing stress of a beam yourself. You just tell the foreman, "I want to add a new wing to the building made of these specific materials," and the foreman does all the heavy lifting.

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

1. The Conversation (The "Chat")

Instead of writing complex computer code or filling out difficult forms, you simply talk to the software. You might say, "Build a model with a new particle that is a color triplet and has a weak charge of 1/2."

The software uses a Large Language Model (LLM)—the same kind of technology behind chatbots—to understand what you are asking. However, the paper makes a very important distinction: The chatbot is just the receptionist. It listens to you, clarifies your instructions, and then hands the actual work off to a strict, rule-following computer program.

2. The Deterministic Backend (The "Calculator")

Once the chatbot understands your request, it passes the details to a deterministic symbolic backend. Think of this as a super-precise calculator that never guesses and never hallucinates.

It builds the blueprint: It automatically writes down the mathematical equations (the Lagrangian) that describe how your new particles interact with existing ones.
It checks for safety: It runs "anomaly checks," which are like stress tests to ensure the new building won't collapse due to mathematical inconsistencies.
It expands the details: It takes the high-level blueprint and breaks it down into every single component part, showing exactly how the new particles interact with the old ones.
It calculates the weight: It figures out the "mass matrices," which tell you how heavy the new particles would be after the universe settles into its current state.

3. The "Human-in-the-Loop" Safety Net

The paper emphasizes that the AI chatbot never does the actual math. If you are vague (e.g., you forget to say if a particle is a "scalar" or a "fermion"), the chatbot will pause and ask, "Did you mean a scalar or a fermion?" This ensures that the strict calculator gets the exact right instructions before it starts working.

4. The Result

Once the work is done, the system generates a professional report (a PDF) that looks like a scientific paper. It lists all the new particles, the interaction rules, and the mass calculations.

A Real-World Example from the Paper:
The authors tested the system by building a complex model involving "Leptoquarks" (hypothetical particles that connect quarks and leptons).

The Old Way: A human physicist might spend days or weeks manually writing down over 100 different interaction terms, checking for errors, and expanding the equations.
The bsm_agent Way: The user typed a few sentences describing five new particles. In less than a minute, the system generated the full model, checked for errors, expanded all the equations, and produced a report with over 100 terms.

Why This Matters

The paper argues that this tool bridges the gap between human intuition and mathematical rigor.

For Students: It makes advanced physics accessible. You can learn what a model looks like without getting bogged down in the tedious algebra.
For Experts: It acts as a safety net. Even experts make mistakes when doing manual calculations; this tool ensures that once the ingredients are defined, the recipe is followed perfectly every time.

In Summary:
bsm_agent is a tool that lets you describe a new universe in plain English, while a strict, error-free computer engine does the complex math to build it. It separates the "creative" part of physics (deciding what new particles to add) from the "boring" part (doing the thousands of calculations required to make it work), ensuring the results are always accurate and reproducible.

Technical Summary: Large Language Model-Assisted Framework for BSM Model Building

Problem Statement
Constructing theoretical models for physics beyond the Standard Model (BSM) is a laborious and error-prone process. While the Standard Model (SM) is well-established, extending it requires adding new scalar and/or fermionic fields and manually deriving the complete set of renormalizable, gauge-invariant operators. As the number of new fields increases, the combinatorial complexity of identifying allowed interaction terms, verifying gauge-anomaly consistency, expanding operators into component fields, and deriving electroweak symmetry breaking (EWSB) mass matrices grows rapidly. This manual workflow often leads to omissions of relevant operators or inclusion of linearly dependent terms, creating a barrier to efficient model exploration, particularly for students and researchers developing complex extensions.

Methodology
The authors introduce bsm_agent, an open-source Python framework that integrates a deterministic symbolic physics backend with a Large Language Model (LLM) orchestration layer. The system is designed to separate conversational intent from physical computation to ensure reproducibility and rigor.

Deterministic Symbolic Backend:
- Field and Group Layer: Defines SM field content and supports extensions with arbitrary $U(1)_Y$ hypercharges, $SU(2)_L$ representations up to dimension 7, and $SU(3)_c$ representations up to the adjoint octet.
- Model Construction: Automatically generates the complete basis of renormalizable (dimension $\leq 4$ ) gauge-invariant operators (scalar potential, Yukawa, fermion mass) based solely on the quantum numbers of new fields. It employs group-theoretic algorithms to handle $SU(2)$ and $SU(3)$ index contractions using Clebsch-Gordan coefficients and invariant tensors.
- Anomaly Checking: Computes standard anomaly coefficients ( $SU(3)^3$ , $SU(2)^2 U(1)$ , etc.) by summing over left-handed Weyl fermions.
- Expansion and EWSB: Expands gauge-invariant operators into explicit component fields. It applies vacuum expectation values (VEVs) to neutral scalar components to derive stationary conditions and tree-level mass matrices for scalars and fermions.
- Optimization: Includes representation-aware optimizations, such as reduced Bose-symmetrized bases for repeated scalar multiplets and adjoint-basis constructions for color octets, to mitigate computational scaling issues.
LLM-Assisted Interaction Layer:
- Orchestration: The LLM serves exclusively as an interface and tool router. It interprets natural-language requests (e.g., "build a model with a fermion singlet"), validates user intent, and manages confirmation steps for ambiguous inputs (e.g., clarifying if a field is real or complex).
- Tool Calling: The LLM triggers specific backend tools (model construction, report generation, mass matrix extraction) via a structured tool-calling interface.
- Constraints: Crucially, the LLM never generates the Lagrangian, anomaly coefficients, or mass matrices. These are computed entirely by the symbolic backend to prevent hallucination and ensure physical correctness.
- Provider Agnosticism: The framework supports local Ollama inference, remote self-hosted servers, and commercial APIs (OpenAI, Anthropic).

Key Contributions

Automated Operator Generation: The framework eliminates the need for manual enumeration of interaction terms. Given only the quantum numbers of new fields, it constructs the full renormalizable Lagrangian.
Hybrid Architecture: It establishes a robust paradigm where an LLM handles natural language understanding and workflow management, while a deterministic symbolic engine (built on SymPy) performs all physics calculations.
Comprehensive Analysis Pipeline: The package automates the entire workflow from field specification to the generation of PDF-ready reports containing expanded Lagrangians, anomaly checks, and mass matrices.
Flexibility in Input: Users can specify models via natural language, including complex descriptions of quantum numbers (e.g., "color anti-sextet, weak triplet"), without adhering to rigid syntax.

Results
The paper demonstrates the framework's capabilities through several case studies:

Standard Model Validation: Successfully reproduces the SM Lagrangian, Yukawa sector, and mass matrices, confirming the correctness of the expansion and EWSB logic.
Simple Extensions: Constructs models with right-handed neutrinos and scalar singlets, verifying anomaly-free status and generating correct interaction terms.
Complex Leptoquark Model: A significant benchmark involves a model containing five distinct scalar leptoquarks with various $SU(3)_c \times SU(2)_L \times U(1)_Y$ representations. The package constructs a model with 14 kinetic terms, 73 scalar potential terms, and 14 Yukawa terms in under a minute. The expanded Lagrangian and derived mass matrices are shown to agree with established literature (specifically Ref. [33]), validating the handling of complex gauge contractions and phase conventions.
Performance: Benchmarks indicate that while computational time scales with representation size (e.g., color octets or high-dimensional $SU(2)$ multiplets), the framework remains practical for phenomenologically relevant models, often completing construction and expansion in seconds to minutes.

Significance and Claims
The authors claim that bsm_agent fills a distinct niche in the BSM software ecosystem by automating the pre-implementation stage of model building. Unlike existing tools (e.g., SARAH, FeynRules) that require users to define the interaction structure or Lagrangian manually, bsm_agent starts from the minimal input of field quantum numbers.

The paper emphasizes that this approach:

Reduces Technical Overhead: Makes advanced model-building methodologies accessible to students and pedagogical users without sacrificing the rigor required for research.
Ensures Reproducibility: By strictly separating the LLM (orchestration) from the symbolic backend (computation), the framework guarantees that physics results are deterministic and free from AI hallucinations.
Accelerates Discovery: It allows researchers to rapidly prototype and analyze complex extensions of the Standard Model that would be tedious to construct manually.

The work positions itself not as a replacement for established symbolic tools, but as a natural-language interface that lowers the barrier to entry for using such tools, thereby facilitating the exploration of a wider variety of phenomenologically interesting BSM scenarios.

1. The Conversation (The "Chat")

2. The Deterministic Backend (The "Calculator")

3. The "Human-in-the-Loop" Safety Net

4. The Result

Why This Matters

More like this