Skip to content
Neural Minute

News

Runway opens a 27B robot model that runs on one H100

By Maxime Aulne, Founder and Editor

Runway published Praxis-1 on November 11, 2026, a 27.2B world action model whose Apache 2.0 weights turn video pretraining into robot control on one H100. Three checkpoints ship with code, a policy server and a simulation, and the report measures 4 cents per completed task against $1.87 for a frontier agent.

Runway opens a 27B robot model that runs on one H100 (Runway)
The visual Runway published with this story, read on November 14, 2026.

Runway published Praxis-1 on November 11, 2026, as a technical report with three downloadable checkpoints, and the title claim is narrow enough to check: an open weight world action model that turns video pretraining into robot control. The headline figures are 27.2 billion parameters, one 80 GB GPU and 46.2 percent on NVIDIA’s RoboLab-120. The number worth more sits further down, where Runway measures four cents per completed task against $1.87 for a frontier model on the same arm.

What was actually released

Three checkpoints go to Hugging Face under Apache 2.0: Praxis-1 fine-tuned on DROID, the same model fine-tuned on a bimanual YAM station, and the base mid-trained model. Code, a policy server, a MuJoCo simulation and both full and LoRA fine-tuning code ship with them, so this is a release a team can run rather than a results page with a waitlist.

The top of the Runway research page Praxis-1: From Video Pretraining to Robot Control, with its headline, the November 2026 date and the contents list
The page Runway published, read on November 14, 2026, with the date it carries under the headline.

The backbone began as Runway’s video foundation model: 26.9 billion parameters, 17 of its 20 feed-forward layers built as mixture-of-experts, about 2.8 billion active per token. A separate action expert of 314 million parameters reads the backbone at eight depths and turns the imagined next chunk into motion. Each robot adds only thin input and output projections, so one model drives different bodies. A call returns 1.6 seconds of motion at 15 Hz, in a median 545 ms on one H100.

What the release actually gives you

  • 27.2B parameters, 54.4 GB in bf16, one 80 GB GPU, and 1.6 seconds of motion per call.
  • Apache 2.0 weights for three checkpoints, plus the policy server and the simulation.

What the claim rests on

The number one claim needs its category. On RoboLab-120, NVIDIA’s simulation of 120 tabletop tasks at ten trials each, Praxis-1 fine-tuned on DROID solved 555 of 1,200 episodes, or 46.2 percent, the highest score for a world action model and for an open source robot foundation model. The page then lists what sits above it, a rare thing in a launch report.

Entry on RoboLab-120 Success What the entry is
AMP1 86.0% zero-shot frontier-model agent
SenseNova-RoboRSI 57.1% frontier vision-language model used as the policy
Lakeside 51.0% closed model, trained partly on simulated data
BiMind v0.5 49.2% closed model, fine-tuned on RoboLab data
Praxis-1, DROID fine-tune 46.2% open weights, Apache 2.0
FLUX 3 Action 42.9% world action model

Four entries beat it. The top two are frontier models acting as agents rather than trained policies: AMP1 at 86.0 percent, and SenseNova-RoboRSI at 57.1 percent, which needs about 55 minutes of computation per episode for 8 to 76 seconds of motion. The other two, Lakeside at 51.0 and BiMind v0.5 at 49.2 percent, are closed models trained partly on simulated data. The board ranks accuracy, one axis of three.

On a real robot the gap narrows. On a Franka FR3 station operated by Positronic, over the ten single-item tasks FLUX 3 Action had published, Runway reports 88 successes against 80, in two sessions on November 2. Eight episodes out of a hundred, one rig, one day, no confidence intervals.

What Runway does not publish

No confidence intervals for the 88 against 80, so the gap could shrink on a second rig. No card-level benchmark for the NVFP4 weights, which makes the cheaper-hardware argument arithmetic rather than measurement. And no per-call price for a hosted policy, so a team that will not run its own H100 has nothing to budget.

On RT-1, a robot absent from mid-training, SimplerEnv success rose from 56.3 percent at the earliest checkpoint to 80.0 at the latest, though not at every step, and Runway says the exact relationship needs further study.

We think the most scalable source is general video, the everyday footage people already record.

The training mix backs it: 58 percent egocentric human video, 20 percent general video, 18 percent real-robot video. Teleoperation on the target arm is not what this model was mostly trained on.

On this page

What it changes for teams that buy robot control

The useful part is the comparison Runway ran against itself: same arm, same console, three tasks, a trained policy against GPT-6 Astra, with the cost basis printed, one H100 at $3.95 an hour against an API bill.

Task Praxis-1 GPT-6 Astra Gap
Remove the pen cap 0:15 for $0.08 7:48 for $3.47 31x faster, 43x cheaper
Sponge in the bag 0:22 for $0.03 2:46 for $1.20 7.4x faster, 49x cheaper
Die in the bag 0:11 for $0.01 2:04 for $0.93 11.5x faster, 79x cheaper
All three tasks 0:16 for $0.04 4:13 for $1.87 15.6x faster, 51x cheaper

That table sets a floor a team can hold a vendor to: four cents per completed task, on hardware anyone can rent, with the failures counted. Reaching a working policy has a published cost too: 50,000 steps on 128 H100s for DROID, 30,000 steps over about 28 hours on 32 H100s for RT-1.

The license changes the order of the checks. A buyer can download a checkpoint, fine-tune it on their own parts and measure it before signing anything, the test we ask of a tool before writing a price into a page. We made that argument in October about Mistral’s promise of weights by the end of the month: a workflow on open weights can be tested by the team that pays for it, while the same workflow behind an API can only be rented.

Two details decide whether a small team can join. NVFP4 took the weights from 54.4 GB to 17.5 GB, with 46.5 against 47.8 percent on 600 simulated episodes and 26 of 30 against 28 of 30 on the real station, and Runway says neither difference is significant. The model also fine-tuned on a low-cost SO-101 arm from 3,956 public datasets.

The limits are stated in the same voice: reaching for an object that looks like the target, vague instructions that name no color or size, and multi-step tasks that work only when each step carries its own instruction. Most remaining error comes from the future the model pictures, not from the action expert: given the true future, end-effector error falls from 5.71 cm to 1.14 cm.

The Neural Minute take

Fifty-one times is the number to keep, and not because Runway wins. It is the first time a vendor in this category has published a per-task cost against a frontier agent on the same hardware, with the GPU rate beside it. That gives a buyer a denominator a robot quote never carries.

The second point is what 46.2 percent means. A policy that fails more than half its tabletop episodes is a research result, not an operator. A reader who stops at the number one claim buys the wrong thing: a frontier agent beats every trained policy on accuracy while costing fifty times more per task. The deployment that follows is the one Runway proposes, an agent that plans and a fast policy that executes.

Third, why this matters more than a benchmark. An Apache 2.0 checkpoint is a claim a buyer can test before paying. The two closed entries above Praxis-1 give a buyer nothing to run, and the 86.0 percent agent gives an API bill nobody can forecast from this page. Our pages put a price in only after reading it at the editor with a date beside it.

What we cannot say is what the model costs outside Runway’s rig: one H100 rate, no card-level benchmark, no hosted price. Four cents is a reproducible measurement, not a rate card.

Sources

Newsletter

One email when a review lands.

That is when the promo codes are still fresh, before the prices move.

Nothing else. Unsubscribe in one click.