One Model Won’t Solve Physical AI

Scale has made robots far better at seeing and moving. It has not, on its own, made them able to do the work.

Watch a person do any physical task, whether cooking, assembling furniture or crossing a crowded station, and you do not see one model at work. You see perception, memory, planning, motor control and error correction trading off constantly. You notice when something feels wrong, change your grip, try another way, and remember what worked last time. A model that can perceive and act is necessary. It is not sufficient.

That is what lets a professional footballer, trained for years on one game, play a decent game of basketball far sooner than a beginner. Their muscles are the same. Something above them noticed what was different, kept what transferred and rebuilt the rest while they played. Humans are the best embodied agents because we think about our own thinking. Robots are starting to get planners. They don’t yet have this.

I think that missing layer, not one bigger model, is what stands between robots that perform and robots that hold down a job. It has to learn on the job, safely and from very few attempts, without retraining the models beneath it.

Scale worked, partway

The bet of the last few years was that a big enough model would give us general-purpose robots. Part of that bet has paid off. Vision-language-action models and world models have made robots far better at seeing and moving. Figure, NVIDIA and Physical Intelligence now pair a slower reasoning model with a fast action model. Google’s Gemini Robotics planners break a task into steps and judge when a step is done. Physical Intelligence is teaching policies to improve from their own practice. This is real progress.

But in almost all of it, the model is still where learning happens. To get better at a new job, the model is retrained.

The old software paradigm

Most robots are still built the way they were when the first Unimate went to work at General Motors in 1961: one cell, one robot, one program. You program or train a system for a specific task, in a specific environment, on a specific robot. It works until something changes. A part is slightly different, the lighting shifts, an object is out of place, a grasp fails, and execution breaks. Then the loop starts again.

For most robots at work today, foundation models changed what a robot can learn more than how it learns. The program became a policy, but the cycle mostly stayed the same: collect demonstrations, retrain, redeploy, and wait for the next failure. Every new task, site or meaningful change starts largely from scratch, which is why integration can cost four to five times as much as the robot itself (MIT Work of the Future).

The newest planners now break a task into steps, call models as tools and judge when a step is done. In most deployments, what still falls to the engineers who babysit them is everything between attempts: working out why it failed, deciding what to change and carrying the lesson into tomorrow.

Five million industrial robots are at work worldwide, a record (IFR, World Robotics 2026). Yet in US Census Bureau survey data for 2016–18, around nine in ten manufacturing firms used no robots at all (Acemoglu et al., via MIT). That needs to change.

Why the physical world has no undo

This is the opposite of how digital AI works. In software, a sloppy answer is a re-prompt away from a better one: you see the result, adjust, and get something better in seconds, at minimal cost. The physical world pushes back. A wrong grasp drops the part, a bad force cracks it, a misjudged motion hits whatever is in the way, and there is no undo. As a16z’s Oliver Hsu has argued, what holds back deployment is worst-case reliability, not average success.

That changes what learning on the job has to look like. A robot cannot improve by trying everything; it has to know the limits of what it may try and explore safely inside them. Nor can it try very often. The data that truly scales in robotics is on-domain experience, this robot, this part, this cell, yet no one can run a million trials on one machine in one factory. Whatever learns on the job has to take a lesson from every attempt, failures included.

That is also why learning only from what happens on the robot will not scale on its own. The layer above needs a grounding engine beside it: one that takes each real attempt, rebuilds the scene in simulation, varies it, and turns a handful of real failures and recoveries into many more, so the robot learns from far more than it ever has to live through.

And failures will come. No one does physical work without error; a surgeon with ten thousand operations behind them still misjudges a cut. Expertise is not never failing. It is noticing at once and recovering.

What is still missing: thinking about thinking

What I mean is a layer that thinks about the robot’s thinking, and its own. Psychologists call it metacognition. It works out what a task needs and what success looks like, knows how far to trust each model it has and when to use none, explores only inside safe limits, and keeps what worked across attempts, all without retraining the models underneath.

Policies map what they see to what they do next. Planners above them now structure the work and check progress within a task. What is still thin is what people lean on most: knowing how far to trust yourself somewhere new, exploring only inside safe limits, and remembering what failed yesterday.

Generating more actions is not the hard part. Models can already propose a grasp, a motion or a few lines of code in seconds. What makes a robot autonomous is the step between proposing and doing: establishing whether an action is admissible under the conditions in front of it, what must be true before it runs, which constraints apply and what could go wrong, then committing to it, checking the outcome and recovering if it failed, without a person in the loop. Without that, you have increasingly sophisticated guesses, not physical autonomy.

Robots need a layer that reasons over the existing stack rather than replacing it: one that works out what a task requires, notices when the world changes and remembers what worked, while the robot is working rather than offline in advance.

Three objections

“One end-to-end model will learn the whole job.” Better models are welcome, and they make the layer above stronger, not unnecessary: it gets better tools to use. But a single model still has to be retrained for each new site, part and change, and every site is different. Something still has to decide what success looks like, notice when it hasn’t happened and carry the lesson forward.

“Policies will just learn from deployment.” Practice on a real robot is slow, costly and risky. No one can run a million trials in one cell, and learning that runs through retraining still takes the robot offline. That is exactly why the layer above, and the grounding engine beside it, matter.

“Chaining models compounds error.” It does: at 95% success per step, a ten-step task succeeds only about 60% of the time. That is the argument for the layer, not against it. Over a long task, what keeps the job on track is noticing a failure mid-task and recovering, not hoping every step goes right.

A new software paradigm

That layer can now be built, and versions of it are being built across the field. Language models made reasoning cheap: a system can now read a goal, break it into steps and write the program to carry them out. Vision-language-action models and world models have become capable components, even if none is the whole answer. And the hardware is already in place, with the cameras, grippers and sensors that feed today’s robots.

Digital work had its moment when language models learned to drive the tools around them. Physical work has not had that moment yet. That is the opportunity: not a bigger model that replaces the stack, and not one more model inside it, but a layer that makes the models already there better at the job without retraining them.

With that layer in place, software stops being something written once and frozen on the robot. It keeps writing itself on the job. Given a goal, it plans the work, chooses which model or tool each step needs, or none, writes the recipe, and judges every step against what success should look like. When conditions change, it adapts online, often with a few lines of new code rather than a retraining run. It looks across many attempts, real and simulated, and many demonstrations, keeps what works and drops what does not, so each task starts from a better place than the last.

This is how people become specialists, too. We start with broad, general capabilities: balance, grip, reach, judgement. On that horizontal base, practice builds depth in one craft, whether surgery, welding or football. The layer above gives robots the same path. A shared foundation of skills and primitives spans every task and every body, and from it each deployment goes vertical, becoming expert in its own work.

The result is the same machines on the same stack, taking on high-mix, variable work that has been too costly to automate, with small changes on the job instead of reprogramming projects.

The breakthrough in robotics will not come from one larger model that tries to do everything. It will come from the layer that knows how to use, coordinate and improve the models and tools that already exist. That is the shift from the old software paradigm to one that can actually work in the physical world.