Recova Speaking Script

In ASENA, we haven’t yet used those recorded runs to train the policy.

In Recova, we explore that next step: using CAP to collect data and improve a learned manipulation policy.

We wanted to see whether this data could be as useful as—or even better than—human demonstrations.

Our end goal is a reliable learned manipulation policy, like a VLA. We use code as policy to make the whole collection, training, and deployment loop as autonomous as possible.

First, we build a digital twin of the real workstation. A coding agent explores how to perform the task—and how to recover when something goes wrong. Successful trajectories then train two policies: a task policy and a recovery policy.

We deploy those policies on real robots, where an agent monitors progress, triggers recovery, and asks for human help when needed. That experience feeds into the next training round. We improve the policies, deploy them again, and repeat the loop.

Recovery is what allows the robot to keep going and keep collecting data. Most demonstrations show successful execution, so policies get little experience recovering from mistakes. Recovery demonstrations and DAgger help, but that data is hard to collect.

We use code as policy to explore failures in the digital twin and generate recovery data. We then learn an explicit recovery policy alongside the task policy. When the task gets stuck, recovery can restore the scene or finish the remaining action.

We collect data for both policies and improve them together, each using its own training data.

On the physical robot, execution is different from the code exploration we just saw in simulation.

A learned task policy generates the motor actions. The VLM monitor observes execution and decides whether the task can continue.

When a recoverable failure occurs, it invokes a learned recovery policy with an instruction. If assistance is needed, the system can fall back to an operator. For a new failure, a human can demonstrate a correction; after training, that instruction is added to the recovery skills available to the monitor.

After the correction, the monitor checks the state before restarting the task. We save task experience and recovery experience into their respective datasets. These can improve the corresponding policies in later rounds. Within one collection round, the policy weights are fixed.

On real robots, combining the agent with our learned task and recovery policies gives us a largely autonomous DAgger loop.

Here, one operator supports four workstations. The robots run their policies, recover when possible, and ask for help when needed.

This means we can scale up robot data collection without increasing the number of operators at the same rate. That matters because scaling human supervision is often the harder part.

Like ASENA, we improve over repeated rounds. But here, we use the collected data to update the VLA itself.

As we collect more experience and retrain, the policy gets better. And what’s especially exciting is that human takeover drops to zero in the final collection round of this experiment.

We use our autonomous DAgger to collect the data, and then we add the learned recovery policy. And you can see, the performance gets even better.

Across these two projects, we use robot experience to improve either the agent’s skills or the learned policies.

Once we’ve trained the coding agent, we want to deploy it on real robots and scale up robot data collection.

And I’m happy to take any questions.