NVIDIA Cosmos 3 Nano Explained: Four Open World Models That Let Robots and Self-Driving Cars Practise in Simulation

Training a robot used to mean buying the robot, building the room, and breaking a few things. Training a self-driving car used to mean putting it on real roads and hoping the rare, dangerous moments showed up before a customer did. NVIDIA Cosmos 3 Nano is NVIDIA’s answer to that problem: four open-weight world models that generate the world a robot or a car needs to practise in, frame by frame, from a text prompt and a set of scene controls.

On 5 November 2026, NVIDIA released four new post-trained checkpoints built on NVIDIA Cosmos 3 Nano, each with 16 billion trainable parameters and all of them under the OpenMDW 1.1 licence, which NVIDIA says permits both commercial and non-commercial use. Two of them serve autonomous driving. Two serve robotics. All four ship with the full post-training recipe, so a team can adapt the models to its own cameras, sensors and robots instead of treating them as a black box.

This guide explains what NVIDIA Cosmos 3 Nano actually is, what each of the four checkpoints does, the hardware you need to run them, how the four-stage training recipe works, and — just as importantly — what the models cannot yet prove. Every capability claim that comes from NVIDIA is labelled as NVIDIA’s own, because no independent team has yet measured these checkpoints on real robotics or driving workloads.

NVIDIA Cosmos 3 Nano training a humanoid warehouse robot in simulation before real-world deployment

Table of Contents

What Is NVIDIA Cosmos 3 Nano?

NVIDIA Cosmos 3 Nano is the smallest open-weight model in NVIDIA’s Cosmos 3 family of world models for physical AI. A world model is an AI system that predicts what happens next in a physical scene: given what a camera sees now, what a robot does next, or how a road is laid out, it generates the video, depth or sensor readings that would follow. Where a chatbot predicts the next word, a world model predicts the next frame — and the frame after that, and the one after that.

The Cosmos 3 family was launched on 31 May 2026 at GTC Taipei as an open frontier foundation model for physical AI. It is built on what NVIDIA calls a Mixture-of-Transformers architecture: two transformer towers, a reasoner and a generator, that work together in a single forward pass. The family handles text, images, video, audio and actions in one shared representation, which is what lets the same base model understand a scene, generate a video of it, and predict what a robot’s action will do to it. Axios reported that NVIDIA trained Cosmos 3 on 20 trillion multimodal tokens, including nearly one billion images and 400 million real and synthetic videos.

NVIDIA Cosmos 3 Nano sits at the practical end of that family. It has 16 billion parameters in total — an 8-billion-parameter reasoner tower and an 8-billion-parameter generator tower — and NVIDIA positions it for workstation-grade hardware, specifically cards like the RTX PRO 6000. Its bigger sibling, Cosmos 3 Super, is a 64-billion-parameter model aimed at datacentre Hopper and Blackwell GPUs. A third size, Cosmos 3 Edge, is a 4-billion-parameter model for on-device inference that arrived on 20 July 2026. The four checkpoints released on 5 November are all post-trained versions of the Nano base model, not a new family and not a new model size.

That distinction matters. If you read that “NVIDIA released Cosmos 3 Nano” this week, you are reading a shorthand. The base model has existed since May. What is new is four specialised, openly licensed NVIDIA Cosmos 3 Nano checkpoints that turn the general-purpose Nano model into working tools for two concrete jobs: generating synthetic driving data and simulating robot behaviour. NVIDIA also published the training recipe for each one, the inference code, and agent-runnable skills that let a coding agent run the whole pipeline.

Why does any of this matter outside NVIDIA’s research labs? Because physical AI has a data problem that chatbots never had. A language model can train on the internet. A robot cannot. Every hour of robot training data has to be collected by a physical machine in a physical place, and the rare events — a child running into the road, a box slipping off a shelf, a gripper losing its hold — are exactly the events you cannot safely stage on demand.

A world model like NVIDIA Cosmos 3 Nano promises to generate those moments instead: the same road layout in rain, at night, with different traffic, so a driving policy can be tested against conditions it has never driven through. The promise is real. Whether the generated scenes are faithful enough to train on is the open question this article keeps coming back to.

What Happened on 5 November 2026

