SDA is not an Industrial DevOps Solution

We named the company Software Defined Automation – and we mean it. Industrial DevOps is the first of a string of fundamental problems on the way to physical AI. So let me correct the label myself, before someone files us under it permanently.

At CES in January, Jensen Huang declared the ChatGPT moment for physical AI to have arrived – machines beginning to understand, reason and act in the real world. He is right – and that wave will land on a fact almost nobody talks about: physical AI touches the world through industrial controllers. You cannot deploy intelligence onto compute you cannot address. You cannot train intelligence on code you cannot read. And you cannot secure what you cannot even see. What SDA builds is the ground floor under that wave: the abstraction layer for the world’s factory compute and factory code.

A big claim. So do the math with me.

How big is this, really?

Twice in living memory, an entire sector of the economy received an abstraction layer over its messy, proprietary foundations. Both times, the result was not an improvement. It was an explosion.

In 1982, financial data got its abstraction: one terminal that normalized the fragmented, proprietary information of every market into a single addressable layer. US equity markets traded on the order of 65 million shares a day back then; today it is more than 10 billion – trading volume two orders of magnitude larger. Nobody claims the terminal did that alone. Nobody disputes that finance could not have scaled a hundred-fold on paper tickers.

In 2006, compute got its abstraction: the cloud turned physical servers into instances you address with an API. The result: a market that did not exist twenty years ago grew nearly six-fold in five years – from $156 billion in 2020 to $913 billion in 2025 – and Synergy Research expects it to cross the $1-trillion mark before the end of this year. Nearly every trillion-dollar company on earth is built on top of that layer.

And it is happening a third time, right now: Palantir is building the abstraction for defense data – ongoing, unfinished, and already one of the most valuable software companies in the world. The pattern is not historical. It repeats in front of us.

Now the biggest sector of them all. Industry – the part of the economy that physically makes things – is roughly a quarter of global GDP, on the order of $30 trillion a year (World Bank). It runs on industrial controllers: at least 50 million of them by our own conservative count – recent industry surveys put the installed base above 70 million. This sector is several times the size of the one that produced the most valuable companies in history. And it never got its abstraction. Its compute cannot be addressed. Its code cannot be read. The largest productive system mankind has ever built cannot, in any meaningful sense, be programmed.

That is not a niche problem in a vertical. That is the single largest unabstracted layer of the world economy – and solving it is not optional. It is inevitable. The only questions are who builds it, and from where.

First principles

Strip away the jargon and an industrial Programmable Logic Controller (PLC) is simply a computer. It was invented in 1968 – Dick Morley’s Modicon, built to replace the relay cabinets of General Motors – and the core architecture has barely changed since. Think about that: the machines that move the physical world run on a compute architecture older than the internet, managed with tooling from the 1990s – engineers flying across continents with brick laptops, USB sticks, one proprietary tool per vendor, no version control on the code that moves atoms. Everyone in this industry knows this. Everyone accepted it. We didn’t – and when you reason from first principles, you arrive at two abstractions, not one.

The first abstraction: the compute. SDA makes industrial controllers behave like cloud compute instances – addressable by API, deployable, backed up, secured, rolled back remotely. What virtualization did to the server room twenty years ago, we do to the shop floor. This is why a factory can be onboarded in a day instead of a year.

The second abstraction: the code. We extract the source from proprietary vendor binaries – across every major automation ecosystem – and normalize it into one system of record. What Bloomberg built for financial data and Palantir built for defense data, we built for the source code of production.

The decade that chased the wrong data

Every factory produces two kinds of data. Telemetry – where the atoms hit the bits: the physical world reporting on itself – the actual state of the factory. And source code – where the bits hit the atoms: software deciding what the physical world does next – its intended state. For a decade, the IIoT platform movement chased the first kind. Hundreds of platforms, tens of billions invested, most of it quietly consolidated – not because the idea was wrong, but because telemetry without meaning is expensive noise. The meaning of factory data was in the PLC files all along: the logic that defines what a signal is, what a threshold does, why a line stops. That movement spent ten years building the penthouse on a building with no ground floor.

A feature is not infrastructure

Lately, a wave of new tools has discovered PLC code – version control here, an AI copilot there. Good. Every new entrant validates the need. But a feature is not infrastructure, and the test between them is brutally simple: run it across every controller of a global manufacturer – every vendor, every hardware generation, certified, secured, in productive use, with engineers who get fired if it goes down. Features demo well. Infrastructure carries factories.

That test is not hypothetical for us. Henkel took SDA into productive use across their factory networks – after their engineers spent years breathing down our neck, which is exactly how it should be. And the spectrum is the point: the same layer runs across PepsiCo’s brownfield plants and Electric Hydrogen’s newly built electrolyzer factory – the oldest and the newest of manufacturing on one system. [CANONICAL CHECK: confirm PepsiCo and Electric Hydrogen are in the approved public reference set before publishing.] At Henkel, our AI works on the code of running production lines: machine programs written decades ago, in languages the night shift does not speak, explained in plain English at the click of a button. And for the first time, one system holds both halves of a factory’s state: the intended state – what the machines were told to do – and the actual state – what they actually did.

That last sentence is the entire company.

Physical AI needs a ground floor

At GTC in March, Huang went further: “Physical AI has arrived – every industrial company will become a robotics company.” And every reshoring initiative, every industrial-policy speech, every physical-AI thesis ends in the same place: a night shift, one engineer, one controller, and not the right software to change it. Because the industrial base that matters is not the greenfield plant on a rendering. It is brownfield: tens of millions of controllers already bolted into factories that cannot stop.

Remember the penthouse with no ground floor? This is the ground floor. If you do not control it, you cannot control any floor above it. SDA is that floor – the compute abstraction and the code abstraction on which industrial AI will actually run.

One more thing, because it decides whether this layer deserves to exist: a layer this fundamental must not become another proprietary tower. Openness means: stable APIs, agent-ready interfaces, no data lock-in, and a genuine embrace of the ecosystem that grows on top. The old world locked the factory behind one toolchain per vendor; we will not repeat that mistake one level higher. Want to build your own DevOps on SDA? Be our guest. A layer wins by being built upon – not by locking in.

So call us an Industrial DevOps company if you need a box to check today. You will not be wrong – you will just be early in the story. Industrial DevOps is what happens when you finally address the compute and read the code. It is the first floor, not the building. Physical AI, autonomy, every layer of intelligence still to come – all of it gets built on what we lay down now, or it does not get built at all.

The factory is code. It always was. We made it readable – and programmable.