Interactive Power Flow in the Browser

arXiv:2610.01922 · eess.SY, cs.HC, cs.MS, cs.SY · Submitted 2026-10-01 · Read on arXiv

Listen

Transcript

Introduction to the show: ident: Robotics Radio. Generated commentary on the latest robotics and control papers.

Rosa: Today's paper: "Interactive Power Flow in the Browser".

Dev: This paper introduces tellegen, an open source framework for interactive power flow (PF) and optimal power flow (OPF) studies that run in the browser.

Rosa: First, who's behind it and why it matters.

Title and authors: Rosa: I'm really looking at this paper titled "Interactive Power Flow in the Browser," and it seems like it’s about bringing complex power system analysis tools directly into a web browser using WebAssembly. It suggests that people don't need specialized software installed locally to do these kinds of studies anymore.

Dev: That accessibility is definitely interesting, Rosa, especially when you think about how often we're dealing with dynamic grid changes. The authors are Samuel Talkington from Harvard University, Frederik Geth from the University of Queensland, Qian Zhang and Le Xie also from Harvard, and Skyler Liu also from Harvard. It sounds like a solid team putting together something quite substantial here.

Taro: I'm curious how this translates to real-world scenarios where things aren't perfectly controlled, Rosa? Does this framework handle situations where the system misbehaves unexpectedly?

Rosa: Well, what the authors are showing is that you can drag and drop a case file, then click around to change things like nodal demand or line ratings and instantly see how it affects the solution through sensitivity analysis. It’s about making complex power flow studies accessible through just a web link.

Dev: From my side, I'm thinking about the execution environment. The paper mentions that they compile the core numerical engine for both native binary and WebAssembly execution, which is key because that means local computation happens right in your browser without needing some remote solver service running on a cloud server. That addresses a lot of latency concerns.

Taro: So it’s about decoupling the analysis from the need for massive centralized infrastructure? That sounds like it could be useful when we're trying to rapidly test response strategies during unexpected events, I think.

Rosa: Exactly, Taro; it’s about democratizing access to these tools. It lets anyone with a web browser get access to power system analysis tools compiled for WebAssembly. The whole point is intuitive and accessible access to the analysis itself.

Dev: And they’ve even shown how the framework handles different types of studies, like DC PF and AC OPF, using various mathematical relaxations such as the SOCWR relaxation of AC OPF, which is ready to be compiled for WASM. We need to look at those numerical methods carefully later on.

Taro: That’s important because if the math itself is flexible enough to handle different formulations, then it’s more useful when real-world conditions are messy and don't fit a single textbook model.

The paper's summary: Rosa: So, in terms of what the paper summarizes, tellegen is essentially an open source framework designed for interactive power flow (PF) and optimal power flow (OPF) studies that run entirely in the browser. It details how you can load a case file, interact with it graphically to change parameters like line ratings or demand, and then get an exact re-solve instantly.

Dev: The summary really focuses on the architecture of this system, explaining that they combine a compiled OPF solver with graphical components for loading and displaying models. Crucially, the underlying OPF solver can be compiled for both native binary and browser execution so computations happen locally on your device.

Taro: I see how that local execution is important for rapid iteration; it means you don't have to wait for a server response every time you tweak a variable, which speeds up the whole testing loop considerably.

Rosa: That’s right, Taro; the paper emphasizes that local case files are parsed and used to build and solve problem instances directly within the browser. This is a big deal because it means studies can be distributed as a web application without needing to operate a solver service on some kind of cloud infrastructure.

Dev: Furthermore, they cover different numerical formulations, including DC PF and OPF which treat the flow as linear problems, and AC PF and OPF which use Newton-Raphson for complex bus voltages, focusing on convex relaxations like the SOCWR relaxation for AC OPF.

Taro: When you look at those formulations, it shows they are trying to cover a wide range of modeling needs, from simple approximations to more detailed nonlinear problems. That flexibility in formulation is what makes it applicable across different types of distribution and transmission studies.

Rosa: It really emphasizes the ability to do this interactively, meaning users can see the results through things like sensitivity analysis for nodal demand changes before committing to a full re-solve. It’s about seeing the impact before you actually do anything permanent.

Dev: And they mention that the workflow involves several components working together: powerio parsing the file into a canonical network, then @tellegen/engine loading the wasm module, and @tellegen/svelte rendering it all as a map and a solve card. It’s a very specific sequence for how everything is put together in the browser environment.