On 5 November 2026, NVIDIA published four open-weight checkpoints on Hugging Face, announced through the Hugging Face blog with a companion technical post on NVIDIA’s developer blog three days earlier, on 2 November. The four NVIDIA Cosmos 3 Nano checkpoints are:

  • Cosmos3-Nano-Transfer-Auto — generates multi-view driving data with varied weather, lighting and time of day.
  • Cosmos3-Nano-Sim-Auto — streams synchronised camera and LiDAR observations for driving simulation.
  • Cosmos3-Nano-Sim-Transfer — turns simulator controls and a text prompt into photorealistic video.
  • Cosmos3-Nano-Sim-Bimanual — predicts video from robot or camera actions.

All four are post-trained versions of Cosmos 3 Nano with 16 billion trainable parameters, and all four use the OpenMDW 1.1 licence. NVIDIA says the licence permits commercial and non-commercial use under its terms, but the full licence text is not reproduced in the announcement, so any team planning production use should read the actual licence terms before relying on that summary.

That is not a warning about a hidden catch — it is the normal caution that applies to every open-weight release, and it is worth stating plainly because “open weights” and “free for any use” are not the same thing.

The release also included the four-stage post-training recipe for each checkpoint, inference notebooks, a technical report, and agent-runnable skills in the Cosmos Framework GitHub repository — one skill folder per checkpoint. The idea is that a robotics or autonomous-vehicle team points a coding agent at the skill and its own dataset, and the agent runs the adaptation pipeline. NVIDIA also scheduled a Cosmos Labs livestream for 5 November to walk through the framework; the replay is posted on YouTube for teams evaluating whether to adopt it.

Two things did not arrive with this release. First, the larger Cosmos3-Super and smaller Cosmos3-Edge variants have no new open checkpoints in this drop — the GPU memory table in NVIDIA’s technical post lists them, but the four checkpoints are all Nano.

Second, NVIDIA has not released evaluation code or independent error bars for these checkpoints, and no outside team has independently measured their visual quality or their usefulness for policy training. The announcement itself says more work is needed to measure where the models faithfully support policy learning and evaluation, and to understand their limits. That honesty is a strength of the release, and this guide treats it as a fact to plan around, not a footnote to skip.

The timing places NVIDIA Cosmos 3 Nano inside a busy week for physical AI. NVIDIA unveiled GR00T 2, an open robot foundation model, on 9 November at the Conference on Robot Learning in Austin, Texas, and Google DeepMind announced Gemini Robotics 2.5 on 10 November. The November 5 checkpoints are the simulation half of that story: GR00T-style action models need somewhere to practise, and world models are where the practising happens.

The Four NVIDIA Cosmos 3 Nano Checkpoints, Explained

The four NVIDIA Cosmos 3 Nano checkpoints split cleanly into two families. The two autonomous-vehicle checkpoints take a text prompt plus World Scenario Map controls — lanes, objects, road markings, traffic signs and road boundaries — so a team can vary road layouts and signal states and watch how a driving policy reacts. The two robotics checkpoints turn simulator controls, or robot and camera actions, directly into predicted video, which helps answer whether a policy still works once the scene or the viewpoint changes.

Within each pair, one checkpoint works offline and one works in a loop. Transfer-Auto generates complete driving clips in a batch; Sim-Auto streams them chunk by chunk as a policy drives. Sim-Transfer renders what a physics simulator computes; Sim-Bimanual skips the simulator entirely and predicts the next observation straight from the robot’s actions. Understanding that split is the fastest way to pick the right checkpoint, so each one gets its own section below.

Cosmos3-Nano-Transfer-Auto: Driving Data on Demand

Cosmos3-Nano-Transfer-Auto is the offline workhorse of the release. It is a bidirectional model for synthetic driving-data generation: it denoises an entire multi-view clip at once, which gives it the consistency that batch generation needs. It produces synchronised video across up to 11 camera views, including fisheye lenses, and supports joint RGB and LiDAR generation, so the pictures and the point cloud agree with each other about where things are.

The controls are what make it useful rather than merely impressive. Per-camera World Scenario Map controls specify scene structure and traffic motion, while text prompts guide appearance. Developers can vary weather, lighting and time of day to expand training and evaluation coverage, with optional initial RGB images to anchor the scene’s appearance. Joint LiDAR generation additionally uses aligned HD-map range-map controls. Change the prompt and the same road layout, with the same vehicle trajectories, becomes a rainy night drive instead of a sunny afternoon one — the geometry stays, the conditions change.

The practical numbers, from NVIDIA’s technical post: Transfer-Auto supports 30-frames-per-second input and output video, with up to 400 frames at 480p or 720p, and longer sequences can be generated through autoregressive chunking. The published reference run, on four GPUs, produces seven 720p videos of 297 frames each at 30 frames per second, plus 99 LiDAR sweeps. That is a usable batch of training data from a single run, not a demo clip.

