Back to Explore
NewsVibeFix editorialUpdated Nov 14, 2026

Watch People Work, Then Do It Yourself: NVIDIA's GR00T 2 Teaches Robots from 100,000 Hours of Human Video

NVIDIA's GR00T 2 learns dexterous skills from 100,000 hours of human video: 40 of 50 tasks completed with zero demos, 71% with one demo, 95% with five. The numbers impress, but the weights have no release date yet.

NVIDIA's official CoRL blog promo image in four panels: a humanoid at a washing machine, a robot arm with a crane model, parallel simulated arms, and a white humanoid in a lab.

Robots Have Started Learning by Watching People Work

Teaching a robot to do delicate work has always been the most grinding part of robotics. Getting it to walk, turn, and avoid obstacles is now routine: train it in simulation for millions of runs and it looks competent. But ask it to tighten a millimeter-scale screw, plug an Ethernet cable into a socket, or fold a wrinkled shirt, and the difficulty jumps sharply. The motion has to be gentle, precise, and constantly adjusted to what the hand feels. Practicing on a real machine is slow, expensive, and liable to break things; practicing in simulation often produces skills that fail the moment they meet the real world. On November 9, at the Conference on Robot Learning (CoRL) in Austin, NVIDIA offered its answer: stop staring only at the robot's own data, and let it watch how people do the job. The company introduced GR00T 2, an open frontier world action model built on its Cosmos platform, trained on robot demonstrations plus 100,000 hours of human first-person video. It is a shift worth taking seriously: the data source for robot learning is expanding from "what the robot did" to "how people do it."

The claim is not empty rhetoric; NVIDIA attached numbers that can be checked. Across 50 evaluated tasks, GR00T 2 completed 40 at least once with no task-specific demonstrations at all. Give it one demonstration per task and the average success rate across the 50 tasks is 71%. Give it five demonstrations and the average rises to 95%. The three numbers have to be read together. The first measures zero-shot generalization: it can get some things right without ever being taught. The second measures few-shot learning efficiency: teach it once and it becomes usable. The third measures the ceiling: teach it a few more times and it becomes fairly reliable. For people who build robots, the second number matters most, because in the real world nobody collects thousands of demonstrations for every new task. Going from zero to 71% on a single demonstration would push the startup cost of a new task down to a level a small team can afford. All of this, of course, comes from NVIDIA's own controlled evaluations. How the tasks were selected and how strict the success criteria were is something outsiders cannot yet verify, so the numbers should not be translated directly into "ready for the factory floor."

Why 100,000 Hours of Human Video Is the Real Leap

The most interesting part of GR00T 2 is not its parameter count but what it was trained on. The bottleneck for robot foundation models has always been concrete: robot demonstration data is expensive. One real machine can only record so many demonstrations per hour, and each one needs a human supervisor, floor space, and someone to throw out the failed takes. Human video is a different order of magnitude: people are doing things all day, and the video is everywhere. By open-sourcing 100,000 hours of human egocentric data, NVIDIA is lowering the data barrier for the whole "learn by watching people" approach. Two companion releases show the company is selling a pipeline, not just a model. The new open Video to Data workflow turns human video into simulated robot demonstrations, and NVIDIA has set up a challenge inviting researchers to push that workflow further. The EgoHand open model reconstructs 3D hand motion from video and has already passed 40,000 downloads on Hugging Face within two weeks of launch. The message is that human video goes in one end and robot skills come out the other.

But "learning by watching people" has an obstacle that cannot be waved away. Human hands and robot hands are built differently, and the range of motion, the way force is applied, and the height of the viewpoint all have to be remapped onto a different body. GR00T 2's claimed "skill transfer" is aimed squarely at this problem: skills learned from human demonstrations can transfer between different robot bodies without robot demonstrations. If that holds up, it matters more than the success-rate numbers, because it would mean a skill proven on one robot could be reused on another instead of starting from scratch with every new piece of hardware. The official announcement does not spell out which bodies were tested or how well transfer worked, so readers should file it as a claim awaiting verification rather than a delivered capability. Also worth noting is agent control: AI agents can use GR00T 2's API and supporting tools to run skills in sequence and recover from errors. That step moves the model from "can do one action" to "can finish a whole job," which is the path any robot must take from demonstration to deployment.

Simulation Is the Real Battlefield

Beyond the model, the heaviest part of this release is simulation. Isaac Lab 3.0 is the latest version of NVIDIA's open-source robot learning framework. It lets researchers use agents to set up training environments quickly, arrange scenes with simulation-ready assets, switch between the PhysX and Newton physics solvers, pick renderers for perception-based training, and apply a new reinforcement-learning post-training library to foundation models like GR00T. Newton, the open-source physics engine, is now more tightly integrated with Isaac Lab, allowing it to model deformable objects such as cables and cloth, as well as complex articulated systems like multi-jointed robotic hands — exactly the physics that dexterous manipulation needs. NVIDIA's headline benchmark figure is that Isaac Lab 3.0 with Newton delivers up to 2.5 times the training throughput of Isaac Lab 2.3 with PhysX on a vision-based dexterous manipulation benchmark. Throughput is not a vanity metric here; it decides directly how many approaches a team can try in a day.

