NVIDIA GR00T 2 Explained: The Robot Brain That Learns by Watching Humans
NVIDIA GR00T 2 is the most important robot AI announcement of 2026, and it works in a way that feels almost too simple to be real. Instead of programming a robot for every task, or making it practise a single job thousands of times, NVIDIA trained a model by showing it hundreds of thousands of hours of video of people doing ordinary work. The robot watches a person pick up a cup, fold a towel or plug in a cable, and then it tries the same job itself. On 9 November 2026, at the Conference on Robot Learning (CoRL) in Austin, Texas, NVIDIA said that approach now works well enough to matter.
The headline numbers are striking. NVIDIA GR00T 2 completed 40 of 50 test tasks at least once with no task-specific demonstrations at all. Give it one demonstration of each task and its average success rate rises to 71%. Give it five demonstrations and it reaches 95%. Those are NVIDIA’s own figures, from NVIDIA’s own test set, and this article treats them exactly that way — as the manufacturer’s claims, not as independently verified results. But even with that caution in place, the direction of travel is clear: the cost of teaching a robot a new job is collapsing, from months of engineering to a handful of examples.
In this guide, we explain what GR00T 2 is, how it learns from human video, what its benchmark numbers actually mean, what Isaac Lab 3.0 adds on the simulation side, who is already testing it, and — just as importantly — what is not available yet. If you build robots, buy automation for a US factory or warehouse, or simply want to know when humanoid robots stop being demos and start being workers, this is the launch to understand.
Table of Contents
- What Is NVIDIA GR00T 2?
- How NVIDIA GR00T 2 Learns From Human Video
- NVIDIA GR00T 2 Results: The Numbers That Matter
- GR00T 2 Turbo: The Version That Runs On the Robot
- Isaac Lab 3.0: Where Robots Rehearse Before Real Work
- New Benchmarks: DexBench, VABAR and Isaac Lab-Arena 0.4
- Who Is Already Testing NVIDIA GR00T 2?
- NVIDIA GR00T 2 vs GR00T N1: What Actually Changed
- When Can You Use NVIDIA GR00T 2?
- What NVIDIA GR00T 2 Means for US Businesses and Developers
- NVIDIA GR00T 2 Limitations and Honest Caveats
- NVIDIA GR00T 2 FAQ
What Is NVIDIA GR00T 2?
NVIDIA GR00T 2 is an open frontier world action model for robots, built on NVIDIA Cosmos, the company’s family of world models. The name is pronounced “Groot”, and it is the successor to the GR00T N1 series of robot foundation models that NVIDIA released earlier as part of Project GR00T. Where a chatbot predicts the next word, NVIDIA GR00T 2 predicts the next few frames of video and the robot’s next actions at the same time, inside a single diffusion transformer. That joint prediction is the whole idea: the model imagines how the scene will change, and it works out the movements that will change it that way.
The model is a 2-billion-parameter transformer based on Cosmos-Predict2.5-2B. That is small by the standards of 2026’s flagship language models, which run into the hundreds of billions of parameters, and the small size is deliberate. A robot brain has to run fast enough to react to the physical world, and a 2-billion-parameter model can be distilled down to a version that runs on the robot itself. NVIDIA is not trying to build the biggest model here. It is trying to build the most useful one for hands that have to touch things.
The job GR00T 2 is built for is dexterous manipulation — the fine, contact-rich work that has always been robotics’ hardest problem. Walking is now a solved problem for humanoid robots. Picking up a soft object without crushing it, threading a cable through a tight hole, folding a piece of cloth, or handling an object you have never seen before are not. These are the jobs where traditional robots fail, because every object is slightly different and every grasp has to adapt in real time. They are also the jobs that make up most of the useful work in a warehouse, a factory, a hospital or a home.

