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
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.
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.
Event-driven pipelines execute with bounded latency and predictable ordering. Behavior is consistent across environments-no reliance on cloud timing or batch processing windows.
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.
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.
Report-by-Exception with configurable deadbands and CEL-based derived value computation execute at the edge. Bandwidth and storage scale with signal, not noise.
External modules extend platform capabilities with independent lifecycle and process isolation. OEM embedding, custom adapters, and third-party extensibility are architectural properties.
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.
Pipeline throughput, latency, and error metrics are always available. Infrastructure teams manage the data plane with the same rigor as any production system.
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
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.
Core Capabilities
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.
Server-push subscriptions with configurable sampling (50–60000ms), Browse services, historical data access, and full security policy support with certificate authentication.
Configurable register polling for holding registers, input registers, coils, and discrete inputs. Covers millions of deployed legacy PLCs and sensors.
Direct S7 protocol communication for S7-300/400/1200/1500 series. No OPC server intermediary required. Optimal for Siemens-dominated environments.
Polling and Change-of-Value (COV) subscription modes with confirmed and unconfirmed COV. Purpose-built for building management and facility automation.
Native Common Industrial Protocol for Allen-Bradley and Rockwell automation ecosystems. Configurable polling with full tag addressing.
100% compliant with the Sparkplug B specification. Birth/death certificates, metric aliasing, sequence number handling, and standardized MQTT-based industrial communication with automatic discovery.
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.
Consume from MQTT brokers (QoS 0/1/2) and Apache Kafka/Redpanda topics with SASL/TLS security, consumer groups, and topic filtering.
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.
Common Expression Language for deterministic transforms. Scale, offset, convert units, compute derived values. Sandboxed execution with predictable latency.
Configurable deadband thresholds filter insignificant changes at the source. Reduces data volume by 90%+ while preserving all meaningful state transitions.
Protocol-specific metadata (OPC UA timestamps, BACnet device_id, MQTT topic) is preserved and normalized into a consistent schema with tag_id, timestamp, value, and quality.
Compute rolling averages, rate-of-change, and composite metrics at the edge. Reduce downstream processing load by delivering pre-computed values.
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.
Enterprise → Site → Area → Line → Cell hierarchy. Every data point is positioned within the operational topology. Context is structural, not metadata added later.
Data is organized by physical asset and operational function. Consumers subscribe to logical entities, not device addresses or protocol-specific identifiers.
Topics are derived from hierarchy configuration. A single source definition produces consistent addressing across MQTT, Kafka, and lakehouse destinations.
UNS decouples data producers from consumers. Add new analytics, AI systems, or destinations without reconfiguring sources. The namespace is the API.
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.
Pipelines trigger on data events, not fixed intervals. State changes propagate immediately through the pipeline with deterministic ordering and bounded latency.
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 transforms for pure computation. Stateful processing for windowed aggregations, rate limiting, and temporal correlation across data streams.
Per-source and per-destination timing configuration. Balance throughput against latency requirements for each data path independently.
Industrial environments have unreliable networks, intermittent connectivity, and destination outages. The data plane must guarantee that no data is lost, regardless of downstream availability.
Persistent local storage ensures zero data loss during network outages. Data is written to disk before acknowledgment. Configurable retention policies per destination.
When destinations are unreachable, data accumulates locally with ordered delivery on reconnection. No manual intervention required. Automatic backpressure management.
Buffered data replays in sequence with original timestamps and ordering preserved. Destinations receive a complete, ordered history-not just current state.
Route data to multiple destinations simultaneously: S3, GCS, Kafka, MQTT, TimescaleDB, InfluxDB, Iceberg. Each destination has independent buffering and delivery guarantees.
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.
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.
Modules communicate with the core runtime over typed, versioned interfaces. Schema validation ensures backward compatibility. No shared memory or unsafe IPC.
AES-256 encrypted credential storage. Use @secret references in configurations-resolved at runtime, never exposed in logs or API responses.
Centralized certificate management for all protocol connections and destinations. Full chain support, rotation, and industrial PKI integration.
Resource isolation prevents noisy neighbors. CPU, memory, and network constraints per module. Security profiles switch between development and production-hardened modes.
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.
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.
Deploy workloads as managed processes with ports, volumes, environment variables, health checks, and secret injection-controlled through the platform with full lifecycle management.
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.
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.
Deploy dependent services together with inter-service networking and dependency ordering. Execute complete protocol environments or analytics stacks as a single managed unit.
The Module Control Plane enables OEMs, integrators, and developers to extend the data plane with new capabilities-without modifying core platform code. Modules are first-class citizens with independent lifecycle, isolation, and well-defined interfaces.
Modules are independent processes that communicate with the core runtime over defined interfaces. Any language, any runtime-as long as it speaks the protocol.
Typed, versioned interfaces between modules and the core runtime. Schema validation, backward compatibility, and structured error handling.
Each module has its own lifecycle: deploy, start, stop, update, and remove independently. Process isolation ensures module failures do not cascade.
Add new protocol adapters, transformation engines, destination connectors, or custom processing logic. The data plane is a platform, not a closed system.
The SDK enables developers to extend both the data plane and the execution layer, without modifying core platform behavior. Build custom source adapters, destination connectors, processing modules, and deployable workloads that integrate natively with the runtime.
Build protocol adapters for proprietary or uncommon systems. The SDK provides typed interfaces for data acquisition, health reporting, and lifecycle management.
Extend egress capabilities to any downstream system. Implement buffering, retry logic, and delivery guarantees using SDK primitives.
Create custom transformation, enrichment, or analytics modules that execute alongside core pipelines. Full access to the data plane's semantic model and pipeline context.
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 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.
Manage configuration, health, and status of all distributed edge deployments from a single control interface. Full visibility across sites, regions, and environments.
Push configuration updates, namespace models, and pipeline definitions across sites with controlled rollout and rollback. No manual node-by-node intervention.
Aggregate telemetry from all nodes including pipeline throughput, latency, module health, and resource utilization across the entire deployment fleet.
Real-time visibility into connectivity, data flow status, and error conditions across every managed node. Detect degradation before it affects operations.
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.
Per-pipeline metrics: messages/sec, bytes/sec, p50/p95/p99 latency, error rates, and backpressure indicators. Understand data flow behavior, not just system utilization.
Connection status, buffer depth, reconnection attempts, and protocol-specific diagnostics per module. Know which sources are healthy and which are degraded.
CPU, memory, network, and restart metrics for every managed workload. Resource consumption visibility for capacity planning and anomaly detection.
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.
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.
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.
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.
Fleet discovery, health queries, fan-out diagnostics, UNS graph queries, and live subscriptions. Tool annotations (readOnly, destructive, idempotent, cost) enable safe autonomous decision-making.
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
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.
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
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.
