A Market-Back Analysis: What Just Changed in Industrial Software, and What It Means for Manufacturers
The CESMII Interoperability Forum was held on August 11, 2026. We did a vendor-agnostic analysis based on analysis of 28 live interoperability demonstrations spanning the full industrial technology stack.
The industrial software market is reorganizing around a five-layer interoperable stack: dozens of providers, one open standard, zero custom integration.
For decades, industrial software has been sold as vertically integrated islands. Each tool required its own point-to-point connections, and every new application meant another custom integration project. That architecture is now breaking apart into an open, layered stack in which any compliant technology at any layer can plug into any other.
LAYER 1: AI & AGENTIC APPLICATIONS
- AI/ML models, autonomous agents, copilots, and retrieval-augmented (RAG) systems that reason over contextualized plant data, answer "why" questions, and recommend or take actions with human approval
- Technology types: enterprise AI assistants over the unified namespace, agentic orchestration across business and plant systems, no-code industrial ML platforms, AI-built applications, natural-language analytics
LAYER 2: MANUFACTURING APPLICATIONS
- The applications operators and frontline teams actually touch every day
- Technology types: MES and shop-floor execution, quality and SPC, maintenance and work-order management (CMMS), machine-health monitoring, low-code application platforms
LAYER 3: DATA PLATFORMS & DATAOPS
- The contextualization and governance tier that turns raw tags into modeled, trustworthy, self-describing data
- Technology types: industrial DataOps hubs, unified namespace (UNS) platforms, knowledge graphs, cloud data warehouses and lakehouses, time-series analytics services
LAYER 4: SCADA, HMI & HISTORIANS
- The traditional automation software layer plants already own: visualization, supervisory control, and time-series history
- Technology types: SCADA/HMI platforms, plant historians, industrial application servers, emerging cloud-native context services layered on top
LAYER 5: CONNECTIVITY & EDGE
- Getting data off PLCs, sensors, and legacy equipment and up into the stack
- Technology types: device connectivity servers and protocol translation (OPC UA, MQTT, proprietary drivers), edge gateways, edge modeling and mapping tools, on-device standard servers embedded in controllers
THE SPINE (cross-cutting, connects all 5 layers): AN OPEN INTEROPERABILITY STANDARD
- A vendor-neutral REST API plus shared, standardized equipment information models ("profiles"), with public conformance testing
- Any compliant layer plugs into any other; context and models travel with the data in both directions
THE ENABLERS (alongside the stack)
- System integrators and consultancies packaging the standard into repeatable deployments and accelerators
LAYER 1, AI & AGENTIC APPLICATIONS
With data that already carries its meaning, AI has escaped pilot purgatory: agents connect in minutes, reason across ERP-to-sensor context, and return decisions rather than dashboards, with humans approving every action.
What the layer does:
- The top of the stack: AI/ML models, agents, copilots, and RAG systems that consume contextualized plant data to answer "why" questions, recommend actions, and, with human approval, act.
Main takeaways:
- Connection time collapsed from months to minutes. AI systems read the standard interface and wrote their own integrations: four different providers' endpoints across two plants were live in about twenty minutes; a second company's entire environment was indexed in seconds; in the most advanced patterns, data never moved at all and stayed governed at the source
- Enterprise-wide reasoning arrived. Single-click "autopilot" capabilities scanned every connected source and surfaced prioritized issues across plants (bearing wear, scrap-rate excursions, power-quality problems, idle equipment) with no queries written and no dashboards built
- Agents now answer both the boardroom and the control room. The same conversation resolved a "will the priority order ship on time?" question and the engineering root cause threatening it, correlating work orders, schedules, and sensor telemetry across systems
- AI is skeptical, not just fast. Investigations distinguished real degradation from data artifacts, caught capped sensors and mis-mapped tags, and recommended proportionate responses (a fifteen-minute walkdown, not a teardown)
- AI now builds the applications too. Spec-driven approaches had AI construct monitoring applications directly against live standard endpoints, write and run their own test suites, and absorb newly added equipment with zero code changes
- Governance is native, not bolted on. Role-based data access enforced on the AI itself, full audit of agent runs and costs, no training on customer data, no access to the control loop, and propose-then-approve workflows throughout
Why it matters for manufacturers:
- Data plumbing is gone from the AI critical path. The months of integration that stalled AI pilots collapse to minutes against one standard API; the binding constraint shifts to data models and governance
- Context makes AI portable and trustworthy: grounded in standardized models and namespaces, the same agent works across companies and vendor stacks unchanged, with dramatically reduced hallucination risk
- The deliverable changes from dashboards to decisions: every demonstration ended in a recommendation with its reasoning, not another chart to interpret
- Humans stay in command, with auditability, role-based access, and approval gates as the consistent operating pattern
- Agents are the next workforce to onboard, and interoperable, contextualized data is what cuts their onboarding time, exactly as it does for people
LAYER 2, MANUFACTURING APPLICATIONS
Frontline applications (MES, quality, maintenance, machine health) now plug into plant data in minutes-to-an-afternoon instead of weeks, turning machine signals directly into operator action.
What the layer does:
- The application layer operators touch every day: shop-floor execution, quality/SPC, maintenance and work orders, machine health, and low-code app development, all consuming contextualized plant data through the standard.
Main takeaways:
- Zero-configuration discovery is the new integration. Compliant applications browse a site's full data model instantly: namespaces, object types, equipment hierarchies, and product catalogs appear without any setup or expert translation
- Applications both consume and contribute. Execution systems capture what machines cannot (operator, serial number, pass/fail, cycle context) and publish it back into the same namespace, so the complete story of every part sits in one place for any client or agent to read
- No-code pipelines replace custom APIs. Visual workflow tools connected shop-floor systems to the standard in an afternoon; maintenance systems auto-created their asset registries from a short script instead of manual data entry
- Machine health becomes closed-loop maintenance. Equipment health signals flow through the stack and become assigned, executed, and closed work orders rather than alerts stranded in a separate portal
- Quality shifts from inspection to prevention: live SPC control charts run directly on standardized equipment data placed in the plant's namespace with its process relationships intact
- AI agents are becoming first-class application users. Agent interfaces layered on the standard let AI orchestrate ERP-to-shop-floor workflows (pull orders, match products, schedule runs) in plain English
- Governed low-code closes the scale gap. Frontline-built apps historically died at scale for lack of governance; standardized, governed data plus managed low-code platforms lets them spread plant-to-plant
Why it matters for manufacturers:
- Application onboarding drops from months to an afternoon, and system discovery from days of expert workshops to minutes
- Every application sees the same self-describing data, so MES, SPC, CMMS, and low-code apps compose instead of colliding
- Machine data becomes frontline action: work orders, control charts, and execution records, not another dashboard
- Write once, run anywhere: an application written against the standard runs on any compliant platform, the foundation for scaling frontline innovation across sites
LAYER 3, DATA PLATFORMS & DATAOPS
When models and context travel with the data, plant data arrives in cloud platforms and knowledge graphs governed and analytics-ready, with no custom pipelines.
What the layer does:
- The contextualization and governance tier: DataOps hubs, unified namespaces, knowledge graphs, and cloud-scale storage/analytics that turn raw tags into modeled, trustworthy, self-describing data any application or AI agent can consume.
Main takeaways:
- Self-describing data replaces per-system reinterpretation. Every platform exposed models, not just tags, over the standard, blending live equipment data with lookups into MES, warehouse, lab, and ERP systems into one coherent, queryable structure
- Cloud analytics connects without middleware. Cloud data platforms demonstrated native extractors, stored-procedure integrations, and open-source standard servers, so plant data lands in the warehouse or lakehouse through one open interface; business users created pipelines by asking in natural language
- Knowledge graphs are becoming the operational brain. Multi-million-node context systems unify equipment data, quality results, and work orders; AI agents run root-cause analysis across them in minutes and quantify the financial impact of projected delays
- Governance is enforced at the data layer, not the app layer. Role-based access rules applied once were honored simultaneously by AI assistants and dashboards, changing what different roles could see; full audit trails record every change
- Autonomous onboarding is emerging. Agents discover unmodeled machines, fetch matching public profiles or propose new models, and trigger ML once enough data accumulates
- Provenance is a built-in by-product. Material ledgers that follow product through the plant enable genealogy, digital product passports, and carbon/cost tracking from the same modeled data
Why it matters for manufacturers:
- Context becomes an asset that compounds instead of a cost re-created for every new application
- The hyperscaler gap is closed. Cloud providers historically stopped at the platform edge; the open standard supplies the contextualization layer they never built, without bespoke middleware
- Governance turns from blocker to enabler: enforceable role-based access on AI itself is what lets security and finance say yes
- Root-cause analysis moves from days to minutes, and this class of application, historically the most likely to stall in pilots for lack of consistent contextualized data, becomes scalable
- The same investment extends beyond the plant into supply-chain traceability and sustainability reporting
LAYER 4, SCADA, HMI & HISTORIANS
The automation platforms plants already own are becoming standard-native: importing shared equipment profiles as first-class objects and serving standardized, AI-ready data in both directions, without custom integration.
What the layer does:
- Visualization, supervisory control, and time-series history: the systems that already sit on every plant floor, now acting as both publishers and consumers of the open standard.
Main takeaways:
- Profiles now drive engineering, not just data exchange. Control-level assets were built directly from shared profiles inside automation engineering environments, and SCADA import tools converted the same profiles into native templates with automated matching to discovered equipment, replacing per-project hand-tagging
- One model, instantiated identically across competing platforms. The same standard equipment profile became native objects in multiple vendors' engineering tools with no special cases, demonstrating true "model once, reuse everywhere"
- Historians are becoming AI gateways. Plant historians now expose both the open standard and AI-agent interfaces (MCP), letting a general-purpose LLM discover tags, summarize assets, and judge data quality against decades of stored history with zero prior context
- Context flows both ways. Cloud context services and knowledge graphs connected to live SCADA endpoints in minutes, enriched the data with relationships, and published that context back through the standard for the SCADA layer and any other system to consume
- Free and low-cost entry points are appearing. Standard servers, explorers, and historians are being given away as free resources, deliberately lowering the barrier to joining the ecosystem
Why it matters for manufacturers:
- The installed base is the entry point, not the obstacle. The standard arrived inside platforms plants already run, as import tools, endpoints, and free add-ons rather than new systems to buy
- Engineering effort collapses. Automated profile-to-template matching and shared models eliminate the most labor-intensive step of every SCADA project
- Decades of historian data become usable AI fuel without migration: AI reads it in place, with data-quality assessment built into the first conversation
- What-if analysis reaches operations in natural language: connected OT/MES/ERP context enabled AI to quantify the production impact of taking specific equipment down, in units the business understands
LAYER 5, CONNECTIVITY & EDGE
The edge has become the on-ramp to interoperability: raw PLC tags are modeled into standard equipment profiles at the source and served as live standard endpoints, turning point-to-point integration into a minutes-long configuration task.
What the layer does:
- The foundation of the stack: getting data off PLCs, sensors, and legacy equipment; translating industrial protocols; contextualizing raw tags into standard profiles at the edge; and exposing the result as standard HTTP/JSON endpoints any compliant application can consume.
Main takeaways:
- Standard models are now applied at the source, not downstream. Edge tools import shared equipment profiles from a public marketplace, auto-resolve dependencies, and map live tags to them, so data leaves the edge already carrying its meaning
- The standard is being embedded everywhere along the edge. It showed up as a one-click data source in established connectivity suites, as a native server in edge data platforms, in IIoT platform templates, and even directly on controllers, meaning the device itself can share contextualized information
- Dual-protocol serving is the transition pattern. The same modeled data is exposed simultaneously over legacy industrial protocols (for the installed base) and the open standard (for the new stack), so nothing breaks during migration
- Automatic discovery replaces re-engineering. Production lines added after an application was built are discovered automatically over the standard interface: new equipment live in seconds, with no code changes and no redeploys
- Assisted mapping is emerging. Tag-to-model mapping is being automated with scripting and early LLM-assisted approaches, attacking the last remaining manual step
Why it matters for manufacturers:
- The recurring integration tax goes away. Custom integration is a cost paid again every time something changes; modeling once against shared profiles replaces per-vendor, per-tool builds
- No rip-and-replace. Every demonstration started from installed-base reality (existing OPC UA servers, driver suites, MQTT brokers) and layered standard models on top; existing equipment speaks the standard without touching the PLC
- Time-to-value is now measured in hours. New lines online in seconds; downstream systems auto-populated from scripts instead of weeks of manual configuration
- Lock-in loses its grip at the foundation. Even historically proprietary full-stack suppliers are competing on openness, because applications written against the standard run on any compliant platform
SO WHAT?
The interoperable industrial stack is no longer a vision: it was demonstrated working end-to-end on one open standard, and the winners of the next decade will be the manufacturers who stop paying the integration tax and start onboarding AI on day one.
What is happening at each layer of the stack
- L1, AI & Agentic Applications: AI has escaped pilot purgatory. Agents connected to multi-vendor plant data in minutes, reasoned across ERP-to-sensor context, and returned governed, audited, human-approved decisions rather than dashboards; always-on agents now monitor entire enterprises and escalate to experts
- L2, Manufacturing Applications: app integration collapsed from months to an afternoon. Frontline systems auto-discover equipment and data models with zero configuration, publish their own context back, and compose with each other instead of colliding
- L3, Data Platforms & DataOps: context now travels with the data. Models, not just tags, arrive in cloud platforms and knowledge graphs governed and analytics-ready with no custom pipelines; root-cause analysis moves from days to minutes; governance is enforced on the data itself, including on AI consumers
- L4, SCADA, HMI & Historians: the installed base is going standard-native. The platforms plants already own now import shared profiles as first-class objects and serve standardized, AI-ready data both ways; decades of historian data becomes usable AI fuel in place
- L5, Connectivity & Edge: the edge became the on-ramp. Raw PLC tags are modeled into shared profiles at the source and served as live standard endpoints; legacy equipment speaks the standard without touching the PLC, and new lines come online in seconds
- The spine: the standard crossed the credibility threshold. Hyperscalers, automation incumbents, and startups implemented the same API, passed the same public conformance tests, and connected to each other's endpoints live, competing on value instead of lock-in
Implications for manufacturers
- Stop budgeting for point-to-point integration; it is becoming a legacy cost. Custom integration is a cost paid again every time something changes. Demand open-standard conformance in every RFP and make openness a selection criterion now
- You do not need to rip and replace to participate. Every demonstration started from the installed base: existing connectivity servers, historians, and SCADA. The path is incremental: model critical assets once against shared profiles at the edge, then let every layer above consume them
- Contextualized data is the prerequisite for AI that scales; plumbing is no longer the excuse. With the standard in place, agent time-to-value moved from months to minutes; the constraint shifts to your data models and governance, so invest there first
- Governance becomes an enabler, not a blocker. Role-based access enforced on AI agents, full audit trails, propose-then-approve workflows, and no agent access to the control loop were demonstrated working, meaning IT/OT and security teams can say yes with controls intact
- Vendor leverage shifts to the buyer. When applications written against the standard run on any compliant platform unmodified, switching costs fall structurally; use that leverage in negotiations and architecture decisions
- Move now; the ecosystem effect compounds. Interoperability is no longer a technical concern but a business imperative. Early adopters onboard every new tool, line, and AI agent in hours; late adopters keep paying the integration tax on a growing stack
the full playlist of the Interoperability Forum is available on YouTube here.