Transfer-Auto also serves as the foundation for adapting NVIDIA Cosmos 3 Nano to your own sensor rig and driving domain. NVIDIA’s own guidance is to start by post-training it on your data to accommodate your camera layout, LiDAR configuration and target environment. The adapted model can then be used directly for offline data generation, or put through causal training and few-step distillation for fast streaming simulation — which is exactly the development path NVIDIA used to create Sim-Auto. In other words, Transfer-Auto is both a tool and a starting point: use it as it ships, or retrain it into something shaped like your fleet.

NVIDIA Cosmos 3 Nano generating multi-view driving video and LiDAR from a self-driving car's sensor pod

Cosmos3-Nano-Sim-Auto: Streaming Driving Simulation

Cosmos3-Nano-Sim-Auto is the causally distilled streaming variant of Transfer-Auto, and it is the checkpoint that turns a world model into a driving simulator. Instead of generating a whole clip offline, it generates successive small chunks of synchronised camera video and LiDAR in just a few denoising steps, using its generated history and updated driving controls to support fast streaming and long, interactive rollouts.

The loop works like this. A driving policy — NVIDIA’s example is its Alpamayo driving model — or a human driver sends an action to a simulation runtime. The runtime updates the scenario and forwards the new World Scenario Map controls to Sim-Auto, which synthesises the next camera frames and LiDAR sweeps and returns them to the policy, completing the loop.

Because each new chunk is conditioned on the history the model has already generated, the simulation can run for a long time without restarting, and because the controls update every chunk, the policy’s decisions actually change what it sees next. That closed loop is the difference between a video generator and a simulator.

There is a catch that NVIDIA states openly: closed-loop interaction requires a simulation runtime and a WSM renderer to update the controls from driving inputs. Sim-Auto does not include those pieces. A team adopting NVIDIA Cosmos 3 Nano needs its own runtime — NVIDIA’s reference uses its AlpaSim simulation runtime — or it needs to build one. The checkpoint is the world model, not the whole simulator. For a new sensor rig or domain, NVIDIA’s guidance is to adapt Transfer-Auto first, then distil it into Sim-Auto, rather than trying to adapt the streaming model directly.

The internal-use story NVIDIA published alongside the release shows what this looks like in practice. A separate 5 November NVIDIA blog post on agent-assisted simulation workflows describes an NVIDIA autonomous-vehicle researcher running a Cosmos3-Nano experiment that varied weather and lighting in recorded driving footage to compare how an Alpamayo driving model responded under different conditions. The experiment predates the public checkpoint release, but it points to the intended daily use: a world model inside an existing simulation pipeline, directed by an AI agent, testing a driving policy against conditions that are expensive or dangerous to collect on real roads.

Cosmos3-Nano-Sim-Transfer: Simulator Controls to Photorealistic Video

Cosmos3-Nano-Sim-Transfer answers a different question: what if you already have a good physics simulator, and what you are missing is the way the world looks? Your simulator computes motion, contacts and physical state. Sim-Transfer uses its spatial controls and a text prompt to render the colour observations that a policy can consume. The loop is simple to state and hard to build: action, simulator update, spatial controls, generated RGB video, next policy action.

The spatial controls are the NVIDIA Cosmos 3 Nano model’s real input. Depth gives relative distance from the camera. Segmentation gives regions and object boundaries. Edges give scene contours. Blur gives coarse appearance and layout. Text guides appearance while the physics and ground-truth state stay with the simulator — the model never has to guess whether two objects collided, because the simulator already knows. That division of labour is the point: the simulator owns the truth about the world, and the world model owns the way the world looks.

For robot demonstrations, Sim-Transfer can change the third-person view while retaining actions, states and wrist-camera recordings, which matters because a policy trained on one camera angle often fails when the camera moves. For driving, the same idea lets a team re-skin a simulated scene — different lighting, textures and backgrounds — while the road geometry and vehicle motion stay exactly as the simulator computed them. The result is training data that is visually varied but physically honest, which is the combination that synthetic data usually fails to deliver.

Cosmos3-Nano-Sim-Bimanual: Robot Actions to Video

Cosmos3-Nano-Sim-Bimanual goes one step further than Sim-Transfer: it predicts the next video observation directly from a robot’s actions, with no simulator in the loop at all. It simulates how an environment evolves in response to a bimanual — two-armed — robot’s actions, supporting interactive two-arm simulation for YAM and AgiBot embodiments, controlled by a policy or by human-operated joysticks.

