How AI agents are starting to train robots on their own

To teach a robot a new action, you normally have to collect data, train a model, test it on real hardware, find where it fails, collect new data and run the training again. Now a different approach is emerging: instead of training a new model for each specific task, the robot is given an AI agent that writes the task program itself, runs it in the physical world, sees the result, fixes the errors, saves what works as new skills — and can then use its own experience to train specialized models.

One of the most interesting examples of this approach right now comes from Waddle Labs — a startup out of Y Combinator 2026. But what matters here is not so much the startup itself as the shift in the whole architecture of robot training.

From VLA to the agent: another layer above the model

For the past few years physical AI has developed mainly around vision-language-action models (VLA). A VLA takes an image from the camera and a command, and then generates the robot's actions directly.

Here the large model becomes not the robot's motor control, but its engineer. And that is a fundamentally different approach.

From training the model to programming behavior

The idea of using an LLM to generate robot control programs is not new. Back in Google's Code as Policies paper, first published in 2022, researchers showed that a model can be used as a generator of robot policies. A human gives a command in natural language, and the model writes an executable program that uses perception and control as the robot's API.

What's more, Code as Policies could already build new functions hierarchically out of simpler ones and accumulate a library of its own code. But today's coding agents can do more. They can write a solution, run it, look at the result, find the error, change the code, run it again. And it is exactly this software development loop that is now moving into the physical world.

The physical world becomes an executable environment

Say a robot has to pick up a part and put it into a slot. The agent gets cameras and a set of available capabilities:

Then it assembles the program itself:

If the part falls out or ends up in the wrong place, the agent receives the new world state, sees that the task has not been completed, changes its solution and runs the next attempt. You get a physical analogue of how a coding agent works:

In a recent paper, CaP-X, researchers compared single-turn code generation for robots with a multi-turn mode, where the agent can see feedback, analyze the result and fix the program. Being able to iteratively look at traces and the environment state improved results for most models. What's more, the agent could recover not only from software errors, but from physical ones too — a failed grasp, for example.

First the model formulates a hypothesis. Then the robot tests it in reality. After that the environment returns the result, and the agent updates its solution. And in the end the physical world becomes part of the compute loop.

But the LLM shouldn't drive every controller

That does not mean the large reasoning model has to be wired directly into every joint of the robot. Quite the opposite. A recent Anthropic paper Claude plays robotics shows clearly how much the result depends not only on the model itself, but on the interface between the model and the robot. The researchers compared several options:

On low-level manipulation, full success for frontier models stayed very low. But when the models were given a VLA or another pretrained controller as a high-level tool, the results improved noticeably. And there is a more fundamental problem — speed.

So the architecture of physical AI will most likely be layered.

So it is wrong to treat agentic robotics and VLA as opposites. Rather, VLA goes from being the whole system to being one of the agent's tools.

The robot starts accumulating skills

The next important step is memory. If the agent solves every task from scratch, there is no real cumulative effect. So successful solutions turn into reusable skills.

Say a robot is learning to grasp the edge of a piece of fabric properly. The first trajectory does not work. The agent changes the contact point. Tries a different angle. Changes the height of the motion. After a few iterations a robust solution emerges. It can be saved as a function — and the next time a similar task comes up, the agent does not have to work out the mechanics from scratch again. It uses a ready-made skill.

This is no longer ordinary memory for an LLM.

Not just memory — building up its own skill library

The same mechanism is being explored independently in CaP-X. There, the agents created helper functions of their own at runtime. The researchers collected the successful traces, picked out recurring patterns and assembled them into a skill library. The skills were not written in advance by a human. They emerged from the agents' own successful actions.

From skills to an in-house data factory

But the most interesting part comes next. An AI agent can be used not only to carry out tasks. It can also be used to produce training data on its own.

Waddle showed this with LEGO. The agent was given the task of grasping and moving an object across a variety of positions and orientations. Over a single night the system ran roughly a thousand attempts on its own, collected the trajectories, and then autonomously trained a policy from scratch on that data.

Robots are starting to produce their own data

One of the main problems of physical AI is the lack of data. For LLMs there is the internet. For vision models there are billions of images and videos. But data on precise physical interactions is far scarcer. To get an example of a specific gripper picking up a specific part at a specific angle, someone has to actually perform that action. That's why robot datasets have to be collected through teleoperation, simulation and manual demonstrations.

An agentic system makes it possible to automate part of this process. It can run the loop by itself:

Failures can turn out to be more valuable than successful actions

Intervention traces are especially interesting here.

So a future model could potentially be trained not only on how to pick up an object correctly, but also on how to work out why a grasp failed and what to do next. You get several levels of learning at once:

A robot experience flywheel emerges

Then you get a rather interesting cycle:

An LLM's ability to write Python code is fairly quickly turning from a competitive advantage into a standard capability. Far more valuable is the accumulated layer of robot experience: which strategies worked, where they broke down, which skills generalize and on what hardware, and how to recover from errors.

But the code may not be the point at all

There is one more interesting paper — VIA. It shows an alternative path. In it the agent doesn't have to generate code-as-policy at all. It gets a visual 3D interface, looks at the environment state, calls a small set of simple, well-defined actions, observes the result and corrects itself.

That's a good counter-hypothesis. Perhaps the fundamental shift is not specifically about generating Python code. Perhaps the more general formula looks like this:

Today the convenient intermediate representation is code. A few model generations from now it could be some other interface. So what matters is not Python itself, but the emergence of a closed agentic loop between a reasoning model and the physical environment.

Google has already arrived at the same stack

It is especially telling that a similar architecture is appearing at the largest labs at the same time. In July 2026 Google DeepMind introduced Gemini Robotics 2. It already keeps several types of intelligence literally separate:

The reasoning model understands the instruction, observes the environment, plans several steps, calls the VLA, tracks progress and corrects itself when something fails. And according to Google, the local version can be adapted to a completely new robot in a few hours, usually using fewer than 200 examples.

From one robot to a team of robots

The next step is a multi-agent system. Waddle describes a superagent that can spawn separate agents for different robots and coordinate their parallel execution.

And this is a logical extension of the whole architecture. If an AI agent can run several coding agents, then the next thing to orchestrate is several physical machines. We then gradually move from AI that runs a single robot to AI that runs a robotic production system.

What is genuinely new here

Put together Code as Policies, CaP-X, ASPIRE, VIA, Anthropic, Waddle and Google's latest models, and a fairly clear direction comes into view.

This is no longer just about an LLM learning to issue commands to a robot. And it is not about code-as-policy necessarily beating VLA. A more fundamental shift is under way.

This is exactly the architecture that the recent papers, taken together, describe best. The physical world becomes an executable environment, successful programs become procedural memory, and errors are used as training data. The large reasoning model here becomes the engineer that ties all these layers together.

Perhaps this is how robots will really start to learn

To my mind, the main question of physical AI is gradually changing.

So the next stage of robotics will probably be the era of agentic physical intelligence, where reasoning agents think and run the process, specialized policies act fast, controllers handle the physics, robots generate experience, and all of that accumulated experience flows back into the system.

And then the robot becomes a machine that can teach itself to work in the physical world.

Related reading

All technology

Sep 2, 2026 A New Era of Sport: How AI Is Changing the Limits of Human Performance Jul 17, 2026 AI Product Discovery: How to Automate Product Idea Generation Apr 5, 2026 One Does Not Simply Ship an LLM to Production: how to manage AI systems in a company