NVIDIA's GR00T 2 learns robot tasks from few demonstrations. The bigger shift is agents writing robot programs
At CoRL, NVIDIA released GR00T 2 and Isaac Lab 3.0, where agents set up simulations, and showed research where agents assemble readable robot programs. Auditability becomes a design choice.
Listen to this article · 4 min
AI-generated narration of the full article.

A plant engineer asked to approve a new robot cell has always had something to read: a program, written by an integrator, that says what the robot does in each state. Learned robot policies changed that. They can be more capable and much harder to inspect.
NVIDIA’s announcements at the Conference on Robot Learning (CoRL) in Austin show both directions advancing at once, and the choice between them is becoming an architecture decision for manufacturers.
A foundation model that needs fewer demonstrations
GR00T 2, NVIDIA’s robot foundation model, is built on its Cosmos world models and trained on robot data and human video, including 100,000 hours of open human egocentric data. NVIDIA says it transfers skills between different robot bodies, generalizes from little data, and can be controlled by agents through an API.
NVIDIA’s figures: across 50 evaluated tasks, GR00T 2 completed 40 at least once with no task-specific demonstrations, reached 71% average success with one demonstration per task, and 95% with five. Foxconn is applying it to factory automation for server manufacturing, Siemens is evaluating it across industrial use cases, and smaller companies are testing it on laundry handling and cable swapping.
Agents in the simulation loop
Isaac Lab 3.0 lets agents set up training environments, switch between physics solvers, choose renderers and apply a reinforcement learning post-training library. Its integration with the Newton physics engine models deformable objects such as cables and cloth, long a weak spot of robot simulation. NVIDIA claims up to 2.5 times the training throughput of the previous version on a dexterous manipulation benchmark. Isaac Lab-Arena 0.4, a developer preview, composes repeatable evaluations run across thousands of variations in parallel.
The most interesting work came from UC Berkeley. Its Graph-as-Policy framework, tested in NVIDIA’s Isaac simulation, uses agents to connect existing skills into robot programs that people can read. Ken Goldberg, who leads it, is among those quoted on agentic robotics.
How a robot's behavior can be produced
Readable programLearned policy
- Hand-written programFully inspectable; slow to build
- Agent-assembled skill graphReadable structure, generated quickly
- Foundation policy, few demosFast to adapt; harder to inspect
- End-to-end policyMost flexible; least explainable
The choice for factories
For a manufacturer, the question is not which approach is more advanced. It is which one the plant can approve, maintain and investigate after an incident.
Readable programs fit safety cases. Machinery safety standards and internal change control expect someone to describe what the machine will do. An agent that assembles a program from tested skills produces something an engineer can review, version and sign. That is the same logic as making an agent’s repeated work into ordinary software.
Learned policies fit variety. Laundry, cables and mixed retail items vary too much for hand-written states. Few-demonstration learning is what makes those tasks economical, and evaluation, not inspection, has to carry the proof.
Evaluation is the shared requirement. Either way, Isaac Lab-Arena’s thousands of parallel variations point to the right practice: test a cell against the variation it will meet before it meets it. Gemini Robotics ER 2’s success detection adds the other half, a robot that checks whether each step worked.
The headline numbers are NVIDIA’s and will vary by task and robot. The architecture lesson does not: decide, per cell, whether the plant needs a program it can read or a policy it can test, and build the approval process to match.