Taro: That layered approach—parsing, engine loading, rendering—suggests they've thought about how to keep the user experience smooth while keeping the heavy computation handled efficiently by that WebAssembly module.

The paper's improvements: Rosa: Regarding the improvements suggested in this paper, it’s centered around giving users a very specific and powerful way to interact with these studies. They propose a workflow where you can select a bus and it immediately displays the derivative of nodal demand with respect to that bus, which is sensitivity analysis.

Dev: That sensitivity analysis capability is crucial for understanding how small changes in an input parameter affect the output, like seeing d lambda i / d d j. It lets you gauge the impact of a change before you actually commit to making that edit in the model.

Taro: I think that ability to preview the impact before committing is what makes this framework really powerful for testing control parameters; it cuts down on trial and error significantly when trying to find the right settings.

Rosa: And they also highlight that retained multiconductor sessions allow you to repeatedly edit active or reactive loads while still reusing the network factorization, which saves time if you’re running similar tests over and over again. It’s about making repeated edits efficient.

Dev: I also see them talking about how local files have no fallback to solving on a server, which means studies stay entirely on your device, ensuring that the data handling remains private and doesn't rely on external services for the computation itself.

Taro: That local-first approach really speaks to autonomy; if you’re working remotely or in a field scenario where connectivity is spotty, having the entire analysis capability on your own device is a huge plus.

Rosa: And they also discuss the agentic interaction through standards like WebMCP, which allows an AI agent to inspect and operate the same study displayed to a human user using tools like capacity proposals. It’s about extending the tool's utility beyond just manual clicking.

Dev: That capability for an agent to perform bounded experiments—proposing edits, predicting results based on first-order responses, and then committing that edit for a re-solve—that sounds like a very controlled way to explore parameter space.

Taro: If the AI can propose changes and get an exact re-solve immediately, it moves the system from just being a display tool to becoming an active testing partner for optimization tasks.

Conclusion: Rosa: So, wrapping up on "Interactive Power Flow in the Browser," this paper shows us how to create a local framework that lets users do interactive PF and OPF studies right in their browser using WebAssembly, providing intuitive access to complex analysis tools. The core idea is making this analysis accessible through a simple web link.

Dev: Essentially, the implications are about shifting computation locally so that operational decisions can be validated quickly against equipment models without needing a constant connection to a solver service. We see performance evaluations showing that WASM OPF solves take only twenty-five to forty-three percent longer than native binary ones on realistic synthetic grids.

Taro: For me, the biggest implication is how this local-first architecture shifts computation to the recipient’s device, meaning the operator of a scientific application no longer needs a solver service to process private case files. That supports research and teaching while acknowledging that operational decisions still require validation against applicable equipment models and operating requirements.

Rosa: It really democratizes access by allowing studies to be distributed as a URL, letting recipients change parameters and get an exact re-solve on release, which is a key feature of tellegen. It’s about giving people the ability to iterate quickly on their models.

Dev: We also have the agentic interaction via WebMCP standards, which lets an agent inspect and operate the same study displayed to a human user with tools like capacity proposals that record trial edits and predicted changes before a final re-solve. That’s about building controlled testing loops using AI assistance.

Taro: I think if we can leverage these features to let agents propose changes and get immediate feedback, it opens up new ways for autonomous systems to handle dynamic environments where they need to adapt their plans on the fly.

Rosa: Well, we've seen how tellegen works in this paper, proving that local numerical execution can make industrial analysis accessible through an ordinary web link. It’s a solid piece of work for anyone looking at bringing these tools into a browser environment.

Dev: It really shows that the performance hit is manageable when you compare it against existing baselines like PowerModels.jl, showing good accuracy for distribution PF solvers too when compared to OpenDSS for static models.

Taro: It’s promising, but we still need to see how this holds up against more complex, nonlinear problems in practice before we can really say it's ready for everything we want to deploy autonomously.

Samuel Talkington, Frederik Geth, Qian Zhang, Le Xie, Skyler Liu

Harvard University

eess.SY, cs.HC, cs.MS, cs.SY

Submitted: 2026-10-01

Updated: 2026-10-01

Comments: 9 pages, 3 figures, 6 tables. To appear in the Inaugural ACM Conference on Digital Transformation (ACM DXConf 2026), Ann Arbor, MI, USA