What makes NVIDIA GR00T 2 different from the robot models that came before it is where its knowledge comes from. Earlier robot models learned mostly from robot data: hours of a specific robot arm, in a specific lab, doing a specific task, recorded by teleoperation. That data is expensive to collect, and it only teaches the model about that one robot in that one setting.
NVIDIA GR00T 2 learned mostly from people. It was trained on 402,730 hours of first-person video of humans at work — cooking, assembling, packing, cleaning, repairing — plus 10,184 hours of demonstrations recorded with a handheld UMI gripper across 2,897 tasks, and 23,500 hours of robot teleoperation spanning YAM and Franka arms, Sharpa and Wuji dexterous hands, and the Unitree G1 humanoid.
The human video is the breakthrough, and it is also the reason the model can generalise. There are far more videos of people doing things than there will ever be videos of robots doing things, and a model that can learn from human video is not limited by how many robots a lab owns. NVIDIA has released 100,000 hours of that human video openly on Hugging Face as the Human-1M-100K dataset, under a Creative Commons CC BY 4.0 licence that permits commercial use. That dataset is available now, and it is one of the largest public collections of its kind.
How NVIDIA GR00T 2 Learns From Human Video
Teaching a robot from human video sounds straightforward until you think about what is actually missing. A video shows what a person’s hands did, but it does not record the forces their fingers felt, the exact joint angles of their wrist, or the weight of the object they lifted. The robot watching the video has a different body, different hands and different sensors. Bridging that gap — from a human’s point of view to a robot’s body — is the central technical problem of GR00T 2, and it is the problem the model’s design is built around.
The first part of the answer is scale. With 402,730 hours of egocentric video, the model has seen the same kinds of actions performed by many different people, in many different kitchens, workshops and warehouses, with many different objects. That variety is what lets it separate the skill from the specifics: the way a hand closes around a mug is recognisable whether the mug is red or blue, whether the person is left-handed or right-handed, and whether the video was shot in a factory or a home. The model learns the pattern of the action, not a memorised recording of one instance.
The second part of the answer is the UMI gripper data. UMI is a handheld gripper that a person holds like a tool while a camera records what they do. The 10,184 hours of UMI demonstrations across 2,897 tasks give the model something raw human video cannot: a record of the gripper’s own movements, aligned with the video of the task. It is a bridge format — human enough to be collected quickly and cheaply, robot enough to map directly onto a machine’s actions. When NVIDIA GR00T 2 has to turn “pick up the screwdriver” into motor commands, the UMI data is the closest thing it has to a translation dictionary.
The training data behind NVIDIA GR00T 2
The full training mix tells you a lot about NVIDIA’s strategy. The 402,730 hours of human video dominate the mix, and they teach the general skills: how objects move, how hands approach them, how a task breaks down into steps. The 23,500 hours of robot teleoperation teach the model about specific robot bodies — how a Franka arm moves, how a Sharpa dexterous hand closes, how a Unitree G1 humanoid balances while it works. And the 10,184 hours of UMI demonstrations tie the two together, showing the same tasks performed in a format both humans and robots can use.
It is worth being precise about what is and is not public here, because the numbers can be confusing. The full 402,730 hours stay inside NVIDIA. The 100,000 hours released as Human-1M-100K are a slice of that human video — still enormous, still openly licensed, but not the whole training set. The robot teleoperation data and the UMI demonstrations are not part of the public release. So a researcher who downloads Human-1M-100K today gets the raw material for learning from human video, but not the complete recipe NVIDIA used to build NVIDIA GR00T 2.
World action models vs vision-language-action models
GR00T 2 is not a vision-language-action model, and NVIDIA is careful about the distinction. A vision-language-action model, usually called a VLA, takes an image and a language instruction — “pick up the red cup” — and outputs robot actions directly. It is a straight line from seeing and hearing to doing. A world action model does something more: it predicts the future. It generates the next few frames of video showing how the scene should look as the task unfolds, and it generates the actions that produce that future, together, in one network.
Why does that matter? Because predicting the future is a much richer training signal than predicting an action alone. When the model imagines the cup lifting off the table, it has to understand gravity, grip, weight and the shape of the hand — all the physics that a bare action command leaves implicit. If its imagined future is wrong, the error is visible in the predicted video, and the model can learn from it. NVIDIA argues that this is why NVIDIA GR00T 2 generalises better than a VLA trained on the same data: the world model has to understand the scene, not just memorise which action usually follows which image.
There is also a practical benefit. Because the model predicts video, its reasoning is partly inspectable. A developer can look at the future frames the model expects and see whether it understands the task before the robot moves. That is a long way from a full safety guarantee — a robot that imagines the right future can still execute it badly — but it is more transparency than a black-box action predictor offers, and for industrial users deciding whether to trust a robot near people and expensive equipment, transparency is worth a great deal.
NVIDIA GR00T 2 Results: The Numbers That Matter
NVIDIA tested NVIDIA GR00T 2 on 50 dexterous manipulation tasks, a set the company calls Dexter-50, and the results are the centrepiece of the launch. With no task-specific demonstrations at all, the model completed 40 of the 50 tasks at least once. With one demonstration per task, its average success rate reached 71%. With five demonstrations per task, it reached 95%. NVIDIA also says the five-demonstration result required only a 30-minute fine-tune on a single RTX 5090 graphics card — a consumer GPU that a robotics lab can buy off the shelf for a few thousand dollars, not a data-centre cluster.
Those numbers deserve a table, because the shape of the improvement matters as much as the headline. The jump from zero demonstrations to one is the largest: the model goes from succeeding on 40 tasks at least once to averaging 71% success. The jump from one demonstration to five is smaller in absolute terms but more important in practice: 95% is the level at which a robot stops being a demo and starts being a tool you can rely on.
| Demonstrations per task | Result reported by NVIDIA | What it means |
|---|---|---|
| 0 (zero-shot) | 40 of 50 tasks completed at least once | The model can attempt genuinely new jobs from human video alone |
| 1 | 71% average success | One example more than doubles the reliable success rate |
| 5 | 95% average success | Five examples reach a level usable in real work; 30-minute fine-tune on one RTX 5090 |
NVIDIA also reports that GR00T 2 ranks among the top three models across all vision-language-action and world action model categories on four public benchmarks — RoboCasa365, RoboLab, RoboDojo and MolmoSpaces — with multiple leaderboard wins. Those are third-party benchmarks, which makes them a useful counterweight to NVIDIA’s own Dexter-50 tests, although the company has not published the full breakdown of its scores on each one.

