AI Agents Are Taking Over the Slow Part of Robot Simulation Training

The most interesting thing about a virtual robot duck that stalks a cat isn't the duck. It's that a language model handled most of the slow, fiddly work that normally eats weeks of a roboticist's time: writing the simulation, running experiments, reading the results and adjusting the training setup. That's the shift worth paying attention to.

A duck, a cat, and a few hours of work

The project started with a simple goal. Using OpenAI's GPT-6 Sol, the author trained a virtual version of Microduck, a small robot from Pollen Robotics and Hugging Face, to walk around a room and identify any Bengal cats nearby. The simulated robot's eye view appears in the top corner of the clip, and it waddles toward its target with a fair amount of determination.

The physical robot hasn't shipped yet, so the work so far lives entirely in simulation. The author's plan is to have the robot dispense a treat for their pet Bengal, Leona, by bowing its head to release one from a 3D-printed storage chamber mounted on its head. The simulated behavior is simple enough that the author expects it to transfer to the real hardware, though that's the step where most projects like this get complicated.

What stands out is the timeline. The author says the coding and training took a few hours. Without the model handling the heavy lifting, the same work might have taken weeks of figuring out how the robot's sensors, joints and environment fit together. The reason it worked, in the author's account, is that the latest OpenAI models are good at reasoning about 3D representations of the physical world and turning that reasoning into code, agent actions and training runs.

Simulation is where robot projects usually stall

Here's the thing: simulation is the bottleneck for most robot learning. A simulated environment has to be detailed and accurate enough that behaviors learned in it carry over to the real world. A humanoid that dances or a robot hand that grasps objects only works if the simulated physics, lighting, materials and camera geometry roughly match reality. Getting that match right is tedious, and small errors compound.

That's why a result from University of California, Berkeley is worth noting. When OpenAI released Astra last September, professor Ken Goldberg and his students saw demos showing its ability to render 3D images, and they wondered whether it could help build the simulations robots need. One member of Goldberg's lab gave Astra access to Nvidia's Newton physics tool, showed it a video of a real robot, and asked it to recreate the scene in simulation.

According to Goldberg, the model produced a full 3D simulation within an hour, with the camera position, lighting, background and materials all set. He also says Astra can automate much of the routine work of training in simulation by running experiments and examining the outcomes. That second part matters more than the first. Building one scene is a demo. Running a loop of experiment, evaluation and adjustment without a person babysitting each step is what changes how a lab works.

How the agent loop actually ran

The duck project used a similar pattern on a smaller scale. The author paired GPT-6 Sol with Hermes, an agentic harness from Nous Research, and ran the work on an Nvidia DGX Spark, a personal machine with a powerful AI chip. The model used Nvidia's Isaac Sim to send instructions to a controller for the virtual robot. It then watched videos of the robot's behavior to judge how well things were going, and suggested changes to the training regime.

That loop of act, observe, critique and adjust is the part I'd watch. Coding models have been able to write robot control code for a while. What's different here is that the model also judged its own results from video and proposed the next experiment. That's closer to how a human engineer works through a training problem, and it's what let the author get a stable walking gait without toppling over.

The limits showed up quickly. The author tried to teach the robot to moonwalk by feeding the system a GIF of Michael Jackson's famous move. After hours of effort, the result was a fairly jaunty backward jog. The gap between "walks stably" and "reproduces a specific expressive motion" is still wide, and it's a useful reminder of where current systems are strong. Stable, goal-directed locomotion is one task. Matching a human's stylized movement from a single reference clip is another.

From one robot to reusable skills

Researchers working on the bigger problem are pushing in the same direction. Jim Fan, a researcher at Nvidia who has worked with Goldberg, argues that the way AI now controls robots resembles how software agents operate. Vision-language-action (VLA) models, which map visual input and language instructions to physical actions, can be called by a language model the way an agent calls a tool on a computer.

This week, Fan, Goldberg and collaborators open sourced an agentic framework for robots called Aspire, which lets a robot discover and reuse new skills. In one example, Astra worked out how to use a pair of robot arms to solve a Rubik's cube. Fan described the process as trial and error: the robot picked up the cube, tried to twist it, got the angle wrong, reasoned for a long stretch, and eventually solved it by building up skills over time.

At the Conference on Robot Learning in Austin, Texas, Fan showed another demo. Astra controlled a robot arm and was told to paint the Golden Gate Bridge, using paint and brushes placed nearby. The model completed the task. Demos like this are impressive, but the more useful signal is the pattern underneath: the system finds its own way through an unfamiliar physical task rather than following a script written for that exact job.

What still doesn't work

None of this makes robotics easy. Getting robots to work reliably and efficiently still demands serious engineering, and the author is blunt about it: the vision system on the robot duck isn't good enough to deploy in a real product. Simulated success doesn't guarantee real-world performance, and the sim-to-real gap is exactly where many promising projects lose momentum. Speed of iteration helps, but it doesn't remove the need to test on hardware, handle sensor noise and design for failure.

There's also a question of what the model is actually doing. In these examples, the AI is doing planning, code generation, simulation setup and evaluation. The physical reliability still depends on hardware, sensors and careful validation. Expect the human role to shift toward defining goals, checking results and handling the cases where the agent gets stuck, rather than disappearing.

What to watch next

Goldberg says a number of industrial robotics and automation companies have expressed interest in this approach. That interest makes sense. Manufacturing and e-commerce both rely on robots that need to be reconfigured for new tasks, and cutting the time to build and tune a simulation could change the economics of that work. Whether that happens will depend on how well simulated training holds up on real equipment across many tasks, not on single showcase demos.

The comparison to vibe coding is apt. A few years ago, people started writing working software by describing what they wanted and letting a model fill in the details. The author suspects something similar could happen with robots, as hobbyists and engineers discover how quickly they can program and train machines. If that happens, the interesting question won't be whether a model can make a duck walk. It will be how many people can now get a robot to do something useful without a month of specialist setup. And, assuming the vision system improves, Leona may finally stop going without treats.