The closed loop that made code explode has been missing from robotics. Anthropic’s hardware move is an attempt to build it — and it is a more consequential announcement than any humanoid demo.

AI use : 25% — thesis, argument and structure from the author; drafting and data sourcing assisted by AI, full human review. Written September 2026. This is not investment advice.

Start with what a language model actually is, because the whole story follows from it. A large language model is a next-token predictor. You show it a colossal amount of text, and you train it to guess the next fragment. That is the entire objective. It is cheap because the supervision is free: the “right answer” is simply the token that came next in the corpus, so no human has to grade anything. That single property — free, self-supervised signal — is why the method scaled to the whole internet.

But next-token prediction on static text has a ceiling. It teaches a model what fluent text looks like; it does not, by itself, teach the model to be right. To get past that, you need a signal that says this answer was correct and that one was not, and you need it cheaply enough to apply millions of times. For most of what we ask an AI, that signal is expensive: it takes a human to judge whether a summary is faithful or a plan is sound.

Why code was the accelerant

Code is the exception, and the exception explains the last two years. Code is executable. You can generate a candidate program, run it, and let the world tell you whether it worked: does it compile, do the tests pass, does the output match what was expected? The verifier is a machine — the compiler, the test suite — not a person. That means the feedback loop is self-contained. The model proposes, the environment disposes, and no human sits in the middle rate-limiting the whole thing.

A self-contained loop is the thing you can turn the crank on. You can let the model try a million times, keep what passes, and train on it. The same is true of formal mathematics, where a proof checker plays the role of the compiler. This is not a coincidence that coding and competition math advanced fastest; it is the direct consequence of their being the two domains where the machine can grade its own homework. Where the loop closes, capability explodes. Where it does not, progress crawls along at the speed of human labelling.

Hold onto that sentence, because it is the lens for everything that follows: capability tracks wherever the feedback loop can be closed without a human in it.

The two things physical AI is missing

Now point the lens at robots. Physical AI — a model that moves a body through the world, folds the towel, sorts the bin, tightens the bolt — is stuck for two reasons, and they are exactly the two ingredients that made code work.

The first is the absence of a closed loop. In the physical world, a trial is not free. Each attempt costs real seconds, real electricity, real wear on real hardware, and a failed attempt can break something or someone. You cannot run a million towel-folds overnight the way you run a million unit tests. Worse, the reward is not machine-cheap: deciding whether the towel is actually folded is itself a perception problem. Simulation buys you some of the loop back, but the gap between a physics engine and a real bolt on a real line — the sim-to-real gap — is precisely the part that matters. The compiler for atoms does not exist.

The second is subtler and, I think, more decisive: there is no standard way to talk to a robot. Every arm, every gripper, every mobile base ships with its own SDK, its own kinematics, its own action space, its own sensor layout. A policy trained to drive one machine does not transfer to the next. There is no HTTP for robots, no common socket into which any body can be plugged. And this is fatal for the loop, because it means experience cannot pool. Every robot is an island collecting its own data that no other robot can learn from. You never accumulate the one giant, shared stream of interaction that the internet was for text.

Why a standard, not a humanoid, is the real announcement

This is the context in which to read Anthropic’s model–hardware standard, released as a research preview. It is easy to scroll past — a standard is not a dancing robot, and protocols do not trend. That is exactly why it is the load-bearing move.

A common interface between models and machines attacks the second problem directly, and by doing so it starts to fix the first. If many different robots expose themselves to a model through one standard, then a policy can drive any of them, and — this is the point — the experience collected on every conforming machine flows into one pool. The fleet becomes the environment. The loop that could not be closed on a single expensive robot begins to close across thousands of cheap ones, because now their trials add up instead of evaporating in a hundred incompatible formats.

We have watched Anthropic run this play once already, in software. The Model Context Protocol was the same shape of move: instead of a hundred bespoke integrations between a model and the world’s tools and data, one standard socket. A hardware standard is MCP pointed at actuators instead of APIs. And it is worth noticing who is making it. Anthropic does not build robots. A model company proposing the interface to physical hardware is staking a claim that the defining layer of physical AI — the layer that decides who captures the value — is the model and the protocol, not the chassis.

