CREATE: Cross-Layer Resilience Characterization and Optimization for Efficient yet Reliable Embodied AI Systems

Tong Xie, Yijiahao Qi, Jinqi Wen, Zishen Wan, Yanchi Dong, Zihao Wang and 6 others

An embodied AI robot pairs a large language model that plans tasks with a reinforcement-learning controller that acts step by step, and running both on a battery-powered device is so power-hungry that engineers want to lower the chip voltage to save energy — but undervolting causes bit errors that can make the robot fail its task; this paper (Peking University and Georgia Tech — Tong Xie, Yijiahao Qi, and colleagues) presents CREATE, which first measures where these systems tolerate errors and where they do not, then adds matched fixes at the circuit, model, and application layers so the system can run at aggressively low voltage without losing task quality, saving about 40 percent of compute energy.

The argument in one glance

Problem

Embodied AI on a battery wants to save energy, but undervolting corrupts its computation

Embodied AI systems put an AI agent into the physical world, and modern ones are built from two parts: a large language model (LLM) planner that reads a high-level task and breaks it into subtasks, and a reinforcement-learning controller that turns each subtask into low-level actions, step by step. Running both is computationally heavy, and much of the time this must happen on a battery-powered local device (a robot, a drone) for latency and autonomy. A standard way to save energy on a chip is to lower its operating voltage: power drops sharply as voltage falls. But there is a catch. Push the voltage too low and the circuits no longer switch fast enough to meet their timing, so bits flip — the hardware computes wrong values. In an ordinary program a few flipped bits might be a minor glitch; in an embodied agent they can derail the plan or the control action and make the robot fail its task entirely. So there is a real tension: undervolting is the biggest lever for extending battery life, but it threatens the reliability the agent needs to actually get things done. The question is whether you can undervolt aggressively and still finish the task correctly.
What people did

Treat the whole system as uniformly fragile and protect everything

The conventional response to voltage-induced errors is to guard against them uniformly — for example, keep a safe voltage margin everywhere, or add generic error-detection and correction hardware across the whole computation, so that any bit flip anywhere is caught. The system is treated as equally sensitive throughout, and protection is applied evenly.
Why it fell short

Uniform protection ignores that different parts tolerate errors very differently

Protecting everything equally leaves most of the energy savings on the table, because it assumes a fragility the system does not uniformly have. Before this work, no one had actually measured how an embodied AI system responds to voltage-induced bit errors, so there was no basis for knowing where errors matter and where they do not. It turns out the tolerance is highly heterogeneous. At very low error rates both the planner and the controller cope fine, but as the error rate climbs, the reinforcement-learning controller stays remarkably resilient while the LLM planner degrades badly — and the planner's fragility has a specific cause: systematic large values (activation outliers) in the LLM, amplified by the normalization steps that follow, turn small hardware errors into large disruptions. Meanwhile the controller's resilience is not even constant: it varies from subtask to subtask and from step to step, with some moments far more critical than others. A uniform safe margin cannot exploit any of this: it over-protects the parts that are naturally tough and misses the chance to run them at much lower voltage. What was missing was a characterization of this heterogeneous resilience, and a set of fixes matched to where each layer is actually weak.
This paper's idea

Characterize the heterogeneous resilience, then fix each layer where it is weak

CREATE is a general design principle for making embodied AI both efficient and reliable by exploiting this heterogeneous fault tolerance across three layers. It starts from the first comprehensive error-injection study of these systems, which reveals the pattern above: the controller is far more error-tolerant than the planner, the planner's weakness comes from activation outliers plus normalization, and the controller's resilience varies by subtask and step. CREATE then applies a matched fix at each layer, working from coarse to fine. At the circuit level, an anomaly detection and clearance mechanism watches the computation's outputs and clamps any wildly out-of-range value (the large errors that come from a high-order bit flipping) to zero, cheaply removing the worst outliers. At the model level, weight-rotation-enhanced planning multiplies the planner's weights offline by a Hadamard rotation matrix, which spreads the troublesome activation outliers evenly across dimensions so smaller errors no longer blow up — and, because the rotation preserves the vector length that normalization relies on, it leaves the network's outputs unchanged with no runtime cost. At the application level, autonomy-adaptive voltage scaling reads how critical the current step is — using the entropy of the controller's action choices as the signal — and lowers the voltage during non-critical moments while keeping a safe margin during critical ones, with a co-designed voltage-regulator circuit to adjust voltage online. Together, without hurting task quality, CREATE saves about 40.6 percent of computational energy on average versus running at nominal voltage (and 35.0 percent over prior methods), extending battery life by roughly 15 to 30 percent.