Code: https://github.com/eigenergy/tellegen

Project page: https://webmachinelearning.github.io/webmcp

License: http://creativecommons.org/licenses/by/4.0/

Importance score: 91/100

The gist: This paper introduces tellegen, an open source framework for interactive power flow (PF) and optimal power flow (OPF) studies that run in the browser.

Key concepts

WebAssembly (Wasm): A compilation target that allows code written in languages like Rust to run efficiently in web browsers. This enables complex numerical solvers for power flow and optimization to execute locally on a user's machine, making the analysis fast and accessible without needing external server services.
Local-First Architecture: The framework is designed so that all heavy computation, including parsing case files and solving the OPF problem, happens entirely on the user's device. This means studies can be distributed as a simple URL, ensuring data privacy and eliminating reliance on cloud solvers for private case files.
SOC Relaxation (SOCWR): This is a specific mathematical technique used to simplify complex AC optimal power flow problems into a form that is easier to solve using the WebAssembly compiler. It allows the framework to handle non-linear AC OPF problems efficiently within the browser environment.

Terminology

Core — 5× in this paper · explained in 2 episodes
Model Context Protocol — 5× in this paper
Transformer — 5× in this paper · explained in 2 episodes
Accuracy — 3× in this paper · explained in 1 episode
Benchmark — 3× in this paper · explained in 2 episodes
Adam — 2× in this paper · explained in 2 episodes
Degeneracy — 2× in this paper · explained in 3 episodes
Agentic Coding — 1× in this paper · explained in 1 episode
Benchmarking — 1× in this paper · explained in 3 episodes
Decoupling — 1× in this paper · explained in 2 episodes
Foundation Model — 1× in this paper · explained in 3 episodes
Generative AI — 1× in this paper · explained in 2 episodes
Iterative Refinement — 1× in this paper · explained in 3 episodes
Power Systems Computation Conference — 1× in this paper
WebAssembly (Wasm) — 1× in this paper · explained in 2 episodes

Summary

The gist: The tellegen framework is an open source framework for interactive power flow (PF) and optimal power flow (OPF) studies that run in the browser, providing intuitive and democratized access to power system analysis tools compiled to WebAssembly.

Framework Architecture

The key idea behind tellegen is combining a compiled OPF solver with graphical components for loading, editing, and displaying power system models. The underlying OPF solver can be compiled for both native (binary) and browser (wasm) execution. With the solver compiled to wasm, the browser performs case parsing and numerical computation locally, so a study can be distributed as a web application without operating a solver service on a cloud server. Fig. 2 describes the architecture of the tellegen framework, showing how Local case files are parsed and used to build and solve problem instances directly in the browser.

Numerical Formulations

The paper details various formulations for transmission and distribution studies:

DC PF and OPF: The DC approximation treats active power flow in an alternating current (AC) network as a lossless linear problem, solving equations like (1). DC OPF minimizes an operational cost function subject to power balance and line limits.
AC PF, AC OPF, and the SOC relaxation: AC PF uses Newton-Raphson for complex bus voltages. AC OPF seeks to minimize an operational cost function subject to the AC power flow equations (2). For tellegen, they focus on convex relaxations of the AC OPF problem, specifically the second-order cone relaxation of AC OPF in voltage product variables (SOCWR), which is readily compiled to wasm.

Interactive Workflow and Sensitivity Analysis

The browser workflow follows a specific sequence: "powerio parses the file into a canonical network; the same Rust engine is compiled to a native target and to wasm32; @tellegen/engine loads the wasm module and exposes the Study lifecycle; and @tellegen/svelte renders the result as a map and a solve card." Users can interact with these results:

** Selecting bus j displays ∂λi/∂d j; (sensitivity analysis for nodal demand). 2.3 Case data and browser packages detail that Local files have no fallback to solving on a server, ensuring studies remain on the device. 4.1 Distribution studies and agent tools mention that Retained multiconductor sessions allow repeated active/reactive load edits while reusing the network factorization.**

Performance Evaluation

The framework's performance was evaluated against baselines:

Transmission OPF solver was compared against PowerModels.jl as a baseline, showing that WebAssembly OPF solves take only 25–43% longer than native binary solves on realistic synthetic grids.
Distribution PF solver was compared with OpenDSS, and comparisons showed high accuracy for static models, with errors and residuals reported in Table 3.
Native distribution PF latency was measured, showing end-to-end latency ranging from a median launchonly baseline of 2.70 ms.

