Capabilities & Differentiators
The industrial data plane is the layer where data from physical systems is acquired, structured, and prepared-before any downstream system sees it. Every capability below is a responsibility of this layer. KŌJŌ Stack establishes the industrial data plane for modern industrial operations.
Own the first mile. Control the data.
Key Differentiators
What makes KŌJŌ Stack fundamentally different
These are not features-they are the core responsibilities of an industrial data plane. Each one addresses a structural gap that does not exist in traditional architectures. Together, they define a layer that middleware, integration tools, and generic IIoT platforms cannot replicate.
First-Mile Data Ownership
A canonical data layer is established at the source-before any downstream system touches it. Downstream consumers receive structured, normalized data without per-source adapters or translation logic.
Deterministic Edge Execution
Event-driven pipelines execute with bounded latency and predictable ordering. Behavior is consistent across environments-no reliance on cloud timing or batch processing windows.
Protocol-Native Ingestion
Direct interaction with equipment in its native protocol. No abstraction layer, no gateway. Signal fidelity, timestamps, and device metadata are preserved at the point of acquisition.
Contextualization at the Source
Every data point is mapped into an ISA-95 compliant Unified Namespace at ingestion. Data arrives at analytics, AI, and enterprise systems ready to use-with full semantic context.
Edge-Native Data Reduction
Report-by-Exception with configurable deadbands and CEL-based derived value computation execute at the edge. Bandwidth and storage scale with signal, not noise.
Composable Control Plane
External modules extend platform capabilities with independent lifecycle and process isolation. OEM embedding, custom adapters, and third-party extensibility are architectural properties.
Co-Located Edge Execution
Workloads execute alongside data pipelines in a shared runtime at the edge. Compute and data are unified at the first mile-no data movement to external systems for processing.
Data Plane Observability
Pipeline throughput, latency, and error metrics are always available. Infrastructure teams manage the data plane with the same rigor as any production system.
API-First Architecture
120+ REST API endpoints with OpenAPI 3.0 spec and interactive Swagger UI. Every platform capability is API-accessible, designed for automation, CI/CD integration, and MCP-style agent interaction.
How It Works
Before data reaches any downstream system, it must be acquired, structured, filtered, and routed.
Industrial data originates at PLCs, sensors, SCADA systems, and historians-each speaking different protocols with different timing models and data formats. Between these sources and every system that needs their data, there is a gap.
KŌJŌ Stack fills this gap. It acquires data natively from each protocol, applies ISA-95 context and structure, filters noise with deterministic logic, and routes the result to every destination that needs it-all at the edge, with bounded latency and guaranteed delivery.
What the first-mile data plane determines
- Acquisition - Protocol-native ingestion from OPC UA, OPC DA, Modbus, S7, BACnet, Sparkplug B, MQTT, Kafka
- Structure - ISA-95 hierarchy, canonical schema, provenance metadata
- Filtering - CEL transforms, RBE deadband, derived value computation
- Routing - Multi-destination fan-out with durable buffering and replay
Core Capabilities
Eleven pillars of the first-mile data plane
Protocol-Native Ingestion
Each protocol adapter speaks the native language of the device-no translation gateways, no protocol converters. Data is acquired at the source with full fidelity, preserving timestamps, quality indicators, and device-specific metadata.
OPC UA
Server-push subscriptions with configurable sampling (50–60000ms), Browse services, historical data access, and full security policy support with certificate authentication.
OPC DA
Full OPC DA client with synchronous and asynchronous read/write, subscription-based data change callbacks, and item quality code (GOOD/BAD/UNCERTAIN) preservation. Connects to legacy Windows-based SCADA, DCS, and historian servers.
Modbus TCP/RTU
Configurable register polling for holding registers, input registers, coils, and discrete inputs. Covers millions of deployed legacy PLCs and sensors.
Siemens S7
Direct S7 protocol communication for S7-300/400/1200/1500 series. No OPC server intermediary required. Optimal for Siemens-dominated environments.
BACnet IP
Polling and Change-of-Value (COV) subscription modes with confirmed and unconfirmed COV. Purpose-built for building management and facility automation.
EtherNet/IP (CIP)
Native Common Industrial Protocol for Allen-Bradley and Rockwell automation ecosystems. Configurable polling with full tag addressing.
Sparkplug B
100% compliant with the Sparkplug B specification. Birth/death certificates, metric aliasing, sequence number handling, and standardized MQTT-based industrial communication with automatic discovery.
DNP3 (IEEE 1815)
IEEE 1815-2012 master station for utility SCADA. Polling and unsolicited (outstation-pushed event) modes with TCP, serial, and TLS transports. Per-endpoint reconnect backoff and automatic outstation-restart recovery.
MQTT & Kafka Ingress
Consume from MQTT brokers (QoS 0/1/2) and Apache Kafka/Redpanda topics with SASL/TLS security, consumer groups, and topic filtering.
Real-Time Transformation Engine
Transformations execute at the edge with bounded, predictable latency. Data is normalized, enriched, and filtered at the point of origin-not reconstructed downstream from raw telemetry.
CEL Expression Engine
Common Expression Language for deterministic transforms. Scale, offset, convert units, compute derived values. Sandboxed execution with predictable latency.
Report-by-Exception (RBE)
Configurable deadband thresholds filter insignificant changes at the source. Reduces data volume by 90%+ while preserving all meaningful state transitions.
Schema Normalization
Protocol-specific metadata (OPC UA/DA timestamps, BACnet device_id, MQTT topic) is preserved and normalized into a consistent schema with tag_id, timestamp, value, and quality.
Derived Value Computation
Compute rolling averages, rate-of-change, and composite metrics at the edge. Reduce downstream processing load by delivering pre-computed values.
Unified Namespace Alignment
All data is structured into an ISA-95 compliant namespace-the organizing principle of the data plane. Tags carry identity, timestamp, quality, and source context. The namespace is the contract between OT producers and every downstream consumer.
ISA-95 Hierarchical Modeling
Enterprise → Site → Area → Line → Cell hierarchy. Every data point is positioned within the operational topology. Context is structural, not metadata added later.
Asset-Based Structuring
Data is organized by physical asset and operational function. Consumers subscribe to logical entities, not device addresses or protocol-specific identifiers.
Automatic Topic Generation
Topics are derived from hierarchy configuration. A single source definition produces consistent addressing across MQTT, Kafka, and lakehouse destinations.
Decoupled Producers & Consumers
UNS decouples data producers from consumers. Add new analytics, AI systems, or destinations without reconfiguring sources. The namespace is the API.
Deterministic Data Pipelines
Pipelines execute with bounded, predictable latency. Event-driven architecture ensures data is processed through the system in response to state changes-not on arbitrary polling intervals. Behavior is reproducible and auditable.
Event-Driven Execution
Pipelines trigger on data events, not fixed intervals. State changes propagate immediately through the pipeline with deterministic ordering and bounded latency.
Bounded Latency Execution
Low-latency pipeline execution within local processing paths. Predictable timing for real-time control loops, quality inspection, and safety-critical data flows. Actual latency depends on transformations and pipeline configuration.
Stateless & Stateful Processing
Stateless transforms for pure computation. Stateful processing for windowed aggregations, rate limiting, and temporal correlation across data streams.
Configurable Pipeline Intervals
Per-source and per-destination timing configuration. Balance throughput against latency requirements for each data path independently.
Reliable Delivery & Buffering
Industrial environments have unreliable networks, intermittent connectivity, and destination outages. The data plane must guarantee that no data is lost, regardless of downstream availability.
Durable Local Buffering
Persistent local storage ensures zero data loss during network outages. Data is written to disk before acknowledgment. Configurable retention policies per destination.
Store-and-Forward
When destinations are unreachable, data accumulates locally with ordered delivery on reconnection. No manual intervention required. Automatic backpressure management.
Ordered Replay
Buffered data replays in sequence with original timestamps and ordering preserved. Destinations receive a complete, ordered history-not just current state.
Multi-Destination Fan-Out
Route data to multiple destinations simultaneously: S3, GCS, Kafka, MQTT, TimescaleDB, InfluxDB, Iceberg. Each destination has independent buffering and delivery guarantees.
Secure & Composable Runtime
The data plane runtime provides industrial-grade security and operational composability. Protocol modules, workloads, and system components operate in isolation with well-defined communication paths.
Modular Architecture
Protocol drivers run as isolated external processes. A crash in one module cannot affect the runtime or other modules. Hot reload enables updates without pipeline interruption.
Structured Inter-Process Communication
Modules communicate with the core runtime over typed, versioned interfaces. Schema validation ensures backward compatibility. No shared memory or unsafe IPC.
Secrets Management
AES-256 encrypted credential storage. Use @secret references in configurations-resolved at runtime, never exposed in logs or API responses.
TLS / mTLS Everywhere
Centralized certificate management for all protocol connections and destinations. Full chain support, rotation, and industrial PKI integration.
Workload Isolation
Resource isolation prevents noisy neighbors. CPU, memory, and network constraints per module. Security profiles switch between development and production-hardened modes.
Security Profiles & Auth Policies
Switch between development (relaxed) and secure (production-hardened) modes. Enforce minimum password length, character classes, password history, and account lockout. CORS restriction and request rate limiting are applied automatically in secure mode.
Co-Located Edge Execution
KŌJŌ Stack executes workloads at the edge, alongside the data plane-eliminating the need to move data to external systems for processing. Custom logic, AI inference, protocol adapters, and infrastructure services share a runtime environment with data pipelines.
Managed Workload Execution
Deploy workloads as managed processes with ports, volumes, environment variables, health checks, and secret injection-controlled through the platform with full lifecycle management.
Co-Located with Data Pipelines
Workloads execute on the same edge hardware as data pipelines. No network hops between data acquisition and processing. Compute happens where data is acquired and structured.
AI Inference & Custom Logic
Execute ML inference models, analytics engines, protocol adapters, and custom processing as first-class workloads. Co-location with the data plane provides low-latency access to structured, contextualized data.
Multi-Service Stacks
Deploy dependent services together with inter-service networking and dependency ordering. Execute complete protocol environments or analytics stacks as a single managed unit.
SDK for Extensibility
The SDK enables developers to extend the data plane in any language, without modifying core platform behavior. Modules are independent processes that communicate with the runtime over typed, versioned interfaces - build custom source adapters, destination connectors, processing modules, and deployable workloads that integrate natively with the runtime.
Custom Source Adapters
Build protocol adapters for proprietary or uncommon systems. The SDK provides typed interfaces for data acquisition, health reporting, and lifecycle management.
Custom Destination Connectors
Extend egress capabilities to any downstream system. Implement buffering, retry logic, and delivery guarantees using SDK primitives.
Processing Modules
Create custom transformation, enrichment, or analytics modules that execute alongside core pipelines. Full access to the data plane's semantic model and pipeline context.
Language-Agnostic Module Development
Any language, any runtime - as long as it implements the module interface contract. Typed, versioned RPC interfaces with schema validation ensure modules integrate cleanly regardless of implementation language.
Partner & OEM Integration
The SDK enables partners to embed KŌJŌ Stack capabilities into their own products. Custom integrations, partner-specific extensions, and platform embedding scenarios are first-class use cases.
Fleet Management
Fleet Management is the control plane for distributed data planes. It enables centralized deployment, orchestration, and operation of all KŌJŌ Stack edge nodes across sites, regions, and environments.
Centralized Node Management
Manage configuration, health, and status of all distributed edge deployments from a single control interface. Full visibility across sites, regions, and environments.
Deployment Orchestration
Push configuration updates, namespace models, and pipeline definitions across sites with controlled rollout and rollback. No manual node-by-node intervention.
Fleet-Wide Monitoring
Aggregate telemetry from all nodes including pipeline throughput, latency, module health, and resource utilization across the entire deployment fleet.
System Health Visibility
Real-time visibility into connectivity, data flow status, and error conditions across every managed node. Detect degradation before it affects operations.
Observability & Data Plane Telemetry
Operational control requires operational visibility. Every pipeline, module, and workload exposes metrics that describe data flow behavior-not just system health. Observability is a property of the data plane, not an add-on.
Pipeline Throughput & Latency
Per-pipeline metrics: messages/sec, bytes/sec, p50/p95/p99 latency, error rates, and backpressure indicators. Understand data flow behavior, not just system utilization.
Module Health Monitoring
Connection status, buffer depth, reconnection attempts, and protocol-specific diagnostics per module. Know which sources are healthy and which are degraded.
Workload Performance
CPU, memory, network, and restart metrics for every managed workload. Resource consumption visibility for capacity planning and anomaly detection.
Hash-Chained Audit Trail
Immutable, tamper-evident logging for all system events: logins, configuration changes, module lifecycle, and policy decisions. Compliance-ready for FDA, NERC CIP, and IEC 62443.
AI Agent Integration (MCP Server)
KŌJŌ Stack exposes its full API surface to AI agents through a fleet-aware MCP (Model Context Protocol) server deployed at the edge. Agents discover, query, and diagnose KŌJŌ Stack deployments through a secure, scoped interface designed for autonomous operation.
Fleet-Aware Federation
One MCP server federates across many KŌJŌ Stack edge instances. AI agents discover and interact with the entire fleet through a single endpoint - no per-node configuration.
Per-Agent Identity & Scoping
OAuth 2.0 with Dynamic Client Registration. Three-axis scope model: operation (read/write), resource (sources/pipelines/modules), and safety zone. Agents in different scopes cannot discover each other.
22 Read-Only MCP Tools
Fleet discovery, health queries, fan-out diagnostics, UNS graph queries, and live subscriptions. Tool annotations (readOnly, destructive, idempotent, cost) enable safe autonomous decision-making.
Team & Scope Isolation
Each agent operates within defined boundaries on the edge infrastructure. Cross-scope discovery is architecturally prevented. Designed for environments where multiple teams or partners share edge deployments.
Performance & Reliability
Built for industrial-grade edge execution
KŌJŌ Stack is designed for high-throughput, low-latency data processing at the edge, with built-in reliability mechanisms for real-world industrial environments.
High-Throughput Ingestion
- Processes high volumes of industrial data streams
- Supports 10K+ tags/sec in typical deployment scenarios
- Performance depends on hardware, protocol, and pipeline configuration
Low-Latency Execution
- Sub-10ms processing latency in local pipeline execution paths
- Deterministic execution within edge environments
- Latency varies based on transformations, buffering, and external systems
Durable Data Delivery
- Built-in offline buffering using local storage
- Automatic replay when connectivity is restored
- Maintains data continuity during network interruptions
Deterministic Pipeline Behavior
- Consistent timing and sequencing of data events
- Predictable behavior across deployments
- Supports reliable downstream processing and automation
Performance and reliability are not defined by isolated metrics-they are a function of how data is acquired, structured, and processed at the first mile.
Why These Capabilities Matter
Not independent features-a unified data plane
These capabilities are not independent modules that can be assembled piecemeal. They form a single, unified data layer where every responsibility-ingestion, structuring, processing, and delivery-executes in a deterministic pipeline with bounded latency. Downstream systems do not define data structures. KŌJŌ Stack does.
Own the first mile. Control the data.