AutoB2G: A Large Language Model-Driven Agentic Framework For Automated Building-Grid Co-Simulation

This paper introduces AutoB2G, a large language model-driven agentic framework that automates the entire building-to-grid co-simulation workflow using natural language descriptions to generate, execute, and refine simulations via a codebase-guided approach, thereby improving grid-side performance metrics without requiring manual programming expertise.

The Gist

Imagine you are the conductor of a massive orchestra. On one side, you have hundreds of musicians (buildings) playing their own instruments (HVAC systems, lights, appliances). On the other side, you have the concert hall itself (the power grid), which has strict rules about how loud the music can get and how the sound waves bounce around.

If the musicians play too loudly in one spot, the hall might shake. If they play too quietly, the sound dies out. Your job is to get them to play together perfectly so the hall stays stable, without drowning out the audience.

The Problem:
Until now, trying to teach these musicians to play together has been a nightmare for researchers.

1. It's too manual: You had to write thousands of lines of complex computer code just to set up the "stage."
2. It's one-sided: Most setups only cared if the musicians were happy (saving money on electricity), ignoring if the concert hall was about to collapse (voltage spikes in the power grid).
3. It's hard to fix: If the simulation crashed, you had to be a coding wizard to find the bug.

The Solution: AutoB2G
The paper introduces AutoB2G, a new system that acts like a super-smart, natural-language-speaking stage manager.

Instead of writing code, you just talk to the system. You say something like: "Set up a simulation where 24 buildings try to save energy, but make sure the power grid voltage stays stable. Use a smart AI to learn the best way to do this."

Here is how AutoB2G makes this happen, using some creative analogies:

1. The "Recipe Book" (The DAG Codebase)

Imagine the computer code for these simulations is a giant, messy library of ingredients and recipes. If you ask a normal computer to "make a cake," it might grab flour, but forget the eggs, or try to bake the cake before mixing the batter.

AutoB2G organizes this library into a Directed Acyclic Graph (DAG). Think of this as a flowchart recipe.

• It knows that you must mix the batter (Step A) before you can bake the cake (Step B).
• It knows that if you want a chocolate cake, you need cocoa (Step C), but if you want vanilla, you skip it.
• When you give your instruction, the system doesn't just guess; it looks at this flowchart to find the exact, correct sequence of steps needed. It acts like a librarian who knows exactly which books to pull off the shelf to build your specific simulation.

2. The "Swarm of Specialists" (The SOCIA Framework)

Once the system knows what to build, it doesn't just ask one robot to do it. It uses a team of specialized agents (a "swarm"), much like a construction crew:

• The Architect: Reads your natural language request and draws the blueprint.
• The Builder: Writes the actual code based on the blueprint.
• The Inspector: Runs the simulation to see if it works.
• The Critic: If the building collapses (the code crashes), the Critic analyzes why and tells the Builder exactly what to fix.

3. The "Textual Gradient Descent" (The Self-Correcting Loop)

This is the magic sauce. In traditional math, you fix errors by calculating numbers. In this system, the "math" is done with words.

Imagine you are trying to tune a guitar string.

• Old way: You pluck it, hear it's flat, and turn the peg a tiny bit based on a formula.
• AutoB2G way: The system plays the note, hears it's flat, and the "Critic" agent says, "Hey, that note is flat because the string is too loose. Tighten the peg on the left side."
• The "Builder" agent reads this sentence, tightens the peg, and tries again.

This happens over and over again. The system generates code, breaks it, gets a "textual gradient" (a written instruction on how to fix it), and repairs itself until the simulation runs perfectly. It's like a video game character that learns from its own mistakes without a human player needing to press the "reset" button.

4. The Result: A Two-Way Street

The best part is that AutoB2G doesn't just look at the buildings; it looks at the Grid too.

• Before: The buildings would just try to save money, even if it caused the power grid to flicker.
• Now: The AI learns a "dance." If the grid is getting too much voltage (over-voltage), the buildings might turn on their heaters slightly to soak up the extra power. If the grid is weak (under-voltage), the buildings might dim their lights to help stabilize it.

Why This Matters

• For Non-Coders: You don't need to be a Python expert to run complex power grid simulations. You just need to speak English.
• For Safety: It helps prevent blackouts by teaching buildings to be good neighbors to the power grid.
• For Speed: What used to take a researcher weeks of coding and debugging now happens automatically in minutes.

In a nutshell: AutoB2G is a self-driving car for energy research. You give it a destination (your research goal), and it handles the steering, the engine tuning, and the navigation, ensuring you arrive safely without needing to know how to build the car yourself.

Technical Summary

1. Problem Statement

The integration of building energy systems with power grids (Building-to-Grid or B2G) is critical for enhancing system flexibility and demand response. However, current research faces three primary challenges:

• Limited Grid Awareness: Existing simulation environments (e.g., CityLearn V1, Energym) focus heavily on building-side metrics (cost, comfort) and lack systematic evaluation of grid-level impacts (voltage stability, line loading).
• Legacy Incompatibility: Previous attempts to integrate grid models (e.g., GridLearn) often rely on outdated versions of simulation frameworks, making them incompatible with modern features like custom datasets, EV integration, and advanced thermal dynamics.
• High Implementation Barrier: Setting up co-simulation workflows requires significant manual coding, expertise in multiple platforms (EnergyPlus, CityLearn, Pandapower), and repetitive configuration. This hinders the adoption of Reinforcement Learning (RL) for large-scale building clusters.