Why this problem is worth solving

Embodied AI is only useful if it runs where the robot is, and that means on a battery, where energy is the binding constraint.

An embodied agent has to act in the physical world in real time, which usually means computing on the device itself — a robot or drone cannot always ship its perception and planning to a distant cloud and wait. But the two models it runs are heavy: an LLM planner with the reasoning ability to decompose a complex, long-horizon task, and a control model that must produce an action every step. Doing all this continuously drains a battery fast, and battery life is often what limits how long and how usefully such a system can operate. So energy efficiency is not a secondary optimization here; it directly sets what the agent can do before it must recharge. Lowering the operating voltage is the most powerful knob available, because dynamic power falls roughly with the square of voltage — a modest voltage cut yields a large energy saving. That is exactly why the community keeps reaching for undervolting, and exactly why the errors it introduces are worth confronting rather than avoiding: the prize is a large extension of the agent’s useful life on a charge.

The subtlety is that these systems are not uniformly fragile, and treating them as if they were wastes the opportunity.

The instinct when facing hardware errors is to defend everywhere: keep enough voltage margin, or add enough error correction, that nothing ever computes wrong. But that instinct assumes the system is equally sensitive throughout, and an embodied agent is not. The paper’s measurements show a striking split: the reinforcement-learning controller shrugs off surprisingly high error rates, while the LLM planner falls apart at much lower ones — and even within the controller, some subtasks and some individual steps are far more critical than others. This matters because the cost of protection is paid in energy: a safe voltage margin held everywhere means running the tough, error-tolerant parts far more conservatively than they need. If instead you know precisely where the fragility is — that it is the planner, that it stems from activation outliers, that the controller’s critical moments are identifiable at runtime — you can spend your protection budget only there and undervolt everything else aggressively. Turning a vague fear of errors into a precise map of who tolerates what is what unlocks the energy savings, which is why the characterization comes first and the fixes follow from it.

What people did before, and where it broke

Keep a safe voltage margin everywhere. Run the chip at a voltage high enough that timing errors essentially never occur. Where it broke. This forfeits most of the energy savings, because it holds the naturally error-tolerant parts (the controller) at a far more conservative voltage than they actually need.
Add generic error detection and correction across the computation. Protect all of the arithmetic uniformly against bit flips. Where it broke. Uniform protection is expensive and still treats every part as equally fragile, missing that the controller barely needs it while the planner needs a different kind of help entirely.
Undervolt naively for energy and hope errors are tolerable. Just lower the voltage and accept whatever bit flips result. Where it broke. The LLM planner is highly sensitive: its activation outliers, amplified by normalization, turn small errors into large ones, so naive undervolting causes task failures.
Characterize resilience of a single model in isolation. Study one LLM’s or one controller’s robustness on its own. Where it broke. An embodied agent is a planner-plus-controller pipeline with dependencies across subtasks and steps; single-model studies miss the heterogeneous, execution-dependent tolerance that the system-level behavior actually has.
The gap. No one had characterized the heterogeneous, cross-layer fault tolerance of a full embodied AI system, so there was no principled way to undervolt aggressively while keeping the agent reliable.

How CREATE works

From a resilience map to matched fixes at three layers

↓ →
new
↓ →
new
↓ →
new
↓ →
new
↓ →
new

The idea