Start with an image, move the robot or the camera, and generate the next observations. One control sequence can switch between viewpoint changes and manipulation, so the same checkpoint can show a robot reaching for an object and then show the scene from a new angle as the arm moves. The mixed-action example in NVIDIA’s announcement uses 59 control values, padded to 64 during training, and its schema defines coordinate frames, rotations, gripper calibration, validity masks and control domains. Teams using it need to follow those conventions so each value describes the intended motion — this is a checkpoint with a data contract, not a prompt box.

Timing discipline matters too. NVIDIA notes that T transitions need T+1 observations, and that training transforms raw captures into the model’s action representation while the released inference actions are already normalised. Those details sound dry, but they are the difference between a model that predicts a plausible next frame and one that drifts into nonsense after a few seconds. The honest summary is that Sim-Bimanual is the most ambitious of the four checkpoints — it asks the model to do the simulator’s job as well as the renderer’s — and it is therefore the one where independent testing of NVIDIA Cosmos 3 Nano matters most before anyone trusts it for policy training.

NVIDIA Cosmos 3 Nano Sim-Bimanual predicting video from dual-arm robot actions in a laboratory

How the Four-Stage Training Recipe Works

What separates the NVIDIA Cosmos 3 Nano release from a typical model drop is that NVIDIA published the full post-training recipe alongside the weights. The recipe runs in four stages, and NVIDIA published the code for each stage as agent-runnable skills under the Cosmos Framework GitHub repository — one skill folder per checkpoint — so a team can point a coding agent at its own dataset and retrain, rather than settling for NVIDIA’s example footage.

  • Stage 0 — Bidirectional adaptation: learn the domain and its control-to-video relationships from complete recorded clips. The model sees whole sequences and learns how controls map to what appears on screen.
  • Stage 1 — Teacher forcing: predict each chunk from earlier recorded observations and available controls, with the clean answer and future targets masked out. The model learns to continue a scene it has only partly seen.
  • Stage 2 — Consistency distillation: use a frozen teacher to train a student that generates each chunk in four denoising steps. This is what makes streaming fast enough to use: four steps instead of dozens.
  • Stage 3 — Self-forcing: train on the student’s own generated history, with a frozen teacher and an auxiliary score model supplying the distribution-matching signal.

The final stage is the one that matters most for long rollouts. A slightly mispredicted object becomes context for later frames, so small errors can compound until the scene falls apart. Self-forcing exposes training to that generated history, so the model learns to recover from its own mistakes instead of only ever seeing perfect ground truth.

Distillation and caching then reduce the cost of producing each observation. NVIDIA’s guidance for teams adapting a checkpoint is practical rather than promotional: give your coding agent the skill and the dataset location, pin all revisions, validate the dataset, keep training and evaluation episodes separate, run a smoke test, save the configuration, and stop at a set number of GPU-hours. Evaluate quality on held-out episodes, and remember that a successful short run verifies execution, not convergence.

The recipe also explains why the four NVIDIA Cosmos 3 Nano checkpoints are related rather than independent. Transfer-Auto is the bidirectional base. Sim-Auto is what you get when you put Transfer-Auto through causal training and few-step distillation. The same pipeline, pointed at different data and controls, produces Sim-Transfer and Sim-Bimanual. A team that understands the recipe can therefore build a fifth checkpoint — one shaped like its own robot, its own cameras, its own warehouse — instead of waiting for NVIDIA to ship one.

What Hardware Do You Need to Run NVIDIA Cosmos 3 Nano?

Open weights are only useful if a team can actually run the model, and NVIDIA has been specific about what that takes. The requirements for the released checkpoints are Linux, an NVIDIA GPU, Docker, and the NVIDIA Container Toolkit, and the published vLLM-Omni streaming setup was tested on a single GB200. That is a test configuration, not a minimum specification — but it sets the tone. This is workstation and datacentre hardware, not a laptop project.

NVIDIA’s own GPU memory table, from the 2 November technical post, makes the picture precise. For generation — the task these four checkpoints perform — NVIDIA Cosmos 3 Nano needs 58 GiB of VRAM in BF16, dropping to 44 GiB in FP8 and 31 GiB with FP8 offloading. For reasoning, Nano needs 23.1 GiB in both BF16 and FP8.

The bigger Cosmos3-Super needs 150 GiB for generation in BF16, 93 GiB in FP8, and 38 GiB with FP8 offloading; its reasoning task needs 135 GiB in BF16 and 67 GiB in FP8. The smaller Cosmos3-Edge needs 16 GiB for reasoning in BF16 and 14.5 GiB in FP8, while its Edge-DROID generation variant needs 14 GiB.

