A battery-powered robot that plans its motion online pays for that planning twice. It pays directly, in the watts drawn by the processor, memory and accelerator that solve the optimization. It also pays indirectly, and possibly far more, through what slow planning does to the motion. When the controller replans less often or runs on a throttled chip, the robot drifts further from its plan between updates. A safe planner must then keep wider margins from obstacles, which forces slower and longer paths and more time spent burning motor power. Today these two costs are studied in separate communities. Computer-systems work models processor, memory and accelerator power in detail but treats the workload as fixed. Robotics work measures solver speed in milliseconds and "energy" as motor effort, and runs the onboard computer at a fixed clock.
We propose to treat the compute configuration as a control input whose cost is total battery energy. The configuration covers processor and GPU frequency, how often the planner replans, and how long its prediction horizon is. The configuration enters the motion problem through a single coupling: a measured map from compute configuration to tracking-error bound, which sets how much the planner must tighten its obstacle constraints. A runtime scheduler then picks the configuration segment by segment. It spends more compute in clutter, where tighter margins buy shorter, faster paths. It throttles down in open space, where margins cost nothing. The claim is falsifiable and scale-dependent. We expect a measurable reduction in total energy per mission over the best fixed configuration on small robots and in variable environments. We expect the effect to vanish on large drones flying through uniform scenes.
Core Claim
Picture a hierarchical MPC (model predictive control, a controller that repeatedly re-solves a short-horizon optimal control problem and applies the first step). Its total mission energy is
$$E(c) = \int_0^{T(c)} \big( P_{\text{motor}}(t) + P_{\text{cpu}}(c) + P_{\text{gpu}}(c) + P_{\text{mem}}(c) \big)\, dt.$$
Here $c$ is the compute configuration, $T(c)$ is mission duration, and the $P$ terms are instantaneous power of the motors and of each computing component. The first-order effect of $c$ on $E$ does not run through the compute terms. It runs through $T(c)$ and $P_{\text{motor}}$, via the constraint tightening margin
$$\delta(c) = \max_t \lVert x(t) - x^{\text{plan}}(t) \rVert,$$
the worst-case gap between the true state $x$ and the planned state under configuration $c$. A larger $\delta$ shrinks the free space the planner may use.
The strongest motivating evidence comes from Embedded Hierarchical MPC for Autonomous Navigation, which splits navigation into a 2 Hz planner and a 20 Hz tracker on a Jetson Xavier NX. Its planner tightens obstacles by an offline tracking-error bound. The goal is reached in 8.1 s versus 35.1 s for single-layer MPC. Under near-constant hover power, a fourfold change in mission time is a fourfold change in motor energy. That gap is driven by how compute is organized, yet the paper reports no energy figures and runs the board at a fixed clock. Our work makes $\delta$ an explicit, measured function of clock frequency, replanning rate and horizon, and then optimizes over it at runtime.
Relation to Prior Work
Three works share pieces of this question and none closes the loop. Dadu-Corki co-designs trajectory-chunked VLA inference with a torque-control accelerator, reporting a 9.2x energy reduction on CORKI-9. Its energy is compute energy only, its trajectories are open-loop splines with no constrained optimal control, and its testbed is tabletop manipulation on CALVIN. DeeR-VLA exits a language-model policy early when actions stop changing between layers, cutting inference time by 68.1% on a V100. It measures FLOPs and GPU memory, not battery draw or the motion consequences of a cheaper action. Fully Autonomous Neuromorphic Navigation and Dynamic Obstacle Avoidance cuts system energy to 21% of baselines on a tiny drone. It does this by abandoning trajectory optimization for reactive potential fields. It does show that at small scale compute is a large share of the budget, which motivates our scale study, but it gives up constraints entirely. We keep constrained MPC and ask how to buy its latency cheaply.
On the actuation side, Comparison of Optimization-Based Methods for Energy-Optimal Quadrotor Motion Planning compares solvers on motor effort $\int \sum f_i^2 dt$. It finds DDP via Crocoddyl one to two orders faster than alternatives and KOMO lowest in effort, but it ignores host energy. We reuse its effort objective and its solver ranking to define our planner options. A Co-Design Framework for Energy-Aware Monoped Jumping shows that detailed actuator models change optima: mechanical energy fell from 31.44 J to 15.36 J. This argues for an electrical motor model rather than squared thrust, and we adopt that lesson.
Two papers supply method. Event-triggered Robust MPC under Hard Computation Resource Constraints tightens constraints as a function of time since the last solve, with stability guarantees. That is exactly the form of $\delta(c)$ for replanning rate, but it models compute as an integer capacity with no power. Quad-LCD learns tracking error from 200,000 RotorPy rollouts and uses it as a planning regularizer. We reuse this recipe to learn $\delta$ as a function of compute configuration and local scene features, instead of trajectory coefficients alone. From systems work, the result in Huai et al. is the closest analog of what we expect. Spreading load at lower frequency beat bin-packing by 14%, which suggests that "race to idle" is not automatically optimal. We test the robotic counterpart.
Research Program
We first build a per-component power model of the onboard computer, covering CPU, GPU and memory rails, measured with board power sensors. The model covers each candidate configuration: clock pairs, planner rate in roughly 1–10 Hz, tracker rate, horizon length, and solver choice between DDP and an interior-point solver. We pair it with an electrical motor model of current, winding loss and battery voltage sag, validated against measured battery current. Second, we learn $\delta(c, s)$ from simulated closed-loop rollouts, where $s$ is local clutter and speed. We fit it with a conservative quantile model, so tightening remains a bound rather than a mean. Third, a scheduler re-selects $c$ at each planner cycle. It minimizes predicted energy over the next segment subject to the latency deadline and to $\delta(c,s)$ fitting within the tightened corridor. Recursive feasibility carries over from the hierarchical scheme as long as the margin in use always upper-bounds the active configuration's error, and we will verify switching transients empirically.
The platforms are chosen to span the compute-to-motor power ratio. The low-compute-share end is an Agilicious-class drone (Agilicious, Jetson TX2, high-power motors). The middle is the Jetson Xavier NX setup of Benders and Köhler in Gazebo and Flightmare (Flightmare). The high-share end is a Crazyflie 2.0 in RotorPy, carrying a compute payload. If time allows, we add an ANYmal-style legged case following Online Dynamic Trajectory Optimization and Control for a Quadruped Robot. There, compute must also trade horizon length against the ~100 ms onboard solve.
Baselines
The naive reference is the Benders and Köhler hierarchical MPC exactly as published: fixed maximum clock, 2 Hz planner, 20 Hz tracker, and a single offline tightening margin. Its reported numbers are 8.1 s to goal versus 35.1 s for single-layer MPC, with solves of ~37.7 ms and ~24.1 ms. No reported result was found on Lacuna for its energy, so we will measure it ourselves on the same arenas. Single-layer MPC at fixed clock is the "do less structure" floor.
The strongest competitor is the best fixed configuration chosen offline by exhaustive grid search over the same configuration space. It uses the same power and motor models and is scored on total energy over a held-out set of training missions. This is strong because, if environments are homogeneous, nothing online can beat it.
We will also run a deadline-driven frequency governor. It picks the lowest clock that meets the planner deadline and keeps rates and margins fixed. This is the standard systems answer and is the direct analog of the governors in Cuttlefish and Countdown Slack.
Two ablations isolate the key ingredient. In the first, the scheduler counts only compute energy, the CORKI-style accounting. In the second, the scheduler counts total energy but uses a constant $\delta$, so compute cannot influence the corridor. All methods share scenes, seeds, hardware and the same planner cost. Every tuned baseline gets the same grid-search budget as our scheduler's training. Beating a baseline means lower mean total battery energy per completed mission, with a 95% bootstrap interval excluding zero over at least 100 missions, at equal or lower collision rate and constraint-violation count.
Why not just…?
Why not just run the processor at the lowest clock that meets the deadline? This minimizes chip power, but it treats the deadline as the only interaction with control. Our hypothesis is that faster, more frequent replanning shrinks $\delta$ and shortens missions, so the energy-optimal clock is often above the minimum feasible one. The comparison against the deadline governor tests this directly. If the governor matches us within noise, the coupling through $\delta$ is weak and the paper reports that.
Why not just pick one good configuration offline? This is the real threat. In uniform environments it should tie with us, and we say so in advance. The online scheduler only earns its keep when clutter varies within a mission. We therefore build missions with controlled clutter variance, mixing open corridors with dense obstacle fields. We report the energy gain as a function of that variance, so the regime where adaptation matters is mapped rather than asserted.
Why not ignore compute, since motors dominate drone power? On a large racing drone this is probably right, and our Agilicious-class platform is included to confirm the null. The argument fails in two ways that we test. First, compute affects motor energy through mission time even when chip watts are negligible, as the 8.1 s versus 35.1 s gap suggests. Second, at nano scale compute is a large share of system power, as the neuromorphic drone result implies. The cross-platform study measures where the crossover lies.
Proposed Experiments and Decisive Checks
The first check is whether $\delta$ actually depends on configuration. On the Xavier NX setup we sweep clock and planner rate and measure closed-loop tracking error. If $\delta$ is flat across configurations, the proposal collapses to compute-only DVFS and we stop. The second check is the cross-platform energy comparison against all baselines above. We report total energy, mission time, the motor and compute energy split, collision rate, and worst constraint violation, with the "constant $\delta$" ablation showing how much of any gain flows through tightening. The third check is the clutter-variance sweep against the best fixed configuration, which decides whether online scheduling is needed at all. The fourth is a hardware test on the Crazyflie of the learned $\delta$ bound's coverage. We count how often real tracking error exceeds the predicted margin, since an unsafe saving does not count. We also run a transfer test of solver choice: for each segment, does the scheduler prefer the faster DDP solver or the lower-effort KOMO-style plan that Rehberg et al. found trade off? This would show whether solver selection is itself an energy decision once compute is counted.
References
- Embedded Hierarchical MPC for Autonomous Navigation
- Dadu-Corki: Algorithm-Architecture Co-Design for Embodied AI-powered Robotic Manipulation
- DeeR-VLA: Dynamic Inference of Multimodal Large Language Models for Efficient Robot Execution
- Fully Autonomous Neuromorphic Navigation and Dynamic Obstacle Avoidance
- Comparison of Optimization-Based Methods for Energy-Optimal Quadrotor Motion Planning
- A Co-Design Framework for Energy-Aware Monoped Jumping with Detailed Actuator Modeling
- Event-triggered Robust Model Predictive Control under Hard Computation Resource Constraints
- Quad-LCD: Layered Control Decomposition Enables Actuator-Feasible Quadrotor Trajectory Planning
- Energy Aware Task Scheduling in Data Centers
- Agilicious: Open-source and open-hardware agile quadrotor for vision-based flight
- Flightmare: A Flexible Quadrotor Simulator
- Online Dynamic Trajectory Optimization and Control for a Quadruped Robot
- Cuttlefish: library for achieving energy efficiency in multicore parallel programs
- Countdown Slack: A Run-Time Library to Reduce Energy Footprint in Large-Scale MPI Applications