What the 95% figure really means
Here is the honest reading, and it is important. The 95% figure is real, but it is a figure about a selected set of tasks, not about robots in general. NVIDIA’s own white paper discloses the condition: the 50 tasks in Dexter-50 were selected because the model could already reach at least 80% success on them with five demonstrations. The tasks were picked from a larger pool, and NVIDIA has not said how large that pool was, how many rollouts produced each average, or exactly which robots ran each task.
The target robot for the evaluation is a bimanual machine with two 22-degree-of-freedom Sharpa hands — a very capable platform — and the tasks appear in the test only through data from a different robot or from human video, never through training data from the target robot itself. That cross-embodiment setup is genuinely impressive, but it is also a specific, controlled setup.
None of that makes the 95% false. It makes it a claim about learnability on tasks the model can already learn, which is a narrower claim than “robots can now do 95% of manipulation tasks”.
The fair summary is this: on a set of 50 dexterous tasks chosen for being learnable, NVIDIA GR00T 2 goes from a 40-out-of-50 zero-shot showing to 95% average success with five examples each, after a short fine-tune on one consumer GPU. That is a strong result, and it is the strongest public evidence yet that the “learn from human video” approach scales. It is not proof that the same numbers would hold on a factory floor tomorrow, on tasks nobody has tried yet, with a robot the model has never seen. Independent replication — which cannot happen until the code arrives in December — is the real test.
GR00T 2 Turbo: The Version That Runs On the Robot
A foundation model that only runs in a data centre is of limited use to a robot, because a robot cannot wait for a round trip to the cloud every time it needs to decide how hard to squeeze. NVIDIA’s answer is GR00T 2 Turbo, a distilled, lighter version of NVIDIA GR00T 2 designed to run on the robot itself. NVIDIA says GR00T 2 Turbo runs on board a Unitree G1 humanoid at 124 milliseconds per prediction — fast enough for real-time control, where a delay of a second or more would make delicate manipulation impossible.
The distinction between the full model and the Turbo version is the distinction between learning and doing. The full GR00T 2 is the model that absorbs the 400,000-plus hours of video and learns the general skills. GR00T 2 Turbo is the model that carries a distilled version of those skills onto the hardware, where it has to make decisions in a tenth of a second while the robot’s hand is already moving. Both will be released as open source in December, according to Jim Fan, NVIDIA’s director of robotics, who presented the model at CoRL.
For anyone planning a robotics project, the Turbo version is arguably the more important of the two. A model that needs a server rack cannot be deployed in a warehouse aisle, a hospital corridor or a home. A model that runs on the robot, at 124 milliseconds a prediction, can. The trade-off is that distillation always loses something, and NVIDIA has not yet published how much of the full model’s 95% success rate the Turbo version keeps. That is one of the first things independent testers will check when the weights arrive.
Isaac Lab 3.0: Where Robots Rehearse Before Real Work
The model is only half of what NVIDIA brought to Austin. The other half is Isaac Lab 3.0, the open-source robot learning framework where robot skills are trained, refined and evaluated in simulation before they touch hardware. Isaac Lab 3.0 became generally available on 20 October 2026, a few weeks before the CoRL announcement, and it is available now on GitHub. If NVIDIA GR00T 2 is the brain, Isaac Lab 3.0 is the rehearsal studio — and NVIDIA’s argument is that robots, like people, learn delicate work faster when they can practise safely first.
The framework’s headline feature is that AI agents can now set up training environments themselves, using simulation-ready assets, instead of a researcher hand-building every scene. It lets developers switch between the PhysX and Newton physics solvers, choose renderers for perception-based training, and apply a new reinforcement-learning post-training library to foundation models like GR00T. The reinforcement post-training is the key addition: after NVIDIA GR00T 2 has learned a skill from human video, it can be refined in simulation through trial and error, practising the task thousands of times in a virtual world where mistakes cost nothing.
NVIDIA reports that Isaac Lab 3.0 with Newton reached up to 2.5 times the training throughput of Isaac Lab 2.3 with PhysX on a vision-based dexterous manipulation benchmark. That is a big number, but it comes with the usual caveat: it is one benchmark, run by NVIDIA, and the comparison changes two things at once — the framework version and the physics engine. Treat it as a signal that the new combination is substantially faster, not as a precise measurement of the speedup you would see on your own workload.

