Before you pour a glass of water, you already “see” it in your head: the jug tilts, the water flows, the glass fills up. You picture what will happen, then your hands follow that picture.
GR00T 2, the new robot foundation model from NVIDIA’s GEAR research lab, announced in November 2026, works the same way. Before it moves, it imagines a short video of what is about to happen, then produces the movements that make that future come true. NVIDIA calls this kind of model a world-action model, or WAM.
This guide explains GR00T 2 from scratch. You don’t need any AI or robotics background. If you’d like a warm-up first, read our VLA Models for Absolute Beginners guide; GR00T 2 builds on the same ideas.
Where the numbers come from: all figures in this post come from NVIDIA’s GR00T 2 project page and whitepaper. They are NVIDIA’s own lab results, with trial counts ranging from 20 to 100 per task.
From GR00T to GR00T 2: what changed?
Earlier GR00T models (GR00T N1 and its updates up to GR00T 1.7) are vision-language-action models (VLAs). A VLA looks through the robot’s cameras, reads an instruction such as “put the battery in the flashlight” and answers with actions: small movements for the robot’s arms and hands.
GR00T 2 adds one big step in the middle. It doesn’t only answer “what should I do?”. It also answers “what will the world look like while I do it?”
Why bother imagining a video? Three reasons, which the rest of this guide unpacks:
- It can learn from ordinary videos of people. A video of someone assembling a toy contains no robot commands, so a normal VLA can’t learn much from it. But a model that predicts what happens next can learn from any video of hands at work.
- It understands physics better. To predict the next frame, the model has to learn how objects fall, slide, bend and fit together.
- Its plans are easy to check and steer. Because it shows what it intends to do, other software can watch, correct or guide it.
How GR00T 2 works, step by step
GR00T 2 runs in a loop, repeating the same four steps until the task is done:
In a little more detail:
- What goes in: about 0.8 seconds of recent video from up to four cameras (usually one on the robot’s head and one on each wrist), the robot’s current joint positions, and a plain-language instruction.
- What comes out: a short action chunk (the next stretch of movements) plus the predicted future frames for every camera.
- Speed: on a single GeForce RTX 5090 graphics card, GR00T 2 predicts each action chunk for a three-camera robot in about 153 milliseconds. The robot executes one chunk while the next is being computed, so motion stays smooth.
What’s inside the model
You can think of GR00T 2 as four parts working together:
| Part | What it does | Plain-language version |
|---|---|---|
| Video compressor (Wan 2.1 VAE) | Shrinks each camera stream into compact “video tokens” | Turns video into a short summary the model can handle |
| Language reader (Cosmos-Reason1) | Encodes the instruction | Understands what you asked for |
| Main transformer (2 billion parameters) | Predicts future video tokens and actions together | The “imagination” and the “decision” in one brain |
| Small per-robot heads | Convert between the robot’s body and the transformer | Adapters, so one brain can drive many different bodies |
The main transformer starts life as Cosmos-Predict2.5, an NVIDIA model trained to generate realistic videos of the physical world. GR00T 2 takes that “video imagination” and teaches it to also produce robot actions.
Inside, the action tokens can look at the imagined future video while they are being generated. In other words, the actions follow the future the model pictures.
How it “imagines”: cleaning up noise
GR00T 2 generates video and actions with a technique related to the diffusion models behind AI image generators. It starts from random noise and cleans it up, step by step, until a sharp prediction appears. GR00T 2 needs only a few of these clean-up steps: one or two for video and two to four for actions. That is part of why it is fast enough to control a real robot.
Where GR00T 2 learns from
Robot data is expensive: every hour needs a robot and a person to control it. Videos of people working are far more plentiful. GR00T 2 is pretrained on a mix of three kinds of data:
- Human video comes from NVIDIA’s Human-1M collection of first-person footage of people working with their hands. 100,000 hours of it are openly available as Human-1M-100K on Hugging Face.
- UMI demonstrations are recorded with a handheld gripper, a “robot hand on a stick” that a person carries around. No robot is needed, so collecting data is fast.
- Teleoperation is a person remotely driving a real robot: two-finger gripper arms (YAM and Franka), five-fingered robot hands (Sharpa and Wuji) and the Unitree G1 humanoid.
Does the human video really help? NVIDIA tested it. They trained versions of the model with none, 1%, 10% and 100% of the human video, then tested each on 72 tasks. On the real robot, average task progress rose at every step, from 50% to 70%, and it had not levelled off at the largest amount tested.
Training happens in three stages: first the model learns to predict video of hands at work; then it learns video and actions together; finally it focuses more on robot data, so its actions fit real robot bodies.
Three new abilities, explained simply
1. Learning from people, not robots (“X-Adapt”)
This is the headline result, which NVIDIA calls cross-adaptation, or X-Adapt. GR00T 2 can do a task on a robot that never practised it, after only seeing it done by:
- People with cameras on their head and wrists. A robot with two five-fingered hands lined a lab funnel with filter paper and wet it with a wash bottle in 65% of trials. Nobody ever remote-controlled the robot through that task.
- A handheld gripper. Shown only UMI gripper demonstrations, a YAM robot arm assembled a toy dump truck end to end in 60% of trials, a task that can take up to four minutes.
- A wearable robot hand. Using DexUMI, a glove-like exoskeleton that copies a robot hand’s joints, people demonstrated breakfast tasks and even striking a match to light a lamp. The robot learned these from the wearable demonstrations alone.
There is one trick. When the demonstrator’s body differs from the robot’s, as with human hands or the handheld gripper, the robot still needs some general “play” data, recorded without any particular task, so the model learns how its own body looks and moves. The demonstrations then teach the task. The DexUMI exoskeleton copies the robot hand it was built for, so on that hand no play data is needed.
2. New tasks from a handful of demos
NVIDIA picked 50 tasks that a two-handed robot had never done itself (they appeared only in human video or in other robots’ data).
With no extra robot data at all, GR00T 2 already succeeded 40% of the time. Most failures weren’t “wrong plan” failures: the model did the right steps in the right order, and one step lacked precision. Five demonstrations per task, less than three minutes of robot data, raised success to 95%. Each of those adaptations took about 30 minutes of training on a single RTX 5090, a card you can put in a desktop PC.
One fair caveat from the paper itself: these 50 tasks were chosen among those the model can learn with five demos, so the 95% is high partly by design. It still shows how little data a strong pretrained model needs.
3. Working with a “thinking” AI (“Agentic GR00T 2”)
GR00T 2 is good at the how: the fiddly hand movements that are hard to program. Large reasoning models (the AI behind advanced chatbots) are good at the what: breaking a long job into steps and checking progress. NVIDIA connects the two through a WAM API, so the reasoning model can call GR00T 2 like a tool.
- Agentic control. The reasoning model watches GR00T 2 work, and when a part drops or progress stalls, it fixes the scene with a pre-learned recovery skill and hands control back. Together they assembled three different toys in 292 of 300 attempts, starting each time from parts dumped in a pile.
- Visual steering. Instead of only giving words, the reasoning model draws marks on GR00T 2’s camera image: “grab here, put it there”. On short pick-and-place steps this raised success from 40% to 92% on the YAM arm.
NVIDIA sums up this split as “think slow, move fast”. The reasoning model thinks slowly about the plan. GR00T 2 moves quickly and precisely.
Bonus: getting better with practice
Demonstrations get GR00T 2 most of the way. For tasks that need millimetre precision, NVIDIA let it practise on the real robot with reinforcement learning: it tries a task many times, and the attempts that succeed are used to train it further. On four precision tasks, such as plugging in cables and chargers, success rose from 40–76% to 88–98%.
GR00T 2 Turbo: a version small enough for a humanoid
A humanoid has to run its brain on board, on a much smaller computer than a desktop GPU. So NVIDIA made GR00T 2 Turbo. Its main trick is compressing video much harder (16 times smaller in each direction instead of 8), so there are far fewer video tokens to predict. It still imagines the future and plans actions together.
On the Unitree G1 humanoid, Turbo runs on the robot’s own Jetson Thor computer and makes each prediction in 124 milliseconds. It doesn’t drive the motors directly. It sends a plan to SONIC, a whole-body controller that keeps the robot balanced while it walks, bends and reaches. Together they scooped and served popcorn in all 48 trials and cleared a table of mixed objects in 93% of trials.
Turbo is not free speed. It trails full GR00T 2 on delicate five-finger tasks, roughly halving success there, while staying close on simpler gripper tasks.
How does it compare?
NVIDIA tested GR00T 2 against other leading robot models on long, multi-step tasks, after fine-tuning each model on the same long tasks:
| Benchmark | GR00T 2 | GR00T 2 Turbo | Best other model tested |
|---|---|---|---|
| 6 long tasks on a YAM gripper arm (toy assembly, wire into breaker…) | 71.7% | 65.0% | 12.5% (π0.5, Physical Intelligence) |
| 7 long tasks with five-fingered hands (memory module, salt filtering…) | 68.6% | 34.3% | 0.7% (GR00T 1.7, NVIDIA) |
Average success rates from Table 1 of the whitepaper, up to 20 trials per task. The other models tested were π0.5, GR00T 1.7, FastWAM, MolmoAct2 and FLUX 3 Action on the YAM tasks, and GR00T 1.7 and π0.5 on the hand tasks.
The tasks were chosen to be hard: tight tolerances and many steps in a row. Previous models rarely finished them end to end, so the gap is large.
What GR00T 2 can’t do (yet)
NVIDIA is open about the limits, and they are worth knowing:
- Short memory. It only sees the last 0.8 seconds. Anything needing longer memory (“did I already close that drawer?”) is left to the reasoning model.
- No sense of touch. It sees, but it doesn’t feel. Touch sensors are not an input yet.
- Marks show where, not how. Visual steering can’t express pouring, wiping or an object’s final orientation; that still needs words.
- Lab results, not a product. Most results come from about 20 trials per task. Telling 95% from 99% reliability would take hundreds of trials per model, which is what real deployment demands.
As with any AI model on a real robot, you still need controllers, safety limits and testing around it. The model suggests; the rest of the robot system decides what is safe.
Where does ROS 2 fit?
Many robots are built with ROS 2, the open-source framework that connects cameras, motor controllers and safety systems. A model like GR00T 2 becomes one part of that system: cameras publish images, a node runs the model and publishes action chunks, and ros2_control controllers move the motors within the limits engineers set. That keeps the model swappable, so you can try GR00T 2 without rewriting the rest of the robot software. Our VLA beginners guide shows this layout in a diagram.
How to get started
- Watch the demos. The GR00T 2 project page has dozens of videos: toy assembly, chemistry-lab tasks and the G1 humanoid serving popcorn.
- Explore the data. Browse first-person human video in the Human-1M Dataset Explorer to see what the model learns from.
- Wait for the code, or start with GR00T today. NVIDIA lists the GR00T 2 code as “available in December”. Meanwhile, the earlier open Isaac GR00T models already run in simulation and on low-cost arms.
- Try a hands-on workshop. Our open Sim-to-Real with SO-101 workshop is an end-to-end workflow with the affordable SO-101 arm, Isaac Lab and Isaac GR00T.
Beginner questions
Is GR00T 2 a VLA?
It is a close relative. Like a VLA, it takes camera images and an instruction and outputs actions. Unlike a typical VLA, it also predicts future video, which is why NVIDIA calls it a world-action model.
Does GR00T 2 only work on humanoids?
No. One trained model covers two-finger gripper arms, five-fingered robot hands and the Unitree G1 humanoid. To use it on a new robot, you map its cameras to the head and wrist views, describe its actions in a supported format and fine-tune on some demonstrations.
What computer do I need?
NVIDIA’s numbers use a single GeForce RTX 5090 both to run GR00T 2 in real time and to fine-tune it on a new task in about 30 minutes. GR00T 2 Turbo runs on board a robot with an NVIDIA Jetson Thor.
Can it learn just from watching me?
Partly. GR00T 2 learned tasks from people wearing cameras, without anyone remote-controlling the robot for that task. It usually still needs some general recordings of the target robot moving, so it knows its own body.
Glossary
- World-action model (WAM): a model that predicts both what the world will look like next and the actions that get it there.
- VLA (vision-language-action model): a model that turns camera images and an instruction into robot actions.
- Action chunk: several future movements predicted at once, so the robot moves smoothly.
- Transformer: the type of neural network behind most modern AI models, including chatbots.
- Parameters: the numbers a model learns during training. GR00T 2 has about 2 billion.
- Diffusion / denoising: generating an output by starting from noise and cleaning it up step by step. GR00T 2 uses a variant called flow matching.
- VAE (video compressor): a network that shrinks video into a compact form and can expand it again.
- Egocentric video: video filmed from a person’s own point of view, usually a head-mounted camera.
- UMI: a handheld gripper with cameras, used to record demonstrations without a robot.
- Teleoperation: a person controlling a robot remotely to record demonstrations.
- Embodiment: a robot’s body type, such as a gripper arm, a five-fingered hand or a humanoid.
- Zero-shot / few-shot: doing a task with no examples, or with only a few examples.
- Fine-tuning (LoRA): extra training on a small dataset. LoRA trains a small add-on instead of the whole model, which makes it fast.
- Reinforcement learning (RL): learning by trial and error, guided by a signal that says whether the task succeeded.
Want to build with GR00T and robot foundation models?
World-action models like GR00T 2 are moving robot learning from “collect thousands of robot demos” towards “show a few and fine-tune”. Turning one into a dependable application still takes the right data, careful evaluation and solid safety engineering.
RUNTIME Robotics helps teams prototype and deploy VLA and VLM robot applications and robot-learning workflows with NVIDIA Isaac and ROS 2, from simulation to controlled real-world testing. We also run hands-on robotics training. Get in touch to talk about your project.