Let the computation tolerate hardware errors instead of forbidding them. CREATE’s circuit-level move accepts that aggressive undervolting will produce bit errors and focuses on catching the damaging ones — clamping the huge outliers that a flipped high-order bit produces — rather than preventing every error. Building a system that keeps working correctly in the presence of corrupted computation, by detecting and neutralizing the corruptions that would matter, is the same undertaking the work on combating silent data corruptions in deep learning (Dr. DNA) covered elsewhere on this site pursues, making the model robust to hardware faults instead of assuming perfect arithmetic. CREATE does this with a cheap in-line detector on the arithmetic output, turning the worst voltage-induced errors into harmless zeros.

Transform the model into a friendlier form without changing what it computes. The weight-rotation trick is a representation change: multiplying weights by a Hadamard matrix reshapes the activations into an outlier-free distribution that resists errors, yet — because the rotation preserves the length normalization relies on — the network’s outputs are mathematically identical. Rewriting a computation into an equivalent form that is far more robust to errors, while provably preserving its result, is the same principle the work on Clifford-assisted problem transformation for error mitigation (Clapton) covered elsewhere on this site is built on, moving to a representation where errors do less harm. CREATE applies this offline to the planner, so its notorious activation outliers stop amplifying small errors, at zero runtime cost.

Adapt energy use to how much the current moment matters. The application-level technique treats voltage as something to spend where it counts: it reads a runtime signal of step criticality and pours voltage margin into the critical steps while starving the non-critical ones, matching energy to importance. Dynamically adjusting a system’s energy expenditure to the demands of the moment, rather than provisioning for the worst case at all times, is the same idea the work on a virtual energy system for carbon-efficient applications (Ecovisor) covered elsewhere on this site develops, aligning energy spent with when it is actually needed. CREATE uses the entropy of the controller’s action choices as that signal, undervolting hardest exactly when the agent is confident and the step is least critical.

Following a task through CREATE

Running an embodied agent at low voltage without failing the task

A trace, drawn from the paper, of how CREATE keeps an undervolted embodied AI system reliable.

Step 1 of 5

The planner decomposes the task under undervolting

The LLM planner reads a high-level task and breaks it into subtasks. The chip is undervolted to save energy, so timing-violation bit errors threaten the planner — which the study showed is the fragile part, because of its activation outliers.

Without help, undervolting here would corrupt the plan and fail the task.

Why it works

The characterization tells CREATE exactly where to spend protection. Protecting everything uniformly wastes energy → but the error-injection study maps precisely which parts tolerate errors and which do not → so each layer’s fix targets the real weakness instead of guarding the whole system.
Clamping outliers kills the most damaging errors cheaply. A flipped high-order bit produces a huge, task-wrecking value → but a simple range check at the output clamps such outliers to zero → so the worst errors are removed with only comparator-and-multiplexer hardware.
Rotating weights removes the amplifier, not just the symptom. The planner’s fragility comes from activation outliers that normalization magnifies → but a Hadamard rotation spreads those outliers evenly and preserves the outputs → so smaller errors stop blowing up, at zero runtime cost.
Entropy reveals when a step can afford low voltage. The controller’s resilience changes step to step and a fixed margin cannot exploit that → but action-logit entropy signals how critical each step is → so voltage can drop during non-critical moments and rise only when it matters.
The three layers compound because they cover different error regimes. No single fix handles both large and small errors across planner and controller → but detection handles large errors, rotation handles small ones, and adaptive voltage handles the controller → so together they enable far lower voltage than any one alone.

What it costs (trade-offs and scope)

It adds hardware and a co-designed voltage regulator. The circuit-level detector adds comparator-and-multiplexer units to the arithmetic arrays, and the application-level scaling needs a custom low-dropout-regulator design for online voltage adjustment; these are lightweight but real additions to the chip.
It is specialized to the planner-plus-controller embodied AI structure. The techniques are built around an LLM planner (with its activation-outlier fragility and normalization) and an RL controller (with step-varying resilience); other AI system organizations, for example end-to-end vision-language-action models, would need their resilience re-characterized.
The adaptive voltage relies on a runtime criticality predictor. Autonomy-adaptive scaling depends on a small network predicting action-logit entropy before inference; its accuracy bounds how aggressively voltage can be safely lowered, and a mispredicted critical step could be under-protected.
Weight rotation is tailored to the planner’s math. The Hadamard rotation works because it preserves the length that normalization uses, so the outputs are unchanged; it targets the pre-normalization components specifically, and applies where that invariance holds rather than to arbitrary layers.
The gains are reported at iso-task-quality on studied benchmarks. The 40.6 percent energy saving and 15 to 30 percent battery-life improvement are measured on the paper’s embodied AI benchmarks and hardware model without degrading task success; other tasks, environments, or process technologies could shift the achievable margin.

