The Open Standards Stack of the Software-Defined Edge

A factory floor used to be a museum of proprietary contracts. The PLC spoke a vendor dialect. The historian was a licensed appliance you could not export without permission. The HMI ran on a Windows version the supplier pinned for you. The “edge gateway” was whatever box the automation vendor shipped, with whatever lifecycle the vendor chose. Every layer was a lock-in point, and every lock-in point was a line item you paid forever.

That arrangement is being dismantled layer by layer — not by a single platform, and not by a vendor promising to free you from other vendors. It is being dismantled by open standards governed by neutral foundations. The container format, the edge runtime, the orchestration layer, the data table format, the agent-to-tool protocol: each one now has a published specification and a governance body that no single supplier controls.

If you have watched one factory pay for itself — the autonomous e-Kanban system that lands at ~$40.50 per bin over three years against vendor-published references of $168–$544 (The Factory That Pays for Itself, Part 5) — this essay is the map that number sits on: every layer that proof exercises is an open standard nobody owns.

That shift has a name worth being precise about. Standardization is industrialization. A technology stops being a craft project and becomes infrastructure at the exact moment it gets a stable, openly governed interface that a second source can implement against. Steel got there with grades and tolerances. Electricity got there with voltage and frequency standards. The software-defined edge is getting there now — and that is the real reason it is fundable. Not because the demos are impressive. Because the interfaces are no longer owned.

The stack, layer by layer#

Here is the claim made concrete. This is the open-standards stack of the software-defined edge — each layer, the standard that defines it, and the body that governs it.

Read that table the way a procurement officer reads a bill of materials. There is no row where the answer to “who controls this interface?” is a single company you have to keep paying. That is the whole point.

The punch line in the right-hand column#

Count the governing bodies and one fact stands out. Twelve of these nineteen standards sit under the Linux Foundation umbrella — directly (OCI, Margo, A2A, eBPF), through the Agentic AI Foundation (MCP, goose, AGENTS.md, Agentgateway), or through CNCF, which is itself part of the Linux Foundation (ModelPack, Podman, K3s, OpenTelemetry).

There is a quiet irony in that runtime row. Podman — the orchestrator-free, systemd-native container engine — was accepted into the CNCF Sandbox on 2025-01-21 as a Red Hat donation. The foundation most commonly identified with Kubernetes now also hosts the runtime you reach for when you specifically do not want Kubernetes on a constrained edge box. The same neutral governance covers both the heavyweight and the lightweight answer. That is what mature infrastructure looks like: the standards body outgrows any single architectural opinion.

The remaining seven standards are governed by equally neutral, equally durable bodies — the Apache Software Foundation (Iceberg), OASIS and ISO/IEC (MQTT), Eclipse (Sparkplug), the OPC Foundation and IEC (OPC UA, 62443), and IDTA (the Asset Administration Shell). Different foundations, same property: none of them is a vendor you negotiate a renewal with.

What this hub does not re-explain#

This post is the map, not the territory. Each of these layers has its own mechanics, and several already have their own deep-dives here. Rather than repeat the engineering, this is where they connect:

• The runtime layer — how Podman’s REST API and Quadlet .container units give you a brokerless, systemd-supervised device lifecycle without a control-plane daemon — is worked out in The Device Control Plane.
• The runtime-meets-data layer — running the container runtime, model artifacts, and the table format together on a single edge box — is built up in The AI-Native Factory Stack.
• The data layer — why an Iceberg table replaces a decomposed historian RDBMS for OT telemetry, and how the partitioning and time-travel actually behave — is the subject of Apache Iceberg for Industrial OT.
• The OCI artifact model — how the subject field and the Referrers API let a signature, an SBOM, or an attestation attach to an existing artifact without changing its digest, and what that means once models and agent tool definitions are artifacts too — is the subject of OCI as the Agentic Substrate.

The mechanism posts in The Software-Defined Industrial Edge series take the remaining layers one at a time — the Margo interop contract, the agentic interfaces, and the observability spine. This hub is the frame they hang on.

The agentic layer is real, but read it carefully#

The newest band in the stack is the agentic one — and the most likely to be misreported, so precision matters.

The Agentic AI Foundation (AAIF) was formed under the Linux Foundation on 2025-12-09 with three anchor projects: MCP (the agent-to-tool-and-context interface, contributed by Anthropic), goose (a local-first agent runtime), and AGENTS.md (machine-readable project intent for coding agents). Agentgateway is also an AAIF project, but it joined after launch — it is not one of the three founding projects, and the founding set is not “four.”

A2A (Agent2Agent) is a separate Linux Foundation project, donated by Google on 2025-06-23. It sits alongside AAIF under the LF umbrella, not inside it. Keep the two distinct.

And the discovery layer — how one agent finds and trusts another — is not settled. The LF has stated an intent to launch an Agent Name Service; DNS-AID is a separate LF effort; NANDA/FAN and the IETF’s DAWN are competing approaches. This is an open question, and a hub post should say so rather than draw a box that does not exist yet. That honesty is part of why the rest of the stack is credible: the layers that are standardized are standardized, and the one that is still forming is labeled as forming.

Why open standards are a fundable bet, not a hobby#

Strip away the layer-by-layer detail and the business case is one sentence: an interface governed by a neutral foundation is an interface you can buy a second source for.

That single property cascades into everything a CFO or a plant director actually cares about. Second sources mean price competition instead of renewal hostage-taking. A published spec means the integrator you hire next year can read the same document as the one you hired this year. A neutral governing body means the standard outlives the vendor — if a supplier is acquired, pivots, or fails, the OCI image still runs, the Iceberg table still reads, the MCP tool still answers. The depreciation schedule on the asset stops being tied to the survival of a company.

That is the difference between a vendor pitch and an industrial standard. A vendor pitch asks you to bet on a company. An open standard asks you to bet on an interface that no company can unilaterally take away. The software-defined edge is fundable precisely because, layer by layer, that bet is now available on every row of the table.

The wider stack. A few more layers above earn their own attention as this series continues: Sparkplug B for giving MQTT a real OT payload structure, the Asset Administration Shell for the Industrie 4.0 digital twin, OpenTelemetry as the now-Graduated observability spine, and eBPF for kernel-level networking and security on the edge node itself. Each gets its own mechanism post in The Software-Defined Industrial Edge. The table above is where they all line up.

Leadership companion. The procurement and strategy decision lens — when to commit to a neutral standard versus extending an integrated vendor stack — is explored in Bet on the Standard, Not the Vendor on javatask.systems.

The full proof. This hub maps the standards; the production system built on them is documented start to finish in The Factory That Pays for Itself.