Robotics Is Moving Beyond VLA: The Closed Loop Comes Next

In a DreamZero research clip, an AgiBot reaches towards a trainer and works at the knot in its laces. The scene is stubbornly undramatic. There is no humanoid striding through a factory and no cinematic voice-over. There are two grippers, one shoelace, and one instruction: untie it.

That modest task exposes the problem I care about. A robot can recognise a shoe, understand the verb “untie”, and move its hand towards the lace, yet still tug the wrong segment and tighten the knot. Language understanding gets the robot to the trainer. It does not tell the robot what this particular pull will do.

That is why I think robotics is moving beyond the stand-alone vision-language-action model. The VLA is not disappearing. It is being reduced from the whole answer to one part of a cycle. A capable robot must predict before it acts, correct itself while the world is moving, and learn after the attempt fails.

The easiest way to understand that architecture is to replay the shoelace attempt and pause it three times: before the gripper moves, while it pulls, and after the knot refuses to open.

The robot understands “untie” and still reaches from habit

A VLA learns a useful shortcut from camera observations and an instruction to robot actions. Web-scale pretraining helps it understand that a lace is part of a shoe and that untying means separating the knot. Robot demonstrations connect those ideas to an executable policy.

That works well when the required movement resembles something in the robot data. When it does not, the semantic knowledge can point in the right general direction while the body falls back to habit.

The DreamZero paper makes that failure unusually clear. On ten AgiBot tasks that were absent from training, its pretrained VLA baselines often defaulted to pick-and-place motions regardless of the instruction. DreamZero reached 39.5% average task progress, compared with 16.3% for the strongest pretrained VLA baseline. These are the research team's own partial-progress scores, not a claim that the robot reliably untied every shoe. The released code and checkpoints make the work testable, but they do not make that evaluation independent.

The interesting result is the type of mistake. The baselines did not lack a word for “untie”. They lacked a convincing physical motion for it, so they reused a familiar one. This is the robotics equivalent of answering a difficult question with a fluent sentence about something else.

At this first pause, before the gripper moves, the missing question is precise: if I pull here, what happens to the knot?

Before the pull, the robot needs a future

A world model tries to answer the question the VLA skipped. It predicts how the scene is likely to change, sometimes after a proposed action. For the lace, the useful prediction is not a polished image of a shoe. It is the difference between a loop loosening, a knot tightening, and the gripper sliding off.

DreamZero couples that prediction to control. It is a world-action model: its video backbone predicts a future transition while the same network produces the robot actions intended to cause it. The name is new and not standardised, but the idea is easy to see at the trainer. The robot should choose a pull that leads towards an open lace, not merely one that looks like a familiar hand movement.

This matters because physical knowledge can come from more places than robot teleoperation. Ordinary video shows fabric folding, lids rotating, objects falling, and knots changing shape. It has no AgiBot motor commands, but it contains an enormous amount of cause and effect.

Meta's V-JEPA 2 gives that claim some weight. Meta pretrained it on more than one million hours of internet video, then used fewer than 62 hours of DROID robot data to make its predictions action-conditioned. The video supplied broad experience of how scenes change. The much smaller robot dataset connected that experience to actions a Franka arm could execute.

I would not turn that ratio into the claim that internet video replaces robot data. It cannot tell a particular hand which joint command to send, what force it applied, or whether a hidden contact began to slip. My article on physical AI training data examines that missing record. Video can supply a physical prior; the robot still has to ground it in its own body.

The world model has now chosen a promising pull. Then the gripper closes, the lace moves, and prediction meets the less accommodating world.

During the pull, reality rewrites the plan

The predicted motion begins. One gripper holds the lace while the other pulls. A few millimetres of slip can now invalidate the plan. This is where I stop caring how persuasive the model's imagined future looked and ask how quickly it notices the real one.

Large robot policies often use action chunking: they predict several commands at once so the robot can keep moving without waiting for another expensive inference call after every tiny motion. The cost is temporary blindness. While a chunk is executing, the object may shift and the next command may already be stale.

