One H100 for Three Hours Beat 128 of Them for Seven Days. The Benchmark Says Why

The pitch on the SuperMimic project page is a single comparison. One H100, three hours, against one hundred and twenty eight L40s running for a week. The Berkeley and Hybrid Robotics team put the two numbers next to each other because they are hard to argue with, and because almost nobody reading a humanoid robotics paper expects to see them.
The paper is CoRL 2026. The repo is Apache 2.0. The claim is that a single learned world model can replace the usual arrangement, where you spawn thousands of environment copies in a physics simulator and grind model-free PPO until the reward curve stops moving.
What actually changed
Standard practice for training a humanoid to imitate motion looks like this. You take a motion capture clip, you put the robot in a rigid-body simulator, you reward the policy for matching joint angles frame by frame, and you run PPO across as many parallel environments as your cluster will hold. The gradient never comes from the simulator directly. It comes from thousands of noisy rollouts inside it.
SuperMimic keeps the simulator, but only as a data source. MuJoCo Warp still produces the transitions. Those transitions go into a replay buffer. Then a world model is fitted to that buffer, and the policy is updated by backpropagating through the model rather than through the simulator.
The loop has four steps, repeated:
1. Collect transitions from MuJoCo Warp. 2. Fit the world model on all the motion data. It is not frozen across iterations. 3. Imagine short rollouts inside the world model, 32 steps at a time. 4. Backpropagate through those imagined steps to update the policy.
Two details make this work. The world model is held fixed inside each policy update, so the gradient is well defined even though the model itself keeps changing between updates. And a critic handles anything beyond the 32 step horizon. The project page is blunt about what happens without one: at 16 steps or fewer with no critic, training fails.
Because gradients go through the learned model and never through MuJoCo Warp, you do not need a differentiable simulator. That matters more than it sounds. Differentiable contact is a research problem. A learned approximation of contact is a training problem, and a much cheaper one.
The number that is more interesting than the compute ratio
The team evaluated against 129,514 motions filtered from the public BONES-SEED subset, which comes to 264.56 hours of motion. Each clip plays once from its first frame, foot friction 1.0, no domain randomisation, deterministic physics. A motion counts as a failure if the rollout trips the training termination condition.
Against SONIC's published checkpoint, the counts are:
| Motion group | SONIC | SuperMimic, 1 GPU for 3h | SuperMimic, 2 GPUs for 9.8h | | --- | --- | --- | --- | | Side rolls (22) | all 22 | 2 | 0 | | Flips, 360/180/90 (44) | all 44 | 1 | 0 | | Cross steps (10) | 9 | 0 | 0 | | Lying, resting, getting up (99) | 28 | 8 | 0 | | Standing long jumps (24) | 15 | 0 | 0 | | Dance (8) | all 8 | 0 | 0 | | Everything else (129,307) | 53 | 14 | 0 | | Total (129,514) | 179 | 25 | 0 |
SONIC misses every side roll, every flip and every dance in the set. SuperMimic, after three hours on one GPU, misses 25 motions out of 129,514. After 9.8 hours on two GPUs it misses none.
Normalised return tells the same story with less resolution. SONIC's released checkpoint sits at 0.90. SuperMimic passes it inside the three hour budget.
Why the model is small enough to be useful
Three measurements on the project page explain the gap better than the marketing comparison does.
The first is prediction error. Across datasets from 1 hour to 264 hours, the world model's prediction error stays between 0.007 and 0.011. It barely moves as the data grows. That flatness is the whole argument: one learned model can absorb an entire motion library without falling apart, which is what makes amortising the cost possible in the first place.
The second is throughput. At realistic batch sizes on an H100, imagining inside the world model runs more than ten times faster than stepping MuJoCo Warp.
The third is step count. To reach the best reward that PPO-inside-a-world-model achieves, first-order gradients need roughly 64 times fewer imagined steps. Cheaper per step, and fewer steps.
Put together, the loop stops being a rounding error against simulator time. It becomes the cheap part.
Where the comparison is soft
The team is more careful about this than most. They note that H100 fp32 peak is about 0.74 times an L40's, while tensor core peak is 5.5 times higher, and that peak utilisation for either run is unknown. They also note they used 2.3 times less data, 264.56 hours against SONIC's 611. Neither factor explains a thousand-fold gap in GPU-hours, which is the point they want to land. It is a fair argument, and it is still an argument rather than a controlled experiment.
The sharper caveat is in the benchmark design, and they state it outright. Every motion in the evaluation set is a training motion for both systems. The failure count measures coverage, not generalisation. A policy that has seen a backflip during training and can reproduce it is not the same as a policy that can handle a backflip it has never seen.
There is no limitations section on the page. The constraints you can extract are the ones above: dependence on MuJoCo Warp for data, a 32 step imagination horizon that needs a critic to be useful, non-zero world model error, and a data ceiling at the public subset.
Running it
The repository is thin by design. Two repos cloned as siblings, one training script, two task IDs.
curl -LsSf https://astral.sh/uv/install.sh | sh
mkdir supermimic_ws && cd supermimic_ws
git clone git@github.com:HybridRobotics/supermimic.git
git clone git@github.com:HybridRobotics/mjlab_research.git
cd supermimic
Then pick a representation. SuperMimic-GenCoord-G1 uses generalised coordinates, SuperMimic-MaxCoord-G1 uses maximal coordinates. Both target the Unitree G1.
CUDA_VISIBLE_DEVICES=0 uv run src/supermimic/scripts/train.py \
SuperMimic-GenCoord-G1 --runner.run_name first-run
Playback takes the Weights and Biases run path:
uv run src/supermimic/scripts/play.py \
SuperMimic-GenCoord-G1 --wandb-path <RUN_PATH>
The policy transfers to a real G1 zero-shot, with no per-motion tuning. That is the part I would want to see video of before believing, and it is also the part the weights make checkable.
What the result actually moves
For a while the story in humanoid control was that compute was the moat. SONIC's budget, roughly 21,000 GPU-hours, is not something a university lab assembles on a whim. If three H100 hours gets you past a released checkpoint, the moat moves to data and to evaluation design. The team's own numbers point that way: their world model gets better slowly as data grows, which means the next bottleneck is a better motion library, not a bigger cluster.
It also sharpens the question. A method that trains inside its own approximation of physics is only as good as that approximation, and 0.007 error on the motions you trained on says nothing about the motion you did not. Coverage at 129,514 clips is an impressive number. Generalisation is still unmeasured, by the authors' own account.
The repo is the right response to that. Apache 2.0, two commands, and a benchmark you can rerun on hardware you own.
Related articles
Six Amateurs, 1,113 Episodes, a Thousand Yuan of Compute an Episode: How an AI Drama Got Hand-Built
The first ten seasons of Armed Into Song run to roughly a thousand episodes and have passed ten billion cumulative views, with six core creators and not one of them film-school trained. Compute runs 1,000–2,000 yuan an episode; a normal shot takes three rolls, a battle twenty-plus, and anything that looks flat is graded a sixty and thrown out.
One server, one AI streamer: inside the code that runs a nightly livestream
open-yoki is the production code behind an AI host who streams nightly on Binance Square, with the persona, voice and money features stripped out. Headless Chrome draws the frame, ffmpeg pushes RTMP, a folder of Markdown decides what she feels and what she posts.
Pinky lets an agent drive your phone, and holds the Send button until you click Allow
Pinky connects any MCP agent to a real iPhone or Android phone and enforces approval in its own gateway rather than in a prompt. Banking apps are invisible, password fields are off limits, and on Android 13 the agent gets a hidden second screen.
ByteDance's SeedRealtime takes two frames a second and decides when to speak
Doubao-Seed-Realtime-1.0 folds camera frames, screen frames and speech into one full-duplex session, at no more than two frames per second. The interesting decisions are the frame rate, the proactive speaking, and the audit reply that ships switched on.