Model Task BF16 VRAM FP8 VRAM FP8 + offloading
Cosmos3-Edge Reasoning 16 GiB 14.5 GiB —
Cosmos3-Edge-DROID Generation 14 GiB — —
NVIDIA Cosmos 3 Nano Reasoning 23.1 GiB 23.1 GiB —
NVIDIA Cosmos 3 Nano Generation 58 GiB 44 GiB 31 GiB
Cosmos3-Super Reasoning 135 GiB 67 GiB —
Cosmos3-Super Generation 150 GiB 93 GiB 38 GiB

In plain terms: a single high-end workstation GPU such as an RTX PRO 6000 can run Nano generation in FP8 with offloading, and comfortably in BF16 on cards with 96 GiB or more. A GB200 handles the published streaming setup. A consumer gaming card with 16 or 24 GiB of VRAM will not run these checkpoints at full quality — quantisation and offloading can stretch further, but NVIDIA has not published a consumer-GPU configuration, so anyone promising one is guessing. The checkpoints run on Hugging Face Diffusers, PyTorch, SGLang, vLLM, vLLM-Omni, TRT-LLM and TRT-Edge-LLM, which keeps a team’s choice of serving stack separate from its choice of training recipe.

For teams that would rather buy serving than build it, NVIDIA’s Cosmos NIM microservices package the NVIDIA Cosmos 3 Nano models in optimised containers.

NVIDIA reports that speculative decoding in Cosmos NIM measured roughly 2 to 3 times inference speedup on H200 GPUs, and that streaming video understanding built on the same checkpoints can cut alert latency by a factor of 10 for live camera feeds, with sub-second alerts. Those are NVIDIA’s measured figures on its own hardware, not independent benchmarks — but they show where the platform is headed: the same weights, served faster, for teams that want an API instead of a training job.

NVIDIA Cosmos 3 Nano running on workstation and datacentre GPUs with 58 GiB VRAM in BF16

The Cosmos Framework: Training, RL and Serving in One Place

The NVIDIA Cosmos 3 Nano checkpoints are one half of the release. The other half is the Cosmos Framework, the platform that trains and serves them, described in NVIDIA’s 2 November technical post. The framework is open and modular, covering world-model training, optimisation and inference across the full model-development lifecycle, and it now extends beyond Cosmos 3 to cover NVIDIA Alpamayo, GR00T, Qwen and pi0.5. That matters because it positions the tooling as shared infrastructure for robotics and autonomous-vehicle projects rather than a one-off research release.

Training through the framework supports text, images, video, audio and actions, with LoRA for parameter-efficient adaptation or full supervised fine-tuning to update every parameter. Data loads through JSONL, WebDataset, LeRobot or custom adapters, training runs across GPUs, and checkpoints save so runs can resume.

The framework also exposes reinforcement-learning paths that NVIDIA says are new in this release: offline preference optimisation (DPO), online RL with reward models and vLLM rollouts (GRPO), actor-critic RL for embodied policies in simulation (PPO), on-policy distillation from a frozen teacher (OPD), and an online RL variant built for diffusion world models (DiffusionNFT). Rollout, reward and training roles can run on shared GPUs or separate pools, and supported simulators can be connected to collect experience.

The agent angle is the part most likely to change how small teams work. The framework exposes its setup, inference, post-training and troubleshooting skills under an .agents/skills directory, and NVIDIA’s suggested workflow is to give a coding agent a bounded task: post-train a named checkpoint on a named dataset using a named recipe, pin all revisions, validate the dataset, keep training and evaluation episodes separate, run the smoke test, save the configuration, and stop at a set number of GPU-hours.

Export and compare against the base model on held-out data using three seeds. Repeat the evaluation at a supported lower precision and record quality, peak memory and latency. That is a serious workflow, not a demo prompt — and it is the clearest sign that NVIDIA expects these checkpoints to be adapted, not just downloaded.

The framework also reaches beyond driving and warehouse robots. The same technical post describes surgical simulation: Cosmos3-H-Embodied-Nano, built on Cosmos 3 and post-trained on Open-H-Embodiment, generates surgical video from robot actions, predicts actions from video, or generates both together, taking an initial RGB frame, a task prompt, the last 16 executed actions and subsequent robot actions. Its distilled sibling, Cosmos3-H-Dreams, generates frames from live robot kinematics for real-time, closed-loop simulation controlled by a human or a learned policy.