Access and Agent Interaction

Tellegen addresses the delivery problem by allowing studies to be distributed as a website link, enabling recipients to change demand, a line rating, or another electrical parameter and obtain an exact re-solve on release. Furthermore, it supports agentic interaction via the experimental WebMCP standard. This allows an agent to inspect and operate the same study displayed to the human user, with tools like a capacity proposal that records budget, trial edits, predicted changes, and re-solved results. The framework also offers access outside the browser through native Rust interfaces and a Python package using PyO3.

Implications for Digital Transformation

The work democratizes access by allowing users to distribute an executable study as a URL. A key lesson is separating a fast preview of the change in a solution to an optimization problem from a completed solve keeps parameter exploration responsive. The local-first architecture shifts computation to the recipient's device, meaning The operator of a scientific application no longer needs a solver service to process private case files. This approach supports research and teaching while acknowledging that operational decisions still require validation against applicable equipment models and operating requirements.

Future Work

Future directions include validating against PSS/E.raw cases, extending validation from objectives alone to bus voltages, flows, and dispatch, and implementing full nonlinear AC OPF. Other extensions considered are distribution optimization controls, state estimation, and teaching materials evaluated with students. The repository is available at https://github.com/eigenergy/tellegen.

Improvements for AI systems

Here are specific improvements to AI systems, derived from the capabilities described in the tellegen framework:

The ability for AI agents to interact with and operate a power system study via a standardized interface (WebMCP).
The capability for an agent to inspect active cases, query solved quantities, and request specific simulations (e.g., multiconductor PF or transmission sensitivity).
The capacity for an agent to conduct bounded experiments by proposing edits, selecting relevant sensitivity trials based on predicted outcomes, and committing the resulting re-solve with human approval.
The ability for AI systems to perform complex numerical computations (PF and OPF) locally in a browser environment using compiled WebAssembly code, without requiring remote solver services or uploading sensitive case files (zero CEII transmission).

These improvements enable the following specific actions for an AI system:

Improved AI System Capability Specific Functionality Enabled by Tellegen Framework

:---:---

Inspect and query a power system model loaded in the browser. For example, an agent can query the solved nodal voltages, line flows, or generator setpoints of a specific network configuration.

Perform on-the-fly sensitivity analysis by requesting the derivative of an objective function (like cost) with respect to a specific input parameter (e.g., line rating or nodal demand) and visualizing the resulting impact in real-time across all buses.

Propose and test operational changes. An agent can suggest a change (e.g., increasing load on a specific feeder), predict the resulting cost/flow impact using first-order responses, and commit that edit to generate an exact re-solve for comparison against the prediction.

Conduct complex, multi-step planning experiments. The agent can use retained study states to run sequences of edits, evaluate their cumulative effect on system performance (e.g., capacity proposal), and present a structured report detailing the budget used and final results for human review and approval.

Interface with heterogeneous numerical solvers locally. An AI system can choose the appropriate formulation (DC PF, SOCWR relaxation of AC OPF, etc.) based on the required accuracy or computational budget, leveraging multiple compiled solver targets (native binary vs. WASM) seamlessly within the same interactive workflow.

Abstract

This paper introduces tellegen, an open source framework for interactive power flow (PF) and optimal power flow (OPF) studies that run in the browser. This provides intuitive and democratized access to power system analysis tools compiled to WebAssembly. A user can drag and drop a case file, click and drag to change a nodal demand or line rating, preview the impacts via sensitivity analysis, and obtain an exact re-solve on release. User case files and results stay entirely on the device: tellegen transmits zero Critical Energy/Electric Infrastructure Information (CEII). The framework comprises a core numerical engine for PF and OPF, reusable browser components, saved studies, and structured WebMCP tools for agentic interaction. We evaluate the transmission OPF solver by comparing objectives with PGLib baselines; the distribution PF solver by comparing voltages and currents with OpenDSS; and the WebAssembly execution times by comparing with PowerModels.jl. On realistic synthetic grids, WebAssembly OPF solves take only 25-43% longer than native binary solves. The implementation shows how an engineer can distribute an executable numerical study as a URL, reducing installation and hosting requirements while keeping case data local.