DreamZero's paper reports an optimised system that generated a chunk every 150 milliseconds and controlled the robot at 7 Hz. The released inference server currently documents about 0.6 seconds per inference on GB200 hardware and about three seconds on H100 after warm-up. That difference is not a clerical detail. Control latency decides how far the lace can move before the policy reacts.

Vision is also weakest at the moment contact matters most. The camera may show the gripper in the right place while hiding whether it has pinched one lace or two. Tactile sensing can reveal pressure and slip; proprioception tells the system how the robot's own joints actually moved. Prediction proposes a motion; contact determines whether it survives.

This creates two clocks. A slower embodied reasoning system can interpret “untie the shoe”, choose a strategy, and decide when to retry. A fast action policy and whole-body controller must deal with the moving lace, joint limits, and balance now.

Google DeepMind's Gemini Robotics 2 demonstration makes that division visible on a humanoid. A high-level reasoning model plans a packing task and tracks progress while the VLA and lower controllers coordinate Apollo 2 from its feet to its hands. It is a company demonstration rather than a reliability study, but the separation of timescales is the point.

Return to the trainer. The robot has pulled, corrected, and stopped. The knot looks different. The next question is deceptively difficult: did that action actually help?

After the pull, somebody has to say whether it worked

A moved lace is not necessarily a looser knot. The gripper may have dragged the shoe across the table, widened the wrong loop, or produced a final image that looks closer to success while making the next pull harder. Unless the system can judge the result, it cannot know whether to continue, retry, or abandon the approach.

That is the job of a reward model or progress evaluator. It watches an attempt and estimates whether the robot moved towards the goal. For the shoe, the question should be brutally concrete: is the knot actually coming apart?

Once that judgement exists, reinforcement learning can use it to improve the policy. The old picture of RL is a robot starting from ignorance and failing thousands of times on real hardware. The more plausible current recipe starts with a capable pretrained policy, uses demonstrations to give it sensible behaviour, and applies RL to the failures and near-successes that remain.

World models make that process cheaper by letting the robot practise some attempts without moving the real machine. Microsoft's RAW-Dream has a VLA act inside rollouts generated by a pretrained world model, while a vision-language system supplies the reward. The policy can try another pull in an imagined scene before risking another physical attempt.

The arrangement has an obvious trap. A generated lace may pass through the gripper, and a visual evaluator may reward a knot that only appears looser from one angle. RAW-Dream includes a verification step to reject unreliable rollouts for this reason. A policy will exploit a bad judge with great efficiency.

This is why I find failed trajectories more valuable than their place in polished demos suggests. They show reward models what incomplete progress looks like and show policies where recovery begins. Robometer, for example, learns progress, success, and preferences from expert, suboptimal, and failed robot trajectories rather than treating only perfect demonstrations as useful.

The first pull has now produced something that the original VLA did not have: a prediction tested against contact, an explicit judgement of the outcome, and a failure that can change the next attempt.

The second pull is the test

Before the first pull, the robot needed to compare possible futures. During the pull, it needed fresh sensory feedback before its action became stale. After the pull, it needed to judge the result and turn failure into a better policy. These are three different loops operating at different times, even when researchers place several of them inside one network.

None of the projects in this article proves that the full system works reliably. DreamZero provides strong evidence for coupling physical prediction with action. Gemini Robotics 2 shows why long-horizon planning and immediate control belong on different clocks. RAW-Dream explores how imagined outcomes can improve a policy. Joining those pieces without compounding their errors remains the hard part.

So when I say robotics is moving beyond VLA, I do not mean that VLAs are finished. They remain a powerful way to connect vision and language to action. I mean that producing a plausible next action is no longer a sufficient definition of robot intelligence.

Back at the trainer, the gripper approaches the lace again. This time the pull should carry a predicted consequence, remain open to correction, and leave behind useful evidence if it fails. Otherwise the robot has learnt nothing and the “general-purpose” label is doing all the work.

The interesting machine is no longer the model that knows what a shoelace is. It is the loop that can learn why the knot did not come undone.