Energy Calculus is a mathematical framework for describing and combining energy measurements from computational tasks. It is designed to help researchers reason about how much energy a complex computing workflow uses—not only by adding isolated measurements, but by accounting for execution order, parallelism, hardware conditions, and measurement uncertainty.
The research paper, Energy Calculus: A Compositional Algebra of Energy in Computational Systems, was submitted to arXiv on July 13, 2026, by Mosharaf Chowdhury, Jae-Won Chung, Jeff J. Ma, Nishil Talati, and Ruofan Wu. The paper proposes treating energy as a first-class property of computation and using mathematical operators to compose measured energy behavior along the structure of a program.
Energy Calculus has also become part of a new University of Michigan research initiative. On October 27, 2026, Michigan Engineering announced E-CALC, a DARPA-funded, two-year project intended to develop tools for measuring and optimizing energy across the machine-learning lifecycle. The project’s stated ambition is to enable reductions of up to half in AI energy needs through more efficient software design. That is a target, not a result that the Energy Calculus framework has already demonstrated across AI systems.
This guide focuses on the technical idea behind Energy Calculus: what it models, how its operators work, why context matters, and what developers should look for when evaluating claims about energy efficiency.
Why was Energy Calculus proposed?
Energy is often reported as a single total: a training run consumed a certain number of joules, or an inference workload used a certain amount of electricity. Those totals are useful, but they can be difficult to combine when engineers want to predict the effect of changing several parts of a system.
Imagine that one optimization changes processor frequency, another changes the scheduling of parallel tasks, and a third changes how work is split across devices. Each technique may have been evaluated separately. Simply adding their individual savings—or assuming the improvements will remain unchanged when combined—can produce an inaccurate prediction.
The reason is that energy use depends on execution context. Tasks can share a processor, memory system, or other hardware resources. Their timing may overlap. A change to one task can affect another task’s runtime or operating conditions. Energy Calculus is intended to represent these interactions in a structured way, instead of treating every measured energy number as context-free.
The central question is therefore not just, “How much energy did this operation consume?” It is also, “Under what conditions was it measured, how does it interact with other operations, and what can we infer when the operations are composed into a larger workload?”
What does “compositional” mean in Energy Calculus?
In this context, compositional means that the behavior of a larger computation can be modeled by combining descriptions of smaller computational elements according to the way those elements execute.
A modern AI workflow can be represented as a directed acyclic graph, or DAG. The graph contains operations and dependencies: some steps must finish before others can begin, while other steps may execute concurrently. Energy Calculus aims to mirror that structure when combining energy signatures.
An energy signature is more informative than one total energy value. In the paper, a signature includes relevant information such as execution time, static and dynamic energy, the hardware operating point, the execution context, and measurement uncertainty.
That context can include the conditions under which a task ran. For example, a GPU kernel may behave differently at a different power limit, clock frequency, or level of resource contention. If the model discards those details, a prediction for a new workload may be less reliable.
Energy Calculus gives researchers a formal way to carry these details into the calculation. Rather than assuming every energy measurement can be reused unchanged, the framework asks how the operations are related and which contextual effects need to be retained.
The three Energy Calculus composition operators
The paper describes three operators for combining energy signatures. They correspond to different ways that computational work can execute.
1. Sequential composition
Sequential composition represents operations that execute one after another. A later operation depends on the earlier stage completing, or the workflow otherwise specifies a sequential order.
A simple example is an AI pipeline that first preprocesses input data and then runs a model. If preprocessing must finish before inference starts, the workflow has a sequential dependency. Energy Calculus represents the combined behavior using the signatures and the relevant rules for sequential execution.
It is tempting to assume that sequential energy is always just the arithmetic sum of two independent measurements. But that assumption is safe only when the relevant context and interactions allow it. The Energy Calculus paper specifically notes that sequential composition has properties that differ from familiar arithmetic: it commutes only when the elements are mutually context-insensitive, and it does not generally distribute over parallel composition.
In practical terms, changing operation order or the state left by an earlier operation can matter. Energy Calculus is designed to make such assumptions explicit rather than hiding them inside a single total.
2. Parallel execution on the same device
The second operator represents tasks that run in parallel on the same device. This is important because concurrent tasks may compete for shared resources or change each other’s execution behavior.
For example, two GPU tasks may overlap while sharing compute units, memory bandwidth, or power capacity. Measuring each task in isolation may not accurately predict how the pair behaves together. Their runtimes can change, and the combined energy profile may depend on the hardware operating point and the scheduling policy.
Energy Calculus aims to model the combined signature in a way that reflects same-device parallel execution. This can help researchers reason about real workloads rather than assuming that isolated measurements always transfer directly to concurrent execution.
3. Parallel execution across devices
The third operator represents work that executes in parallel across different devices. Distributed AI training often splits work across many GPUs or other accelerators, with communication and synchronization between them.
In this setting, the overall workflow depends on more than the sum of the energy used by individual devices. The timing of tasks, the dependencies between them, and the execution context all influence the complete computation.
Energy Calculus is intended to compose the signatures of work distributed across devices while preserving the structure of the computation. This is relevant to large model training, multi-device inference, and other distributed computing systems.
The three operators are a key part of what distinguishes Energy Calculus from a simple spreadsheet of energy measurements. They provide a mathematical vocabulary for describing sequential, same-device parallel, and cross-device parallel execution.
Why does measurement uncertainty matter?
No measurement system is perfectly exact. Sensors have limits, sampling intervals affect observations, and background activity can complicate the attribution of energy to a specific task. A model that reports an energy prediction without representing uncertainty can give readers a false sense of precision.
Energy Calculus incorporates measurement uncertainty into its energy signatures and propagates uncertainty through composition. The intended result is a prediction that carries an error bound, not merely a number that appears exact.
This matters when engineers compare two configurations. Suppose one configuration appears to use slightly less energy than another. If the difference is smaller than the uncertainty of the measurement, the evidence may not support a confident claim that the first configuration is more efficient.
By tracking uncertainty, Energy Calculus aims to help researchers distinguish a meaningful difference from one that may be explained by measurement limitations. It also provides a way to reason about how uncertainty in individual elements affects the estimate for a larger workflow.
This does not make every prediction automatically accurate. The quality of the result still depends on the underlying measurements, assumptions, and model of execution. Energy Calculus provides a framework for representing uncertainty; it does not remove the need for careful experimental design.
Energy Calculus and time-energy trade-offs
Energy efficiency is rarely the only goal of an AI system. Developers may need to meet a latency target, complete training by a deadline, or keep an interactive application responsive. An optimization that saves energy but makes a workload unacceptably slow may not be useful.
The Energy Calculus paper extends its composition operators to time-energy Pareto frontiers. A Pareto frontier describes options where improving one objective generally requires a trade-off in another. For example, one configuration might minimize energy, while another finishes sooner but consumes more energy.
Representing these trade-offs helps engineers evaluate a range of feasible choices instead of optimizing a single number. A service with strict latency requirements may prefer a different point on the frontier from a batch-processing job that can run overnight.
This is particularly relevant to AI deployment. Inference workloads may need to balance energy per request, throughput, latency, and the number of simultaneous users. For training, teams may need to balance total energy against completion time and hardware availability.
Energy Calculus does not decide which trade-off is best for every application. It aims to provide a structured way to express the options and the information needed to compare them.
How is Energy Calculus different from an energy benchmark?
An energy benchmark measures and compares systems under defined conditions. It can answer questions such as how much energy a particular model uses for a workload on specified hardware, or how energy consumption changes when the software configuration changes.
Energy Calculus has a different primary purpose. It is a compositional mathematical framework for reasoning about energy signatures and how they combine across a computation. A benchmark can provide measurements that inform such reasoning, but the benchmark and the mathematical framework are not interchangeable.
The distinction matters because an energy measurement is evidence about a particular execution. Predicting the behavior of a different execution requires understanding whether the original measurement remains applicable, what context has changed, and how the tasks interact.
The University of Michigan’s ML.ENERGY initiative provides a related example of measurement and comparison. It benchmarks energy consumption across open-weight AI models and software frameworks. The Zeus framework, also developed by researchers in the group, focuses on optimizing AI model training settings such as batch size and power limits. These tools address connected problems, but their results should not be described as proof that Energy Calculus itself has achieved a specific energy reduction.
For context on the newer research initiative, read our report on the University of Michigan and DARPA Energy Calculus project. For broader infrastructure implications, see our coverage of AI data centers and electricity bills.
What could Energy Calculus enable for developers?
If the framework and associated tools prove accurate and practical, Energy Calculus could support several kinds of engineering decisions.
- Comparing software and hardware configurations: Developers could use energy signatures to reason about how design choices affect a complete workflow, rather than relying exclusively on isolated measurements.
- Finding expensive stages: A workflow-level view could help teams identify where energy is consumed across preprocessing, training, inference, and supporting operations.
- Reasoning about parallel workloads: The operators provide a formal approach to representing tasks that overlap on one device or execute across multiple devices.
- Evaluating uncertainty: Explicit error bounds could help teams judge whether an apparent improvement is supported by the available measurements.
- Balancing energy and latency: Time-energy Pareto frontiers could help developers compare configurations that trade lower energy use against shorter execution time.
These are potential uses, not guaranteed outcomes. Their value will depend on how well the model captures real systems, how much measurement effort is required, and whether the tools can be integrated into ordinary development and deployment workflows.
What are the limitations of Energy Calculus?
Energy Calculus should not be interpreted as a universal calculator that can predict the energy cost of any AI system without data. The framework depends on energy measurements and on an appropriate representation of the computational structure and execution context.
A model may need new measurements when the hardware, software stack, workload, or operating conditions change. Interactions that are negligible in one setting may be significant in another. In addition, the framework’s predictions should be checked against actual measurements, especially when the expected savings are small or the system is safety-critical.
The research paper is a preprint hosted on arXiv. Readers should distinguish the authors’ proposed mathematical framework and reported analysis from independent validation across production AI workloads. The existence of a formal framework is an important research contribution, but it is not by itself evidence that every optimization derived from it will reduce energy use.
Likewise, the 50% figure associated with the E-CALC project is an ambition stated in the University of Michigan announcement. It should not be attributed to Energy Calculus as an already verified, general-purpose result. Actual savings must be demonstrated for specific workloads, hardware, baselines, and performance requirements.
What should researchers evaluate next?
The most useful next step is rigorous evaluation. Researchers and developers should look for comparisons between Energy Calculus predictions and directly measured energy consumption across sequential workflows, same-device parallel workloads, and cross-device execution.
Evaluations should document hardware and software configurations, measurement methods, execution context, uncertainty estimates, and the workload graph. They should also report runtime and quality effects where relevant. A claimed energy saving is more informative when readers can see the baseline, the measurement process, and whether the improvement repeats under comparable conditions.
It will also be useful to understand when simpler context-independent calculations are adequate. The paper presents a Reduction Theorem that recovers simpler algebra when interactions fall below measurement uncertainty. This is an important practical idea: a useful Energy Calculus implementation should not require unnecessary complexity when the available evidence shows that context effects are negligible.
As tools and documentation emerge from the E-CALC project, the central questions will be whether the framework predicts energy reliably, whether its uncertainty bounds are useful, and whether it helps teams find repeatable improvements that existing methods miss.
Energy Calculus: the bottom line
Energy Calculus is a proposed compositional algebra for reasoning about energy in computational systems. Its energy signatures represent more than a total: they include execution time, static and dynamic energy, hardware operating conditions, context, and measurement uncertainty. Three operators describe sequential execution, parallel work on the same device, and parallel work across devices.
The framework is intended to help researchers combine energy measurements in ways that reflect how computation actually executes. Its treatment of context and uncertainty is central to the approach, as is its ability to represent trade-offs between energy and time.
For AI developers, Energy Calculus is worth following because it addresses a gap between measuring one workload and reasoning about an entire AI pipeline. But its practical value must be established through reproducible measurements and comparisons against real executions. It is a framework for better energy reasoning—not a guarantee that every AI workload will use less power. Energy use is one of the broader infrastructure issues discussed in our guide to the biggest AI challenges in 2026.
Sources and further reading
- Primary research paper: Energy Calculus: A Compositional Algebra of Energy in Computational Systems — the preprint describing energy signatures, composition operators, uncertainty propagation, and time-energy Pareto frontiers.
- University of Michigan Engineering: Optimizing AI energy consumption throughout its entire lifecycle — announcement of E-CALC, its DARPA funding, collaborators, and project goals.
- University of Michigan Engineering: AI energy use: New tools show which model consumes the most power, and why — background on measuring energy use across AI models and software configurations.
- University of Michigan Engineering: AI training energy reduced up to 50% with U-M software — separate research on training-energy optimization with Kareus and Perseus; these results are not the same as a demonstrated saving from Energy Calculus.
Research note: Energy Calculus is discussed here as a proposed framework described in an arXiv preprint. Project goals, paper claims, and independently verified outcomes are treated as distinct categories of evidence.