A robot on a factory floor has to see a scene, predict how it will change, and decide its next move faster than a round-trip to a cloud GPU allows. That loop is what NVIDIA built Cosmos 3 Edge for: it is the first world model in the Cosmos family shrunk to 4 billion parameters so it can run on the machine itself, not in a data center. It is useful for on-device robot loops on Jetson-class hardware, but as the numbers below show, it is not a drop-in replacement for the larger Cosmos models when you need maximum quality.
What Cosmos 3 Edge is
Cosmos 3 Edge is a 4-billion-parameter open "world model": a model that learns how the physical world behaves so it can reason about motion, causality, and the consequences of an action. NVIDIA released it on July 20, 2026 in its Hugging Face Cosmos 3 repository.
It takes in vision, text, and audio (plus images, video, and action trajectories) and produces three kinds of output: reasoning tokens, video, and action tokens. In plain terms, one model watches a scene, works out what is happening, and emits the motor actions a robot should take next, collapsing the "see, reason, act" pipeline that usually spans several separate systems.
The distinction from its siblings is where it runs. Cosmos 3 Super and Nano, released with the family at GTC Taipei on May 31, 2026, target workstations and data centers. Edge is the variant built to run on the robot, the vehicle, or the industrial camera itself. The launch also widened NVIDIA's Cosmos Coalition, with Japanese robotics and manufacturing firms including Fanuc, Kawasaki Heavy Industries, Yaskawa, Sony, and SoftBank signed on to build on the platform.
The on-device numbers, and what they mean for a robot
NVIDIA quotes three headline figures for Edge on a Jetson Thor module. Each one translates into a concrete engineering constraint:
- 15 Hz real-time control. The model closes a full perception-to-action loop about every 67 milliseconds. That is fast enough for continuous closed-loop robot control such as steady manipulation and navigation, though below the rates you would want for high-speed dynamic maneuvers.
- 32 actions per inference. A single forward pass emits a short *sequence* of actions, not one step. The robot gets a planned motion chunk to execute while the next inference runs, which is what keeps a 15 Hz loop smooth instead of jerky. The trade-off is responsiveness: a controller that cannot interrupt a chunk will react late to a surprise, so action chunking pairs best with receding-horizon replanning.
- 640×360 observations. That is the resolution the model reasons over on-device. It is enough to track objects and predict trajectories, and it is a deliberate trade to fit the compute budget. Fine-grained visual inspection is not what this resolution is for.
Latency on bigger hardware fills in the rest of the picture. On a single H100, Edge returns a robot policy (a DROID action) in 1.25 seconds and runs forward and inverse dynamics (predicting the next world state, or inferring the action between two states) in about 3.6 seconds each. Full image-to-video generation is the heavy operation at 23.92 seconds, which tells you where the model is cheap (action and dynamics) and where it is expensive (generation).
How a 4B model both reasons and acts
Fitting understanding *and* generation into 4 billion parameters comes from the architecture. Edge runs two transformer towers that share their multimodal attention layers: an autoregressive tower that handles reasoning and understanding by predicting the next token, and a diffusion tower that handles generation by iteratively denoising. Because they share attention, the model can ground what it generates in what it has reasoned about, doing "see, then act" in a single network rather than a chain of handoffs.
Edge differs from its siblings in one more way. Cosmos 3 Nano and Super are built on pretrained Qwen3-VL weights; Edge is a dense model trained from scratch for the edge case. That focus is why a 4B model competes in its class here instead of reading as a naive down-scaling of a bigger one.
Edge vs Nano vs Super: which Cosmos 3 to run
The three variants are not tiers of the same thing you pick by budget; they are matched to *where the model physically runs*. Decide the hardware first, then the variant follows.
| Variant | Parameters | Composition | Target hardware | Best for |
|---|---|---|---|---|
| Edge | 4B | Dense, trained from scratch | Jetson (incl. new T2000 / T3000), Jetson Thor, GeForce RTX, DGX | On-device, real-time robot loops |
| Nano | 16B | 8B reasoner + 8B generator (Qwen3-VL) | RTX PRO 6000 workstation | Workstation-grade real-time inference |
| Super | 64B | 32B reasoner + 32B generator (Qwen3-VL) | Hopper / Blackwell data center | Maximum quality, offline generation |
Beyond the table, the trade-off that decides most projects is capacity versus latency. Edge is the only variant that fits on the robot, but its single dense stack has to timeshare reasoning and generation; Nano and Super split those into separate reasoner and generator halves, which is why they scale quality further and why they need workstation or data-center GPUs to do it. Rule out Edge when the task hinges on fine visual detail, high-speed control, or top-fidelity video.
Benchmarks, in context
Among models of a similar 4B size, Cosmos 3 Edge ranks #1 on VANTAGE-Bench for vision analytics and is state of the art for robot policy learning, the two jobs it targets. For generation it produces image-to-video at 480p and 24 fps with competitive quality on the PAIBench and RBench suites, which suits synthetic-data and preview generation rather than competing with dedicated video models.
That fits the wider family. Across the Cosmos 3 lineup, NVIDIA reports #1 open-model rankings on seven physical-AI leaderboards, spanning reasoning (Robotics, Smart Space, and Driving averages) and generation (R-Bench, Artificial Analysis, RoboLab, and RoboArena). These are vendor-reported results, so read them as "strongest in its size class for on-device perception and control," not as the strongest Cosmos model overall.
Where Cosmos 3 Edge falls short
Small-and-on-device is a set of trade-offs, and they are worth naming before you commit:
- Resolution ceiling. 640×360 observations are fine for trajectory prediction but limiting for tasks that hinge on fine visual detail, such as small-defect inspection.
- Capacity ceiling. 4B parameters cap how much long-horizon reasoning and high-fidelity generation the model can do. When quality matters more than latency, Nano or Super are the right call.
- Adaptation is expected, not optional. NVIDIA documents customizing the base model for a specific robot, sensor set, or environment in about a day on a small H100 or DGX Station cluster. That is fast, but it also signals that out-of-the-box behavior in an unfamiliar, unstructured setting usually needs tuning first.
- Generation is a secondary skill. The model can generate video, but that is not where its edge is; treat it as a perception-and-action model that can also generate, not a generation model.
How to get it running
The weights are public at huggingface.co/nvidia/Cosmos3-Edge, released under the OpenMDW 1.1 license, an open model-weights license that permits commercial use and fine-tuning. (Some early write-ups called it Apache 2.0; the model card lists OpenMDW 1.1, so check the license text for its attribution and distribution terms before you ship.)
For deployment, NVIDIA points at optimizing the checkpoints with open inference frameworks such as vLLM, alongside its own NIM microservices, and ONNX export for pushing the model onto Jetson hardware. The broader family also ships a Cosmos3OmniPipeline in Hugging Face Diffusers. A realistic path for a robotics team is: download from Hugging Face, fine-tune on your own task data for roughly a day (per NVIDIA's guidance), then export and deploy to the on-device target.
The same weights run across a broad hardware range: Jetson modules including the new T2000 and T3000, Jetson Thor, GeForce RTX and RTX PRO GPUs, and DGX systems, so the same model can move from a developer's desktop to the deployed machine without a rewrite.
FAQ
Is Cosmos 3 Edge open source?
The weights are openly downloadable under the OpenMDW 1.1 license, which allows commercial use and fine-tuning. That makes it "open weights" you can run and adapt yourself, rather than an API-only release; the training code and data are a separate question the license text spells out.
What hardware does Cosmos 3 Edge need?
It is built to run on-device on NVIDIA Jetson modules (including the newly announced T2000 and T3000) and Jetson Thor, and it also runs on GeForce RTX and RTX PRO GPUs and DGX systems. The 15 Hz control figure is quoted specifically on Jetson Thor, so expect lower rates on smaller Jetson modules.
When was Cosmos 3 Edge released?
Cosmos 3 Edge launched on July 20, 2026, added to the Cosmos 3 family that first debuted at GTC Taipei on May 31, 2026.
Cosmos 3 Edge or Nano: which should I use?
Pick by where the model runs. If it has to run on the robot or camera itself, use Edge (4B). If it runs on a workstation next to the machine, Nano (16B) buys more quality for the extra compute.