The evaluation

Undervolting an embodied AI system for energy savings

Property	Safe voltage margin	Naive undervolting	CREATE
Energy saving
Task quality under errors
Large outlier errors
Planner fragility (activation outliers)
Controller voltage

A comparison of ways to run an embodied AI system at low voltage. By characterizing the heterogeneous fault tolerance and applying matched fixes at the circuit (anomaly detection and clearance), model (weight-rotation-enhanced planning), and application (autonomy-adaptive voltage scaling) layers, CREATE undervolts aggressively without losing task quality — saving about 40.6 percent of computational energy versus nominal voltage (35.0 percent over prior art), 29.5 to 37.3 percent chip-level energy, and 15 to 30 percent battery life.Underlined values explain themselves when clicked.

Where this stops working

What to keep in mind

This explainer is based on the paper’s full text (the authors’ arXiv copy of the ASPLOS 2026 paper). The design principle described is the paper’s: CREATE leverages the heterogeneous resilience of embodied AI systems for synergistic energy-reliability co-optimization. The paper conducts what it describes as the first comprehensive error-injection study of modern embodied AI systems (an LLM-based planner plus an RL-based controller), finding an inherent but heterogeneous fault tolerance — the controller is far more resilient than the planner, the planner’s poor resilience at higher error rates traces to systematic activation outliers combined with normalization, and the controller’s resilience varies across subtasks and execution steps. Building on this, CREATE applies three matched techniques: circuit-level anomaly detection and clearance (comparator-and-multiplexer units that clamp out-of-range values to zero to eliminate large timing errors), model-level weight-rotation-enhanced planning (offline Hadamard-matrix rotation of weights to redistribute activation outliers while preserving outputs via norm invariance), and application-level autonomy-adaptive voltage scaling (using action-logit entropy as a step-criticality signal to drive an LDO-based online voltage adjustment). The paper reports that, without compromising task quality, CREATE achieves 40.6 percent average computational energy savings over nominal voltage and 35.0 percent over prior-art techniques, 29.5 to 37.3 percent chip-level energy savings, and about 15 to 30 percent longer battery life. Exact resilience measurements, circuit and algorithm details, benchmarks, and full results should be read from the paper.

Background

Why the energy-reliability trade-off keeps returning in edge AI

It helps to see CREATE within a long-running theme in efficient computing: the tension between spending less energy and computing correctly. Almost every powerful efficiency technique — lowering voltage, reducing precision, approximating arithmetic — buys energy by giving up some margin of correctness, and the art is to give up only the margin you can afford. On battery-powered edge devices this tension is sharpest, because energy is the hard limit and yet the system must still act reliably in the world. What has changed with modern AI workloads is that they often have slack the old worst-case designs never exploited: neural networks tolerate some noise, and different parts of a computation matter unequally, so blanket protection is wasteful. The productive path has been to measure that slack carefully and then design hardware and software together to harvest it — pushing efficiency exactly as far as each part’s tolerance allows and no further. Embodied agents raise the stakes because a corrupted computation is not a wrong pixel but a wrong action in the physical world. The broader effort to build efficient hardware for autonomous physical agents under tight energy budgets is the same terrain the work on an accelerator generation framework for optimization-based robotics (Orianna) covered elsewhere on this site occupies, squeezing capable robot computation into a constrained device. CREATE contributes the insight that an embodied AI system’s tolerance to error is neither uniform nor fixed, and that mapping it precisely lets you undervolt far more aggressively than a one-size-fits-all margin ever could.

