Runway Praxis-1: Open-Weights Robot Model Guide (Benchmarks, VRAM, Setup, Fine-Tuning)

Runway, the company best known for AI video, has released Praxis-1 with open weights. It is a 27B “world action model” that watches a robot’s cameras, imagines the next 1.6 seconds of video, and outputs the arm movements to make that future happen.

Weights, inference code and fine-tuning code went public on 11 November 2026 under Apache 2.0, commercial use included. Runway says it now tops NVIDIA’s RoboLab-120 leaderboard.

This guide covers what Praxis-1 is, every published number, the exact checkpoints and GPU needs, how to run it in simulation step by step, how to fine-tune it, what it costs hosted, and how it compares with FLUX 3 Action, Cosmos 3 and π0.5.

What Praxis-1 Is (and Why Runway Built a Robot Model)

Most open robot models today are VLAs (vision-language-action models). They bolt an action head onto a model that was trained to describe images in words.

A world action model (WAM) starts from a video model instead. It learns how the physical world moves from huge amounts of video, then learns to predict robot actions alongside that video.

NVIDIA’s developer blog sums up the difference well: a language backbone learns to “describe the world, not predict how it evolves”. A video backbone learns physics, contact and object behaviour as part of pretraining.

That is why Runway is in robotics at all. It already trains large video world models (Solaris and GWM Worlds 2), and Praxis-1 reuses the same pretraining.

Runway’s key research claim is about data. In its tests, pretraining on ordinary web video gave a final placement error of 16.1 cm after fine-tuning, against 16.0 cm for expensive teleoperated robot video. Runway says the gap is not statistically significant.

If that holds up, robot builders can lean on cheap, plentiful video instead of collecting thousands of hours of human-driven robot demos.

From September Preview to Open Weights

Launch partners running it on their own hardware are Noble Machines (a legged humanoid), Standard Bots (the RO1 six-axis industrial arm) and Ultra (a dual-arm warehouse robot). Runway is also a founding member of NVIDIA’s Cosmos Coalition.

Specs, Inputs and Outputs

What you feed it

• Single arm (praxis-1-droid): an exterior camera and a wrist camera. Each view is cropped and resized to 224×416, side by side on a 224×832 canvas.
• Two arms (praxis-1-yam): a top camera plus left and right wrist cameras, three 256×416 tiles. The Praxis server only accepts 16:10 views.
• Arm state: the end-effector position and rotation plus the gripper value (0 = open).
• Instruction: a plain text task, passed to the text encoder unchanged. For YAM, Runway advises caption-style prompts with no closing full stop.

Note: the native repo uses an 8-value pose (x, y, z, qw, qx, qy, qz, grip), while LeRobot uses DROID’s 7-value Euler form (x, y, z, roll, pitch, yaw, gripper). Each converts internally, so match the format of the tool you use.

Benchmarks: Every Number Runway Published

All results below are vendor-reported by Runway, from its announcement, GitHub README and LeRobot docs. No independent lab has published its own Praxis-1 runs yet.

Runway gives the leaderboard data as of November 2026. The 36.8% Cosmos figure matches NVIDIA’s own blog, which reported RoboLab success rising from 28.1% to 36.8% for its omni-initialised DROID policy.

Other published results

Speed (from the README)

• One H100 80 GB, video guidance 4.0 (default): about 701 ms per later call (p50).
• Video guidance 1.0: about 406 ms per call.
• First call: 35.6 s, because kernels compile once.
• Hosted RoboLab runs: clients saw a median of 1.1 to 1.4 s per call over the network.

Since each call returns 1.6 s of motion, a 0.4 to 0.7 s call keeps up with real time on an H100.

Which Checkpoint to Download

You also need two public models: Wan2.2_VAE.pth from Wan-AI/Wan2.2-TI2V-5B and Qwen/Qwen3.5-2B. Budget roughly 62 GB of disk for one checkpoint plus these, and far more if you download all three.

GPU and VRAM Needs

Warning: NVFP4 here is experimental. It refuses to load on H100, B200 and older GPUs, packing the experts takes about 18 minutes on CPU the first time, and the “hard” suite showed a real accuracy drop. Test before you trust it on hardware.

If you are choosing a card for this kind of work, my best workstation GPU for AI guide covers the RTX PRO 6000, and RTX 5090 vs RTX 5080 for AI explains why 32 GB matters. Background on the FP4 format is in NVFP4 vs MXFP4.

How to Run Praxis-1 in Simulation, Step by Step

You do not need a real robot to try it. The repo ships a MuJoCo tabletop sim (praxis-sim) with a Franka arm and Robotiq gripper. You do need Linux, Python 3.12, CUDA 13.0 drivers and an 80 GB GPU (or a 32 GB Blackwell card for NVFP4).