Those two surgical models were published on 20 October 2026, before the four Nano checkpoints, and they show the same idea applied to the hardest simulation problem of all: tissue that deforms, bleeds and moves in ways no physics engine models well.

What NVIDIA Cosmos 3 Nano Is Not (Yet)

The most useful thing about the NVIDIA Cosmos 3 Nano release is how plainly NVIDIA states its limits, and the most useful thing a reader can do is take those limits seriously. Here is what the release does not prove, does not include, and does not promise.

No independent evaluation exists yet. No team outside NVIDIA has independently measured the visual quality of these NVIDIA Cosmos 3 Nano checkpoints, their faithfulness for policy learning, or their error rates on real robotics and driving workloads. NVIDIA says plainly that more work is needed to measure where the models faithfully support policy learning and evaluation. Until outside teams publish their own post-trained checkpoints and their own evaluation numbers, every claim about usefulness is NVIDIA’s claim, not a measured fact.

Simulated scenes can teach the wrong behaviour. This is the sim-to-real gap, and it is the central risk of the whole approach. A driving policy trained on generated rain may learn to trust generated rain — which behaves like NVIDIA’s model thinks rain behaves, not like real rain behaves. A robot policy trained on generated grasps may learn grips that work in generated video and fail on a real object.

More generated data is not automatically better training data. The honest use of a world model is to expand coverage of conditions you cannot collect, and then to validate the trained policy on real hardware before trusting it. Any team that skips the validation step is not saving time; it is moving the failure from the simulator to the street.

It is not a simulator by itself. Sim-Auto needs a simulation runtime and a World Scenario Map renderer. Sim-Transfer needs a physics simulator. Sim-Bimanual needs a data contract and an action schema. The checkpoints are components, and a team adopting them still needs the surrounding pipeline — or it needs to build one. The agent-runnable skills lower that bar, but they do not remove it.

It is not cheap to run or to adapt. Generation needs 58 GiB of VRAM in BF16, and the reference runs use four GPUs. Post-training an NVIDIA Cosmos 3 Nano checkpoint on your own data is a GPU job measured in GPU-hours, and NVIDIA’s own guidance tells teams to cap it. The weights are free; the compute is not. A small team should budget for that before downloading anything.

It is not the whole Cosmos 3 family. The four checkpoints are all Nano. Cosmos3-Super and Cosmos3-Edge appear in the memory table but have no new open checkpoints in this release, and whether they follow the same Nano-first pattern is still to be watched. The Cosmos Labs livestream replay and the coming weeks of community adoption — whether outside teams actually publish their own post-trained checkpoints — are the clearest signal of whether this release gets used or merely downloaded once.

NVIDIA Cosmos 3 Nano vs Super vs Edge

The three Cosmos 3 sizes are built for different jobs, and the November 5 release only touches one of them. Here is how they compare, using NVIDIA’s published figures.

Model Parameters Built for Generation VRAM (BF16) Status
Cosmos3-Edge 4B total On-device, real-time inference 14 GiB (Edge-DROID) Released 20 July 2026
NVIDIA Cosmos 3 Nano 16B total (8B reasoner + 8B generator) Workstation GPUs, real-time robotics 58 GiB Released 31 May 2026; four new checkpoints 5 Nov 2026
Cosmos3-Super 64B total (32B reasoner + 32B generator) Datacentre Hopper and Blackwell GPUs, large-scale synthetic data 150 GiB Released 31 May 2026; no new checkpoints in this drop

The practical reading is simple. Edge is for the device. Nano is for the lab workstation and the robot that needs answers now. Super is for the datacentre job that generates training data at scale. A team choosing between them is really choosing between latency, quality and hardware budget — and for most robotics and AV teams, Nano is the size that fits the hardware they already own. That is why NVIDIA post-trained Nano first, and why the four checkpoints matter more than a Super release would have.

NVIDIA also announced the Cosmos Coalition alongside the Cosmos 3 launch, with founding members Agile Robots, Black Forest Labs, Generalist, LTX, Runway and Skild AI, focused on sharing evaluation techniques, training data and research around open world models. If that coalition produces shared evaluation standards, the “no independent measurement” gap above starts to close — and that is worth watching as closely as any new checkpoint.

Who Should Use NVIDIA Cosmos 3 Nano — and Who Should Skip It

