Runway Praxis-1
Runway's open-weight world action model that predicts video and robot actions
License
Apache 2.0
Code: Apache-2.0, read from the LICENSE file of runwayml/praxis-1-oss. Weights: Apache-2.0 on all eight model cards in Runway's collection (base, DROID, YAM, the two NVFP4 versions and the three LeRobot versions), none of them gated; Runway's announcement says commercial use is included. Evaluation sets: Apache-2.0 on the praxis-1-eval dataset card. Frozen dependencies: the Wan2.2 VAE and the Qwen3.5-2B text encoder are not in Runway's repositories; both are Apache-2.0 on their own Hugging Face cards. Simulation assets: downloaded at first run from MuJoCo Menagerie under their own licences: the Franka arm Apache-2.0, the Robotiq 2F-85 gripper BSD-2-Clause and the YAM arm MIT. Checked 2026-11-12 against the LICENSE file and the Hugging Face cards.
Overview
Runway Praxis-1 is an open-weight world action model for robot arms from Runway, the AI video company, released to everyone on 11 November 2026 under Apache-2.0. It is built on Runway's own video foundation model: on every call it predicts the next 1.6 seconds of camera video and, together with it, the robot actions that produce that video. The model has 27.2B parameters in total, a mixture-of-experts video backbone of which about 2.8B are active per token plus a small action expert. Three checkpoints are open: a base model to fine-tune for a new robot, a single-arm policy for the Franka arm of the DROID setup and a two-arm policy for the YAM arms, with NVFP4 versions of the two policies for newer NVIDIA GPUs. Runway publishes the inference, serving, simulation and fine-tuning code, including LoRA, and the model also runs as a LeRobot policy and has a NeMo Automodel fine-tuning recipe.
Runway announced Praxis-1 in September 2026 and released it on 11 November 2026, with code on GitHub, weights in a Hugging Face collection and a technical report on its research site.
Praxis-1 is what Runway calls a world action model: a video world model that also outputs robot actions. On each call it reads the task as text, the latest frames of the robot's cameras and the arm's pose. A video backbone predicts the next chunk of video, and a small action expert reads the backbone's internal features to work out the motion that produces it. Each call returns 24 action rows at 15 Hz, 1.6 seconds of motion, together with the predicted video; the robot executes the chunk and calls again.
The backbone is a diffusion transformer with 26.9B parameters, of which about 2.8B are active per token because most layers are mixture-of-experts. The action expert adds about 0.3B. Images pass through the frozen Wan2.2 VAE and instructions through the frozen Qwen3.5-2B text encoder, both downloaded separately.
Runway trained it in four stages: its general video model first, then embodied video (58% egocentric human video, 20% general video, 18% real-robot video and a little gameplay), then video and actions together, and finally one robot at a time.
The open checkpoints are:
- praxis-1-base, the mid-trained model without robot-specific action heads, the starting point for a new robot. - praxis-1-droid, a single-arm policy for the Franka arm with an exterior and a wrist camera, fine-tuned on about 277 hours of DROID data. - praxis-1-yam, a two-arm policy for YAM arms with a top camera and two wrist cameras. - praxis-1-droid-nvfp4 and praxis-1-yam-nvfp4, the two policies after quantization-aware training for NVFP4 4-bit experts.
Each checkpoint is 54.4 GB in bfloat16 and runs on one 80 GB GPU such as an H100, where a call takes about 0.55 to 0.6 seconds. With NVFP4 the policy shrinks to 17.5 GB on Blackwell GPUs, RTX 5090-class cards and Jetson Thor; NVFP4 is not available on H100.
The repository has a policy server, a MuJoCo simulation of the DROID and YAM setups with evaluation suites, and two fine-tuning recipes: a full fine-tune of the base for a new robot on one node of 8 GPUs, and LoRA on praxis-1-droid for a new task on one 80 GB GPU. LeRobot added Praxis-1 as the praxis policy on 11 November 2026 (LeRobot guide), with all three checkpoints converted to its format, and NVIDIA's NeMo Automodel has a fine-tuning recipe with a LIBERO tutorial.
Runway reports 46.2% success on NVIDIA's RoboLab-120 leaderboard for the DROID policy, the top world action model there at publication. Fine-tuned on Google's RT-1 robot, which was not in its training data, it reached 80.0% on SimplerEnv against 52.4% for the original RT-1 policy. Runway also shows it fine-tuned on community SO-101 data; that checkpoint is not released yet.
Why it matters
Most open robot policies, such as VLA models, learn to act from robot demonstrations, which are scarce and expensive to record. Praxis-1 starts from a video model trained mostly on everyday and egocentric video, and Runway's results suggest that this head start carries over to robots it has never seen, such as Google's RT-1 robot. Like NVIDIA's Cosmos Policy, built on Cosmos Predict 2.5, it is an open world model that acts as a robot policy, and its weights are under Apache-2.0 with commercial use allowed. For a reader with a Franka DROID setup, a pair of YAM arms or LeRobot data it is usable on day one: download a checkpoint, run it in simulation and, on the DROID setup, adapt it to a new task with LoRA on one GPU.
Problem it solves
Training a robot policy that generalises takes large amounts of robot demonstration data, and collecting it by teleoperation is slow and costly. Praxis-1 moves most of the learning to video: a model pretrained on general and egocentric video already knows how objects and hands move, so a robot needs only light fine-tuning on its own data. Runway releases the weights, the code to run them on real robots or in simulation and the recipes to adapt them to a new arm, camera setup or task.
Key takeaways
- A 27.2B-parameter world action model that predicts video and robot actions together
- Built on Runway's video foundation model and trained mostly on human and general video
- Open checkpoints: base, single-arm DROID Franka, two-arm YAM and NVFP4 versions
- Runs on one 80 GB GPU; NVFP4 brings the policy to 17.5 GB for Blackwell and Jetson Thor
- Fine-tuning recipes in the native code, LeRobot and NeMo Automodel, including LoRA on one GPU
- Code and weights under Apache-2.0, commercial use included
Who it is for
- Robot learning researchers comparing world action models and VLA policies
- Teams with a Franka DROID setup or bimanual YAM arms who want a ready policy
- Developers adapting a large pretrained policy to their own arm with LoRA or full fine-tuning
- LeRobot and NeMo users who want a world action model inside the tools they already use
Limitations
- Needs one GPU with 80 GB of memory for the bfloat16 checkpoints; the native full fine-tune of the base uses 8 GPUs with 80 GB, and LeRobot asks for at least 4
- NVFP4 changes the actions: Runway measured similar success on RoboLab-120 but lower success for an earlier checkpoint on its hard simulation suite, and it has not yet run in closed loop on RTX 5090-class GPUs
- The base checkpoint has no action heads and does not run on a robot until it is fine-tuned
- Runway names its own failure cases: reaching for a look-alike object, vague instructions and long tasks given in a single prompt
- The sampling settings were tuned for the DROID Franka; other robots need their own
- All benchmark and real-robot results are Runway's own measurements, published on the day of release
- The LeRobot integration is new: it was added on 11 November 2026, after the LeRobot 0.7.0 release
- The Wan2.2 VAE and the Qwen3.5-2B text encoder are separate downloads under their own Apache-2.0 licences