Real-Time Industrial AI
Starts Inside the Control Loop
The Industrial Intelligence Layer.
DADOS delivers decision-ready industrial state in milliseconds by converting live Sparkplug B telemetry into queryable Apache Arrow tables for control.
Industrial AI only matters if its decisions arrive before the control loop closes.
In real-world systems, control decisions must be made before the loop closes
—within 100 milliseconds of a condition emerging.
Anything slower doesn’t matter.
Speed isn’t a feature here — it’s the entire value proposition.
What matters is end-to-end latency, from live telemetry to action.
Proven Inside the Loop
Industrial control does not care how fast individual components are.
It cares how long it takes for live telemetry to become queryable state.
End-to-end latency is the system
DADOS measures time from:
- Sparkplug B message publish (ingress)
- decode and normalization
- conversion to Apache Arrow
- queryable state
Measured performance
- <50 ms end-to-end, publish to queryable state
- Single-digit millisecond query latency at P95
- 3M/msgs/sec sustained at industrial message rates
This fits inside supervisory control timing budgets — while conditions are still changing.
A new data architecture for real-time Industrial AI
The Timing Requirement
Real-Time Industrial Control Has a Strict Timing Budget
In industrial control systems, decisions must be made within tens of milliseconds, but not all decisions live in the same timing tier.
Typical Timing Envelopes
Industrial control operates across multiple timing layers.
DADOS is designed for supervisory and coordination loops — not PLC scan-cycle execution.
- 10–20 ms — fast closed-loop control inside the PLC (scan-cycle execution: PID, interlocks, sequencing)
Handle entirely by the PLC.
- 50–100 ms — supervisory control and coordinated actions (setpoint changes, mode transitions, multi-device coordination)
This is where DADOS operates.
- 50 – 100 ms — usually too late to influence live control behavior
After the loop closes, intelligence cannot influence control.
Fast Message Transport Is Not Enough
Low-latency Sparkplug B message delivery through brokers is required, but control depends on when decision-ready state becomes available—not when messages arrive.
Sparkplug B provides structured telemetry, but control-relevant decisions require more than delivery:
- Data must be decoded
- Timestamps
- State made consistent across devices
- Results made queryable
All of this must occur within the supervisory control timing budget (50–100 ms) — not afterward, and not inside the PLC scan cycle.
How DADOS Delivers Control-Speed State at Scale
DADOS converts Sparkplug telemetry into clean, time-aligned, queryable state as it arrives.
This processing occurs:
- Without pipeline delays
- At industrial scale
The result is decision-ready state available within the tens-of-milliseconds window required for supervisory control and coordination, without extending or interfering with PLC execution.
Why it Matters
Because intelligence arrives in time:
- Conditions can be evaluated while they are still changing
- Actions can be computed and validated before supervisory loops close
Late intelligence cannot influence control — only explain it.
PLC control runs in 10–20 ms.
Supervisory decisions run in 50–100 ms.
DADOS is explicitly designed for the supervisory tier.
A new data architecture for real-time Industrial AI
The Industrial Intelligence Layer
The constraint in industrial systems is not telemetry — it’s how fast live telemetry becomes decision-ready.
DADOS removes that constraint by separating transformation, state, and decision latency into components that operate in parallel.
DADOS Flow — Real-Time Transformation
Sits next to the broker. Decodes Sparkplug, enforces schema, and converts telemetry into clean, decision-ready state as it arrives. No downstream delay.
DADOS Current — Live State
Maintains a rolling, in-memory view of what is happening now. Provides immediate operational context without querying historical systems.
DADOS Lightning+ — Decision Latency
Exposes the same live state, optimized for sub-5 ms queries. Supports deterministic logic, agents, and automated control decisions before the loop closes.
Why it matters
Aligned state and latency allow action before the loop closes.
Real-Time Data Architecture for Control-Loop Operation
Why a New Architecture is Required
Real-time control requires more than fast transport.
It requires decision-ready state that is:
- available in milliseconds
- clean and structured
- immediately queryable
- deterministic
Without this foundation, intelligence arrives too late to matter.
Why Existing Stacks Fall Short
Industrial systems move data fast.
But decision-ready state arrives too late.
Most stacks optimize message delivery, then defer decoding, alignment, and state formation to downstream systems. Under load, latency grows — and intelligence arrives after the control window closes
Fast transport isn’t enough.
Control requires decision-ready state inside the loop
How DADOS Meets the Requirement
Meeting control-loop timing is not about making one component faster.
It requires an end-to-end data path designed for millisecond deadlines.
DADOS provides a single, purpose-built execution path:
Flow → Current → Lightning+
- DADOS Flow ingests Sparkplug B telemetry at wire speed and converts it directly into Apache Arrow.
- DADOS Current maintains a continuously updated in-memory view of live system state.
- DADOS Lightning+ executes vectorized, in-memory queries on that state with single-digit millisecond latency.
Together, these form a direct path from telemetry publish to usable, queryable state — without batching, ETL, or databases in the decision path.
The result is decision-ready state delivered fast enough for agents, automation, and analytics to operate inside the control window.
Performance & Benchmarks
Median latency is 2.89 ms, with P99 remaining under 5 ms across 215 million queries over 24 hours, delivered through the Lightning+ API.
The real-time performance shown below is the result of an architecture designed to deliver decision-ready state within control-loop timing — not isolated component speed.
DADOS benchmarks the only latency that matters
DADOS measures the only latency that matters: end-to-end time from live telemetry to decision-ready state.
Under sustained load, DADOS delivers sub-50 ms end-to-end state readiness and 2.89 ms median query latency (sub-5 ms P99) via the Lightning+ API.
This architecture is protected by a pending U.S. patent covering high-volume, real-time message stream processing and state construction for control-loop operation.
What We Measure
Benchmarks include the full execution path:
- Sparkplug B message ingest at the broker
- Payload decode and schema normalization
- Conversion to Apache Arrow
- In-memory state update
- Query execution via the Lightning+ API
No ETL layers. No historical databases in the decision path.
How End-to-End Latency Is Defined
End-to-end latency includes ingest, decode, schema normalization, conversion to Apache Arrow, and state readiness under sustained load.
Single-message timings, warm-cache runs, or best-case measurements are excluded.
Why These Numbers Matter
Most industrial systems benchmark throughput or isolated component speed.
Those numbers do not indicate whether intelligence arrives in time to influence control.
DADOS benchmarks whether live telemetry becomes decision-ready — and remains predictably queryable — within the supervisory control window.
What This Enables
Because decision-ready state arrives on time and queries execute with deterministic latency, DADOS enables:
- Real-time analytics
- Deterministic rules
- AI agents
to operate while control decisions are still possible, not after the loop has closed.
FOLLOW US ON FOR THE LATEST DEVELOPMENTS
Real-Time Data Stream Demo
In-memory live data stream showing a chart and dataframe.
Data Center Control Demo
Ten server racks operate in steady state while CRAC-1 maintains cooling at 2000 RPM. Three racks overheat to 25 °C, creating a localized thermal fault.
Live telemetry triggers an automatic response, ramping fan speed to 2600 RPM. Temperatures stabilize and PUE adjusts — all within real-time control limits.
Energy Ramp Demo
A distribution feeder operates in steady state with six solar inverters online. When grid frequency drops from 60.0 Hz to 59.7 Hz, the system detects excess demand in real time.
A DCMD places BESS-01 into frequency-support mode, ramping output by 650 kW within configured limits and holding briefly.
Frequency stabilizes and the system returns to normal operation — without manual intervention or control rewiring.