People will tell you manufacturing had its decades of development — mature, saturated, done. Maybe. But there has never been a moment when this much intellectual firepower was pointed at this industry.
1. Two storylines
Physical AI is entering the factory through two storylines, and they run on separate channels.
The first: the end-to-end, closed-loop robot — an AI and a body fused into one device. The humanoid is its poster child. Camera in, joint angles out, and no human ever wrote a line of process logic in between. March’s GTC was this storyline’s home game: Jensen Huang said every industrial company will become a robotics company, with 110 “robot brain” developers in the audience. GR00T N1.7 went to commercial licensing under Apache 2.0; N2 got a preview.
The second: existing machines, wrapped in an agent loop and layer after layer of guardrails — a system that accumulates. This storyline doesn’t build new bodies. It takes the bodies we already have — PLCs, robot arms, engineering toolchains — gives them interfaces an agent can call, stacks independent checks outside those interfaces, and lets every call and every check leave a trace that compounds. Hannover Messe in April and the ninety days after it were this storyline’s home game. Siemens shipped Eigen, an agent that writes PLC code inside TIA Portal and validates its own work — in Siemens’ own words, it “plans, executes, and validates” engineering tasks end to end. It shipped as generally available, in front of 600,000 TIA Portal users; Siemens says more than 100 companies in 19 countries are already using it. Rockwell strung Emulate3D, FactoryTalk Design Studio and a Copilot into one pipeline — the controller project is fully tested in simulation before it ever touches hardware — and took it commercial in May. On June 23, Beckhoff released TwinCAT CoAgent, which at its core is an MCP client: any model plugs in, local models included, air-gapped if you need it.
The two storylines are in very different places. The first is still looking for a cell — a workstation forgiving enough, slow enough, reversible enough for a humanoid to prove itself in. The second is rewiring manufacturing at scale — not in one cell but across the engineering toolchain, with three hundred-year-old giants moving in a single quarter.
This piece is about the second storyline. Not because the first doesn’t matter — because the second is actually happening, while most people are watching the first.
2. Why the first storyline is still looking for a cell
I’ve written about the wall this path runs into (The Submillimeter Trap of Embodied AI): an industrial robot’s repeatability and its absolute accuracy differ by a factor of twenty, every precision process in production today is built on repeatability, and the end-to-end paradigm thinks in absolute positioning. That wall is still standing. The models that shipped this year did not knock it down.
Same machine, same datasheet: repeatability 0.025 mm, path accuracy 0.53 mm — a 20× gap, with the ±0.3 mm deburring tolerance sitting right between them. Data: ABB IRB 1200 official datasheet.
So “still looking for a cell” is not a sneer. It’s a statement of physics: the cells a humanoid can occupy today live where precision is loose, tolerance is high, and failure is reversible — and that is not where most of manufacturing lives.
A qualitative map — no units, author’s judgment. Humanoid demos sample the lower left; manufacturing lives in the upper right. The two annotated points tell one rule: the order in which tasks get eaten is set by verification cost and failure cost, not by how “intelligent” the task looks. Palletizing sits in the overlap — it commoditized first. Inspection sits in the cheapest-to-verify corner — it became industrial AI’s first beachhead.
But this piece isn’t a retraction of that one. Quite the opposite. That piece said the “model holds the grinder itself” road is hard. This piece says a different road is quietly becoming fact: the model doesn’t need to hold the grinder. It needs to be able to call the machine that already knows how.
And that changes the test. The question is no longer “how smart is this machine.” It’s “can this machine be called.”
3. Three tests, and a blunt claim
First, what “inside the agent loop” means. An agent’s core move is simple: read the current state, pick a tool, the tool runs, the result comes back into context, look again. I wrote in “The Builder Cannot Be the Verifier” that this loop takes a few dozen lines of code. The hard part is the ring around it — who may call what, what gets checked before a call, who confirms the result, how you replay what it saw when something goes wrong.
For an industrial process step to enter that loop, three things are the floor:
It can be called, structurally. Not “there’s a screen you can click” — another program can send it instructions in a defined format and get results back in one.
Its state can be read out and injected back. The agent has to know which operation the line is on, where the workpiece sits, how far the last pass got — and a human has to be able to take over mid-task.
Its actions can be verified independently and replayed. Every execution gets a check that does not belong to the executor, and afterwards you can see exactly what it saw.
These read like software engineering. They’re what the shop floor has been doing for thirty years. Teach, dry-run, single-step, low-speed, full-speed — the whole ritual of commissioning a robot boils down to one sentence: the mind that wrote the program can’t be trusted, so wrap it in layers of checks that don’t depend on it. The shop floor had harnesses long before software gave them a name.
The word accumulates lives in test three. Every pit you fall into — a coordinate frame off by one fixed transform, a geometry that breaks the standard simplification — becomes a check once you’ve hit it, and the next part never pays that tuition again. The compound interest isn’t in features. It’s in constraints that don’t pay tuition twice. That is why the second storyline can scale: it accumulates. The first storyline relearns half of everything each time it changes cells.
Now the blunt claim: any step that can’t meet those three tests will get squeezed out, fast.
The mechanism isn’t technological backwardness. It’s cost structure. Picture a chain where eight of nine steps can now be run by agents — proposal, simulation, deployment, tuning, monitoring, anomaly triage, reporting, review — and one step still needs a human hand. Its absolute cost hasn’t moved. But it just became the only place the whole chain waits, and its relative cost explodes. Capital routes around bottlenecks. It doesn’t wait for them.
Notice what this has nothing to do with: how smart the machine is. An ordinary six-axis arm that an agent can call will outlive a “smart” device that nothing can call.
4. What an AI-native PLC looks like
Take the claim to the most concrete object on the floor: the PLC.
The precondition is already met: the PLC is turning into software. Siemens’ S7-1500V virtual PLC runs on industrial PCs and servers; its fail-safe variant has TÜV certification to IEC 61508 and is running at pilot customers. At Hannover this year, Siemens’ three entry points for manufacturers were the virtual PLC, Industrial Edge for AI workloads, and an open engineering toolchain. Only after control logic moves from dedicated silicon onto standard compute does “callable” become technically possible — you can’t give a structured interface to a board that only speaks ladder logic.
But an AI-native PLC is not a chat window bolted next to a PLC. I wrote about this distinction two years ago: stuffing an AI feature into an existing UI is AI-powered; an architecture that an outside agent can actually operate is something else. Back then I called it AI-ready — leaving a door open for the AI that might come. I wouldn’t put it that way anymore. The door doesn’t need to be left open. The AI is already standing inside it, and the question has become: what happens to the things that have no door.
An AI-native PLC, translated through the three tests:
Its programs are generated by an agent and validated by a loop that doesn’t belong to that agent. Eigen’s validate, Rockwell’s fully-tested-before-hardware — both are this layer.
Its runtime state is readable and injectable by an agent — structurally, not by exporting a spreadsheet.
Every change is replayable and auditable.
Scan cycles, determinism, safety circuits — none of that goes away. It migrates from being properties of the PLC to being the constraint layer around the PLC: checks bolted on outside, stackable, no need to touch the tool itself. An AI-native PLC is not a smarter PLC. It is a PLC surrounded by discipline.
Robot arms, one paragraph, same logic. The change that matters this cycle is not whether the arm can learn — push that line far enough and you hit the wall in section 2 again — but that arm controllers are starting to expose interfaces to agents. Strip the Physical AI packaging off what the arm makers on that GTC list are building on NVIDIA’s platform, and the most substantial layer underneath is exactly this.
5. Three giants, three bets
Half a year of public moves is enough to make out three postures. I’m not ranking them — I don’t know who wins, and you know I don’t — just naming what each is betting on.
Siemens is betting on the closed loop. Eigen lives inside TIA Portal, the virtual PLC runs on Industrial Edge, the toolchain is theirs end to end. Generation, validation, deployment — one house. The upside is the most complete experience on offer. The cost: if this agent can only be used inside TIA Portal, and outside agents can’t call it, then it’s the very thing section 4 warned about — a door that opens inward. I can’t tell yet which way it opens. That’s in the falsifiable markers below.
Beckhoff is betting on the body. CoAgent isn’t a brain — it’s an MCP client. Any model plugs in; local and air-gapped work too. The bet: brains get swapped and brains depreciate, but the body that is easiest to call does not. Of the three, this posture maps most cleanly onto the three tests.
Rockwell is betting on borrowed brains. Azure, Microsoft Foundry, Azure OpenAI — wired into its own Emulate3D and Design Studio for closed-loop validation. It doesn’t build the brain and doesn’t preach openness; it plugs someone else’s brain into its own verification loop. Fast off the line. The brain lives in someone else’s house.
Behind the three bets, one shared judgment: whoever makes “being called” cleanest becomes the default body of the agent era; whoever locks the agent inside its own UI repeats the oldest mistake in this business — hanging an AI sign where the AI can’t reach.
How fast is “fast”? I won’t name a year. My yardstick: watch how long these products take to go from developer preview to GA. Announced in April, commercial in May, released in June. That is not the ten-years-a-generation cadence this industry is used to.
6. Falsifiable markers
A prediction that can’t be falsified is a mood. Four markers; I’ll come back and grade myself:
If into 2027, a giant’s agent still works only inside its own IDE, uncallable by outside agents → revise section 5’s read on that giant’s bet.
If a mainstream VLA enters a precision process station with Cpk data (±0.3 mm deburring, grinding) → revise sections 1–2, and “The Submillimeter Trap” alongside.
If virtual PLCs fail to reach mainstream production lines within three years → revise section 4 — “precondition already met” was premature.
If two years from now, agent calls still stop at the engineering toolchain — writing programs, running simulations — and haven’t entered production runtime: online tuning, anomaly handling, handover → revise section 3 — “rewiring at scale” only rewired the engineer’s desk, not the factory.
7. Dusk or dawn
Back to the opening line.
The people who say manufacturing finished developing decades ago are right about one thing: most of what could be automated was automated, everything lean has been leaned, and the margins are paper. By that story, this is a mature industry, and a mature industry’s next stop is dusk.
Then look at where the intellect is flowing. Crunchbase’s numbers: in the first half of 2026, global venture investment in physical AI was $47.4 billion across 521 deals — more than the $41.9 billion of 2022 through 2024 combined. On PitchBook’s definition, 2025 alone was $27.6 billion across 1,009 deals. A hundred and ten robot-brain developers at GTC. Three century-old industrial giants shipping agent products inside one quarter. That money and those people are not aiming at a sunset industry.
Six months now outweigh three years. Definition: Crunchbase’s physical AI category — robotics, AVs, aerospace, drones, industrial automation, sensors.
We’ve seen this movie recently. After the ChatGPT moment, a flood of research poured into language models and took them from “can chat” to “can work” in about two years — not because of any single breakthrough, but because enough smart people stared at the same problem at the same time. The same thing is starting to happen to manufacturing.
The price of constant-quality intelligence fell ÷1000 in three years (a16z, “LLMflation”; the GPT-4-class tier is ÷62 since March 2023). Cheap brains flow toward cheap verification first — which is exactly why the rewiring started in the engineering toolchain, not on the production line.
So my answer is dawn. With two reservations — and the reservations matter more than the answer.
First, this sunrise will be slower than the LLM one. LLMs matured in two years because their verification loop is cheap: text, benchmarks, minutes per round. Manufacturing’s verification loop is physical. A toolpath point that flies a meter off course is a re-run in simulation and a crash on a production line. The tolerance for error that exists offline does not exist on the floor. No amount of intellectual firepower goes around that loop’s speed — so the intellect pours first into wherever verification is cheap: engineering tools, simulation, offline generation. Which is precisely where the second storyline is happening right now.
Second, dawn only lights half the floor. The lit half is whatever can enter the loop — callable, state readable, verifiable, replayable. The other half — the steps only a human hand can touch, no interface, no independent check — for them, this is dusk. Not because they broke. Because they are about to become the only place the whole line waits.
Dusk or dawn doesn’t depend on which industry you’re in. It depends on whether you’re inside the loop or outside it.
8. A judgment call for decision-makers
You don’t need to know what MCP is. Take three questions to every machine and every piece of software you’re about to buy:
Can another program call it in a defined format — not “it has an API,” but every key operation?
Can its current state be read out, and can a human take over mid-task?
Does every action it takes get a check that isn’t its own — and can you replay it afterwards?
One “no” out of three, and its depreciation curve needs to be recalculated. Not because it’s a bad machine. Because it’s about to become the place where everything else waits.
How to build a system that can enter the loop — the interface, the state, the reins, from zero — is what I’m doing episode by episode on another track. This piece is the why. That one is the how.
First Principles Manufacturing — dispatches from a Novi robotics lab.
amazing...