What Praxis-1 YAM is and what it produces
Praxis-1 YAM is a robotics policy from Runway tuned for a bimanual system: two YAM arms, a top camera, and a camera on each wrist. It receives an instruction, camera images, and the robot's state; it produces a video prediction and actions for both arms. It is not a chatbot or a general model that can control any robot without adaptation.
The published checkpoint has 27.2 billion parameters and combines a video diffusion trunk with an action expert of about 300 million parameters. The card describes a video representation with three views placed side by side and a control output in blocks of 24 steps at 15 Hz. This describes the format of this policy; it does not by itself prove that a task is completed correctly or that the same configuration works on other robots.
The actions are 20-dimensional vectors: for each arm, they include position, orientation, and gripper opening. Each arm expresses its movement relative to the pose it had at the start of the block, while the pose reference corresponds to the rig's coordinate system. When integrating the model, these details matter: a controller that interprets the coordinates differently may execute movements different from those expected.
The model uses dependencies that are downloaded separately: the Wan2.2 video autoencoder and the Qwen3.5-2B text encoder. The checkpoint card indicates that instructions are sent to the text encoder and that the weights of those dependencies are not included in the Praxis-1 YAM repository. Each dependency retains its own license; the checkpoint's license does not replace the review of those components.
The availability of the YAM checkpoint is dated November 11, 2026, in the version catalog. The date identifies this specific release and does not by itself establish that there is a hosted API, a usage price, or a service available in all countries. To evaluate the model, it is advisable to separate access to the weights from the infrastructure needed to run them.
Practical card of the YAM checkpoint
| Aspect | Published specification | What it means for evaluation |
|---|---|---|
| Target robot | Two YAM arms | This tuning should not be attributed to a different arm without adapting and evaluating the policy. |
| Cameras | One top and two wrist | The perspective and camera installation are part of the input environment. |
| Output | Blocks of 24 steps at 15 Hz | It is a temporal block of actions; it is not a guarantee of task success. |
| Actions | 20 dimensions for both arms | Includes position, orientation, and gripper opening, with coordinates relative to the block start. |
| Weights | 54.4 GB in bfloat16 | The file size does not equate to the total memory required for inference. |
| Reference GPU | One 80 GB GPU | It is the published requirement to run the checkpoint in its reference configuration. |
How it converts video into movement
Praxis-1 belongs to the family of world action models: it predicts a visual continuation of the scene and relates that prediction to the robot's actions. In simple terms, the system estimates how the scene might change and generates movements associated with that future. Predicting a plausible video does not equate to verifying that the movement is safe, reachable, or suitable for the goal.
The architecture divides the work between a video trunk and an action expert. The trunk processes the instruction and camera views; the expert receives internal representations from the trunk and predicts the actions. The card indicates that the model uses chunk-causal attention, a way of organizing sequential prediction, and a mixture-of-experts design for the trunk.
The policy was tuned for the YAM rig, with three camera views and actions for two arms. Therefore, the visual input and robot geometry are not interchangeable details: changing cameras, tools, orientation, or scale can alter the signals the model needs to interpret. An adaptation to another setup requires re-checking the inputs, outputs, and controller.
The card presents natural language instructions and gives an example of a two-stage task: picking up a pen from a table and placing it in a bag. This example shows the type of instruction the checkpoint expects, but it does not constitute proof that the policy completes the task. For practical use, the instruction must name the object and action with enough precision to distinguish them from close alternatives.
The output arrives in blocks, not as a demonstration that the robot can follow a task indefinitely. A system that chains blocks must decide how to update images, robot state, and instruction, and how to stop or recover from an error. The checkpoint documentation specifies the block length and frequency; it does not publish a guarantee of long-horizon task planning for this variant.
What results can be attributed to this variant
The material provided for the YAM checkpoint describes its configuration and requirements, but it does not include a benchmark score for this variant. Therefore, it is not correct to transfer the RoboLab-120 result attributed to the Praxis-1 policy tuned for DROID, nor results from other configurations. Robot, cameras, tuning data, and evaluation protocol can change performance.
A published result for another variant is only useful as context if its scope is preserved. For example, the RoboLab-120 figure that appears in secondary material corresponds to a DROID policy and a set of episodes defined for that benchmark. It is not a measurement of Praxis-1 YAM, it is not an independent evaluation of the YAM checkpoint, and it does not allow inferring how it will behave with two arms.
The YAM card also does not present results reproduced by an independent laboratory. The fact that the checkpoint has available weights allows other teams to evaluate it, but availability does not equate to replication. To assess a performance claim, one needs, at minimum, the exact variant, the robot, the tasks, the number of attempts, the success criterion, and the handling of failures.
The primary source available for the specifications is the checkpoint's own card, published by Runway on Hugging Face. The model information allows describing its inputs, outputs, and requirements, but it does not replace an evaluation report of this configuration. One cannot conclude from the architecture that the policy outperforms other systems, generalizes to new environments, or reduces work time.
A valid comparison between bimanual policies would have to fix the same robot, the same cameras, the same tasks, and a comparable protocol. It should also record if each system receives external help, such as additional instructions or planning from another model. If a comparison changes the policy, hardware, and procedure at the same time, the observed difference does not identify which component explains the result.
What can and cannot be concluded
| Data or claim | Scope that it supports | Conclusion that it does not support |
|---|---|---|
| The checkpoint is tuned for two YAM arms | The card identifies the intended bimanual configuration. | That it works unchanged on other robots. |
| The output uses blocks of 24 steps at 15 Hz | The specification of the published policy. | That a complete task ends successfully. |
| Weights in bfloat16 of 54.4 GB | The published size of the weights. | The total memory needed during inference. |
| Results attributed to a DROID policy | Context about another variant and another setup. | A score for Praxis-1 YAM. |
| Weights available for evaluation | Possibility to deploy and study the checkpoint. | Independent replication or safety validation. |
Execution requirements, license, and NVFP4 option
The official card indicates that Praxis-1 YAM inference in bfloat16 requires an 80 GB GPU. The weights occupy 54.4 GB, but the size of the weights is not the total memory requirement: the process may need additional space for activations, caches, and other operations. An 80 GB card is the published reference requirement, not a promise that any installation will work without adjustments.
The YAM checkpoint and reference code are distributed under the Apache 2.0 license according to the model card. Wan2.2 VAE and Qwen3.5-2B are distributed separately and have their own licenses. Before integrating the model into a product or service, one must review the conditions of each dependency and the obligations applicable to the specific form of distribution.
The Praxis-1 YAM NVFP4 variant has a separate card. According to that card, it is based on the YAM checkpoint and underwent 5,000 additional steps of training with quantization-aware training on the routed expert layers. The other parts—including shared experts, routers, and the action expert—remain in bfloat16. Therefore, it is not a four-bit version of all weights.
The NVFP4 card reports that the routed experts are packed at load time and that the policy memory goes from 54.4 GB to 17.5 GB. However, the downloaded file still occupies 54.4 GB. The card limits the NVFP4 execution mode to SM120 GPUs, such as RTX 5090 and RTX PRO 6000 Blackwell, and qualifies it as experimental. The memory reduction does not prove that the variant maintains the same performance or is suitable for physical control.
The catalog does not show a verified hosted API price for this checkpoint. Self-execution requires infrastructure; the cost will depend on the equipment, energy, usage time, and integration work. The rate of an external service, if it were to be offered, cannot be inferred from the model size or the license.
Choice between bfloat16 and NVFP4
| Option | Published data | When to consider it | Relevant limit |
|---|---|---|---|
| Reference bfloat16 | 54.4 GB of weights; one 80 GB GPU for inference | When the reference configuration is available and the checkpoint is to be evaluated as specified. | The weight size does not include all execution memory. |
| NVFP4 for routed experts | 17.5 GB of policy memory when loading packed experts; the file is still 54.4 GB | When compatible hardware is available and an experimental path is accepted for evaluation. | The card limits the mode to SM120 and does not establish result equivalence with bfloat16. |
| Hosted service | There is no verified rate for this checkpoint in the catalog. | Only if it is confirmed that a service applicable to the required market and configuration exists. | Availability or price should not be assumed from the model license. |
Limits, safety, and evaluation alternatives
The checkpoint card describes a policy for a specific two-arm and three-camera configuration. It does not certify compatibility with other effectors, cameras, or controllers. A change in the robot can alter scales, joint limits, spatial references, and response times; the team integrating the system must check these elements before performing physical movements.
The use of a generative policy on a robot requires external controls. An operator can limit the workspace, speed, and force, verify actions before executing them, and maintain an independent emergency stop. These measures are prudent deployment criteria; they do not turn the model into a safe system by themselves nor replace an evaluation of the complete robot.
Two-arm tasks can fail for different reasons: an object may be out of view, a gripper may not hold it, one arm may interfere with the other, or the instruction may be ambiguous. The YAM card does not quantify these failures. It is advisable to record them by category rather than reducing each evaluation to a single success rate.
Comparison with an alternative policy must start with the task. If the problem requires single-arm control, a DROID checkpoint is not automatically an equivalent substitute: the physical configuration and visual distribution change. If a different robot is needed, Praxis-1 YAM is not a ready-to-use option; a compatible variant must be identified or an adaptation prepared and measured.
For a team without an 80 GB GPU, the NVFP4 option may be relevant only if the hardware matches the published requirements and its experimental condition is accepted. Before connecting it to a robot, one should measure the maximum memory, compare outputs with bfloat16 on representative tasks, and perform controlled trials with movement limits. A memory measurement, by itself, does not demonstrate functional equivalence.
The adoption decision must distinguish four questions: if the robot matches the YAM setup; if the infrastructure can run the chosen variant; if the policy passes its own repeatable evaluation; and if the dependencies and licenses are compatible with the intended use. The availability of weights resolves access to the model, not those four decisions.
Process to decide whether to test the checkpoint
- 01Confirm that the robot uses a bimanual configuration compatible with the checkpoint and that its cameras produce the expected views.
- 02Verify GPU memory and dependencies for the chosen variant; separate the weight download from the maximum execution memory.
- 03Check the interpretation of the 20 action dimensions, the coordinates of each arm, and the control frequency before enabling movements.
- 04Define tasks, repeated attempts, and success criteria; record interventions, collisions, wrong objects, and placement failures.
- 05Start in a controlled environment with movement limits and an independent stop; compare variants only with the same robot and protocol.
- 06Review the licenses of the checkpoint and of Wan2.2 VAE and Qwen3.5-2B for the specific use.
Keep exploring
Sources consulted
Corrections and transparency
If you spot incorrect or outdated information, send us a correction with the page and source we should review.
Submit a correction