The most telling simulation result is AlphaNIST: a single policy learned all 20 tasks on the NIST Assembly Task Board, manipulating millimeter-scale parts with nothing but a yes-or-no success signal as feedback. Training success exceeded 98%, against 81% for separate per-task policies, using roughly 39 times less GPU time. One policy learning 20 things, beating 20 policies each learning one thing, faster and better — that is exactly the result the foundation-model approach is supposed to deliver in simulation. Behind it is Success-Guided Sampling, a method from the University of Washington and NVIDIA that concentrates practice on tasks the policy succeeds at about half the time — the skills it is in the middle of learning — with training able to scale beyond a million parallel environments. Individual developers may not reproduce these numbers directly, but they point in a clear direction: training dexterous manipulation is shifting from "collecting real-machine demonstrations" to "trial and error at scale inside simulation."

The Exams Have to Keep Up: Two New Benchmarks

With new models and new simulation comes the need for new tests; otherwise nobody can say clearly who is better than whom. NVIDIA introduced two open benchmarks, both running on Isaac Lab-Arena. DexBench, developed by RLWRLD with NVIDIA, moves dexterity evaluation off the tabletop and into real workflows: 15 tasks across four scenes spanning retail, logistics, manufacturing, and hospitality, testing generalization across object, spatial, and physics variations. VABAR, the Variational Automation Benchmark for Agentic Robotics from UC Berkeley and NVIDIA, evaluates robots across six industrial tasks, each with standardized variations, difficulty tiers, and success metrics. The developer preview of Isaac Lab-Arena 0.4 arrives alongside them; its job is to compose diverse, repeatable evaluations, run policies across thousands of variations in parallel, and expose the shared causes of failure so researchers know what to fix next. NVIDIA also says GR00T 2 ranks among the top three models across all vision-language-action and world action model categories on the RoboCasa365, RoboLab, RoboDojo, and MolmoSpaces benchmarks, with multiple leaderboard wins. Leaderboard results should be read with the caveat that this is NVIDIA's own selection, but at minimum the model is not a bystander in public evaluation.

Who Is Actually Using It: Still "Testing" Across the Board

The most direct way to judge a release is to see who is using it for real work, and here the wording deserves to be read literally. Nexuni is testing it for robotic laundry handling, Foxconn is applying GR00T 2 to factory automation for server manufacturing, Siemens is evaluating it across industrial use cases, and MicroAGI is using a reinforcement-learning post-trained GR00T 2 to perform Ethernet cable swapping with a YAM robotic arm. None of the four says "in production." All are tests, explorations, or evaluations. That is honest, and it matches the reality of the robotics industry: between benchmark numbers and a production line sit reliability, cycle time, and safety certification. The partner activity around the release is also worth noting: Skild AI announced STEEL, a rigid-body physics solver built on Newton; Flexion showed how Isaac Lab and Newton train Reflect, its robot-intelligence model; and FieldAI, Dyna Robotics, Walden Robotics, and Dexmate are all building on the same simulation stack. The ecosystem is genuinely broad. How deep it goes — how many of them put it into a production process — this announcement does not answer.

The Word "Open" Deserves a Question Mark

GR00T 2 is described by NVIDIA as an "open frontier world action model," but how open it is remains unclear from the announcement itself. The official blog post gives no public release date or license terms for the GR00T 2 weights or the 100,000-hour dataset. According to AIWeekly's check, the post contains no release timetable for them, while Unite.AI notes that the research page says code will be available in December. In other words, what the public received on November 9 was a declaration of capability with evaluation numbers, not a model that can be downloaded and run today. That is not an accusation — "announce first, release later" is now standard practice for large models — but readers should keep "announced" and "available" separate. Until the weights and the license land, any development plan built on this release should leave room for slippage. Isaac Lab 3.0 is in better shape: it is an open-source framework whose latest version is already obtainable, and according to Unite.AI it has been generally available since October 20, so developers can start working with it today.

Fast in Simulation Does Not Mean Steady on a Real Machine

