Runway Praxis-1: Open Robot Model Hits 46.2% on RoboLab-120
Runway released Praxis-1, a 27B video-action model for robot arms, with Apache 2.0 code and weights. It reports 46.2% on RoboLab-120.
Runway released Praxis-1, a 27B video-action model for robot arms, with Apache 2.0 code and weights. It reports 46.2% on RoboLab-120.
Introduction
On November 11, 2026, Runway made Praxis-1 available to everyone, publishing the weights and inference and fine-tuning code under the Apache 2.0 license. Runway describes the model as a world action model, meaning a video model that predicts how a scene will change and, in the same pass, the robot motion that produces that change. Runway says it introduced Praxis-1 in September to launch partners Noble Machines, Standard Bots and Ultra, who ran it on a legged humanoid, a six-axis industrial arm and a dual-arm warehouse robot. The November release opens it to any robotics developer or researcher. Most of the results below are Runway's own measurements.
Feature Overview
Architecture. According to Runway's technical report, the backbone is a 26.9B-parameter mixture-of-experts diffusion transformer, with about 2.8B parameters active per token. Each expert layer has one shared expert and 128 routed experts, and each token uses eight of the routed ones. It works in the latent space of a frozen Wan2.2 VAE and reads instructions through a frozen Qwen3.5-2B text encoder. A separate dense action expert of about 314M parameters reads the video model's internal state and outputs the motion, so the full model is 27.2B parameters.
Chunked control. On each call the model takes an instruction, the latest camera frames and the robot's current pose. It returns a predicted chunk of future video plus 1.6 seconds of actions, which is 24 action rows at 15 Hz. The robot executes the chunk, sends back what its cameras saw, and calls again. On one H100 a default call takes roughly 0.55 to 0.6 seconds round trip. An opt-in real-time chunking mode with streaming optimization brought median server time per call down to 128 ms on the bimanual setup and 124 ms on the single-arm setup.
Training in four stages. Runway says the backbone starts from its general video foundation model, switches to chunk-causal attention on embodied video such as egocentric human footage, then gains the action expert during joint video and action training, and finally gets fine-tuned per robot. For the single-arm checkpoint Runway used about 277 hours of successful DROID episodes on 128 H100s. The bimanual YAM fine-tunes used roughly 1,400 to 2,600 hours of recordings.
Adapting to new robots. Runway reports that a single checkpoint adapted to several embodiments with light fine-tuning, and that LoRA fine-tuning is supported on one 80 GB GPU. Fine-tuned on Google's RT-1 robot, which Runway says never appeared in its training data, Praxis-1 reached 80.0% on SimplerEnv's visual-matching grid of 864 simulated episodes, against 52.4% for the original RT-1 policy. That fine-tune used about 95 hours of head-camera data from the full RT-1 training split.
Benchmark Results
The headline number is NVIDIA's RoboLab-120, a simulation benchmark of 120 tabletop tasks. Under the official protocol of 10 trials per task, Runway reports 555 of 1,200 episodes solved.
| Model | RoboLab-120 success |
|---|---|
| Praxis-1 | 46.2% |
| FLUX 3 Action | 42.9% |
| Cosmos3 Nano | 36.8% |
| π0.5 | 28.0% |
Runway says this is the highest score among world action models and open-source robot foundation models on the leaderboard, and ahead of every open-weight vision-language-action model listed, including π0.5 and GR00T N1.6. The same report is explicit that four entries score higher overall. Two are agents that drive a frontier model directly (AMP1 at 86.0% and SenseNova-RoboRSI at 57.1%), and two are closed models (Lakeside at 51.0% and BiMind v0.5 at 49.2%). The Decoder's coverage likewise notes that Runway ran the tests itself and that the results have not been independently verified.
On a real Franka FR3 station operated by Positronic, Runway ran Praxis-1 and FLUX 3 Action on the ten single-item tasks that FLUX 3 Action had published, with 10 episodes per task. Praxis-1 succeeded in 88 of 100 episodes and FLUX 3 Action in 80. In a separate comparison on a bimanual station across three tasks, Runway reports that GPT-6 Astra took 15.6 times longer and cost 51 times more per completed task than Praxis-1, with the Praxis-1 cost based on one H100 at $3.95 per hour.
Usability Analysis
The code lives at github.com/runwayml/praxis-1-oss under Apache 2.0. The weights are in a Hugging Face collection that includes base, DROID, bimanual YAM and SO-101 checkpoints, NVFP4 variants and LeRobot-format copies. The model cards list Apache 2.0 but say the frozen Wan2.2 VAE and Qwen3.5-2B text encoder are distributed separately under their own licenses. The repositories are gated, so a Hugging Face login and acceptance of the access conditions are required before downloading.
Hardware is the practical hurdle. The README's quick start calls for Python 3.12, a CUDA GPU with at least 80 GB of memory and the CUDA 13.0 driver, and the bf16 weights are 54.4 GB. Runway's launch post says the model runs on NVIDIA hardware from H100 and B200 to RTX 5090, RTX PRO 6000 and Jetson Thor. The 4-bit NVFP4 route shrinks the policy to 17.5 GB, and the README estimates that a 32 GB RTX 5090 should fit but says peak memory has not been measured yet. It also says NVFP4 has not been run in closed loop on that GPU class. In Runway's tests, an NVFP4 quantization-aware fine-tune scored 279 of 600 on RoboLab-120 against 287 of 600 for bf16. The README separately reports 138 of 352 versus 188 of 352 for an earlier checkpoint on a harder simulation suite, and recommends measuring your own checkpoint before deploying.
Pros and Cons
Pros: open Apache 2.0 code and checkpoints that allow commercial use, a documented path from LoRA to full fine-tuning, and published failure analysis. Runway's own tests show about 0.55 to 0.6 seconds per 1.6-second chunk on one H100.
Cons: the standard path needs an 80 GB GPU, the benchmark results are self-reported and four leaderboard entries score higher overall, and downloads are gated. Runway also lists failure modes. The most common real-robot error is reaching for a look-alike object, vague instructions are harder than ones naming a color or size, and chaining several steps from a single prompt remains hard.
Outlook
Runway says it will keep investing in world action model research, with a focus on long-term reasoning, agentic planning and self-improvement loops. Its report points at two concrete directions. One is pairing a planning model that breaks a task into steps with a fast policy like Praxis-1 that executes each step. The other is using the model's predicted future to judge whether an action will succeed. In an early experiment on an earlier, unreleased version, Runway trained a small head to estimate success from the predicted future, and notes it does not yet read the instruction. Runway also reports that most remaining error comes from which future the video model imagines rather than from the action expert.
Conclusion
Praxis-1 is a large, openly licensed robot policy with detailed documentation: architecture, training recipe, latency, quantization trade-offs and failure modes are all spelled out. The benchmark claims are scoped to specific categories and come from Runway, so treat them as a starting point for your own evaluation. It suits robotics labs and companies with an 80 GB GPU and a DROID-style or bimanual rig, and researchers studying video-pretrained control. Hobbyists on smaller GPUs should wait for measured memory figures.
Editor's Verdict
Runway Praxis-1: Open Robot Model Hits 46.2% on RoboLab-120 earns a solid recommendation within the open source space.
The strongest case for paying attention: open Apache 2.0 code and checkpoints that Runway says cover commercial use, with LoRA and full fine-tuning support. That alone raises the bar for what readers should expect in this space. Reinforcing that is detailed public documentation of architecture, training stages, latency, quantization trade-offs and failure modes — practical value rather than just headline appeal. The broader signal worth registering is straightforward: reading the leaderboard carefully matters here, because Runway's top ranking applies to world action models and open robot foundation models while four entries score higher overall. On the other side of the ledger, one constraint is real rather than a marketing footnote: heavy hardware floor, since the standard path needs one 80 GB GPU and the smaller-GPU route has no measured peak memory yet. It should factor into any serious decision. Layered on top of that, benchmark results are self-reported by Runway and four RoboLab-120 entries score higher overall — which narrows the set of teams for whom this is an obvious yes.
For robotics labs and companies with an 80 GB GPU and a DROID-style or bimanual rig, and researchers studying video-pretrained control, this is a serious evaluation candidate, not just a curiosity to bookmark. Teams on smaller GPUs should wait for measured memory figures.
Pros
- Open Apache 2.0 code and checkpoints that Runway says cover commercial use, with LoRA and full fine-tuning support
- Detailed public documentation of architecture, training stages, latency, quantization trade-offs and failure modes
- About 0.55 to 0.6 seconds per 1.6-second action chunk on one H100, with an opt-in real-time chunking mode that cuts server time to roughly 125 ms
- NVFP4 variants shrink the policy from 54.4 GB to 17.5 GB, widening the range of GPUs it may run on
Cons
- Heavy hardware floor, since the standard path needs one 80 GB GPU and the smaller-GPU route has no measured peak memory yet
- Benchmark results are self-reported by Runway and four RoboLab-120 entries score higher overall
- Hugging Face downloads are gated behind a login and acceptance of access conditions, and the frozen VAE and text encoder carry separate licenses
- Runway lists look-alike objects, vague instructions and long multi-step tasks as known weak spots
References
Comments0
Key Features
1. World action model that predicts future video and robot actions together, built as a 27.2B-parameter mixture-of-experts diffusion transformer with about 2.8B active parameters per token. 2. Chunked control that returns 24 action rows at 15 Hz (1.6 seconds of motion) per call, about 0.55 to 0.6 seconds round trip on one H100. 3. Apache 2.0 code and checkpoints on GitHub and a gated Hugging Face collection, with LoRA and full fine-tuning code and NVFP4 variants. 4. Runway-reported results of 46.2% on RoboLab-120 (555 of 1,200 episodes), 88 of 100 real Franka episodes versus 80 for FLUX 3 Action, and 80.0% on SimplerEnv after RT-1 fine-tuning. 5. Documented limits including look-alike objects, vague instructions and long multi-step tasks, plus an 80 GB GPU requirement for the standard path.
Key Insights
- Reading the leaderboard carefully matters here, because Runway's top ranking applies to world action models and open robot foundation models while four entries score higher overall.
- Runway says web video matches teleoperated robot video as pretraining data for policy performance, which, if it holds up, shifts the bottleneck from robot data collection to how much general video a model can learn from.
- The recipe keeps the video-prediction loss on through every stage, and Runway's analysis says most remaining action error comes from which future the video model imagines, not from the action expert.
- Speed is part of the pitch, since Runway reports a 15.6x time gap and 51x cost gap against GPT-6 Astra on three bimanual tasks, though that comparison is Runway's own and covers only three tasks.
- Licensing is nuanced, because the Apache 2.0 grant covers Runway's weights and code while the frozen Wan2.2 VAE and Qwen3.5-2B text encoder are distributed under their own licenses.
- Quantization results are mixed, with NVFP4 close to bf16 on RoboLab-120 (279 versus 287 of 600) but clearly lower on a harder suite for an earlier checkpoint (138 versus 188 of 352).
- The RT-1 result (80.0% versus 52.4%) comes from simulation on a robot absent from pretraining, which tests transfer but is not a real-world deployment number.
- Launch partners ran the model on a legged humanoid, a six-axis industrial arm and a dual-arm warehouse robot before the public release, according to Runway.
Was this review helpful?
Share
Related AI Reviews
Microsoft Mage-VL-Cowork: 4B Computer-Use Model, Apache-2.0
Microsoft's 4B Mage-VL-Cowork joins GUI actions and bash in one policy under Apache-2.0, reporting 66.0% on OSWorld-Verified (50 steps).
NVIDIA Open-Sources Run:ai GPU Orchestration Platform
NVIDIA released the full Run:ai platform as open source under its DSX AI Factory org, with four modules that can be adopted independently.
Nemotron 3 Diarization: NVIDIA's Open 100M Speaker Model
NVIDIA's open-weight 100M-param diarization model tracks up to 8 speakers live or offline, ranking #1 on VoiceArena's initial benchmark at 14.72% DER.
Nvidia PAIR Routes Local AI Across Your Idle Home PCs
Nvidia's free open-source PAIR sends local AI requests to idle home PCs, but it does not pool GPU memory or shard a model across machines.
