⚛️ phenomenology

LeWRON: Agentic Analysis of Electroweak Phase Transitions

The paper introduces LeWRON, an agentic framework that automates the complex, convention-sensitive pipeline for analyzing electroweak phase transitions—from Lagrangian input to gravitational-wave predictions—while ensuring reproducibility and supporting both the verification of published results and the discovery of new beyond-the-Standard-Model scenarios.

Original authors: Isaac R. Wang

Published 2026-06-19

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Isaac R. Wang

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

The Big Picture: A Cosmic "Switch"

Imagine the early universe as a giant, super-hot pot of soup. As it cooled down, it went through a "phase transition," similar to how water turns into ice. In physics, this is called the Electroweak Phase Transition (EWPT).

Why do we care?

The Recipe: If this transition happened smoothly (like water slowly freezing), our universe would be very different.
The Explosion: If it happened violently (like water suddenly boiling over), it could explain why we have more matter than antimatter (which is why we exist) and might create "sound waves" in the fabric of space-time that we can detect today as gravitational waves.

The problem is that figuring out exactly how this transition happened for any new theory of physics is incredibly difficult. It requires a massive, multi-step recipe involving complex math, computer code, and checking for errors at every single step.

The Problem: Too Many Steps, Too Many Mistakes

Until now, if a physicist wanted to study a new theory (a "Beyond the Standard Model" scenario), they had to:

Write down the math equations by hand.
Translate those equations into computer code.
Run the simulation.
Check if the code has bugs.
Repeat if the results look weird.

This process is slow, prone to human error, and requires deep expertise. It's like trying to build a custom car engine by hand, where one wrong bolt can ruin the whole thing.

The Solution: LeWRON (The AI Architect)

The author, Isaac R. Wang, has built a new tool called LeWRON (Learning ElectroWeak phase tRansitiON). Think of LeWRON not as a calculator, but as a team of specialized AI agents working together to build the engine for you.

Here is how the team works, using a construction analogy:

1. The Blueprint Team (The "Auditor" Agents)

Before any building starts, these agents act like strict architects.

The Job: They take the raw math (the Lagrangian) and break it down into tiny, manageable steps.
The Safety Net: They don't just guess; they check their own work. If an agent derives a formula, an "Auditor" agent immediately checks it against known physics rules. If it fails the check, the agent has to redo the work.
The Analogy: Imagine a team of engineers where one person draws a blueprint, and a second person immediately checks it against the building code. If the code is wrong, the blueprint is thrown out and redrawn before anyone lays a single brick.

2. The Construction Team (The "Explorer" Agent)

Once the blueprint is approved and the "tools" (computer code) are built, the Explorer takes over.

The Job: This agent uses the tools to run simulations, scan through different scenarios, and draw graphs.
The Human Touch: This is where the human physicist steps in. The AI pauses at specific checkpoints to say, "Here is what I found. Does this make sense to you?" The human can say, "Yes, keep going," or "No, change that assumption."
The Analogy: This is like a robot builder that stops to ask the homeowner, "I'm about to paint the walls blue. Is that what you wanted?"

How LeWRON Works in Practice

The paper demonstrates LeWRON in two ways:

The "Reproduction" Mode (The Copycat):
LeWRON was given a famous paper from the past and asked to recreate the results. It successfully read the old paper, figured out the hidden math rules the authors used, wrote the code, and reproduced the graphs. It proved it could "learn" from existing literature without being explicitly programmed with every rule.
The "Discovery" Mode (The Explorer):
LeWRON was given a new, complex model (involving a particle called an ALP) that hadn't been fully analyzed yet.
- It built the math tools from scratch.
- It found a small error in how previous scientists had handled the math (a "renormalization" issue).
- It ran the simulation and produced new, more accurate graphs showing how the universe might have behaved in this scenario.

Why This Matters

LeWRON is a framework, not just a one-time trick.

It's Open Source: The code is available for anyone to use.
It's Safe: By using "Auditor" agents to check the math, it reduces the risk of the AI making up fake physics.
It's Flexible: It can handle both simple models and complex, new theories.

