Getting an industrial robot to do useful work has never been the hard part — describing the work to it has. Programming a new robotic workcell takes weeks to months, and the code always lands at the worst point in the project: after the robot, feeders and conveyors are physically installed, with the deadline looming. UC Berkeley’s AUTOLAB and Nvidia are proposing a different division of labour, unveiled this week at CoRL 2026 in Austin: teams of AI coding agents write, simulate and refine the robot programs, with humans supervising rather than hand-tuning every behaviour.
“Agentic robotics is a fundamental shift in how robots are programmed,” said Ken Goldberg, the William S. Floyd Jr. Distinguished Chair in Engineering at UC Berkeley. “Instead of collecting massive amounts of data and hand-tuning every behavior, teams of agents can quickly generate, test, and refine robot programs that allow human engineers to interpret how the programs work for fine-tuning and verification.”
The demo that makes the case
The centrepiece is RoboSimStudio, an open interactive toolkit for rapidly building physics simulations of real robot tasks. According to Goldberg, in September his graduate student Kaiyuan (“Eric”) Chen gave the then-new GPT-6 Astra model the tool and a video of a robot wiping a bar with a sponge — and within about an hour, through iterative trial and error, it produced a Newton physics simulation closely matching the video. The underlying research is public as an arXiv preprint, first posted on 13 October, with Berkeley and Nvidia authors including Eric Heiden, Erwin Coumans, Miles Macklin and Spencer Huang, director of product for robotics at Nvidia.
That hour-long turnaround matters because of what the simulation unlocks. Newton, Nvidia’s open-source physics engine, is powerful but exposes hundreds of parameters, which Goldberg says kept most developers from using it at all — too many dials and switches. RoboSimStudio puts sliders on those parameters next to a visualiser, which turned the simulator from a bottleneck into something an AI agent can tune on its own. And the agent needs it: the whole approach is a loop where agents write robot code, test it in simulation, see where it fails and revise. The project site shows the full pipeline — a smartphone video plus a one-line prompt becomes a multiphysics simulation (rigid bodies in Newton coupled with a deformable-object FEM model in SuperDex), which humans and agents inspect until it matches the video, and from which a trained policy runs back on the real robot.
The pieces: GaP organises the agents, VABAR grades the homework
Two more open components round out the stack. Graph-as-Policy (GaP) is a modular framework that splits a task into skills — perception, grasp planning, collision-free motion — each assigned to its own agent, so they work in parallel without stepping on each other’s toes. The graph structure doubles as the harness: thousands of prompts and structures constrain the agents, and Goldberg credits it as the difference between this and ordinary “vibe coding” of an app. The output is readable Python calling existing vendor modules for low-level control — it slots beside an existing robot controller rather than replacing it, and converts to ROS 2.
VABAR — the Variational Automation Benchmark for Agentic Robotics — is the grading rubric, built on Nvidia’s Isaac Lab-Arena and Newton. Six contact-rich industrial tasks (tool sorting, tool hanging, gear meshing, syringe packing, cable insertion, cable routing) with standardised variations and difficulty tiers, so researchers can measure whether agent-written programs survive changing conditions rather than acing a single scripted run.
Who is actually using it
The industrial endorsements give the research its weight beyond academia. Bosch is evaluating agentic robotics for industrial automation: “It generates interpretable code that engineers can thoroughly analyze before production deployment,” said Liu Ren, senior vice president and AI fellow at Bosch Research, which is collaborating with the Berkeley team. Ambi Robotics reports the approach is already in production — “Agentic robotics converted production data into robot behavior updates, increasing throughput across our U.S. fleet while keeping engineers in control,” said co-founder and CTO Jeff Mahler, whose company Goldberg advises.
Our take: the code-shaped hole in the data flywheel
This is the factory-floor counterpart to Nvidia’s GR00T 2 world action model announced at the same conference. GR00T 2 attacks the data problem — learn from human video and a handful of demonstrations. The Berkeley stack attacks the code problem: most of the world’s robots are industrial arms already installed and waiting for someone to program them, and no amount of learning transfers fixes the weeks it takes to write that code. If agent-written, human-verified programs cut workcell programming from months to days, the installed base becomes programmable at software speed, which is arguably the bigger near-term prize.
A couple of caution flags of our own. First, this is, as far as we can tell, the definitive public source on a story not yet independently reported elsewhere — as of publication, coverage traces back to The Robot Report’s interview and the team’s own papers and project sites; the claims above are the researchers’ own. Second, the bottleneck has arguably moved, not vanished: simulation-to-reality transfer is where similar pipelines have historically lost their promises, and a sponge-wiping demo matching a video is a much easier physics problem than a cable-routing benchmark is a real-world one. VABAR exists precisely to measure that, which is the right instinct.
The NZ-read: an open-source stack that turns robot programming into prompt-plus-verification work is worth more to a country of small manufacturers than another closed model. The same integration-over-licensing dynamic that made open robot platforms the practical entry point applies here — the tools are public on GitHub, and the skills to drive them are the ones the country’s software workforce already has.