Computer use is closer to a robot than it looks

If that sounds abstract, we already have the miniature version running, and most people misfile it as a party trick. Computer use — a model that controls a screen, clicks, types, and reads the result back from a screenshot — is physical AI with the difficulty turned down. Watch a model open a decades-old copy of Paint and draw a picture: it puts down a stroke, looks at the canvas, and adjusts the next one. That is a closed loop over pixels. Propose, observe, correct.

The screen is the perfect training ground precisely because it is a world you can close the loop on: it is fully observable, it resets instantly, a mistake costs nothing, and a million trials run overnight. It is a sandbox for embodiment that happens to be made of pixels instead of atoms. The gap between “the model moved the cursor to the right place on the canvas” and “the model moved the gripper to the right place on the part” is real, but it is a gap of degree, not of kind. Computer use is the proof that the loop can be closed when the environment cooperates. The hardware standard is an attempt to make the physical environment cooperate.

What this means if you run a factory — or invest in one

Here is where I want to be careful, because this is where the money is and where the reasoning most often goes wrong. The capital and the mental models built up in software are now bleeding into the physical world — but the physical world does not obey software dynamics, and pretending it does is how investors lose money.

Software had near-zero marginal cost, near-instant iteration, and winner-take-most distribution. Atoms have none of that. The marginal unit costs real money to build, iteration is slow and expensive, capital intensity is brutal, safety and regulation bind hard, and distribution is physical and local. You cannot lift a software multiple, or a software go-to-market, and drop it onto a robotics company. The dynamics are genuinely different, and the difference is not a detail.

And yet — the same move that made value migrate in software may repeat here, which is the part that should keep both incumbents and investors awake. As the hard, defensible part of a robot becomes the policy that controls it rather than the metal that composes it, the metal drifts toward commodity. The body becomes a fairly interchangeable vessel around a subscription brain. If that holds, the next winners of physical AI may not be the robot makers at all. They may be the software actors — the model labs and the owners of the data — exactly as the value in the language era pooled around whoever owned the model rather than whoever owned the servers.

For anyone running a plant, this reframes the decision you are about to face. The strategic question about the robot on your floor is not going to be “which arm is cheapest.” It is going to be the question I keep coming back to about every enterprise AI purchase: who owns the brain, who owns the data it generates on my line, and how locked in am I? A commodity body running a policy you rent, trained on data you handed over for free, is a very different thing to buy than a machine you own outright. Procurement is quietly becoming a question about vendor lock-in and data ownership, and the factory directors who see that early will negotiate very differently from the ones who think they are just buying equipment.

The scramble for the missing data

All of which explains the strangest behaviour in the market right now. If real-world interaction data is the true bottleneck — because you cannot close the loop cheaply without it — then whoever collects the most of it holds the scarce asset. And so a race for physical data is on, run with two very different playbooks.

One is state-directed: the Chinese approach of standing up data-collection at industrial scale — teleoperation farms and heavily subsidised deployments whose real output is not the task performed but the stream of demonstrations harvested while performing it. The other is market-driven: American startups subsidising robot butlers and humanoids into homes and warehouses, selling the hardware at or below cost, because the razor was never the point — the blade is the loop of interaction data flowing back. In both cases the hardware is a straw, and the thing being drunk is experience. It is a land-grab, and what is being grabbed is the training distribution of embodiment itself.

Put the pieces together and the shape is clear. The reason code raced ahead was a closed, self-contained loop. The reason robots did not was the lack of one, compounded by the lack of a shared socket to pour experience into. A hardware standard is the unglamorous, load-bearing attempt to build both at once — and the actors moving on it are, tellingly, the software actors. Standards never make the headlines. They just quietly decide who owns the ecosystem that grows on top of them.

Interesting times.