Runway released Praxis-1 on November 11, 2026, under Apache 2.0, with weights, inference code and fine-tuning code. It is a 27 billion parameter video model that predicts the next 1.6 seconds of a scene and the joint targets that make it happen. The checkpoint is 54.4 GB in bfloat16 across 17 safetensors shards. On NVIDIA's RoboLab-120 benchmark it solved 555 of 1,200 episodes, 46.2 percent, first among world action models and first among open source robot foundation models.

In the same week, OpenAI disbanded its standalone robotics team for the second time. Fortune reported the decision and The Decoder carried the detail: researchers move under chief research officer Mark Chen, applied robotics and hardware move under Greg Brockman, and OpenAI had already booked a booth at the Conference on Robot Learning in Austin. The stated reason is that a general purpose model, GPT-6 Astra, can drive robots directly, which makes specialized robotics models less necessary. The number behind that claim is 74.8 percent on simulated DROID against 51.0 percent for the strongest specialized policy.

This is not "robots are here." This is an architecture decision with a known failure mode, and almost nobody writing about it is naming the failure mode. The failure is that one of those two headline numbers was produced with the physics engine paused while the model thought.

WHAT A VIDEO MODEL ACTUALLY BUYS YOU

Video pretraining buys you priors that are miserable to hand-code. Object permanence when the gripper occludes the target. Contact behavior when two surfaces meet. Temporal coherence, meaning the model knows a scene that looks half finished should look different a second later. Runway's head of robotics Andy Chen put the mechanism plainly to The Robot Report: "The core piece is that a model trained to predict video really understands a lot about the physical world: how objects behave, how hands move, what a task looks like partway through."

What it does not buy you is force control, a safety envelope, or long horizon planning. Runway says so in its own limitations section. The most common real robot failure is reaching for a look-alike object, and the wrong choice is usually already visible in the imagined video. Vague instructions are harder than instructions that name a color or a size. Multi step tasks work when each step gets its own instruction, and chaining steps from a single prompt does not.

The architecture is worth naming because it explains the limits. The backbone holds 26.9 billion parameters and activates about 2.8 billion for any token. Seventeen of its twenty feed-forward layers are mixture-of-experts, with one shared expert and 128 routed experts, of which each token picks eight. The video autoencoder is a frozen Wan2.2 VAE. The text encoder is a frozen Qwen3.5-2B. An action expert of 16 blocks at dimension 1024 reads the backbone's hidden states through cross attention and denoises the actions.

Then there is the part that is actually the product. One policy call takes a task string, the current frame from an exterior camera and a wrist camera, the frames of up to three executed chunks, and the pose of the arm. It returns 21 rows of commands on the first call of a context window, which is 1.4 seconds of motion, and 24 rows on every call after that, which is 1.6 seconds at 15 Hz. Each row is a target pose in metres plus a gripper value. The model returns the predicted video of the same span alongside it.

Call that THE VIDEO-POLICY STACK, and treat the four layers as four different failure modes. The backbone fails by imagining a plausible scene that is not the real one. The action head fails by representing motion badly, and that one is measurable: with the same Astra model on a 30 task subset, NVIDIA's study scored 72.7 percent with end effector targets, 48.7 percent with joint positions, and 37.3 percent with joint space B-splines. That is a 35 point swing from the interface alone. The horizon chunker fails by compounding error past its window. The safety envelope fails by not existing, because nothing inside a video model knows what an emergency stop is.

THE 74.8 NUMBER IS A TRAP (AND HOW TO READ IT)

Keep two things apart before the numbers start. Praxis-1 is a world action model: one checkpoint that predicts the next video latents and emits joint targets from that prediction, trained on video and fine-tuned per rig. Astra is a frontier multimodal model used as a policy, reading the same pixels and returning action targets through a tool call, with its action representation chosen at inference time. One is a specialist artifact you deploy, the other a general model you rent by the token. They share a leaderboard and they are not the same object.

The 74.8 comes from NVIDIA's Astranomy study, which evaluated GPT-6 Astra as a native robot policy on RoboLab-120: 120 tasks, five episodes each, fixed seeds zero through four, control at 15 Hz, on L40S GPUs. The study reports three policy forms. Direct Policy, the model generating actions with no harness, reaches 66.3 percent. Orchestrated Policy, where a world action model proposes and Astra reviews each chunk, reaches 66.5 percent. Agentic Policy, Astra inside a persistent Codex session, reaches 74.8 percent and beats the strongest leaderboard reference, Lakeside, by 23.8 points.

