By Sarah Xiao 
On 21 October a UC Berkeley team released SuperMimic, a method for training humanoid whole-body controllers that was accepted as an Oral at CoRL 2026. The claim at the centre of the paper is a cost comparison, not a capability demo: on a library of 129,514 reference motions, one GPU for three hours beats the previous best method, SONIC, which needed 128 GPUs for seven days.
Put in the unit that actually bills: roughly 21,000 GPU-hours down to three. Zero-failure training takes longer — two GPUs for 9.8 hours, about 20 GPU-hours — which is still three orders of magnitude below the baseline.
The interesting part is not the arithmetic. It is the mechanism the team used to get there, and the specific things that mechanism still cannot do.
The number, and what it is measured against
The Berkeley result rests on one observation about the training loop. Every reference motion is different, but all of them are executed by the same body. Conventional reinforcement learning re-learns that body’s physics for each task, because each task samples its own noisy simulator trajectories to estimate what an action will do next. A hip that behaves like a hip in a dance clip behaves like a hip in a backflip clip. The baseline spends compute rediscovering that.
SuperMimic learns the body once.
The paper’s comparison table, reduced to what is publicly stated:
| Setup | Hardware | Wall clock | GPU-hours | Failed clips |
|---|---|---|---|---|
| SuperMimic, minimum viable | 1 GPU | 3 h | 3 | 25 of 129,514 |
| SuperMimic, zero failures | 2 GPUs | 9.8 h | ~20 | 0 |
| SONIC (previous best) | 128 GPUs | ~168 h | ~21,000 | not reported |
Cross-hardware comparisons invite scepticism, so the team also ran a controlled test with observation space, reward, termination conditions, randomisation and policy network size held fixed, on 40 clips totalling about 2.45 hours of motion. SuperMimic reached an evaluation return of 0.82 in about 1.2 hours on a single H100. In-simulator PPO had not reached that level after an 18-hour budget on one, four or eight GPUs, finishing at roughly 0.60, 0.70 and 0.72.
That is a cleaner result than the headline, because it isolates the method from the cluster.
What the controller actually is
The policy is small and conventional in shape. The reference motion enters as the next ten frames, is compressed into a 32-dimensional motion latent, and is combined with ten frames of proprioception — joint positions, joint velocities, IMU data, previous action. A shared decoder turns that into 29 joint targets, issued at 50 Hz.
The latent space is deliberately shared with a second entry point: forward, lateral and yaw velocity commands plus observation history, encoded by a velocity encoder the team trained with RL. Both entry points can drive the same decoder, which separates “what to do” from “how this body does it”. It is the architectural bet that a skill learned from motion capture can be re-addressed by a velocity command later.
The policy output is not a torque. It is a joint position reference, assembled from the network output, an action scale and a nominal joint pose, which the low-level controller then tracks. This is the same division of labour most production humanoids already use, and it is why the controller never has to solve contact equations at inference time.
One world model for every motion
The core object is a differentiable world model fitted to state transitions recorded by a standard rigid-body simulator. It predicts, from a state and an action, what the body does next. It is updated every training iteration, but frozen inside any single policy optimisation, so the policy always faces a stable prediction target.
Three details make it work rather than merely exist.
It is trained on multi-step agreement, not one-step accuracy. The model rolls out eight steps from a recorded state along recorded actions and is checked against the simulator at each step. Four error classes are matched: state, reward, noise-free observation, and termination label. Each maps to a concrete failure — the body predicted in the wrong place, an action scored too generously, implausible proprioception fed back to the policy, and a model that cannot tell when the motion has already failed.
It receives privileged parameters. Friction, joint calibration offsets and torso centre of mass are fed in during training, so the network learns clean dynamics instead of averaging over unknown noise sources. At deployment the policy uses only noisy proprioception and the target; none of those parameters are required.
It is differentiable. That is the whole point. Change a joint command and the model returns not just the predicted state but the derivative — which direction to move the action for a higher return. Errors are backpropagated along the imagined trajectory to earlier actions and policy parameters, which is BPTT over the model rather than over the simulator. Because the gradients come from a learned network, the method stays compatible with simulators that use non-smooth contact or are not differentiable at all.
The default rollout is 32 control steps, which at 50 Hz is 0.64 seconds. Anything beyond that window is handled by a learned value network: the objective sums discounted rewards inside the short trajectory and adds a critic estimate of value at the end of it. The critic also weights the contribution of failed trajectories using the model’s predicted survival probability, which is what keeps the policy from stumbling into states that merely look survivable for two thirds of a second.
Where the savings come from
Two separate effects, and the paper is careful to separate them.
The first is cheaper practice. The neural world model generates trajectories at more than ten times the throughput of MuJoCo Warp in the parallel batch range that matters. A simulator integrates rigid-body and contact physics every step; the trained network approximates the same transition with one forward pass.
The second is fewer practice steps. Holding the world model fixed, the team compared analytic-gradient updates against continuing to use PPO inside that same model. The analytic route reached PPO-WM’s best return using about one sixty-fourth of the imagination steps. So the gain is not only a faster stand-in for the simulator — the policy extracts more from each imagined consequence.
The scaling evidence is the part worth watching. As the training set grows from 1 hour of motion to 7, 40 and about 264 hours, the eight-step prediction error stays inside a narrow band of roughly 0.007 to 0.011, and the GPU-hours needed to reach a target return grow slowly. Motion variety went up more than two hundredfold; the compute needed to model one body did not follow.
That is a statement about the body being shared, and it is the reason the result is interesting beyond this paper. It is also four data points, not a law. New terrain, objects and contact modes change the problem the shared model has to solve, and the paper says so.
What it does not solve
It is state-based. The controller tracks motion from proprioception and a reference target. Vision, terrain, and manipulation are out of scope, and the authors’ own suggested next step is extending the approach to perception-conditioned whole-body control and walking.
Contact-rich interaction is untested. Whether a shared dynamics model survives object contact — where the “body” is now body plus object — is an open question, and one that researchers raised publicly within days of release.
Success is being measured as not falling. A critic of the work made the point that survival is a weak proxy: a policy that stays upright by abandoning the reference motion would score well on it, while a slightly less agile policy that recovers the motion in global coordinates would not. The paper’s own perturbation tests address part of this — with the critic, recovery from 0.5 to 4 m/s root velocity disturbances takes about 0.5 to 2.4 seconds, and without it the robot stumbles and falls at the higher end — but the metric question is legitimate.
Gradient quality is bounded by model coverage. The derivative is a learned stand-in for physics. Where the model has seen little data, the gradient is an extrapolation, and the paper’s 0.64-second imagination window means long-horizon credit still depends on the value function being right.
Real-robot data is not in the loop yet. Fine-tuning on hardware data is the obvious next experiment, and the team has said future work will fold real robot data and online system identification into model learning.
Reproduction is already happening
Within days, a doctoral researcher at ETH Zurich’s AI Center published a reproduction that reached similar results on a single RTX PRO 6000 in about 1.5 GPU-hours, describing the learned model as effectively a faster, differentiable Isaac Sim.
The lineage matters for judging how sudden this is. The same research line produced SuperTrack at SIGGRAPH Asia 2021, then SuperDyno in 2025, then SuperMimic. Five years from simulation to hardware, with the same idea — replace the simulator with a learned model, train the tracking policy by backpropagation — refined at each step.
One downstream result is worth quoting because it is measurable and modest: with a velocity-command encoder trained by RL on task reward, 650 of 672 step responses had lower error than the distillation baseline, with a median relative error of 0.16 against 0.49, about 67% better. Skills learned from motion capture can be re-addressed through a new command interface, not only replayed.
What it changes for the hardware side
Whole-body control training has been one of the few parts of the humanoid stack where a well-funded lab had a structural advantage, because the answer to a hard motion was more GPUs. If the result holds at scale, that advantage narrows: iteration speed stops being a function of cluster size, and smaller teams can run more experiments and compare them more systematically.
It does not make the robot cheaper. Training cost was never the dominant line in a humanoid bill of materials; actuators, reducers, sensors, batteries and integration are. What changes is the cost of being wrong — of trying a different reward, a different action space, a different reference library — and that is what determines how fast a control stack improves.
For component suppliers the requirement set does not move. A policy trained in a differentiable model still has to run on hardware with real backlash, real thermal limits and real compliance. Cheaper iteration makes weak hardware more visible, not less: more policies get tested per unit time, and the ones that fail do so on the robot.
The short version
SuperMimic’s contribution is organisational rather than architectural. The policy network is ordinary; the components — motion latent, velocity encoder, critic, world model — all existed. What the team did was insist that the body’s dynamics be learned once, shared across 129,514 motions, and made differentiable so policy gradients could be computed through it instead of through a simulator.
Three GPU-hours against twenty-one thousand is the kind of ratio that changes what a research group attempts. The caveats are equally clear: no perception, no objects, a 0.64-second imagination window, and a success metric that measures survival rather than fidelity.
The next twelve months will decide whether this is a training trick that scales, or the point where humanoid whole-body control stopped being a compute problem.