1. Clone the repo and create an environment. git clone https://github.com/runwayml/praxis-1-oss, then cd praxis-1-oss and uv venv --python 3.12 .venv && . .venv/bin/activate.
2. Install PyTorch for CUDA 13. uv pip install torch==2.13.0 torchvision==0.28.0 --index-url https://download.pytorch.org/whl/cu130, then uv pip install packaging ninja wheel.
3. Build causal-conv1d. CAUSAL_CONV1D_FORCE_BUILD=TRUE MAX_JOBS=16 uv pip install --no-build-isolation --no-cache causal-conv1d==1.6.1. There is no wheel for PyTorch 2.13, so this compiles with nvcc (about 1 GB RAM per job).
4. Install Praxis with kernels and sim. uv pip install -e ".[kernels,sim]", then re-pin cuDNN: uv pip install --no-deps nvidia-cudnn-cu13==9.24.0.43.
5. Check the build. python -c "import torch, causal_conv1d_cuda; print('causal-conv1d OK')".
6. Log in to Hugging Face. hf auth login with an account that can read the runwayml repos.
7. Download the frozen parts. hf download Wan-AI/Wan2.2-TI2V-5B Wan2.2_VAE.pth --local-dir weights and hf download Qwen/Qwen3.5-2B --local-dir weights/Qwen3.5-2B.
8. Download a checkpoint and verify it. hf download runwayml/praxis-1-droid --local-dir checkpoints/praxis-1-droid, then inside that folder run sha256sum -c --quiet SHA256SUMS.
9. Run a sim task. CUDA_VISIBLE_DEVICES=0 MUJOCO_GL=egl python scripts/run_sim.py --config configs/sim_droid.yaml --set task.name=block_in_bowl --set task.prompt=null --set viewer.host=0.0.0.0.
10. Watch it. Open port 8000 in a browser to see three episodes live. Videos are saved to outputs/sim_droid.

Available sim tasks are lift_cube, cube_on_plate, block_in_bowl, block_out_of_bowl, move_block, stack_block and press_button. For the two-arm model use scripts/run_sim_yam.py with configs/sim_yam.yaml and the block_tower task.

Tip: without the flash-attn-4 package, set backbone.attention.backend to triton in the checkpoint’s config.json. Outputs differ only in the last bits.

Calling it from Python

from praxis.pipeline import PraxisPipeline

pipe = PraxisPipeline(
    checkpoint="checkpoints/praxis-1-droid",
    vae_weights="weights/Wan2.2_VAE.pth",
    text_encoder="weights/Qwen3.5-2B",
)
session = pipe.session(prompt="Put the red block in the bowl.", seed=0)
result = session.step(observation)  # one call per executed action chunk

To run on recorded episodes instead, create episodes/<name>/ with meta.json, per-camera PNG frames and observed_pose8.npy, point configs/inference_droid.yaml at it and run python scripts/run_inference.py --config configs/inference_droid.yaml.

For a real robot, the repo includes a policy server (configs/serve_droid.yaml) and a latency checker: python -m praxis.serve.latency --url <session URL>.

Using Praxis-1 With LeRobot

Hugging Face’s LeRobot library supports Praxis natively as PraxisPolicy. Install it with pip install -e ".[praxis,dataset]" inside a LeRobot checkout.

• Load: lerobot-eval --policy.path=runwayml/praxis-1-droid-lerobot (there is no short policy type name; use the path).
• Tested stacks: LeRobot 0.7.1 with torch 2.15.0 + CUDA 13.2, or LeRobot 0.6 with torch 2.11.0 + CUDA 12.8.
• Call rate: call select_action at every 15 Hz tick, and call drop_queued_actions when the instruction changes.
• RTX Blackwell (RTX PRO 6000, RTX 5090): use attention_backend="triton"; “auto” picks it for you, “flash” raises an error.
• B300/GB300: needs torch built for CUDA 12.9+; the cu128 build fails with cutlass cannot run, error 7.

Warning: with transformers 5.4.0 to 5.5.4, the Qwen3.5 text encoder can load with random weights. LeRobot detects and fixes this with a warning, so read your logs.

Fine-Tuning and LoRA for Your Own Robot

This is where the Apache 2.0 licence matters. You can adapt the model to a new arm, camera layout or task and ship the result commercially.

• Install: uv pip install -e ".[train]".
• Data: configs read DROID from the Hub (cadene/droid_1.0.1). For your own data or long runs, set --set data.source= to a local LeRobot dataset folder.
• LoRA size (LeRobot, r 16, alpha 32): 5.5M trainable parameters, a 22 MB adapter. Merge it with examples/praxis/merge_praxis_adapter.py.
• Full run (LeRobot recipe): 3.7 s/step on 8x H100, 48.5 GB per rank. One save is about 54 GB of weights plus about 108 GB optimizer state.
• Video quality matters: fine-tuning on the Hub’s 180×320 DROID copy dropped the score from 54 to 50 of 56. Use the raw 1280×720 recordings for faithful results.

NVIDIA’s NeMo Automodel also has a Praxis-1 post-training tutorial if you already use that stack.

Hosted Option: Reactor Pricing

If you do not own an 80 GB GPU, Reactor runs Praxis-1 as a hosted service.