So the headline is the most expensive of the three configurations, and the paper states what it costs. Direct Policy averages 18.56 seconds per inference call. Agentic Policy averages 30.9 million tokens and $36.40 per episode, against 160 thousand tokens and $1.96 for Direct. Same model, same tasks, 18.6 times the bill for eight and a half points.

Now the sentence that decides how you should read all of it. NVIDIA's own protocol line reads, "The simulator is paused during model inference." Control runs at 15 Hz, one step every 0.0667 seconds, and the clock stops every time the model thinks. Run the arithmetic and the real number falls out. A 32 step chunk is 2.13 seconds of motion. An 18.56 second call producing 2.13 seconds of motion is 8.7 times slower than real time, and physics does not pause on a factory floor.

Runway ran the obvious test. Same YAM station, same console, same three tasks, Praxis-1 against GPT-6 Astra. Astra took 15.6 times longer to finish and cost 51 times more per completed task. Removing a pen cap took Praxis-1 fifteen seconds and Astra seven minutes and forty eight seconds. The same model reads 22.5 percent on RoboDojo, 76.0 percent on RoboTwin 2.0, and 74.8 percent on RoboLab-120, a 54 point spread across three benchmarks that all claim to measure tabletop manipulation.

The protocol is not even stable inside one benchmark. Runway ran RoboLab-120 at 1,200 episodes, ten per task. NVIDIA ran it at 600, five per task with fixed seeds, and the paper says five episodes is insufficient to characterize per task variability. Tabletop manipulation is sensitive to where objects begin, since a few centimetres changes which grasp is reachable, so five seeds sample five poses and a lucky draw reads as healthy while the failure that matters stays hidden. Two numbers on one leaderboard, two protocols, no correction applied anywhere. None of that is fraud. It is what happens when a leaderboard number becomes a press release.

On hardware the picture narrows again. On StationeryBench, 200 trials across five desk tasks on dual arm YAM robots, Astra fully completed 7 of 100 tasks while Ai2's MolmoAct2 completed none, with average progress scores of 46 and 12. Seven percent completion is not a deployment.

The decision rule is four questions.

  1. Sim or hardware.
  2. What distribution shift.
  3. What does recovery from a contact failure look like.
  4. Who ran the eval.

I add a fifth, and it is the one that would have caught this one: does the harness pause physics, and what is the inference latency against the action chunk duration.

THE HORIZON MATH (THE PART NOBODY TEACHES)

The horizon problem is older than any of these models, and there is now clean evidence about what actually moves it. LeWorldModel is a 15 million parameter JEPA world model from Lucas Maes, Quentin Le Lidec, Damien Scieur, Yann LeCun and Randall Balestriero, and its benchmark is Push-T, a robot pushing a T shaped block to a target.

Neon infographic titled What Breaks at Step 26, The Horizon Problem, showing a robot arm tracing a planned trajectory from step 1 through step 25 to a red step 26 marker where the path breaks above a T shaped block, with a stacked side panel listing Backbone, Action Head, Horizon Chunker and Safety Envelope
Step 26 is where the chunk ends and the error compounds.

Engineer Haddy Alchaer ran about 600 experiments on it and published the results on November 13, 2026. Used exactly as published, LeWM solves 22 percent of tasks where the goal is 75 steps away. At 25 steps it solves 89.7 percent, against 90.5 percent for a version handed the simulator's exact physics. Give both versions subgoals from an expert demonstration every 25 steps and LeWM reaches 78 percent while perfect physics reaches 77 percent. Prediction is not the bottleneck.

The ablation is the teaching. Swap in exact physics and success goes from 22 to 42 percent, a gain of 20 points. Cut the task into 25 step segments and chain searches through subgoals and success goes to 80 percent, a gain of 58. Replace the expert subgoals with a graph over 460,000 embedded demonstration states and you reach 85 percent, which matches handing the planner expert subgoals. Every one of those points came from how the trained model is used, not from a better model.

Put the arithmetic on a real task. Ten minutes at 10 Hz is 6,000 control steps. At the 15 Hz Praxis-1 runs, it is 9,000. In 25 step chunks that is 240 or 360 planning calls, and no monolithic policy runs 6,000 steps in one shot. Chunked subgoal planning with replanning is the only shape with evidence behind it.