The paper proposes AutoB2G, a framework that automates the entire building-grid co-simulation workflow using natural language (NL) task descriptions, eliminating the need for manual coding and deep domain expertise.

2. Methodology

AutoB2G is an agentic framework that combines a DAG-based retrieval mechanism with the SOCIA (Simulation Orchestration for Computational Intelligence with Agents) framework. The workflow consists of three main stages:

A. Extended Simulation Environment

The authors extended CityLearn V2 to support B2G interactions.

• Data Generation: Uses EnergyPlus and LSTM models to generate realistic building thermal dynamics and electricity demand.
• Co-Simulation: Integrates CityLearn with Pandapower for power flow analysis. At each time step, building loads are mapped to grid buses, power flow is calculated, and grid states (e.g., bus voltages) are fed back to the building agents.
• Grid Metrics: Introduces specific grid-side evaluation metrics, including voltage admissibility, thermal loading limits, N-1 resilience, and short-circuit current analysis.

B. DAG-Based Agentic Retrieval

To address the LLM's lack of prior knowledge regarding specific simulation dependencies:

• DAG Construction: The codebase is organized as a Directed Acyclic Graph (DAG) where nodes represent functional modules (e.g., data generation, reward definition, power flow) and edges represent input-output dependencies.
• Retrieval Process: An LLM agent interprets the user's NL task and retrieves relevant modules from the DAG.
• Iterative Repair: A validator checks the retrieved set for structural consistency. If dependencies are missing or the execution order is invalid, the agent receives feedback and refines the selection until a valid execution path is formed.

C. The SOCIA Framework & Textual Gradient Descent (TGD)

Once the modules are retrieved, the SOCIA multi-agent framework automates code generation and refinement:

• Multi-Agent Roles: Specialized agents manage the pipeline:
  • Workflow Manager: Orchestrates the process.
  • Code Generator: Synthesizes code based on retrieved templates.
  • Simulation Executor: Runs the code and captures logs/errors.
  • Result Evaluator: Checks for constraint violations.
  • Feedback Generator: Analyzes errors and generates repair instructions.
• Textual Gradient Descent (TGD): Instead of numeric gradients, TGD treats the code itself as the optimization variable. The system iteratively:
  1. Executes the code.
  2. Detects violations (syntax, logic, interface mismatches).
  3. Generates a "textual gradient" (natural language feedback) describing the error and the fix.
  4. Updates the code via a patching mechanism.
     This loop continues until the code converges to a fully executable, constraint-compliant simulator.

3. Key Contributions

1. B2G Co-Simulation Environment: A novel extension of CityLearn V2 that supports full building-grid interaction, including customizable datasets, EV integration, and comprehensive grid-side metrics (voltage, N-1, short-circuit).
2. DAG-Based Retrieval Mechanism: A structured approach to guide LLMs in retrieving simulation modules. By explicitly encoding dependencies, it ensures the generated workflow is structurally sound and executable.
3. Automated Pipeline via SOCIA & TGD: The application of the SOCIA framework with TGD to automatically construct, debug, and refine complex simulation code from natural language, significantly reducing manual intervention.

4. Experimental Results

The framework was evaluated on natural-language-driven tasks ranging from simple to complex, using the IEEE 33-bus distribution network.

• Task Success Rate:
  • Simple Tasks: SOCIA + Agentic Retrieval (AR) achieved a 100% success rate.
  • Complex Tasks: While a baseline LLM dropped to 53% success, SOCIA + AR maintained an 83% success rate.
  • Code Score: In complex tasks, SOCIA + AR achieved a code score of 0.88 (vs. 0.44 for baseline LLM), indicating higher accuracy in component selection and configuration.
• Grid Performance:
  • RL-based control strategies generated by AutoB2G successfully regulated bus voltages, keeping them close to the nominal 1.0 p.u.
  • Compared to baseline control, the RL strategy significantly narrowed the voltage distribution, reducing over-voltage risks.
  • The system demonstrated adaptive load modulation, increasing demand during over-voltage and reducing it during under-voltage scenarios.
• Convergence: The TGD mechanism showed rapid improvement in the first iteration, with success rates stabilizing as complex errors were resolved in subsequent cycles.

5. Significance

• Lowering the Barrier to Entry: AutoB2G allows researchers to focus on scientific questions (e.g., control strategies) rather than low-level implementation details, democratizing access to complex building-grid co-simulation.
• Bridging the Gap: It effectively bridges the gap between data-driven building control and power system analysis, enabling systematic evaluation of grid safety and resilience under RL-based control.
• Scalability and Automation: The framework demonstrates that LLMs, when guided by structural constraints (DAG) and iterative feedback (TGD), can reliably automate complex, multi-stage engineering workflows that were previously too error-prone for single-shot generation.
• Future Potential: The modular design suggests the framework can be extended to other simulation platforms and control paradigms, paving the way for fully autonomous energy system design and optimization.