MODEL DEPLOYMENT → · 2026-11-12 · 12 min read
Deploy Praxis-1 on one H100
Runway's Praxis-1 is a 27B robot policy that genuinely runs on one rented GPU — but “deploy” is three different jobs: serve a ready-made policy, adapt one to your task with LoRA, or fine-tune the base checkpoint for your own rig. Each prices differently, and one of them is not a one-card job at all. This guide prices all three from our verified board, checked Nov 12, 2026 — starting from the fact most coverage skips: the base checkpoint cannot drive a robot until you fine-tune it.
The verdict
- Run a ready policy on an H100 (DROID or YAM rig, BF16) — H100 PCIe at RunPod Community, no minimum listed — the cheapest one-card H100 route on the board. Runway's stated bar is one 80GB GPU; this is one. Catch: Runway's own measured runs are on SXM H100s — the fit is by the maker's stated requirement, not a benchmark we can cite.
- The same, on the SXM card — H100 SXM at RunPod Community, no minimum listed. Catch: TensorDock's $2.25 wears the lower number but bills an 8-GPU minimum — $18.00/hr before you have run anything.
- Cheapest card of any kind for the BF16 model — RTX PRO 6000 at RunPod Community (Blackwell) — a card Runway lists as running Praxis-1 out of the box. Catch: a workstation card, not a datacenter Hopper — you trade datacenter manners for 96GB at a lower rate.
- The NVFP4 route (17.5GB in memory) — RTX 5090 at RunPod Community — the cheapest way to run a Praxis-1 policy at all. Catch: experimental and Blackwell-only (SM120: RTX 5090, RTX PRO 6000) — not on an H100, not on an L40S. Only the ready policies have NVFP4 checkpoints, and you still download the full 54.4GB.
- Room to spare — H200 at RunPod Community. Catch: more than inference needs; it earns the premium for heavy evaluation batches and zero memory suspense.
- Fine-tune for a new rig — Not a one-card job: Runway's recipe is one node of 8 × 80GB GPUs, ~15 hours measured — priced as a node in the tables below. Catch: the one-card fine-tune is LoRA, and it only adapts the DROID checkpoint, on the DROID rig. A different arm means the node.
What Praxis-1 is — and what it is not
Praxis-1 is a world action model for robots: a 27.2-billion-parameter mixture-of-experts diffusion transformer that takes two camera feeds and a task string (“Put the red block in the bowl”) and predicts, together, the next chunk of video and the next chunk of robot motion — 24 commands at a time, at 15 Hz control. It is not a chatbot and not an image model; if your work doesn't end at a robot arm, this is the wrong download. What Runway released on Nov 11, 2026 — weights, inference code and fine-tuning code, all Apache 2.0, commercial use included — is a small family, and picking the right member is the first deployment decision. praxis-1-droid is the finished single-arm policy for the DROID rig (a Franka arm, exterior + wrist cameras); it is the checkpoint that tops RoboLab-120 on Runway's figures (46.2% success across 1,200 episodes — the maker's numbers, not measured by us), and it runs as a policy as downloaded. praxis-1-yam is the finished bimanual policy, for two YAM arms with three cameras. praxis-1-so101 is a fine-tune for the low-cost SO-101 LeRobot arm, added to the collection on Nov 12. praxis-1-base is the pretrained checkpoint the others were made from, trained on robot and human video across 18 embodiments: it has no action heads for any rig, so — in its own model card's words — “it does not run as a policy as is.” It exists to be fine-tuned; renting a GPU to “serve the base” buys a 54.4GB download and nothing that moves. Each policy also ships in a LeRobot layout (praxis-1-droid-lerobot and siblings) and, for the ready policies, in an NVFP4 build. Two frozen dependencies ride along, not included in the Praxis repos: the Wan2.2 VAE and the Qwen3.5-2B text encoder, each a separate download under its own licence — Apache 2.0 covers Praxis-1 itself, not them.
Every one-H100 route, priced
All 19 H100 offers on our board, checked Nov 12, 2026 (Microsoft Azure's NVL appears at two VM sizes). The one-card routes are the ones with no node or minimum attached — read the terms column before the price column.
| Variant | Provider | $/GPU/hr | Terms that decide the real bill |
|---|
| H100 SXM (80GB) | TensorDock | 2.25 | 8-GPU minimum — $18.00/hr for 8 GPUs. A node rate wearing a per-GPU price. |
| H100 SXM (80GB) | RunPod Community | 2.69 | On-demand, no minimum listed — the cheapest true one-card SXM route. |
| H100 SXM (80GB) | Thunder Compute | 3.20 | On-demand, no minimum listed. |
| H100 SXM (80GB) | Hyperstack | 3.20 | On-demand, no minimum listed. |
| H100 SXM (80GB) | RunPod Secure | 3.99 | On-demand, no minimum listed; the vetted-datacentre tier. |
| H100 SXM (80GB) | Lambda | 3.99 | On-demand, no minimum listed. (Lambda has announced rises effective Nov 16 — announced, not yet in effect, not applied here.) |
| H100 SXM (80GB) | Verda | 5.14 | On-demand, no minimum listed. |
| H100 SXM (80GB) | Microsoft Azure | 12.29 | 8-GPU VM — $98.32 per node. You rent the whole VM, not one card. |
| H100 PCIe (80GB) | RunPod Community | 1.99 | On-demand, no minimum listed — the cheapest one-card H100 route. |
| H100 PCIe (80GB) | Hyperstack | 2.50 | On-demand, no minimum listed. |
| H100 PCIe (80GB) | RunPod Secure | 2.89 | On-demand, no minimum listed. |
| H100 NVLink (PCIe) | Hyperstack | 2.60 | Hyperstack's own label for its NVLink-linked PCIe-form H100. |
| H100 NVL (94GB) | RunPod Community | 2.59 | Sold as linked pairs, not as a lone card. |
| H100 NVL (94GB) | RunPod Secure | 3.19 | Sold as linked pairs, not as a lone card. |
| H100 NVL (94GB) | Microsoft Azure | 6.98 | 1-GPU VM — a genuine one-card NVL route (also a 2-GPU VM at the same per-GPU rate). |
| H100 (HGX) | Nebius | 4.50 | Listed as HGX — no variant split. Excl. VAT. |
| H100 (HGX) | CoreWeave | 6.16 | 8-GPU node — $49.24 per node, not one card. |
| H100 (HGX) | Oracle OCI | 10.00 | Listed as HGX · 8-GPU node — $80.00 per node. |
Three readings. The H100 decision for this model is a terms decision, not a price decision: the two lowest SXM numbers split into a node commitment (TensorDock) and a true single card (RunPod Community). The PCIe card at $1.99 is the rational default for one-card work — a lone card never touches NVLink, so the SXM premium buys interconnect you can't use; what it does buy is the exact hardware Runway measured on, worth something while you're chasing setup problems and nothing once you're running. And the hyperscaler rows price the whole machine; they belong in a node comparison, not this one.
The cards that undercut the H100
Praxis-1 is unusual: its maker blesses two workstation cards by name, and one of them undercuts every H100 on the board. (The full H200 and PRO 6000 sets, including node-priced rows, are in the method note.)
| GPU | Provider | $/GPU/hr | Terms |
|---|
| RTX PRO 6000 (96GB) | RunPod Community | 1.69 | On-demand, no minimum listed. Runs BF16 outright (96GB) and is NVFP4-capable. |
| RTX PRO 6000 (96GB) | Nebius | 1.80 | On-demand, excl. VAT. |
| RTX PRO 6000 (96GB) | RunPod Secure | 2.49 | On-demand, no minimum listed. |
| RTX PRO 6000 (96GB) | Google Cloud | 5.17 | 1-GPU VM. |
| RTX 5090 (32GB) | RunPod Community | 0.69 | On-demand, no minimum listed. NVFP4 route only — 17.5GB in memory fits 32GB with room for the runtime. |
| RTX 5090 (32GB) | RunPod Secure | 1.19 | On-demand, no minimum listed. |
| H200 (141GB) | RunPod Community | 3.59 | On-demand, no minimum listed — the roomier Hopper alternative. |
| H200 (141GB) | Hyperstack | 3.99 | On-demand, no minimum listed. |
| H200 (141GB) | RunPod Secure | 5.29 | On-demand, no minimum listed. |
Worked costs
Assumptions, stated once: you pay only for hours the card is rented; a “day of experiments” is 8 rented hours; fine-tune durations are Runway's measured figures for its own worked examples — your data and step counts will move them; storage, data transfer and your own time are excluded.
| Job | Route | Hours | Cost |
|---|
| A day of experiments (serve + evaluate in sim) | RTX 5090, RunPod Community (NVFP4 policy) | 8 | $5.52 |
| RTX PRO 6000, RunPod Community (BF16) | 8 | $13.52 |
| H100 PCIe, RunPod Community (BF16) | 8 | $15.92 |
| H100 SXM, RunPod Community (BF16) | 8 | $21.52 |
| H200, RunPod Community (BF16) | 8 | $28.72 |
| LoRA run (maker's example: ~5 hrs training; +1–2 hrs if you record the sim demos first) | H100 PCIe, RunPod Community | 5 (7) | $9.95 ($13.93) |
| H100 SXM, RunPod Community | 5 (7) | $13.45 ($18.83) |
| Full fine-tune from base (maker's run: 15.7 hrs on 8 × H100) | TensorDock, 8 × H100 SXM at $2.25/GPU/hr | 15.7 × 8 cards | $282.60 |
| RunPod Community, 8 × H100 SXM at $2.69/GPU/hr | 15.7 × 8 cards | $337.86 |
Note where the TensorDock minimum lands: a trap for the one-card jobs, and the cheapest honest route for the one job that actually needs eight cards. The same rate is the wrong answer and the right answer, depending on the shape of the work — the whole argument for reading terms before prices.
The fit maths: BF16 vs NVFP4
The arithmetic is the maker's own. 27.2B parameters at 2 bytes in BF16 is 54.4 GB of weights — the exact figure on the model card, in 17 safetensors shards. Runway's quick start states the requirement plainly: one CUDA GPU with at least 80 GB of memory, Python 3.12, the CUDA 13.0 driver; the LeRobot card repeats it (“Inference needs one 80 GB GPU”). On an 80GB card the weights leave 25.6GB for the VAE, the text encoder and the runtime — and the maker's measurements say the stack stays inside it: Runway's LoRA training run, which holds the whole frozen checkpoint plus adapters and optimizer state, peaks at 65 GiB on one 80GB card. Inference is the lighter job. The NVFP4 build is narrower than the headline suggests. Runway fine-tuned the ready policies with quantization-aware training on the routed MoE experts only; everything else stays BF16. You still download the full 54.4GB — the experts are packed to NVFP4 at load time, and in memory the policy shrinks from 54.4 GB to 17.5 GB (the maker's figure). Two hard limits: the path is labelled experimental, and it runs only on SM120 Blackwell cards — the RTX 5090 and RTX PRO 6000. Not on Hopper (H100/H200), not on Ada (L40S). Which makes the board's cheapest 48GB card a dead end twice over: an L40S (RunPod Community $0.79/hr) can't hold 54.4GB in 48GB, and its architecture has no NVFP4 path in Runway's code. The same honesty applies to the A100 80GB (from $1.09/hr): the memory fits, but Runway doesn't list the A100 among the cards that run Praxis-1 out of the box, so this guide doesn't price it as a route.
Steps
1. The reference code (runwayml/praxis-1-oss)Three documented ways in share one front door: Python 3.12, the CUDA 13.0 driver, one GPU with at least 80GB for anything BF16, and a Hugging Face login. Clone, install, download the checkpoint plus the two frozen dependencies, and serve with the shipped configs — configs/serve_droid.yaml for the single-arm policy, serve_yam.yaml for the bimanual. The same repo runs a built-in MuJoCo simulation: the sensible first hour is three episodes of block_in_bowl in the sim, before any real arm is involved. The install builds at least one component from source — Runway's own fresh-clone run on an H100 took 17 minutes end to end (13 of it installing, most of that compiling causal-conv1d; 3 downloading weights; 1.5 to load and run — the maker's figures, on their setup).
2. The LeRobot routeIf your stack is already LeRobot, the -lerobot checkpoints drop in as a native policy: pip install “lerobot[praxis]”, then lerobot-eval --policy.path=runwayml/praxis-1-droid-lerobot --policy.device=cuda, or PraxisPolicy.from_pretrained(...) in code. Same weights, byte for byte; the repo adds the LeRobot config and the pre/post-processors.
3. Hosted and other enginesRunway's announcement also places Praxis-1 in vLLM-Omni and offers hosted inference on its Reactor platform — the zero-rental comparison point: if you only need to evaluate the policy briefly, weigh rented hours against simply calling the hosted version first. Reactor's pricing is not published in a form we could verify, so it is named here without a rate.
4. LoRA — the one-card fine-tuneIf your robot is the DROID rig and the task is new, Runway documents a complete recipe (configs/finetune_droid_lora.yaml): the DROID checkpoint stays frozen while low-rank adapters train on the action expert — at the documented rank 16, 80 layers carrying 5.5M adapter weights in total. It runs on one 80GB GPU at a measured 65 GiB peak, and the maker's worked example — 1,200 steps of 16 windows, taught from 3,000 recorded demonstrations — takes about 5 hours on one H100. Recording those demonstrations in simulation takes another 1–2 hours of GPU time, and every save is a full 54GB checkpoint: save every 200–400 steps and rent the disk to match (six saves ≈ 324GB). The maker's results, stated plainly: about +10 success points on three of four test tasks; the fourth, the hardest, unmoved. And LoRA cannot help a different rig — it keeps the DROID heads and normalization, so other cameras or arms need the full recipe.
5. Full fine-tune — the node jobA new rig starts from praxis-1-base: compute your rig's normalization statistics (scripts/compute_norm_stats.py), grow the missing action heads (scripts/init_heads.py — allow about 55GB of ordinary CPU memory for this step), pass the documented overfit check, then train all weights (configs/finetune_base.yaml). Your data is a LeRobot v2.x tree in the DROID layout at 15 fps; the config defaults to the public DROID dataset, so the recipe runs as written. Runway's recipe table prices the hardware honestly — one node of 8 × 80GB GPUs — and its own worked run on 8 H100s (5,000 steps, 53.3 GiB per GPU) took 15.7 hours. Set expectations by the maker's scoreboard: that run produced a working policy (19.0% on their hard simulation suite) that does not match the shipped DROID checkpoint (56.5%) — one node-day buys a working policy for your rig, not a replica of theirs.
Alternatives
What a call costs in time — the maker's measurements onlyOn one H100 80GB at the default serving settings, Runway measured a median 501 ms per policy call for calls after the first (344 ms with video guidance at 1.0), each call returning 24 commands — 1.6 seconds of robot motion — so a call takes about a third of the time it commands. The first call of a process took 35 seconds (kernel compilation; warm-up is real). The inputs were synthetic camera frames, which Runway notes can differ from real ones. We have not benchmarked this model, and no one else's numbers were available to check.
Watch out — the base checkpoint is not a policyNo action heads, no normalization — it cannot run a robot until the full fine-tune. If a rig-ready checkpoint matches your hardware (DROID, YAM, SO-101), start there.
Watch out — the $2.25 headline is an 8-card billTensorDock's board-leading H100 SXM rate carries an 8-GPU minimum: $18.00/hr from the first minute. For one-card work the real floor is the PCIe card at $1.99.
Watch out — NVFP4 is Blackwell-only and experimentalSM120 cards only; the experts pack at load time, so the 54.4GB download happens either way; and there is no NVFP4 base — a new-rig fine-tune is a BF16 job.
Watch out — check the driver before you pay for hoursThe documented stack wants the CUDA 13.0 driver and Python 3.12, and builds a kernel from source at install. An older provider image turns your first rented hour into systems administration.
Watch out — LoRA saves eat diskEvery save is a full ~54GB checkpoint; six saves ≈ 324GB before your dataset. Size the volume when you rent, not at step 1,000.
Watch out — judge fine-tunes closed-loop, not by lossRunway's own warning, both recipes: training loss flattens while simulation scores still move by points between saves. Budget evaluation time — in the sim or on the arm — into every fine-tune.
Watch out — the dependencies have their own licencesThe Wan2.2 VAE and Qwen3.5-2B text encoder are separate downloads under their own terms; Apache 2.0 covers Praxis-1, not them.
Watch out — Community tier means independent hostsRunPod Community — where most of this guide's cheapest rates live — runs on independent hosts, not RunPod's vetted datacentres (that is RunPod Secure, at higher rates). A specific card's availability varies by the hour; if it's gone when you look, Secure is the same model on the other shelf.
How we know
Rental rates are from GPUJournal's verified price board, checked Nov 12, 2026 on providers' own published pages and banked daily: H100 SXM — TensorDock $2.25/GPU/hr at an 8-GPU minimum ($18.00/hr for 8 GPUs), RunPod Community $2.69, Thunder Compute $3.20, Hyperstack $3.20, RunPod Secure $3.99, Lambda $3.99, Verda $5.14, Microsoft Azure $12.29 (8-GPU VM, $98.32/node); H100 PCIe — RunPod Community $1.99, Hyperstack $2.50, RunPod Secure $2.89; H100 NVLink (PCIe) — Hyperstack $2.60 (the provider's own variant label); H100 NVL — RunPod Community $2.59 and RunPod Secure $3.19 (both sold as linked pairs), Microsoft Azure $6.98 (1-GPU VM; also a 2-GPU VM at the same per-GPU rate); H100 HGX (no variant split) — Nebius $4.50 (excl. VAT), CoreWeave $6.16 (8-GPU node, $49.24/node), Oracle OCI $10.00 (8-GPU node, $80.00/node); H200 — RunPod Community $3.59, Hyperstack $3.99, RunPod Secure $5.29, Nebius $5.40 (excl. VAT), Verda $6.57, plus node-priced CoreWeave $6.31, Oracle OCI $10.00 and Microsoft Azure $10.60, none used as one-card routes; RTX PRO 6000 — RunPod Community $1.69, Nebius $1.80 (excl. VAT), RunPod Secure $2.49, Verda $2.78, Google Cloud $5.17 (1-GPU VM), plus node-priced CoreWeave $2.50 (High-Memory variant) and Oracle OCI $4.50; RTX 5090 — RunPod Community $0.69, RunPod Secure $1.19; L40S — RunPod Community $0.79 (cited only to rule it out); A100 80GB — from $1.09 at Thunder Compute (cited only to rule it out). “No minimum listed” means the board records no minimum or node term for that offer. Lambda's announced rises (announced Nov 6, 2026, effective Nov 16) are not yet in effect and are not applied. Model facts are from Runway's own pages, read Nov 12, 2026: the Hugging Face cards for runwayml/praxis-1-base (27.2B MoE video-diffusion policy; chunk-causal trunk + 0.3B action expert; BF16 weights 54.4GB in 17 shards; no per-embodiment action heads — “does not run as a policy as is”; control 15 Hz, 24-step chunks; frozen dependencies Wan2.2 VAE and Qwen/Qwen3.5-2B under their own licences; Apache 2.0), praxis-1-droid-lerobot (“Inference needs one 80 GB GPU”; pip install “lerobot[praxis]”; lerobot-eval and PraxisPolicy routes) and praxis-1-droid-nvfp4 (quantization-aware training on the routed experts; the 54.4GB BF16 download packs to 17.5GB in memory at load; experimental, SM120 GPUs only — RTX 5090 and RTX PRO 6000 Blackwell; NVFP4 cache 14.4GB); the Hugging Face collection (base, DROID and YAM policies, LeRobot layouts, NVFP4 builds of the ready policies, and the SO-101 fine-tune added Nov 12); and the runwayml/praxis-1-oss repository — the main README (quick start: Python 3.12, one CUDA GPU with at least 80GB, CUDA 13.0 driver; measured times on one H100 80GB: 501 ms median per later call at default settings, 344 ms at video guidance 1.0, first call 35.0 s, fresh-clone-to-running 17 minutes) and praxis/train/README.md (full fine-tune from base on one node of 8 × 80GB GPUs, about 15 hours measured — worked run 5,000 steps, 10.6 s/step, 53.3 GiB/GPU, 15.7 hours on 8 H100, scoring 19.0% vs the shipped DROID checkpoint's 56.5% on the maker's hard simulation suite; LoRA on praxis-1-droid on one 80GB GPU, 65 GiB measured peak, 1,200 steps in about 5 hours on one H100, rank-16 adapters on the action expert totalling 5.5M weights, saves are full 54GB checkpoints, demonstration recording 1–2 hours, about +10 points on three of four tasks). RoboLab-120 (46.2%) and SimplerEnv (80.0% vs 52.4%) figures are Runway's, from its Nov 11, 2026 announcement, as reported in our news story of the same date — not independently reproduced. Worked costs are arithmetic on the rates and durations above, with their assumptions stated in the section; nothing in this guide is a measured benchmark of our own, and no provider's availability at any moment is claimed.
Our reading
Our reading — interpretation, not fact. Everything in this box is GPUJournal's judgement on the verified record above it; the record itself is in the tables and the method note. We sell nothing and take no commission from any route on this page. Praxis-1 is the rare frontier release whose rental maths is genuinely small: a working robot policy for a few dollars a day of experiments, and a documented adaptation recipe — LoRA — that costs about ten dollars of H100 time. The traps are all in the framing, not the model. “Runs on one H100” is true for serving and for LoRA, and quietly false for the job a new rig actually needs, which is an eight-card node-day; “NVFP4” sounds like a compression option for the H100 you were about to rent and is in fact a different, cheaper card entirely; and the cheapest H100 number on any board, ours included, is a node rate in a per-GPU costume. Rent the PCIe H100 — or the PRO 6000, if a workstation card fits your setup — serve the ready policy in simulation first, and let the fine-tune decision wait until the policy has failed at your task in a way LoRA can fix.
Related guides
Model Deployment · 2026-10-30 · 12 min
The weights are out. Moonshot published Kimi K3.1 Pro on Hugging Face on Nov 4, 2026 — 96 safetensors shards summing to 1,561,293,160,568 bytes (about 1.56TB) in native MXFP4 — under its own Kimi K3.1-Pro License, with vLLM, SGLang and TokenSpeed named on the model card as the serving engines. This guide, first published Oct 30, 2026 as pre-release maths, was refreshed on Nov 6, 2026 with the real file sizes, the real licence and the official recipes: the smallest honest setup is one 8-GPU B300 node, the cheapest node-shaped setup on the current board is 16× H200 at $57.44/hr — and Moonshot’s own API, at $2.00 in / $10.00 out per 1M tokens, still beats self-hosting on price at ordinary volumes.
Model Deployment · 2026-10-23 · 9 min
For teams eyeing the weights that landed on Hugging Face on 23 October 2026 and asking a simple question: can we run this ourselves, and what would it actually take? MiniMax M3.1 Flash is a 428B mixture-of-experts model (~23B active per token) that handles text, images and video, with a context window of up to 1 million tokens. It is big, it is capable, and it does not fit on one card. This guide shows the memory maths plainly, the smallest node that honestly works, and what that node costs today.
Model Deployment · 2026-10-21 · 8 min
Voxtral 3 is Mistral's new speech stack — transcription, text-to-speech and a voice-agent SDK, launched Oct 20, 2026. Before you rent a GPU for it, read this: the weights are not openly downloadable, and this guide says so plainly, then costs the routes that actually exist today.
Go deeper