The Newton physics engine
Newton is the open-source physics engine at the centre of Isaac Lab 3.0, and it is what makes the simulation good enough to matter for dexterous work. Earlier physics engines were built for rigid objects — boxes, balls, robot arms — and they struggled with the things that make manipulation hard in real life. Newton models deformable objects: cables that bend, cloth that drapes, a soft fruit that squashes under a gripper’s fingers. It also handles robotic hands with many interacting joints, where each finger affects the others and the object at the same time.
That matters because the gap between simulation and reality — the “sim-to-real” gap — has always been the reason robot skills learned in a virtual world fail on a real robot. If the simulation treats a cable as a rigid rod, the robot learns a skill that only works on rigid rods. Newton narrows that gap by simulating the flexibility that real objects actually have, so a policy trained in Isaac Lab 3.0 has a better chance of working when it meets the real thing. It is not a complete solution — no simulation is — but it is a meaningful step, and it is open source, which means the whole field can build on it.
AlphaNIST and the 39x efficiency gain
The most concrete demonstration of what Isaac Lab 3.0 can do is AlphaNIST, a system built inside the framework that trains a single policy across all 20 tasks on the NIST Assembly Task Board — a standardised set of precision assembly jobs used to test industrial robots. NVIDIA reports that AlphaNIST reached over 98% training success across all 20 tasks using roughly 39 times less GPU time than the previous approach. That is an efficiency gain, not a capability gain: the robot can do the same jobs, but it takes far less computing to teach it.
Efficiency gains like that are easy to overlook next to a 95% success rate, but for a US manufacturer they may matter more. Training a robot policy on a data-centre cluster costs real money, and a 39-fold reduction in GPU time turns a training run that needed a week of rented compute into one that finishes overnight. It also lowers the barrier for smaller companies and university labs that cannot afford large GPU budgets, which is exactly the audience NVIDIA’s open release strategy is aimed at.
New Benchmarks: DexBench, VABAR and Isaac Lab-Arena 0.4
A model is only as trustworthy as the test that measures it, and NVIDIA knows its own Dexter-50 numbers will be read sceptically until outsiders can reproduce them. That is why the CoRL announcement also included two new open benchmarks and a new evaluation framework — tools that let anyone test a robot policy, including GR00T 2, in public, on standardised tasks.
DexBench, developed by RLWRLD with NVIDIA, tests dexterity across 15 tasks in four scenes: retail, logistics, manufacturing and hospitality. The point of the four scenes is that a robot that can only pick up objects on a clean lab bench is not much use in a shop or a warehouse. DexBench varies the objects, the spatial layout and the physics of each task, so a model has to generalise rather than memorise.
VABAR, the Variational Automation Benchmark for Agentic Robotics, built by UC Berkeley with NVIDIA, evaluates robots on six industrial tasks, each with standardised variations, difficulty tiers and success metrics. It is designed for agentic robotics — the pattern where a reasoning agent breaks work into steps and a model like NVIDIA GR00T 2 performs the contact-rich parts.
Alongside them, NVIDIA released the developer preview of Isaac Lab-Arena 0.4, an open-source framework for scaled policy evaluation that lets developers compose large evaluation runs and compare policies repeatably. The combination matters: DexBench and VABAR define what to measure, and Isaac Lab-Arena provides the machinery to measure it at scale. Together they give the field a way to check NVIDIA’s claims in public, on tasks NVIDIA did not choose itself. That is the honest test NVIDIA GR00T 2 still has to pass, and the tools to run it are now available.
Two NVIDIA research papers were also named among the six finalists for the Best Paper Awards at CoRL — GRAIL and RoboTTT — out of thousands of submissions. The papers cover the research behind the announcement, and their finalist status is a signal that the academic community takes the work seriously, independent of the product announcement around it.
Who Is Already Testing NVIDIA GR00T 2?
A launch announcement is a promise; a customer list is evidence. NVIDIA named several companies already evaluating or testing GR00T 2 and the surrounding tools, and the names span the exact industries where dexterous robots would first earn their keep.
Foxconn is applying NVIDIA GR00T 2 to factory automation for AI server manufacturing — the company’s own production lines, where the work is precise, repetitive and currently done by people. Siemens is evaluating the model for industrial use cases, bringing one of the world’s largest industrial automation companies into the test group. Nexuni is testing it for robotic laundry handling, a job that is almost comically hard for robots — every item is soft, deformable and different — and therefore a perfect stress test for a model that claims to handle deformable objects.
The most detailed example NVIDIA gave comes from MicroAGI, which post-trained NVIDIA GR00T 2 with reinforcement learning to swap Ethernet cables using a YAM robotic arm. Cable swapping is a fiddly job: it needs precise insertion, the right amount of force, and recovery when the plug does not seat properly. MicroAGI’s approach uses an agent to build and calibrate simulation environments in Isaac Lab 3.0 with Newton, trains the policy there, and then transfers it to the real arm. NVIDIA presents this as the pattern it wants the industry to follow — rehearse delicate work in simulation, then deploy — and MicroAGI is the first public proof that the pattern works end to end.

