Nvidia's Cosmos 3 Edge scores 22.9% and never leaves the robot

Nvidia has published a recipe for turning Cosmos 3 Edge, a 4-billion-parameter world model, into a robot manipulation policy that runs entirely on a Jetson Thor with no server GPU in the loop. In closed-loop testing on the RoboLab benchmark, the post-trained policy completes 22.9% of tasks. Nvidia's own larger Cosmos 3 Nano reaches 36.8% on the same benchmark. The company is shipping the weaker number on purpose: with Edge the claim is about where the model runs, not how often it succeeds.

Cosmos 3 Edge is a general model of 4 billion parameters paired with a 2-billion-parameter Nvidia Nemotron reasoning module. It belongs to the Cosmos 3 family and was pretrained on the same physical-world data as Cosmos 3 Nano and Cosmos 3 Super, so it arrives already carrying patterns of how objects move, fall, slide and respond to contact. That inheritance is the entire argument for the approach: a policy built on top of it does not have to rediscover physics from the examples of one task.

Moving a world model onto a real machine normally breaks on two constraints — the model has to fit in the robot's memory, and it has to emit commands fast enough to keep the arm moving. The post-training recipe addresses both. On a Jetson AGX Thor T5000 the DROID policy produces each action chunk in about 1.53 seconds at 640×540 and 15 Hz, and one chunk covers roughly 2.13 seconds of arm motion. The next chunk is ready before the current one runs out, so the manipulator moves continuously with nothing offboard.

That margin is six tenths of a second, and it defines what "real-time" means here. The model stays ahead of the arm, but the arm commits to about two seconds of plan at a time — Nvidia states plainly that replanning does not happen after every observation. Uninterrupted, not reactive.

The policy is served over the OpenPI WebSocket protocol, the same one used across the DROID policy ecosystem: a client sends a dictionary of observations, the server returns an action chunk. For Edge the server runs on the Thor itself with host="localhost", so requests never leave the robot. BF16 weights take about 9 GB, which fits Thor's onboard memory alongside both the policy server and the control program. The policy is state-aware — joint_position and gripper_position are genuine model inputs, not form fields — and the replanning loop feeds back fresh camera images and measured joint and gripper positions each cycle, so each new plan starts from where the arm actually is rather than where the previous chunk assumed it would be. Start the server with video decoding enabled and it returns the model's own predicted rollout alongside the actions, which is the cheapest way to see what Cosmos thinks it is doing.

The training side is where the word "edge" gets complicated. This is post-training of a base model, not a single-GPU fine-tune. The validated run used 64 nodes with four GB200s each, 60,000 iterations and roughly 68 hours of wall clock — about 17,400 GB200-hours. The policy that comes out runs on one embedded module bolted to a robot; producing it takes a data center. Nvidia has put the finished checkpoint on Hugging Face and the pipeline in the open cosmos-framework repository, which tells you which side of that line most teams will be on.

The recipe itself is four steps. In the original launcher it is registered for Cosmos 3 Nano; three changes are needed before training Edge, and everything else — dataset, action space, selection filter, training schedule — stays as it is. Full instructions, including checkpoint conversion, environment setup and selection filter configuration, sit in the DROID post-training reproduction guide and the model card, both of which track the repository.

The training data is nvidia/Cosmos3-DROID: 76,000 successful teleoperation trajectories, roughly 350 hours across 86 tasks and 564 scenes, collected on a Franka Panda arm with a Robotiq gripper and shipped as LeRobotDataset v3.0 at 640×360. Preparation runs in three stages into LeRobot Dataset v3, carrying per-frame camera video, joint states, gripper state, actions and the task instruction. For a DROID-like Franka setup the only change is the dataset path; a different robot needs its own experiment configuration covering action space, dimensionality, camera placement and normalization. Cosmos 3 supports bimanual Franka, UR, WidowX 250 and LeRobot SO101 among others, with the complete list on the Cosmos 3 Edge model card.

Evaluation runs in RoboLab, an open benchmark built on Isaac Lab-Arena that backs the RoboLab leaderboard. Its client connects to the same policy server, executes each action chunk in physics simulation and hands back new visual observations, closing the loop across 120 manipulation tasks specified in natural language. Swapping the --task argument moves through the set; each run writes video from the simulation window and the robot camera plus a success log, so both the outcome and the trajectory that produced it are inspectable. Nvidia recommends simulating before touching a physical arm, on the sound reasoning that an untested policy has a body. Isaac Sim 5.x requires Nvidia RTX server driver 580 or newer.

Nvidia frames 22.9% against Nano's 36.8% as a deliberate choice of balance: autonomous real-time operation fully on the robot, at lower inference cost. As engineering that is honest. As a product claim it is thin. A policy that fails roughly four attempts in five across 120 tasks is a research checkpoint, and the deployments that eventually matter will not be the ones willing to live with that rate. The more interesting gap is on the other side of the trade. The announcement gives latency and memory figures for Edge and no comparable figures for Nano, so there is no way to judge whether the 13.9-point deficit in success rate bought a large saving in compute and latency or a small one. The trade-off is asserted, not priced.

The same post-training methods point somewhere other than on-device control, and that direction may be the more durable one. Developers can build specialized world models that generate synthetic training data tuned to a particular environment, indoors or outdoors. Aigen fine-tuned Cosmos to produce varied crops and weeds, and its autonomous weeding system reached high effectiveness while training on just 1% real data. The Cosmos weights are open and the software platform is licensed under OpenMDW1.1, which is what makes that kind of derivative work possible in the first place.

That 1% is the sharpest number in the whole package. A policy that succeeds 22.9% of the time on a benchmark is a demonstration; a pipeline that removes 99% of the field data collection a customer would otherwise pay for is a line item on someone's budget. If Cosmos becomes permanent infrastructure in robotics, the evidence here points to it living upstream of the policy rather than inside it — which is a quieter business than an on-device brain, and one that runs on the servers Nvidia is already selling.