The World Model Planning Accelerator (WMPA): Hardware-Algorithm Co-Design for Embedded AI in Robotics

Prerana Ramkumar, Suhas Suresh Bharadwaj, Fazal HameedarXiv 2026 · arXiv

TL;DR

This paper quantifies a staggering eleven-order-of-magnitude energy gap between current GPU hardware and the theoretical CMOS floor for robotic "world model" planning. To bridge this, the authors propose the World Model Planning Accelerator (WMPA), a co-designed architecture that uses near-memory computing and entropy-driven precision scaling to keep embedded robot controllers from overheating during complex simulations.

What Problem Does This Paper Address?

Modern robotics is shifting from simple perception to "imagination." Using world models—learned simulators—robots can rehearse thousands of potential action sequences in a compressed latent space before moving a single motor. This is critical for safety and efficiency in complex environments.

However, these "rollouts" are computationally brutal for embedded systems. Unlike standard deep learning tasks (like image classification) that can be easily parallelized across wide systolic arrays, a rollout is a deep sequential chain: step $t+1$ cannot be calculated until step $t$ is finished. This creates a massive bottleneck where expensive compute cores sit idle, waiting for data from memory. On edge robots with strict thermal and power budgets, this inefficiency leads to unsustainable heat—potentially melting the very hardware meant to guide the robot.

Methods

The authors attack this problem through a "chain from bound to bottleneck":

  1. Theoretical Bounds: They use information theory (Shannon entropy) and Boolean circuit complexity to derive the absolute minimum energy required to transition from one latent state to the next.
  2. Empirical Profiling: They profile a DreamerV3-style Recurrent State Space Model (RSSM) on NVIDIA T4, A100, and H100 GPUs. They use Roofline Analysis to determine if the workload is limited by math (compute-bound) or data movement (memory-bound).
  3. Thermal Simulation: They solve 3D transient non-linear heat equations to see how a millimeter-scale silicon tile behaves under sustained planning loads.
  4. Hardware-Algorithm Co-Design: They propose the WMPA, a conceptual architecture featuring:
  5. Near-Memory Compute Units (NMCU): Moving the math inside the memory subsystem to kill off-chip traffic.
  6. Entropy Estimation Hardware (EEH): Real-time monitoring of how "certain" the model is about its prediction.
  7. Variable Precision Rollout Units (VPRU): Dynamically switching between FP16, INT8, and INT4 math based on the EEH's confidence.
  8. Latent State Scratchpad (LSS): A copy-on-write buffer to handle branching trajectories efficiently.
Fig. 4. WMPA block diagram showing the NMCU, EEH, VPRU, and LSS components and the data flow during a rollout step (1.70 W denotes the 40×-reduced package power target, corresponding to 0.154 W per 1 mm2 tile under the hotspot scaling of Section IV-D).

Datasets

The paper does not use a traditional dataset for training. Instead, it evaluates a DreamerV3-style RSSM architecture. The evaluation relies on an analytic "stress test" that emulates entropy collapse—the process where a model becomes more confident in its predictions as it simulates further into the future.

Key Insights and Ideas

  • The Sequential Trap: The core reason GPUs struggle is that rollouts are sequential. As shown in the roofline model, every single operation in a world model rollout is memory-bandwidth bound. Adding more TFLOPS doesn't help if the data can't get to the cores fast enough.
  • The Energy Abyss: The gap between a GPU's energy consumption and the theoretical CMOS switching floor is roughly eleven orders of magnitude ($5.9 \times 10^{10}$ at a horizon of 20 steps).
  • Entropy as a Control Signal: A brilliant "aha moment" in the paper is using predictive entropy to scale hardware precision. If a robot is highly confident about the next state (low entropy), the hardware can drop to 4-bit precision (INT4) to save massive amounts of energy without sacrificing much accuracy.
  • Thermal Feasibility: Inefficiency isn't just a battery problem; it's a thermal one. Sustained planning on a GPU-class tile drives temperatures to 556 K ($283^\circ$C), which would cause immediate hardware failure.
Fig. 1. Roofline projection of the rollout operations on three GPU generations (FP16 Tensor Core path). Ridge points are 203.5 (T4), 153.0 (A100), and 295.2 FLOPs/byte (H100), all for dense FP16. All operations (0.38 to 15.55 FLOPs/byte) lie in the memory-bound region R1 on every GPU.

Key Results

  • Memory Bottleneck: Arithmetic intensity for rollouts ranges from 0.38 to 15.55 FLOPs/byte, far below the "ridge point" of modern GPUs (e.g., 153 FLOPs/byte for an A100).
  • Energy Gap: Measured GPU energy per planning call is $\sim 0.38$ Joules, while the CMOS floor is $\sim 6.55 \times 10^{-12}$ Joules.
  • Thermal Relief: The WMPA design target of a 40$\times$ power reduction (from 68W to 1.7W for the package) keeps the silicon tile at a safe 306.52 K ($33^\circ$C), compared to the unsustainable 556 K of the baseline.
  • Precision Scaling: In simulations, the system was able to run 60% of its steps at reduced precision (INT8/INT4) once the model's confidence crossed a 90% threshold.
Measured GPU energy vs. the 12nm CMOS dynamic floor, highlighting the massive architectural gap.

Limitations and Future Work

The authors acknowledge several key limitations:

  • Synthetic Proxy: The precision-switching schedule is based on a synthetic entropy-collapse proxy, not a trained agent in a real-world environment.
  • Conceptual Design: The WMPA is currently a conceptual co-design with "design target" numbers. It has not yet been synthesized or fabricated.
  • Accuracy Trade-offs: While the paper argues that low-entropy states are robust to quantization, the actual impact of INT4/INT8 precision on a robot's task success rate remains to be validated with a fully trained agent.
  • Thermal Modeling: The thermal model assumes an idealized heat sink; real-world robot chassis may offer less favorable cooling conditions.

Summary updated

Abstract

Embedded AI is moving from perception to prediction. Robots now use world models$\unicode{x2014}$learned simulators that predict the outcome of candidate actions in a compressed latent space before any is executed. Every predicted step must be computed on board within a tight power and thermal budget, yet the energy these steps fundamentally require, and how far real hardware sits from it, have not been characterized. We derive lower bounds on the arithmetic operations and the CMOS dynamic energy of a latent state transition from information theory and Boolean circuit complexity. Profiling a DreamerV3-style Recurrent State Space Model (RSSM) shows that every rollout operation is memory-bandwidth bound and that a GPU consumes at least $5.9\times10^{10}$ times the CMOS energy floor. Transient 3D thermal simulations show that this inefficiency is also a thermal one, since sustained back-to-back planning heats a millimeter-scale silicon tile to 556 K even behind an ideal copper heat spreader. Guided by this chain from bound to bottleneck, we propose the World Model Planning Accelerator (WMPA), a chip architecture for embedded world model planning that combines near-memory computation, real-time entropy estimation, variable-precision rollout units, and copy-on-write latent scratchpads. With a design target of 40x lower power, the same tile stays near ambient at 306 K in simulation, pointing toward practical planning on thermally constrained robots.
BibTeX
@misc{ramkumar2026world,
  author = {Prerana Ramkumar and Suhas Suresh Bharadwaj and Fazal Hameed},
  title = {{The World Model Planning Accelerator (WMPA): Hardware-Algorithm Co-Design for Embedded AI in Robotics}},
  year = {2026},
  eprint = {2611.10316},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2611.10316},
}
Figure