Beyond the named testers, NVIDIA listed a broader group of partners working with the new technologies: Ambi Robotics, Bosch Research, Dexmate, Dyna Robotics, FieldAI, Flexion, Noitom Robotics, Skild AI, RLWRLD, UC Berkeley, Walden Robotics and the University of Washington. That list mixes robot makers, research labs and industrial giants, which is the point. NVIDIA is not selling a robot. It is selling the platform every robot maker builds on, and the partner list is the evidence that the platform strategy is working.
NVIDIA GR00T 2 vs GR00T N1: What Actually Changed
GR00T 2 is not NVIDIA’s first robot foundation model. The GR00T N1 series came first, and its latest checkpoints — GR00T N1.6 and N1.7 — are already on Hugging Face. Understanding what changed between the generations is the fastest way to understand what NVIDIA GR00T 2 actually is.
The first change is the architecture. GR00T N1 was a vision-language-action model: it took images and language instructions and produced actions. NVIDIA GR00T 2 is a world action model: it predicts future video and actions together, in one diffusion transformer built on Cosmos. That is not a marketing rebrand. It is a different kind of model, trained with a different objective, and NVIDIA’s argument is that predicting the future is what lets the model understand a scene deeply enough to generalise to new tasks.
The second change is the data. GR00T N1 learned primarily from robot demonstrations. GR00T 2 learned primarily from human video — 402,730 hours of it — with robot data as the smaller part of the mix. That is the shift that makes the few-demonstration results possible: the model arrives at a new task already knowing how humans do it, so a handful of robot-specific examples are enough to adapt the skill to a particular body.
The third change is the ecosystem around the model. GR00T N1 shipped as a model. NVIDIA GR00T 2 ships as a stack: the model, the distilled Turbo version, the Human-1M-100K dataset, Isaac Lab 3.0, the Newton physics engine, two new benchmarks and an evaluation framework. NVIDIA is building the whole pipeline from data to deployment, and the model is one piece of it. That is also why the announcement matters beyond the benchmark numbers — it is a platform play, and platforms are harder to displace than models.
When Can You Use NVIDIA GR00T 2?
This is the question every reader actually wants answered, and the honest answer is: not yet, but soon — and parts of the stack are available today. Here is the timeline as NVIDIA has stated it.
| What | Status | When |
|---|---|---|
| Human-1M-100K dataset | Available now on Hugging Face, CC BY 4.0 | Since 9 November 2026 |
| Isaac Lab 3.0 | Generally available, open source | Since 20 October 2026 |
| DexBench and VABAR benchmarks | Open benchmarks announced at CoRL | November 2026 |
| Isaac Lab-Arena 0.4 | Developer preview | November 2026 |
| GR00T 2 code and weights | Announced as open source; no licence published yet | December 2026 |
| GR00T 2 Turbo weights | Announced as open source, with the cross-adaptation training recipe | December 2026 |
If you are a robotics researcher, the useful work you can do today is real. You can download the Human-1M-100K dataset and start training your own models on human video. You can install Isaac Lab 3.0 and build simulation environments with the Newton physics engine. You can run DexBench and VABAR against your own policies. What you cannot do yet is download NVIDIA GR00T 2 itself.
What “open” really means for NVIDIA GR00T 2
The word “open” is doing a lot of work in this announcement, and it needs careful reading. NVIDIA calls GR00T 2 an open frontier world action model, and Jim Fan said at CoRL that the weights for GR00T 2 and GR00T 2 Turbo, plus the cross-adaptation training recipe, will be released as open source in December 2026. But as of the announcement, NVIDIA’s own research page lists the model code as “Available in December” and publishes no licence for the weights, no exact release date and no hardware requirements.
That matters because the licence decides what “open” actually allows. NVIDIA’s earlier Flora models were released under a non-commercial research licence despite similar “open” language, and the GR00T N1 checkpoints on Hugging Face carry an NVIDIA licence whose terms restrict commercial use. Until the GR00T 2 licence is published, nobody planning a business on this model should assume they can use it commercially. The dataset is genuinely open — CC BY 4.0 permits commercial use — but the model itself is, for now, open in the sense of “coming soon”, not “download it today”. Check the licence when December arrives, and do not build a product roadmap on an assumption.
There is also no price for NVIDIA GR00T 2, because it is a research model, not a product. You will not buy it. You will download it, if and when NVIDIA releases it, and run it on your own hardware — most likely NVIDIA GPUs, since the training and fine-tuning figures NVIDIA quotes are all measured on its own hardware, including the single RTX 5090 used for the 30-minute fine-tune.
What NVIDIA GR00T 2 Means for US Businesses and Developers
For a US factory, warehouse or logistics company, NVIDIA GR00T 2 matters because it attacks the cost that has kept dexterous robots out of real work. Traditional industrial robots are cheap to buy and expensive to programme: every new task needs an engineer, weeks of work and a production line stopped while the robot is taught. A model that learns a new task from five demonstrations, after a 30-minute fine-tune on a consumer GPU, turns that economics upside down. The robot becomes the cheap part and the teaching becomes nearly free.
That is the promise, and it is worth separating from the present reality. Today, the model is not downloadable, the licence is unpublished, and the 95% figure comes from a selected test set. No US business should budget around GR00T 2 as a 2026 purchase. But a business that runs a warehouse, a fulfilment centre or an assembly line should be watching December closely, because if the open release lands as promised, the first movers will be the companies that already have a task list, a simulation setup in Isaac Lab 3.0, and a team that has experimented with the Human-1M-100K data.
For developers, the practical advice is concrete. Start with what is available now: download the Human-1M-100K dataset, install Isaac Lab 3.0, and build a simulation of one real task from your own operation. Learn the Newton physics engine’s behaviour on deformable objects, because that is where the sim-to-real gap lives. When the December release arrives, you will be adapting a model to a task you already understand, in a simulation you already trust, instead of starting from zero. The developers who do that preparation are the ones who will get a working robot first.