Where this release most needs a clear head is the gap between simulation and the real machine. The AlphaNIST figure of 98% against 81% was produced in simulation, trained on a binary success signal; the DexBench and VABAR evaluations also run inside Isaac Lab-Arena's simulated environments. Simulation's greatest strengths are that it is cheap, repeatable, and able to run a million environments in parallel. Its greatest weakness is that it is always cleaner than the real world: real cables wear out, real cloth clings with static, real metal parts have tolerances, and sensor noise, changing light, and floor friction can each cut a simulated 95% success rate in half on a real machine. NVIDIA understands this, which is why the announcement keeps stressing a loop of "train, evaluate, and let failures guide the next round of learning" rather than claiming the model is ready for deployment. Sim-to-real transfer remains the hardest problem in the whole robotics industry. Isaac Lab 3.0 and Newton have made it smaller, but they have not solved it.

Three more hurdles go unmentioned in the announcement, and anyone planning to follow this work should keep them in mind. First is hardware cost: the humanoid bodies, dexterous hands, and force-controlled equipment that can run GR00T 2 are not cheap. A free model does not mean a cheap system, and a small team has to budget for hardware, floor space, and safety protection together. Second is safety and certification: factories, warehouses, and hospitals impose strict safety certification on robots, and a policy that performs perfectly in simulation can take years of review before it is allowed near people at work. Third is data licensing: the 100,000 hours of human video are open-sourced, but the announcement says nothing about who the people in the videos are or whether the licensing chain is clean for commercial use, including portrait and privacy questions. Put those three points next to the evaluation numbers and the conclusion is clear: GR00T 2 is a solid demonstration of capability and a measured release. It proves the "learn by watching people" approach works in simulation, but between working and being usable stand hardware, certification, and licensing. After the code arrives in December, the thing to watch is not who else reproduces 95%, but whether any team can hold onto even half of that number on a real machine.

What It Means for Vibe Developers

This release looks far away from the average vibe developer: nobody is training a shirt-folding humanoid in a bedroom. But its direction deserves attention from everyone building AI products. For the past two years, AI progress has mostly happened on screens — chatting, writing code, drawing pictures. GR00T 2 represents the same "foundation model plus large-scale data" playbook moving into the physical world. If the 100,000-hour human video approach works, the cost of acquiring robot skills could collapse the way text data costs did: everyday human activity is itself an endless supply of demonstrations. The more immediate lesson for independent developers is on the simulation side. Isaac Lab 3.0, Newton, and Lab-Arena are open source, and the Video to Data challenge is public, which means one person with one machine can take part in training and evaluating robot skills without buying a robot first. That is the story NVIDIA is really telling here: robots no longer belong only to companies with hardware labs. Watch people work, practice in simulation, compare on benchmarks — that pipeline is opening up to everyone. Whether it works will become clear after the code arrives in December and the community tries to reproduce that 71% and that 95%. Until then, stay excited — and stay patient.

Views 4Comments 0

Comments (0)

ME
0/1000
Loading comments...

Sources

Browse projectsPublish your project

Related articles

A developer with glasses types on a laptop at a wooden desk, an external monitor to the left showing C code on a dark background, a small plant on the desk
News
Microsoft's Coding Model Stops Playing Second Fiddle: MAI Code 2 Scores 96% of Opus 5.5 for 5% of the Cost — Read the Three Caveats First

On 17 November 2026, Microsoft launched MAI Code 2 and Code 2 Flash: the larger model has 77 billion active parameters and a one-million-token context, averaging 63.2% across four benchmarks — close to GPT-6.1 Sol and Claude Opus 5.5 — at $0.309 per task. Read the three caveats first: promotional pricing, the lowest score of the three, and no long-horizon work.

Developer WorkflowProduct LaunchModel Updates
Against a black background, a conductor seen from behind raises a baton, with swirling trails of light circling beneath him like an orchestra being conducted
News
One API for 45 Models, and It Switches Providers When One Fails: Perplexity's Orchestrator Wants to Be the Switchboard

On 17 November 2026, Perplexity launched the Orchestrator API: one interface reaching OpenAI, Anthropic, Google, xAI and open-weight models such as GLM, Kimi and DeepSeek, billed at the answering model's published rate with no platform fee. When one provider fails, the same model retries on another deployment, and preview routing assigns requests to models by task.

Developer WorkflowProduct LaunchModel Updates
In a dim office, a developer wearing glasses sits with his back to the camera before several monitors showing code, lit by blue and purple light
News
The Fourth Gemini 4 in Seven Weeks: Neon Sits Between Carbon and Hydrogen, Selling Speed With Enough Smarts

On 18 November 2026, Google released Gemini 4 Neon: third overall on the Artificial Analysis Intelligence Index (61) and first on the Coding Agent Index (58.6), priced at $3 per million input tokens and $15 per million output. It sits between the heaviest Carbon and the lightest Hydrogen, conducting teams of Hydrogen subagents in Antigravity — yet per token it is November's priciest Gemini 4, only becoming the cheaper middle option after 1 December.

Product LaunchModel UpdatesAI Coding