The Limitations (What It Can't Do Yet)

The paper is honest about what LeWRON cannot do right now:

It doesn't calculate the speed of the "bubble walls" (the edge of the phase transition) because that math is still being figured out by the physics community.
It currently focuses on the Higgs sector (the part of physics related to the Higgs boson). It doesn't yet handle other complex types of phase transitions (like those in "dark matter" sectors) without more work.

Summary

LeWRON is a smart, self-checking AI team that automates the difficult, math-heavy process of studying how the early universe changed. It acts as a bridge between a physicist's idea and a working computer simulation, ensuring that the math is correct at every step and allowing humans to guide the process when things get tricky. It turns a months-long, error-prone manual task into a streamlined, reproducible workflow.

Technical Summary of LeWRON: Agentic Analysis of Electroweak Phase Transitions

Problem Statement
The analysis of the Electroweak Phase Transition (EWPT) is a critical but technically demanding task in particle physics and cosmology, linking collider phenomenology, baryogenesis, and gravitational-wave observatories. Unlike collider phenomenology, which benefits from mature, run-card-based tools, EWPT analysis for Beyond-the-Standard-Model (BSM) scenarios requires a complex, model-dependent pipeline. For every new model, researchers must manually derive background field potentials, field-dependent mass spectra, loop corrections, renormalization schemes, and thermal corrections (including resummation). This process is sensitive to convention choices and implementation details, often requiring dedicated coding and numerical troubleshooting. While libraries like CosmoTransitions exist, they do not automate the derivation of model-specific analytic ingredients from a Lagrangian.

Methodology: The LeWRON Framework
The authors present LeWRON (Learning ElectroWeak phase tRansitiON), an agentic framework designed to orchestrate the entire EWPT analysis pipeline, starting from an input Lagrangian or a target result in the literature. The framework is built on a "controlled human-agent workflow" rather than a one-shot code generator, prioritizing reliability and reproducibility through the following architectural principles:

Role-Separated Model Calls:
- Coding Model: Assigned mechanical tasks with sharply specified targets, such as symbolic derivation. These calls use extended thinking disabled and temperature=0 to minimize stochastic variation in convention-following.
- Reasoning Model: Assigned diagnosis, exploration, numerical implementation, and auditing. This model handles steps requiring physics judgment.
Audited Toolbox Construction:
The core of LeWRON is a pipeline that builds a model-specific toolbox. This pipeline is divided into three stages, with intermediate analytic outputs checked by "auditor agents" and stored as structured artifacts (Pydantic objects):
- Stage 1 (Symmetry & Tree Level): Identifies background field directions, derives the tree-level scalar potential, mass spectra, Goldstone modes, vacuum conditions, and bounded-from-below constraints using symbolic SymPy routines.
- Stage 2 (Zero-Temperature One-Loop): Constructs the zero-temperature effective potential (Coleman-Weinberg), fixes renormalization conditions (using a counterterm prescription by default), and implements the model in a Python script compatible with CosmoTransitions.
- Stage 3 (Finite-Temperature): Adds the finite-temperature potential, including thermal masses and user-selected resummation prescriptions (defaulting to Parwani, with options for Arnold-Espinosa, improved Parwani, and partial-dressing).
Human-in-the-Loop Checkpoints:
The framework includes specific checkpoints where human physicists can inspect artifacts, correct assumptions, provide model-specific guidance, or request revisions. This ensures that the final calculation record is preserved and that physics correctness is verified.
Explorer Module:
Once the toolbox is constructed, the "Explorer" module (using the Claude Code SDK and a customized experience library) performs downstream tasks. These include scanning parameter spaces, computing phase-transition quantities (critical temperature $T_c$ , nucleation temperature $T_n$ ), generating bubble nucleation rates, and predicting gravitational-wave spectra.

Key Contributions

First Domain-Specialized Agentic Framework: LeWRON is claimed to be the first agentic framework demonstrated on end-to-end EWPT analyses that derives analytic ingredients from a Lagrangian without assuming a pre-existing, mature model-specific pipeline.
Dual-Mode Operation:
- Reproduction Mode: Infers conventions from literature to reproduce published results, flagging inconsistencies in formulae or conventions.
- Discovery Mode: Guides users through structured checkpoints to analyze new models, allowing for interactive refinement of observables and visualizations.
Structured Artifacts & Reproducibility: By storing intermediate analytic outputs (potentials, tadpoles, mass matrices) as structured artifacts, LeWRON enables reproducible human inspection and downstream use via a command-line interface and a public Python API.

Validation and Results
The framework was validated across four representative examples:

Reproduction of Z2-Symmetric Singlet Model (Ref. [71]): LeWRON successfully reproduced benchmark nucleation temperatures and wall velocities. Results agreed with the reference within an error smaller than 1%. Minor discrepancies were attributed to missing exact input parameter values in the original paper.
Reproduction of 2HDM+a Model (Ref. [69]): LeWRON reconstructed the finite-temperature potential structure, handling the non-trivial rotation between the Higgs basis and the $Z_2$ basis. The computed critical temperature differed by approximately 3%, likely due to implementation-level numerical details (e.g., thermal function treatment).
Discovery in ALP-Higgs Model: LeWRON addressed limitations in previous literature regarding renormalization prescriptions and the numerical challenge of computing tunneling actions for MeV-scale Axion-Like Particles (ALPs). The framework derived a consistent renormalization scheme and computed the tunneling path, showing agreement with extrapolated boundaries from prior work.
Discovery in 2HDM+S Model: The framework explored the thermal history of a 2HDM+S model under different resummation schemes. It revealed qualitatively different thermal histories: Arnold-Espinosa resummation predicted a first-order phase transition followed by a crossover, while Parwani resummation predicted a simple smooth crossover.

Significance and Limitations
The paper claims that LeWRON significantly lowers the barrier to entry for EWPT analysis by automating the derivation of model-specific analytic ingredients while maintaining rigorous human oversight. It bridges the gap between theoretical model building and phenomenological prediction.

The authors explicitly note several limitations:

Physics Scope: The current version is limited to EWPTs driven by the SM Higgs sector. It does not yet compute bubble-wall velocities (a first-principles determination still under active development) or include three-dimensional effective-theory approaches and higher loop orders.
Model Coverage: To ensure reliability, the symbolic derivation component (Stage 1b) restricts the class of accepted inputs. Consequently, transitions in left-right symmetric models, dark phase transitions, or models requiring dedicated effective-potential treatments (e.g., supersymmetric models) are left for future work.
Agent Flexibility: There is a tradeoff between reproducibility and flexibility; the system prioritizes reliability by restricting input classes, which may limit the acceptance of arbitrary user specifications.

The code is released as an open-source package with both a command-line interface for full runs and a Python API for integrating individual stages into external frameworks.