The wider context matters too. NVIDIA GR00T 2 is part of a larger shift in which AI moves from screens into the physical world, and NVIDIA is positioning itself as the platform for that shift — the same way it positioned its GPUs as the platform for the language-model boom.
Our NVIDIA Cosmos 3 Nano guide covers the world-model family NVIDIA GR00T 2 is built on, and our Meta Muse Ember guide covers the small, cheap agent model that plays a similar role on the software side — the execution model inside a larger agent workflow. Together with our Claude Fable 5.2 guide, which covers the reasoning model at the top of that same workflow, they map the full stack: a reasoning agent plans the job, a small model handles the routine steps, and a world action model like GR00T 2 does the physical work.
NVIDIA GR00T 2 Limitations and Honest Caveats
No launch is complete without the caveats, and this one has several that matter more than usual, because the gap between the announcement and the download is where misunderstandings grow.
The benchmarks are NVIDIA’s own. Almost every performance number in this article comes from tests NVIDIA ran itself, on tasks NVIDIA selected, on robots NVIDIA chose. The third-party benchmark rankings — top three on RoboCasa365, RoboLab, RoboDojo and MolmoSpaces — are a useful check, but the detailed Dexter-50 numbers have not been re-run by an outside lab. Until the December code release makes independent replication possible, treat the figures as a strong signal, not a settled fact.
The 95% figure is about a selected task set. Dexter-50 tasks were chosen because the model could already reach at least 80% success on them with five demonstrations. The figure says nothing about tasks the model cannot learn, and NVIDIA has not disclosed the size of the pool the 50 were drawn from. Do not quote 95% as a general statement about robot capability.
The model is not downloadable yet. The code arrives in December 2026, according to NVIDIA’s research page and Jim Fan’s CoRL presentation. No licence has been published, no weights release date has been set, and no hardware requirements have been stated. Anyone who tells you they are running NVIDIA GR00T 2 today is mistaken or misleading you.
Safety is an open problem. NVIDIA’s own white paper lists safe physical action as an unsolved problem, and notes that the safety training that works for language models is “not known to carry over to what a robot does”. A robot that misunderstands a language instruction produces a wrong sentence. A robot that misunderstands a physical instruction can break an object or hurt a person. That is not a reason to dismiss the model, but it is a reason to keep humans in the loop, to test in simulation first, and to treat any deployment near people as a safety engineering project, not a software install.
There is no price, and no product. NVIDIA GR00T 2 is a research model. There is no purchase page, no subscription tier and no support contract. The cost of using it is the cost of the hardware it runs on, the engineers who adapt it, and the simulation time needed to train it — all real costs that the announcement does not itemise.
NVIDIA GR00T 2 FAQ
What is NVIDIA GR00T 2?
GR00T 2 is an open frontier world action model for robots, announced by NVIDIA on 9 November 2026 at the Conference on Robot Learning in Austin, Texas. Built on NVIDIA Cosmos, it learns dexterous manipulation skills from human video and a handful of demonstrations, jointly predicting future video frames and robot actions in a single 2-billion-parameter transformer.
How accurate is NVIDIA GR00T 2?
According to NVIDIA’s own tests on 50 tasks, NVIDIA GR00T 2 completed 40 tasks at least once with no demonstrations, averaged 71% success with one demonstration per task, and 95% with five demonstrations. These are NVIDIA’s own figures on a task set selected for learnability, and they have not been independently replicated yet.
Is NVIDIA GR00T 2 open source?
Not yet. NVIDIA calls NVIDIA GR00T 2 an open model and says the weights, plus the lighter GR00T 2 Turbo variant and the cross-adaptation training recipe, will be released as open source in December 2026. No licence terms have been published, and no exact date has been set. The 100,000-hour Human-1M-100K dataset is already available on Hugging Face under a CC BY 4.0 licence, and Isaac Lab 3.0 is open source now.
What is Isaac Lab 3.0?
Isaac Lab 3.0 is NVIDIA’s open-source robot learning framework, generally available since 20 October 2026. It is the simulation environment where robot skills are trained and refined before they touch hardware, with the Newton physics engine, a reinforcement-learning post-training library, and up to 2.5 times the training throughput of Isaac Lab 2.3 with PhysX on one NVIDIA benchmark.
When can developers use NVIDIA GR00T 2?
Researchers can use the Human-1M-100K dataset and Isaac Lab 3.0 today. The NVIDIA GR00T 2 model code and weights are expected in December 2026, according to NVIDIA’s research page and Jim Fan’s CoRL presentation. No exact date or licence has been announced.
How much does NVIDIA GR00T 2 cost?
There is no price, because NVIDIA GR00T 2 is a research model, not a product. NVIDIA says adapting it to a new task takes a 30-minute fine-tune on a single RTX 5090 consumer GPU, so the cost of using it is the hardware and engineering time, not a licence fee — although the licence terms, when published, will decide whether commercial use is permitted at all.
The honest summary of NVIDIA GR00T 2 is this: it is the clearest sign yet that robots are about to learn the way people do — by watching — and that the cost of teaching a robot a new job is about to fall by orders of magnitude. The numbers are NVIDIA’s own, the model is not downloadable yet, and the licence is unpublished, so caution is warranted.
But the direction is unmistakable. Watch December. If the open release lands as promised, the companies and developers who spent the intervening weeks learning Isaac Lab 3.0 and the Human-1M-100K data will be the first to put a robot to work on a job it learned from watching a person. For the full announcement, read NVIDIA’s own account on the NVIDIA blog, and the independent trade coverage in The Robot Report.
