The Runway Praxis-1 open weights requirements come down to one number. The documented setup needs a single CUDA GPU with at least 80 GB of memory (one H100 is enough), and a full fine-tune needs at least 4 x 80 GB. A 32 GB RTX 5090 can try an experimental 4-bit path that Runway says should fit but hasn't measured or tested in closed loop. A 24 GB card does not fit at all.
The weights and code are Apache 2.0, commercial use included, but two frozen dependencies ship under their own licences. That means three licences to check, not one.
This is the checklist to run before you start a 54.4 GB download. It covers the hardware ladder, which checkpoint fits which robot, the licence split, and the places where launch-day claims and the repo's fine print disagree.
What are the Runway Praxis-1 open weights requirements, path by path?
As of November 2026, Runway documents one reference way to run Praxis-1 and one experimental low-memory way. The reference way is bf16 on an 80 GB GPU. The experimental way is NVFP4, at about 23.5 GB of weights by Runway's own estimate.
Fine-tuning is a separate tier. A full fine-tune needs at least 4 x 80 GB, and none of the sources we checked give a memory figure for LoRA.
This ladder combines the runwayml/praxis-1-oss README, the Hugging Face model cards and the LeRobot Praxis-1 docs:
| Path | GPU memory | Status (Nov 2026) | Where it's stated | Best for |
|---|---|---|---|---|
| bf16 inference (default) | at least 80 GB on one GPU | Reference setup | README, DROID model card, LeRobot docs | Labs with an H100, B200 or B300 |
| NVFP4 inference | about 23.5 GB of weights (estimate); peak not measured | Experimental, not yet run in closed loop on an SM120 GPU | README | Tinkering on a 32 GB RTX 5090 |
| LoRA fine-tune | not published in the sources we checked | Supported, per Runway's launch post | Launch post | Adapting to your own rig and cameras |
| Full fine-tune | at least 4 x 80 GB | Documented | LeRobot docs | Teams with a multi-GPU node |
On the software side, the README says to use Python 3.12 with a CUDA GPU. Native bf16 is supported on H100, B200 and B300.
Why does a model with 3B active parameters still need 80 GB?
LeRobot describes Praxis-1 as a 27B-parameter mixture-of-experts transformer with about 3B active parameters per token. Mixture-of-experts (MoE) means the model is split into many specialist sub-networks, and a router picks a few of them for each token.
That saves compute, not memory. Picture a restaurant with a huge pantry where each dish uses only a handful of ingredients: you still pay rent on the whole pantry.
Every expert has to sit in GPU memory, because any of them might be picked next. That is why the base weights weigh 54.4 GB in bf16 across 17 safetensors shards. It is also why the README's NVFP4 numbers show the routed experts alone dropping from 51.3 GB to 14.4 GB.
Can I run Praxis-1 on an RTX 5090 or a 24 GB card?
As of November 2026, Runway's GitHub README says a 32 GB RTX 5090 should fit Praxis-1's NVFP4 path, but peak memory isn't measured and it hasn't been run in closed loop. A 24 GB card is a firm no. The only documented route onto a 32 GB RTX 5090 is the NVFP4 path, because the bf16 policy alone is 54.4 GB.
Runway's launch post lists hardware from "workstation GPUs like RTX 5090 and RTX PRO 6000, to Jetson Thor on the robot itself." The README is more careful about the 5090:
- It should fit, but peak memory isn't measured. Runway estimates about 23.5 GB of weights on the NVFP4 path and says "a 32 GB RTX 5090 should fit (the peak is not measured yet) and a 24 GB GPU does not."
- It hasn't driven a robot yet. The NVFP4 path "has not been run in closed loop on an SM120 GPU yet", and the RTX 5090 is an SM120 GPU.
- The first load is slow. The first NVFP4 load packs 4,352 expert matrices on the CPU, which takes minutes (about 18 with 22 threads, per the README). Start it before you go get coffee.
- H100 owners can't take this shortcut. H100 uses bf16. An explicit NVFP4 request on H100 raises an error before any weights are packed or transferred.
We didn't find per-device memory instructions for the RTX PRO 6000 or Jetson Thor in the sources we checked. If either is your target, confirm it in the repo before you buy hardware around it.
Does the 4-bit NVFP4 version of Praxis-1 lose accuracy?
Sometimes. Runway's Praxis-1 README reports that one NVFP4 fine-tune performed about level with bf16, while another was clearly worse. Its instruction is to measure the checkpoint you use before you deploy it.
NVFP4 is a 4-bit weight format. For the released checkpoints it is post-training quantization, which means compressing the weights after training with no retraining to compensate. That applies here because the released checkpoints are bf16.
The README is blunt that "this option changes the actions." For a robot, that means different motor commands, not a slightly reworded sentence.
These are Runway's own earlier checks on NVFP4 fine-tunes:
| Test | NVFP4 | bf16 (same weights) | Runway's read |
|---|---|---|---|
| RoboLab | 279/600 | 287/600 | No clear difference |
| Hard simulation suite | 138/352 | 188/352 | Clearly lower |
The practical rule is to run your exact checkpoint on the README's hard simulation suite in both formats before NVFP4 goes anywhere near real hardware. If your gap looks like the second row, you need the 80 GB path.
Which Praxis-1 checkpoint do I download for my robot arm?
As of November 2026, we verified two Praxis-1 checkpoints:
- the base model, which is a starting point for fine-tuning, not a policy;
- a DROID policy for a single-arm Franka with a Robotiq gripper.
A checkpoint for the SO-101 arm is announced in the README but not released.
| Checkpoint | Robot it targets | Runs a robot as is? | Size and hardware | Best for |
|---|---|---|---|---|
| praxis-1-base | None specific; trained on robot and human video across 18 embodiments | No, it has no action heads | 54.4 GB bf16, 17 shards | Fine-tuning on a new rig |
| praxis-1-droid | Single-arm DROID rig (Franka + Robotiq gripper) | Yes | One 80 GB GPU for inference | Labs that already have a DROID setup |
| SO-101 checkpoint | SO-101 arm | Not released yet | Not published | Waiting, or fine-tuning base yourself |
The repo may list other embodiment checkpoints beyond these. Check the README for the current set before you decide your arm isn't covered.
Does the base checkpoint run a robot as it is?
No. The Praxis-1 base model card says it "has no per-embodiment action heads, so it does not run as a policy as is."
Action heads are the final layers that turn the model's internal state into commands for one specific robot body. Downloading base and pointing it at your arm gets you nowhere until you fine-tune.
What does the robot loop actually receive?
Praxis-1 outputs robot commands at 15 Hz in action chunks, which are batches of future commands returned per call, per the README. The first call of a context window gives 21 rows (1.4 s of motion), and each later call gives 24 rows (1.6 s). Build your controller to consume chunks, not single steps.
How much GPU memory does Praxis-1 fine-tuning need?
A full fine-tune of Praxis-1 needs at least 4 x 80 GB GPUs, according to the LeRobot docs as of November 2026. Runway's lighter option is LoRA, but none of the sources we checked publish its memory requirement.
LoRA (low-rank adaptation) trains small add-on matrices instead of the whole model. It is Runway's suggested route. The launch post says "with LoRA you can adapt it to your own embodiment, cameras and tasks without retraining the full model."
The frozen base still has to be loaded. So don't assume LoRA runs on less than the 80 GB inference tier until you've measured it.
Runway's evidence that adaptation pays off comes from RT-1. After fine-tuning on RT-1, the company reports 80.0% success on SimplerEnv, against 52.4% for the original RT-1 policy. That is a vendor-reported result on one robot in one benchmark. Treat it as a promising signal for your rig, not a forecast.
Is Praxis-1 really free for commercial use under Apache 2.0?
Yes, for Runway's part. As of the November 11, 2026 release, the Praxis-1 weights, inference code and fine-tuning code are under Apache 2.0, and Runway's launch post says this includes commercial use. The catch is that two frozen dependencies are distributed separately under their own licences.
| Component | Licence | Where it's stated | What to do |
|---|---|---|---|
| Praxis-1 weights, inference and fine-tuning code | Apache 2.0 | Runway launch post, model cards | Read the repo's LICENSE file before you redistribute |
| Wan2.2 VAE (frozen) | Its own licence; the Wan2.2 model card says Apache 2.0 | Wan2.2-TI2V-5B model card | Read the card; it puts responsibility for lawful use on the user |
| Qwen3.5-2B text encoder (frozen) | Its own licence; the model card lists apache-2.0 | Qwen/Qwen3.5-2B model card | Pin the version you ship and re-check its card |
On paper, the whole stack reads as Apache 2.0 today. But the README notes that "Wan2.2 and Qwen3.5 have their own licenses." Those terms are controlled by Wan-AI and Qwen, not Runway, so record which versions you downloaded.
This section has two honest limits:
- We read the launch post and model cards, not the full LICENSE file text in the repo.
- A permissive licence covers your right to use and ship the weights. It doesn't make a policy safe to run on a physical arm; safety validation is still on you.
If you're weighing open-weights terms across vendors, our breakdown of the Kimi K3.1 Pro open weights license shows how much these licences can differ.
How good is Praxis-1's 46.2% RoboLab-120 score?
On NVIDIA's RoboLab-120 leaderboard, Runway reports that Praxis-1 succeeds in 46.2% of 1,200 episodes. The table is labelled "Data as of November 2026." That puts it ahead of the other models Runway lists, but it also means more than half of the attempts failed.
These are the figures Runway publishes from that leaderboard:
- Praxis-1: 46.2%
- FLUX 3 Action: 42.9%
- Cosmos3 Nano: 36.8%
- pi0.5: 28.0%
Keep two things in mind when you read them.
- It is a pass/fail rate. It records whether each episode completed the task. It tells you nothing about how close the failures came or how they failed, which matters a lot when the failure is a dropped object or a collision.
- Other published numbers are noisier. The DROID model card reports 52.5% full prompt adherence with a 95% confidence interval of 35.8 to 68.3. A spread that wide suggests a small test set.
Use the leaderboard to build a shortlist, then trust your own rollouts on your own rig.
Where do Runway's launch post and the Praxis-1 repo disagree?
As of November 2026, Runway's launch post and the Praxis-1 repo agree on the facts but differ in emphasis. The post lists what's possible, while the README and model cards list what's tested. This table pairs them up.
| Topic | Launch post says | Repo and model cards say | What it means for you |
|---|---|---|---|
| RTX 5090 | Listed among the GPUs Praxis-1 runs on | NVFP4 only; should fit 32 GB, peak not measured, not run in closed loop on SM120 | Experimental; validate before relying on it |
| Ready to use | Open weights released | Base has no action heads; SO-101 checkpoint not released | You need a matching checkpoint or a fine-tune |
| Commercial use | Included under Apache 2.0 | Wan2.2 VAE and Qwen3.5-2B have their own licences | Check three licences, not one |
| Adapting to your robot | LoRA, without retraining the full model | Full fine-tune needs at least 4 x 80 GB; LoRA memory not stated | Budget for 80 GB-class GPUs until you measure |
Should you download Praxis-1 today? A go/no-go rule
Download Praxis-1 now if you have either of these:
- an 80 GB GPU and a DROID-style rig;
- the hardware to fine-tune base: at least 4 x 80 GB for a full fine-tune, or an 80 GB GPU if you'll measure LoRA memory first.
Go experimentally on a 32 GB RTX 5090 only if you'll measure it yourself. Wait if you're on a 24 GB card, or on an SO-101 arm with no bigger hardware.
Go now if:
- You have an H100, B200 or B300 and a single-arm Franka + Robotiq gripper rig: grab praxis-1-droid.
- You have a different robot and either at least 4 x 80 GB for a full fine-tune of base, or an 80 GB GPU and a plan to measure LoRA memory yourself first (the sources we checked give no figure).
Go experimentally if:
- You have a 32 GB RTX 5090. Expect a slow first NVFP4 load and log peak memory. Compare NVFP4 against bf16 on the
hardsuite before any closed-loop run.
Wait if:
- Your GPU has 24 GB. The README says it does not fit.
- You own an SO-101 arm and no 80 GB GPU. Watch the repo for the announced checkpoint.
Your three-step starter plan:
- Check your GPU memory against the ladder above, and pick bf16 or NVFP4 before downloading 54.4 GB of shards.
- Match your robot to a checkpoint. If none fits, plan a LoRA fine-tune of base and measure its memory early.
- Save the licence pages for Praxis-1, Wan2.2 and Qwen3.5-2B with the versions you pulled. Validate any NVFP4 checkpoint on the
hardsuite before it touches hardware.