Use it if you are: a robotics team with a two-armed manipulation problem and a GPU workstation, an autonomous-vehicle team that needs synthetic driving data across weather and lighting conditions your fleet has not collected, a simulation engineer whose physics simulator is good but whose rendered scenes look nothing like the real world, or a researcher studying world models who wants the training recipe rather than just the weights. In each case the value is the same: the checkpoints are a starting point you can adapt, not a finished product you install.

Skip it — for now — if you are: a hobbyist with a consumer GPU, a team with no simulation runtime and no plan to build one, or anyone who needs a driving or manipulation policy that works on real hardware this month. The checkpoints will not run well on 16 or 24 GiB of VRAM, they will not replace a simulator you do not have, and they have not yet been independently shown to produce policies that transfer to the real world. None of that is a criticism of the release. It is a statement about where the release sits on the road from research to production — and that road still has several miles on it.

For the site’s regular readers, the closest comparisons on Tool Minds AI are the site’s earlier NVIDIA coverage — the NVIDIA Nemotron Transcribe guide for another open NVIDIA model with a practical deployment story, and the LingBot VLA 2.0 explainer for the vision-language-action side of the same robotics stack. The best AI video generator roundup is the consumer-side contrast: those tools generate video for people to watch, while NVIDIA Cosmos 3 Nano generates video for machines to learn from.

How to Get Started with NVIDIA Cosmos 3 Nano

If the hardware and the caveats above have not put you off, the path from download to first generated scene is deliberately short. NVIDIA’s own documentation lays it out as a sequence, and it is worth following in order rather than skipping to the interesting part.

  1. Check the hardware first. Confirm you have Linux, an NVIDIA GPU with at least 31 GiB of free VRAM for FP8 generation with offloading — 58 GiB for BF16 — plus Docker and the NVIDIA Container Toolkit. The published streaming setup was tested on a single GB200; treat that as the reference, not the minimum.
  2. Download the NVIDIA Cosmos 3 Nano checkpoints from Hugging Face. The four model pages are Cosmos3-Nano-Transfer-Auto, Cosmos3-Nano-Sim-Auto, Cosmos3-Nano-Sim-Transfer and Cosmos3-Nano-Sim-Bimanual, all under NVIDIA’s Hugging Face organisation. Read the OpenMDW 1.1 licence terms on the model page before using the weights commercially.
  3. Run the reference inference first. Each checkpoint ships with an agent-runnable skill and a notebook in the Cosmos Framework repository. Run the published sample — for Transfer-Auto, the four-GPU reference produces seven 720p videos and 99 LiDAR sweeps — and check the outputs before touching your own data. If the reference run fails, fix the environment before going further.
  4. Pick one checkpoint, not four. If you need offline driving data, start with Transfer-Auto. If you need a closed-loop driving simulator, start with Sim-Auto and confirm you have a simulation runtime and a WSM renderer. If your physics simulator is solid but its rendering is not, start with Sim-Transfer. If you need two-arm manipulation without a simulator, start with Sim-Bimanual and read its data contract and action schema first.
  5. Adapt on your own data — in a bounded run. Give your coding agent the skill and the dataset location, pin all revisions, validate the dataset, and keep training and evaluation episodes separate. Cap the run at a set number of GPU-hours, save the configuration, and evaluate on held-out episodes with three seeds. A successful short run verifies execution, not convergence.
  6. Validate on real hardware before trusting it. A policy trained in generated worlds should be tested on the real robot or the real vehicle, in the real conditions, before it is trusted with anything that matters. That is the step the whole release is building toward — and the step no checkpoint can do for you.

NVIDIA Cosmos 3 Nano predicting what a robot hand will do next in simulation

NVIDIA Cosmos 3 Nano vs the Alternatives

World models are not the only way to train a robot or a car, and NVIDIA Cosmos 3 Nano is not the only world model. The alternatives each solve a different part of the problem, and the honest comparison is about what each one owns.

Classical simulators such as NVIDIA’s own Isaac Sim or the open-source CARLA driving simulator own physics: they compute contacts, collisions and vehicle dynamics exactly, but their rendered scenes look like a video game, and policies trained in them often fail when the real world looks different. Sim-Transfer is built to sit on top of those simulators, not replace them — it takes their physics and re-renders the visuals. In that sense it is a complement, not a competitor.

Closed world models from the big labs can generate beautiful video, but they are APIs, not weights: you cannot adapt them to your own sensor rig, you cannot run them on your own hardware, and you cannot inspect how they were trained. The open-weight release is the whole point of the November 5 drop. A team can download NVIDIA Cosmos 3 Nano, retrain it, and keep the result. That is a capability no closed video API offers, and it is the reason this release matters to robotics and AV teams even though the checkpoints are only 16 billion parameters.