Reactor’s page does not mention a free tier or rate limits. Custom post-training on your data is available through Reactor by contact, and Runway has a separate robotics contact form for deployments.

Praxis-1 vs FLUX 3 Action vs Cosmos 3 vs π0.5

*RoboLab scores as published by Runway (vendor-reported). FLUX 3 Action’s own launch said it was up to 3.95x faster than the previous top open model, so it remains the pick when latency and size beat raw success rate.

• Pick Praxis-1 if you have 80 GB GPUs (or a 5090 and patience for NVFP4) and want the strongest open policy with a clean commercial licence.
• Pick FLUX 3 Action if your compute on the robot is tight.
• Pick Cosmos 3 if you already build on NVIDIA Isaac and Jetson, or need many robot types beyond Franka and YAM.

Limits, Licence and Safety

• Only two rigs out of the box: single-arm DROID and bimanual YAM. Fine-tuning recipes and sim are single-arm only; YAM has no sim suite or two-arm training recipe yet.
• Arm control only: outputs are Cartesian targets for an impedance controller. LeRobot has no Franka robot class, so a real arm needs your own client.
• No remote serving in LeRobot: the policy keeps past observations, so run it in-process or use the native Praxis server.
• Validation gaps: full bitwise GPU validation is listed as pending for praxis-1-droid. Recommended settings may change as robot results come in.
• Hard cases: Runway’s own research page lists cluttered scenes, transparent objects, cloth and rows of identical objects as typical failure areas for demo-only policies, which it is still testing.
• Licences: Praxis code and weights are Apache 2.0, but the Wan2.2 VAE and Qwen3.5-2B encoder carry their own licences. Check both before shipping.

Warning: any learned policy can move unpredictably. Test in simulation first, then on a real arm with speed limits, a clear workspace and an emergency stop within reach.

Troubleshooting

My Take

This is the most interesting open robotics release of the autumn, mostly because of the licence. An Apache 2.0, commercially usable policy that beats NVIDIA and Black Forest Labs on RoboLab gives small robot companies a real starting point.

The bigger story is the trend. Two AI video companies, Runway and Black Forest Labs, now hold the top open robot models. Video pretraining looks like it transfers to physical control better than many expected.

Keep two caveats in mind. Every number is Runway’s own, and hobbyists are mostly locked out: bf16 needs an 80 GB GPU, and the 32 GB NVFP4 route is untested closed-loop. For most readers, the sim and the $1.80 per hour hosted tier are the realistic ways in today.

FAQ

What is Runway Praxis-1?

It is Runway’s open-weight world action model for robots. It predicts the next 1.6 seconds of camera video and the robot arm commands together, from camera frames, arm pose and a text instruction.

Is Praxis-1 free for commercial use?

Yes. The weights and the inference and fine-tuning code use Apache 2.0, which allows commercial use. The bundled Wan2.2 VAE and Qwen3.5-2B text encoder have their own licences to check.

Can I run Praxis-1 on an RTX 4090 or other 24 GB GPU?

No. Runway says 24 GB cards will not fit even with NVFP4. You need an 80 GB GPU for bf16, or a 32 GB RTX 5090 or RTX PRO 6000 Blackwell with the experimental NVFP4 path.

Do I need a real robot to try it?

No. The repo includes a MuJoCo sim with seven tabletop tasks, and results are shown live in your browser on port 8000.

Which robots does Praxis-1 support?

The released checkpoints cover a single Franka-style DROID arm and two YAM arms. Other robots need fine-tuning from the base checkpoint, which launch partners have done for a humanoid, an industrial arm and a warehouse robot.

How much does hosted Praxis-1 cost?

Reactor lists $1.80 per hour for the DROID and YAM checkpoints, with under 260 ms p99 latency. A faster 62 ms tier is in early access.

Is Praxis-1 better than FLUX 3 Action?

On RoboLab-120, Runway reports 46.2% vs 42.9%. FLUX 3 Action is much smaller (7B) and faster, so it can still be the better choice for on-robot compute.

Does Praxis-1 work with LeRobot?

Yes, natively. Load it with --policy.path=runwayml/praxis-1-droid-lerobot after installing LeRobot’s praxis extra.

Sources

• Runway: “Praxis-1 is now available” (company news, 11 November 2026)
• Runway Research: “Introducing Praxis-1” (September 2026)
• GitHub: runwayml/praxis-1-oss README (install, checkpoints, VRAM, latency, NVFP4, known issues)
• Hugging Face: LeRobot Praxis documentation and runwayml/praxis-1 collection
• Reactor: Praxis-1 hosted inference page (pricing and latency)
• NVIDIA Technical Blog: “Beyond VLAs: How World Action Models Reshape Robot Manipulation”
• Hugging Face: nvidia/Cosmos3-Nano model card (size, licence)
• The Decoder: Black Forest Labs launches FLUX 3 Action (24 September 2026)
• Robotics & Automation News: “Runway moves into robotics with open-weight Praxis-1 AI model” (1 October 2026)