The industry already ships that shape without naming it. Praxis-1 returns 24 command rows, which is 1.6 seconds at 15 Hz. NVIDIA's Astra study varied its chunk length between 3 and 15 actions and between 16 and 32 actions, and the longer setting cut calls by 62 percent at similar completion time while dropping success by 6 points, because it could not correct fast enough. Two independent groups, one on a 15 million parameter simulation model and one on a frontier language model, land on roughly 25 steps as the useful planning window.

Then comes the duty cycle, the number that decides whether any of this works outside a simulator. 1.6 seconds of motion per call against a measured 1.1 to 1.4 second client median in Runway's RoboLab runs is a margin of 1.14 to 1.45. The robot thinks almost as long as it acts. If a call takes longer than the chunk it produces, real time margin drops below 1.0 and the arm stutters or stops. Server side, on one H100 with the default settings, the median was 501 milliseconds, so headroom exists. It exists on data center silicon, not on the Jetson Thor bolted to the machine. An edge accelerator has far less room, and thermal throttling takes more of it under sustained load, so arm the watchdog for the worst sustained rate, not the bench number. If a local accelerator cannot finish a chunk inside its own duration, the watchdog trips and the robot halts mid task.

Where that leaves the decision:

  • Reach for a video policy when the task is short horizon, visually dense, and the instruction names the attribute of the target.
  • Keep a classical planner when the constraint is hard, the horizon is long, or a person stands within reach of the machine.
  • Do not replace a safety interlock with a model that has never been told what one is.

A CHECKLIST BEFORE YOU SHIP A VIDEO-POLICY ROBOT

  1. Sim assets first, because your evaluation is only as honest as your scene. NVIDIA's SimReady walkthrough is the cheapest checklist available. The specification works on three levels: a profile for a use case, the features that profile requires, and the concrete settings each feature needs. The example builds a pick and place from a UR17G arm, a Robotiq 2F-140 gripper and a beverage can in Isaac Sim 6.2, and the validation reports show the arm against the Robot-Body 4.0.0 profile and the gripper against Robot-Gripper 3.0.0, both passing the PhysX driven joint checks. Read the caveat in the same document. No vision was used and collision checks were limited.
  2. Test the action interface on hardware before you test the policy. NVIDIA's 72.7 against 48.7 against 37.3 result, measured on a 30 task subset, is free to reproduce and it will tell you more about your deployment than a week of backbone experiments.
  3. Budget replanning latency as a hard constraint, not a tuning knob. Praxis-1 needs one 80 GB GPU at bf16, with a 54.4 GB checkpoint. NVFP4 packing brings the weights to 17.5 GB and costs about a point of success across 600 sampled episodes, 279 against 287, which is not significant. Runway's docs estimate that a compressed build fits a 32 GB RTX 5090, with peak memory still unmeasured. Whatever you run, measure your own path with a latency harness before you promise a control rate.
  4. Define the abort path before the demo path. A watchdog that stops the arm when the last chunk is older than its own duration. Joint limits enforced outside the policy. An emergency stop wired to hardware and not to an inference server. The model has no representation of any of it.

WHAT TO DO TODAY

  1. Pull the weights and run one tabletop task in simulation before you believe any of this. The repository ships a MuJoCo simulation and a block in bowl task that runs three episodes in minutes on one GPU.
  2. Write a five question eval card and apply it to every robotics pitch you see this quarter: sim or hardware, horizon, recovery, interlock, and latency against chunk duration.
  3. Add one question to design review this week. What breaks at step 26?
  4. Read the LeWM work before your next architecture review. It is the strongest public evidence that the planning layer, not the model, is where your remaining points are.

THE UNCOMFORTABLE QUESTION

If a video model with a weekend of fine-tuning beats your hand-built perception, planner and controller stack on a benchmark, what exactly is your team still maintaining, and would you notice if the benchmark was flattering it?

Enjoyed this article?

☕ Buy Me a Coffee

Support PhantomByte and keep the content coming!

Build Real AI Infrastructure

PhantomByte teaches you to build real AI infrastructure yourself: local AI stacks, autonomous agents, multi-agent orchestration, web scraping, and custom tools. Step-by-step PDF tutorials you download, follow, and deploy. No subscriptions. No fluff. Just skills that ship.