If you remember only three things

1. Embodied AI systems pair an LLM planner (task decomposition) with a reinforcement-learning controller (per-step actions) and must run on battery-powered devices, where lowering the operating voltage is the biggest energy lever — but undervolting causes timing-violation bit errors that can fail the task. The key insight is that these systems are not uniformly fragile: a comprehensive error-injection study shows the controller tolerates far higher error rates than the planner, the planner's weakness comes from activation outliers amplified by normalization, and the controller's resilience varies by subtask and step.
2. CREATE applies a matched fix at each of three layers. At the circuit level, anomaly detection and clearance clamps wildly out-of-range values (from high-order bit flips) to zero using cheap comparator-and-multiplexer units. At the model level, weight-rotation-enhanced planning multiplies the planner's weights offline by a Hadamard rotation to spread activation outliers evenly, so smaller errors no longer blow up — and because the rotation preserves the length normalization uses, the outputs are unchanged at zero runtime cost. At the application level, autonomy-adaptive voltage scaling uses the entropy of the controller's action choices to lower voltage during non-critical steps and hold a margin during critical ones, via a co-designed voltage regulator.
3. Without compromising task quality, CREATE saves about 40.6 percent of computational energy versus nominal voltage (35.0 percent over prior art), 29.5 to 37.3 percent chip-level energy, and 15 to 30 percent battery life. The trade-offs: it adds detector and voltage-regulator hardware, is specialized to the planner-plus-controller structure (other AI organizations would need re-characterizing), relies on a runtime criticality predictor whose accuracy bounds how far voltage can safely drop, and its weight rotation is tailored to the planner's normalization math.

Check yourself

Check your understanding

1. Why does lowering the operating voltage of an embodied AI chip risk failing the task, even though it saves energy?
2. What did the error-injection study reveal about how embodied AI systems tolerate voltage-induced errors?
3. Why can CREATE rotate the planner's weights with a Hadamard matrix to improve robustness without changing what the model computes?
4. Predict: during a task the controller reaches a step where its action-logit entropy is very low (it is highly confident about a specific action). What will autonomy-adaptive voltage scaling do, and why?

Sources

The paper is “CREATE: Cross-Layer Resilience Characterization and Optimization for Efficient yet Reliable Embodied AI Systems” by Tong Xie, Yijiahao Qi, Jinqi Wen, Zishen Wan, Yanchi Dong, Zihao Wang, Shaofei Cai, Yitao Liang, Tianyu Jia, Yuan Wang, Runsheng Wang, and Meng Li (Peking University and Georgia Institute of Technology), published at ASPLOS 2026, DOI 10.1145/3779212.3790147. It is licensed CC BY, with an author copy at arXiv:2601.14140.

This explainer is written from the paper’s full text (the authors’ arXiv copy). CREATE is a general design principle that leverages the heterogeneous resilience of embodied AI systems (an LLM-based planner plus an RL-based controller) for synergistic energy-reliability co-optimization. The paper conducts the first comprehensive error-injection study of such systems and finds an inherent but heterogeneous fault tolerance: the controller is far more resilient than the planner, the planner’s poor resilience at higher error rates comes from systematic activation outliers combined with normalization, and the controller’s resilience varies across subtasks and execution steps. Building on these insights, CREATE develops a circuit-level anomaly detection and clearance mechanism to eliminate large outlier errors, a model-level weight-rotation-enhanced planning algorithm (offline Hadamard rotation) to improve the planner’s fault tolerance while preserving outputs, and an application-level autonomy-adaptive voltage scaling technique (using action-logit entropy as a criticality signal, with a co-designed voltage-scaling circuit and low-dropout regulators) to dynamically adjust the controller’s voltage. The paper reports that, without compromising task quality, CREATE achieves 40.6 percent average computational energy savings over nominal-voltage operation and 35.0 percent over prior-art techniques, leading to 29.5 to 37.3 percent chip-level energy savings and about 15 to 30 percent longer battery life. Numbers are the paper’s own; exact measurements, mechanisms, and full results should be confirmed in the paper.