IAES vs Sparkplug B vs AAS vs OPC UA Events

At a Glance

Four standards, four layers. They don't compete — they complement.

OPC UA

Communication

How machines talk to each other. Secure M2M on the factory floor.

Sparkplug B

Telemetry

How devices report metrics. Real-time sensor data over MQTT.

AAS

Digital Twin

What the asset IS. Nameplate, specs, capabilities — the identity card.

IAES

Event Semantics

What HAPPENED to the asset. Measurement, diagnosis, action — across any system.

Key insight: Comparing IAES to Sparkplug B is like comparing SQL to TCP/IP. One defines what data means, the other defines how data moves. In practice, many plants use two or three of these simultaneously, each at its own layer.

Side-by-Side Comparison

Nine dimensions, four standards. The differences become obvious once you see them together.

Dimension	OPC UA	Sparkplug B	AAS	IAES
Layer	Communication protocol	Telemetry model	Digital twin model	Event semantics
Primary purpose	How machines talk (secure M2M)	How devices report metrics	How to model an asset digitally	What happened to the asset
Transport	OPC UA binary / HTTPS	MQTT only	HTTP/REST, AASX files	Any (MQTT, HTTP, Kafka, files)
Data format	XML / Binary (OPC UA-specific)	Protobuf (Sparkplug B spec)	JSON / XML (AAS metamodel)	JSON (simple, human-readable)
Event correlation	No native correlation	No native correlation	No native correlation	correlation_id chains related events
Standards referenced	IEC 62541	Eclipse Foundation	IEC 63278 (draft)	ISO 17359, 13374, 14224, 55000
Complexity	Very high (500+ page spec)	Medium (~100 pages)	High (~300 pages)	Low (7 event types, ~40 pages)
Best for	Factory floor M2M, SCADA	Edge-to-cloud telemetry	Digital twin registries	Cross-system event interop
Adoption	Widespread (established)	Growing (IIoT)	Early (Industry 4.0)	New (condition monitoring)

Deep Dives

How each standard relates to IAES, and where they complement each other

OPC UA Alarms & Conditions vs IAES

OPC UA is the nervous system. IAES is the medical record.

OPC UA A&C (Part 9) handles real-time alarm propagation on HMIs and SCADA screens — it tells the operator "something is wrong right now." IAES captures what happened after the alarm: the measurement, the diagnosis, and the maintenance action. Every downstream system (CMMS, ERP, analytics) consumes the IAES event without needing OPC UA's address space.

In practice: A bridge subscribes to OPC UA alarm events and translates them into IAES events. OPC UA stays on the factory floor. IAES flows everywhere else.

Sparkplug B + IAES (Complementary)

Sparkplug B is the postal service. IAES is the letter inside the envelope.

Sparkplug B gets telemetry from edge devices to a broker with state awareness (birth/death certificates, structured MQTT topics). IAES events ride on top of Sparkplug B infrastructure — same MQTT transport, different semantic layer. No conflict.

# Sparkplug B metric → IAES asset.measurement transform
from iaes import MeasurementEvent

def sparkplug_to_iaes(spb_payload):
    metric = spb_payload.metrics[0]
    return MeasurementEvent(
        asset_id=spb_payload.name,
        measurement_type="vibration_rms",
        value=metric.float_value,
        unit="mm/s",
        source="gateway.sparkplug_b.adapter"
    ).to_dict()

Install the IAES SDK to use this pattern: pip install iaes (Python) or npm install @iaes/sdk (TypeScript).

AAS + IAES (Complementary)

AAS is the noun (what the asset IS). IAES is the verb (what HAPPENED to the asset).

AAS (IEC 63278) models the asset: nameplate, specs, capabilities — "what IS this thing?" IAES records the asset's operational history: the vibration spike, the bearing wear diagnosis, the work order, the replacement — "what HAPPENED to this thing?"

Together: AAS provides static identity, IAES provides dynamic history. An AAS submodel references IAES events. An IAES asset_id resolves to an AAS endpoint. Complete lifecycle picture.

They don't overlap. OPC UA = communication. Sparkplug B = telemetry transport. AAS = digital twin structure. IAES = event semantics. Each layer has a job. A real plant might use all four simultaneously. The question isn't "which one?" — it's "which layers does my architecture need?"

Decision Tree

Start with your problem. The right standard follows.

Need secure machine-to-machine communication on the factory floor?

→ OPC UA

Need real-time sensor telemetry over MQTT with device state awareness?

→ Sparkplug B

Need a digital twin registry to model asset properties and capabilities?

→ AAS

Need to record what happened to assets and share events across systems?

→ IAES

Need multiple? They work together. IAES events can flow over OPC UA, ride Sparkplug B MQTT, or describe AAS submodel events. Each standard handles its own layer.

Use them together at different layers of your stack