Within NVIDIA’s own stack, the comparison that matters is with GR00T, NVIDIA’s robot-action model family. GR00T 2, unveiled on 9 November 2026, learns manipulation skills from human first-person video and outputs robot actions.

NVIDIA Cosmos 3 Nano does the other half of the job: it predicts what the world will look like after those actions. A GR00T policy decides what to do; a Cosmos world model shows it what will happen. The two are designed to work together, and the Cosmos Framework’s support for GR00T alongside Cosmos 3 makes that pairing explicit. Neither replaces the other, and a team that confuses the two will build the wrong thing.

NVIDIA Cosmos 3 Nano: Frequently Asked Questions

Is NVIDIA Cosmos 3 Nano free to use?

The weights are open under NVIDIA’s OpenMDW 1.1 licence, which NVIDIA says permits commercial and non-commercial use under its terms. There is no published price for the checkpoints themselves. The compute to run them is not free: generation needs 58 GiB of VRAM in BF16, and the reference runs use four GPUs. Read the full licence text on the Hugging Face model page before using the weights commercially.

What is the difference between the four NVIDIA Cosmos 3 Nano checkpoints?

Transfer-Auto generates offline multi-view driving data with joint LiDAR. Sim-Auto streams driving observations in a closed loop with a simulation runtime. Sim-Transfer renders photorealistic video from a physics simulator’s spatial controls. Sim-Bimanual predicts video directly from two-arm robot actions, with no simulator. All four are post-trained versions of the same 16-billion-parameter Nano base model.

Can I run NVIDIA Cosmos 3 Nano on a gaming GPU?

Probably not at full quality. NVIDIA Cosmos 3 Nano generation needs 58 GiB of VRAM in BF16, 44 GiB in FP8, or 31 GiB with FP8 offloading. Most consumer cards have 16 or 24 GiB. NVIDIA has not published a consumer-GPU configuration, and its published streaming setup was tested on a single GB200. Workstation and datacentre GPUs are the intended hardware.

Does NVIDIA Cosmos 3 Nano replace a physics simulator?

Only Sim-Bimanual tries to, and only for two-arm manipulation. Sim-Transfer is explicitly designed to work with a physics simulator, not instead of one — the simulator owns motion, contacts and physical state, and the model renders the visuals. Sim-Auto needs a simulation runtime and a World Scenario Map renderer. The checkpoints are components of a simulation pipeline, not a complete simulator.

Has anyone independently tested these checkpoints?

Not yet, as far as public reporting goes. No outside team has published independent measurements of visual quality or policy-learning usefulness for these four checkpoints, and NVIDIA’s own announcement says more work is needed to measure where the models faithfully support policy learning and evaluation. Treat every capability claim as NVIDIA’s own until independent results appear.

When did the Cosmos 3 family launch?

The Cosmos 3 family launched on 31 May 2026 at GTC Taipei, with Nano and Super available from the start and Edge following on 20 July 2026. The four checkpoints in this article are new post-trained versions of the Nano base model, released on 5 November 2026 — they are not the Cosmos 3 launch itself.

The Bottom Line on NVIDIA Cosmos 3 Nano

NVIDIA Cosmos 3 Nano is the most practical open world-model release of 2026 so far, and the reason is not the parameter count. Sixteen billion parameters is modest by frontier standards. What matters is the package: four specialised checkpoints for the two jobs that physical AI actually needs — driving data and robot simulation — plus the full training recipe, the inference code, and agent-runnable skills that let a team adapt the models to its own sensors instead of accepting NVIDIA’s example footage.

The NVIDIA Cosmos 3 Nano release is also unusually honest about its own limits. NVIDIA says more work is needed to measure where the models faithfully support policy learning. No independent evaluation exists yet. The sim-to-real gap is real, the hardware bar is high, and the checkpoints are components that need a surrounding pipeline. A reader who takes those limits seriously will get far more out of this release than a reader who treats it as a solved problem.

For robotics and autonomous-vehicle teams with the hardware and the data, the next step is concrete: download one checkpoint, run the reference inference, adapt it on your own data in a bounded run, and validate the result on real hardware. For everyone else, the step is to watch what outside teams publish in the coming weeks — because the real test of NVIDIA Cosmos 3 Nano is not whether NVIDIA’s models generate convincing video, but whether other people’s robots get better at their jobs after training inside it.

Leave a Comment

Your email address will not be published. Required fields are marked *