Zenoh for Industrial IoT: Reference Architecture (2026)
Last Updated: November 11, 2026
A typical brownfield plant now runs three messaging worlds side by side: MQTT and Sparkplug B for SCADA telemetry, DDS inside every ROS 2 robot, and OPC UA at the controller boundary. Each works well alone, and each fails differently when you try to stretch it across cells, subnets and a WAN. Zenoh industrial IoT deployments exist because one data fabric that speaks publish/subscribe, queries and storage can absorb all three patterns without a broker in every hot path.
The timing matters. ROS 2 Kilted Kaiju made Eclipse Zenoh a Tier 1 middleware in May 2025, Zenoh itself has shipped a steady 1.x line through 1.10.2 in late October 2026, and Zenoh-Pico now reaches microcontrollers on Zephyr, FreeRTOS and ESP-IDF. The question is no longer whether Zenoh works, but how to lay it out so it survives a design review and month three of production.
You will leave with a four-plane reference architecture, a router topology, an ISA-95 key-expression scheme, working configuration, capacity heuristics and the failure modes that actually bite.
What this covers: where Zenoh fits in 2026, the four-plane reference architecture, peer, client and router topology, key-expression design, ROS 2 and MQTT integration, storage and queries, security, capacity planning, failure modes and a rollout checklist.
Context and Background
Industrial messaging grew up in silos. MQTT, standardized by OASIS (version 3.1.1 in 2014, version 5.0 in 2019), gave the plant floor a lightweight broker pattern, and Sparkplug B added state management and a topic namespace on top. DDS, the Object Management Group standard, gave robotics and defense a broker-less, QoS-rich data bus, which is why ROS 2 adopted it as its default middleware. OPC UA brought a rich information model and, later, PubSub transports. If you need a refresher on how these fit together, our guide to industrial IoT communication protocols maps the landscape.
The trouble starts at the seams. DDS discovery is chatty and assumes multicast, so it struggles across routed subnets, Wi-Fi and WAN links. MQTT is centralized by design, so every sample takes a hop through a broker even when publisher and subscriber sit on the same machine. Neither offers a native way to ask the network “give me the last hour of joint temperatures for every robot in this area” without bolting on a historian API.
Eclipse Zenoh, described by its maintainers as “Zero Overhead Pub/Sub, Store/Query and Compute”, was designed for exactly that seam. It is an Eclipse Foundation project led by ZettaScale Technology, dual-licensed under EPL-2.0 and Apache-2.0, with a Rust reference implementation and bindings for C (zenoh-c and the pure-C Zenoh-Pico), C++, Python, Java, Kotlin, Go and TypeScript. One protocol carries three primitives: publications, queries answered by queryables, and liveliness tokens that signal presence.
Two facts changed the 2026 calculus. First, the ROS ecosystem moved: Open Robotics announced that “ROS Kilted Kaiju is our first ROS release to support Eclipse Zenoh as a Tier 1 middleware”, meaning it is tested daily alongside the DDS implementations. Fast DDS remains the default in ROS 2 Lyrical Luth (May 2026), but rmw_zenoh is a supported, binary-released choice for Humble, Jazzy, Kilted, Lyrical and Rolling. Second, the core library matured into a predictable 1.x cadence, with features that industrial architects care about: access control, downsampling, QoS overrides by key expression, shared memory and an advanced publish/subscribe layer with history and gap recovery.
The rest of this article assumes you have a mixed-protocol plant and want a defensible Zenoh industrial IoT layout, not a toy demo.
The Zenoh Industrial IoT Reference Architecture
A defensible Zenoh industrial IoT architecture has four planes. Devices publish and answer queries, cell routers federate local traffic, a persistence and bridge plane stores samples and translates legacy protocols, and consumers such as digital twins and MES read through one key-expression namespace. Each plane scales and fails independently.

Figure 1: The four-plane Zenoh reference architecture. Devices reach the fabric natively or through bridges; routers federate cells; storages and bridges sit beside the plant router; consumers never talk to devices directly.
The device plane at the bottom holds PLC gateways, ROS 2 robots running rmw_zenoh, and microcontroller sensors running Zenoh-Pico. The routing plane is a set of zenohd routers, one per cell and a small cluster for the plant. The persistence and bridge plane hosts the storage manager plugin and protocol bridges. The consumer plane holds the digital twin, MES, historian and analytics jobs, all reading through key expressions rather than device addresses.
Plane 1: devices speak Zenoh natively where they can
The single most useful rule in Zenoh industrial IoT design is to put the Zenoh session as close to the data source as possible. A robot running rmw_zenoh, a vision PC using the Python or C++ API, or a sensor node with Zenoh-Pico publishes directly into the fabric. Each extra translation step adds latency, a process to supervise and a place where semantics can be lost.
Native is not always possible. A Siemens or Rockwell controller will not run a Zenoh client, and many vendors expose only OPC UA, Modbus or MQTT. Those devices attach through a gateway: an OPC UA or Modbus driver on an edge box that republishes into Zenoh, or an MQTT client connected to the Zenoh MQTT bridge. The point is to treat the gateway as part of the device plane, owned by the cell, not as a central integration hub.
Zenoh-Pico matters more than most architects assume. Its README lists Unix, Windows, Zephyr, Arduino, ESP-IDF, MbedOS, OpenCR, Emscripten, FreeRTOS-Plus-TCP and Raspberry Pi Pico as platforms, with UDP, TCP and serial links depending on the target. That means a vibration sensor on an ESP32 or a Zephyr board can publish into the same key space as the plant historian, with no MQTT broker in between. Zenoh-Pico supports client mode (connect to a router) and peer mode over UDP multicast, and recent releases added peer-to-peer unicast and automatic reconnection with declaration restoration.
Plane 2: routers federate, they do not store
The zenohd router is the backbone of any Zenoh industrial IoT deployment. Each production cell gets a router, usually on the cell’s edge PC or a small industrial server, and the plant runs a router pair or cluster that federates the cells. Routers route samples by key expression, forward queries to matching queryables, propagate liveliness and enforce access control. By default they do not persist anything.
This separation is deliberate. A router that also stores becomes a stateful pet that you cannot restart casually, and its disk I/O competes with routing. Keeping routers stateless means a cell router can be rebuilt from configuration in minutes, and a plant router failure is a reconnection event rather than a data-loss event.
Routers are also where policy lives. The access-control layer, downsampling interceptors, low-pass filters and per-key QoS overrides all run in the router’s configuration. That gives OT security teams a small number of choke points to audit, which is a much easier conversation than securing every robot’s DDS participant.
Plane 3: storages and bridges are plugins beside the plant router
Persistence in Zenoh is a plugin, not a separate product. The storage manager plugin subscribes to a key expression, writes matching samples to a volume, and registers a queryable so that a get on that key expression returns stored values. The documented backends are an always-available in-memory volume plus RocksDB, InfluxDB, S3 and the file system.
Bridges live in the same plane. The MQTT plugin (or standalone zenoh-bridge-mqtt) accepts MQTT V3 and V5 clients and maps topics to key expressions. The ros2dds plugin carries DDS-based ROS 2 traffic over Zenoh for robots that still run a DDS RMW. Placing both next to the plant router, or next to the legacy system they translate, keeps the translation hop short.
Plane 4: consumers read the namespace, not the network
Digital twins, MES, historians, dashboards and ML pipelines subscribe to or query key expressions. They do not know which robot, cell router or bridge produced a sample. This is the architectural payoff of Zenoh industrial IoT: you can swap a historian, re-host a twin or replace a bridge without touching device configuration.
It also enables a pattern MQTT cannot express natively. A twin can subscribe to live samples and, in the same session, issue a get that is answered by both storages (history) and live queryables (current computed state). For a plant digital twin, that collapses the “load history, then switch to live” logic into one key-expression contract.
Topology: Peers Inside Cells, Routers Between Them
Zenoh nodes run in one of three modes. Peers talk directly to other peers and can discover them over multicast scouting. Clients connect to a single router and delegate routing to it. Routers form the backbone, forward between networks and apply policy. The practical Zenoh industrial IoT topology is a hybrid: peer meshes inside a cell, routers at every cell boundary.

Figure 2: Hybrid Zenoh topology. Tight loops stay inside peer meshes; cell routers uplink to a plant router pair; one WAN-facing router terminates TLS or QUIC toward the data center.
In Figure 2, the robot, vision PC and PLC gateway in Cell A exchange samples peer to peer, so a camera-to-robot correction never leaves the cell switch. The cell router is still present because it bridges the cell to the plant, enforces policy on everything that leaves, and gives clients a stable endpoint. Cell B mixes an AMR fleet with Zenoh-Pico sensors, which typically run in client mode against the cell router.
When peer mode is the right call
Peer mode removes the broker from the data path. The Zenoh-commissioned 2023 study by National Taiwan University researchers measured median one-way latency of about 10 microseconds for Zenoh peer-to-peer on a single machine and about 16 microseconds across two machines on 100 GbE, versus 21 and 41 microseconds for Zenoh in brokered mode. The absolute numbers come from a tuned lab testbed with Zenoh 0.7.0-rc and 64-byte payloads, so treat them as an upper bound on what is possible, not a plant number. The relative point holds: removing the router hop roughly halves median latency in that setup.
Use peer mode for vision-to-motion loops, multi-sensor fusion on one cell, and any flow where a few hundred microseconds of broker jitter matters. Keep peer meshes small, typically one cell, because every peer maintains state about its neighbours.
When client mode is the right call
Client mode suits constrained devices and untrusted endpoints. A Zenoh-Pico sensor in client mode holds one connection, needs no routing tables, and can be refused by the router’s access control. It is also the right mode for HMI panels and laptops that come and go, because they never become part of the routing fabric.
Why rmw_zenoh changes the robot cell
rmw_zenoh uses a router for discovery by default. Its documentation states that nodes learn about each other through the router’s gossip and that multicast discovery is disabled by default, so you start the router with ros2 run rmw_zenoh_cpp rmw_zenohd. Data still flows peer to peer once discovered. For a plant, this is a feature: discovery traffic is no longer a multicast storm on a shared VLAN, and the robot’s router doubles as the cell router or uplinks to it.
Multicast is often blocked, plan for it
Many corporate and OT networks block or rate-limit multicast. Zenoh does not require it. You can configure explicit connect endpoints, use gossip scouting through routers, or set a multicast TTL so that scouting crosses a routed boundary in a controlled way, a capability added in the 1.3 line. Document which mechanism each cell uses, because a silent fallback to “nothing discovered” is the most common first-week support ticket.
Designing the Key-Expression Namespace
Zenoh addresses data by key expressions: slash-separated strings such as acme/pune/bodyshop/line01/weld-a/robot-01/telemetry/joint-temp. Subscriptions, queries, storages and access-control rules all use key expressions with wildcards. * matches exactly one chunk, ** matches zero or more chunks, and $* matches part of a chunk. Because every other design decision keys off this namespace, it is the most consequential artifact in a Zenoh industrial IoT rollout.
Map ISA-95 into the first chunks
ISA-95 gives you a stable equipment hierarchy: enterprise, site, area, line or unit, work cell, equipment. Mirror it in the leading chunks, then add a data-class chunk and a signal name. A pattern that holds up across sites is:
{enterprise}/{site}/{area}/{line}/{cell}/{asset}/{class}/{signal}
where class is one of telemetry, event, state, cmd or cfg. If you already run an MQTT unified namespace, reuse its hierarchy so the MQTT bridge maps topics one to one. Our comparison of Sparkplug B and plain MQTT topic design covers the trade-offs of that choice in more depth.
Why the data-class chunk earns its place
Putting the class before the signal makes policy and storage selectors trivial. A historian storage on acme/pune/**/telemetry/** captures every telemetry signal on the site and nothing else. An ACL rule allowing put on acme/pune/**/cmd/** only from the MES subject keeps commands locked down in one line. Without the class chunk you end up writing long allow-lists of signal names, which rot as soon as a team adds a sensor.
Rules that prevent namespace drift
Keep chunks lowercase and stable for years. Never embed IP addresses, serial numbers or firmware versions in key expressions, because they change and every consumer embeds the strings. Put those in the payload or in a cfg key. Do not use the namespace as a database: a key per row, or per timestamp, explodes routing state and makes wildcard queries expensive. Use a storage for that.
Treat the namespace as a public API. Keep a versioned registry, one YAML file per site is enough, and require review to add or rename a top-level chunk. Breaking renames go through a deprecation window where both keys publish in parallel for at least one production cycle. Zenoh’s namespace-prefix feature, added in 1.3, helps here: a session can be confined to a prefix such as acme/pune, so a misconfigured edge app cannot write outside its site.
Walk-through: From Robot Sample to Twin Query
The clearest way to see why a Zenoh industrial IoT architecture holds together is to follow one sample. A welding robot publishes its joint state, the fabric routes and persists it, and a digital twin both receives it live and later queries an hour of history through the same key expression.

Figure 3: One sample’s journey. A put is routed by key expression, persisted by a matching storage and pushed to live subscribers; a later get fans out to storages; a dropped liveliness token tells the twin the robot went offline.
The sequence in Figure 3 shows three Zenoh primitives working together. The robot’s put is routed to every matching subscriber and storage. The twin’s get is a distributed query: the router forwards it to every queryable whose key expression intersects the selector, collects replies and returns them. The liveliness token is a presence signal that disappears when the session dies, which the twin observes as a delete event.
Getting ROS 2 data into the fabric
You have two integration paths. With rmw_zenoh, the robot’s ROS 2 nodes are native Zenoh participants, so topics, services and actions already exist as key expressions and queryables. Set RMW_IMPLEMENTATION=rmw_zenoh_cpp, start the router, and the cell router can federate the robot directly. This is the cleaner path for new robots on Jazzy, Kilted or Lyrical.
With a DDS-based RMW that you cannot change, run zenoh-bridge-ros2dds (or the ros2dds plugin in zenohd) next to the robot. The bridge uses Cyclone DDS internally, is tested with rmw_cyclonedds_cpp, maps services and actions to queryables, and prefixes everything with a configurable namespace such as /bot7. That namespace option is what lets ten identical robots share one plant fabric without renaming topics inside each robot. For tuning the DDS side before it reaches the bridge, our deep dive on ROS 2 QoS profiles and DDS tuning for lossy Wi-Fi fleets is the companion piece.
Be explicit about the key mapping either way. rmw_zenoh embeds the ROS domain, topic name and type information in its key expressions, which is right for ROS tools but awkward for a twin that wants acme/pune/.../robot-01/telemetry/joint-state. Many teams add a thin republisher, a few dozen lines of Python, that subscribes to the ROS key expression and republishes a curated, ISA-95-shaped key with a stable payload schema. That republisher is your contract boundary between robotics and the rest of the plant.
A minimal edge publisher and twin query
The Python binding is the fastest way to prototype the contract. This example publishes joint temperatures with an explicit priority and drop-on-congestion policy, declares a liveliness token, and shows the twin-side query.
import json, time
import zenoh
KEY = "acme/pune/bodyshop/line01/weld-a/robot-01/telemetry/joint-temp"
conf = zenoh.Config()
conf.insert_json5("mode", '"client"')
conf.insert_json5("connect/endpoints", '["tls/cell-router-a.pune.acme:7447"]')
with zenoh.open(conf) as session:
token = session.liveliness().declare_token(
"acme/pune/bodyshop/line01/weld-a/robot-01/state/alive")
pub = session.declare_publisher(
KEY,
priority=zenoh.Priority.DATA_HIGH,
congestion_control=zenoh.CongestionControl.DROP,
)
for _ in range(600):
pub.put(json.dumps({"ts": time.time(), "j1": 41.2, "j2": 39.8}))
time.sleep(0.1)
# Twin side: one get returns stored history and live queryable answers
with zenoh.open(zenoh.Config()) as twin:
for reply in twin.get("acme/pune/bodyshop/**/telemetry/joint-temp"):
if reply.ok:
print(reply.ok.key_expr, reply.ok.payload.to_string())
Two details matter for industrial use. Drop congestion control is the protocol default for publications and is correct for high-rate telemetry, where a stale sample is worse than a missing one. Commands and configuration writes should use Block instead, so they are never silently discarded under load. The Zenoh specification also defines BlockFirst, where the first message of a burst blocks and later ones drop.
Router configuration: storage plus access control
The cell or plant router carries the policy. Below is an abridged zenohd JSON5 configuration for a plant router that persists site telemetry to RocksDB and allows a historian identity to subscribe to telemetry but not to publish commands. Field names follow the storage-manager and access-control documentation; check your backend’s README for its volume options.
{
mode: "router",
listen: { endpoints: ["tls/0.0.0.0:7447"] },
plugins: {
storage_manager: {
volumes: { rocksdb: {} },
storages: {
site_telemetry: {
key_expr: "acme/pune/**/telemetry/**",
volume: { id: "rocksdb", db: "pune-telemetry", create_db: true },
},
},
},
},
access_control: {
enabled: true,
default_permission: "deny",
rules: [
{ id: "read-telemetry", permission: "allow",
messages: ["declare_subscriber", "put", "query", "reply"],
flows: ["ingress", "egress"],
key_exprs: ["acme/pune/**/telemetry/**"] },
],
subjects: [ { id: "historian", cert_common_names: ["historian.pune.acme"] } ],
policies: [ { rules: ["read-telemetry"], subjects: ["historian"] } ],
},
}
The access-control model is worth understanding precisely. Rules name message types: put, delete and declare_subscriber for publish/subscribe; declare_queryable, query and reply for queries; and, since 1.0.3, liveliness_token, declare_liveliness_subscriber and liveliness_query. Subjects match on network interface, TLS or QUIC certificate common name, or username from user-password authentication. Within a list the values are OR-ed, across lists they are AND-ed, and an omitted list is a wildcard, so an empty subject matches everyone. Start with default_permission: "deny" on any router that faces another trust zone.
Bridging MQTT without a forklift migration
The MQTT plugin listens on port 1883 by default and accepts V3 and V5 clients. Three options shape a safe deployment. scope prefixes every bridged topic, so spBv1.0/... from line 3 becomes acme/pune/mqtt-l3/spBv1.0/... and cannot collide with native keys. allow and deny are regular expressions over topic names, so you can bridge only the namespaces you mean to. TLS and mutual TLS are supported, which matters because the plugin’s own documentation notes that MQTT usernames and passwords travel in clear text in the CONNECT packet.
Sparkplug B payloads pass through as opaque protobuf bytes. Zenoh does not interpret birth and death certificates, so a SCADA that depends on Sparkplug state management should keep talking to a Sparkplug-aware broker. The bridge’s job is to expose that data to robotics and analytics consumers on the Zenoh side, not to replace the SCADA contract.
Capacity Planning, High Availability and Security
In Zenoh industrial IoT systems, raw protocol performance is rarely the first bottleneck. Storage write throughput, TLS handshakes on reconnect storms, and slow consumers usually surface first. Plan from the workload, then benchmark your own payload mix on your own hardware.
What the published numbers do and do not tell you
The 2023 throughput and latency study (arXiv 2303.09419) is the most cited reference. On an AMD Ryzen 7 5800X testbed it reported more than 4 million messages per second for small payloads in Zenoh peer-to-peer mode on a single machine, and roughly 50 Gbps peer-to-peer and 34 Gbps brokered between two machines on 100 GbE, against about 14 Gbps for Cyclone DDS, 9 Gbps for Mosquitto and 5 Gbps for Kafka in the same setup. Those figures used Zenoh 0.7.0-rc, MQTT at QoS 0, and differing reliability settings across systems, and the study was published on the Zenoh project’s blog. Use it to understand headroom, not to size a router.
A more independent 2025 paper from RWTH Aachen University (arXiv 2505.02734) compared Fast DDS, Zenoh and vSomeIP in automotive topologies. It found Zenoh and Fast DDS broadly similar on latency, Zenoh fastest to first message and the only one to deliver every message in its two hardest topologies, while Fast DDS used less CPU and memory. It also concluded that the operating system network stack, not the middleware, sets the latency floor. That last point is the one plant architects should internalize.
An illustrative sizing worksheet
The table below is a worked, illustrative example for one body-shop line, not a measured benchmark. It shows how to reason from device counts to router and storage load.
| Input | Illustrative value | Derived load |
|---|---|---|
| Robots, 6 joints each, 100 Hz state | 12 robots | 1,200 samples per second |
| Vision PCs, 30 Hz results | 4 PCs | 120 samples per second |
| PLC tags via gateway, 10 Hz | 2,000 tags | 20,000 samples per second |
| Zenoh-Pico vibration nodes, 1 kHz batched to 10 Hz | 40 nodes | 400 samples per second |
| Mean payload size | 200 bytes | about 4.3 MB per second at the line router |
| Subscriber fan-out, mean | 3 consumers | about 13 MB per second egress |
| Storage write multiplier, two replicas | 2 | about 43,000 writes per second |
The router load in this example is modest. The storage is not: tens of thousands of writes per second is where an under-provisioned RocksDB or InfluxDB volume will push back. Two mitigations come straight from Zenoh’s feature set. Downsampling interceptors on the router can cap the rate at which a key expression is forwarded to a given interface, so the historian receives 1 Hz PLC values while a local control loop still sees 10 Hz. The low-pass filter interceptor, added in 1.3, can drop messages above a size threshold before they reach a constrained link.
High availability patterns
Routers are stateless with respect to data, so availability comes from redundancy and client reconnection. Give each client or Zenoh-Pico device two router endpoints, run the plant tier as a pair or small cluster, and let peers reconnect after a failover. Recent Zenoh-Pico releases restore declarations automatically on reconnect, which removes a class of “the sensor came back but nobody hears it” bugs.
Storages need their own redundancy. Run two storages on the same key expression on separate hosts, and rely on the backend’s own durability story for the disk. Zenoh’s advanced publish/subscribe layer adds a complementary safety net at the edge: an AdvancedPublisher keeps a cache of recent samples and sequence numbers, so an AdvancedSubscriber can detect gaps, request recovery and fetch history on late join. Bridges are the real single points of translation, so run them as supervised pairs with distinct scopes or a health-checked active/standby arrangement.
Security model in practice
Zenoh’s transport options include TCP, UDP, TLS, QUIC and WebSocket, with serial links for Zenoh-Pico. Use TLS or QUIC with certificates on every link that crosses a trust boundary, and mutual TLS between routers. QUIC is attractive for cellular or Wi-Fi backhaul because it recovers from loss without head-of-line blocking across streams; 1.9 added QUIC streams per priority, which keeps bulk transfers from delaying control traffic.
Map a Zenoh industrial IoT network to IEC 62443 zones and conduits: each cell is a zone, each cell-router uplink is a conduit, and the router’s ACL is the conduit’s enforcement point. For ROS 2 fleets, the zenoh_security_tools package in the ROS index helps generate rmw_zenoh security configuration, and our guide to SROS2 and DDS Security covers the DDS side for robots that still use it.
Trade-offs, Gotchas, and What Goes Wrong
Zenoh industrial IoT adoption is not a free lunch, and the honest comparison is with the incumbents you already operate. The decision tree below is the one I use in design reviews: it routes pure SCADA telemetry to MQTT with Sparkplug B, isolated robot cells to DDS, and mixed or query-heavy workloads to a Zenoh fabric.

Figure 4: A decision tree for Zenoh industrial IoT adoption. Zenoh wins where traffic is mixed or needs queries over live and stored data; MQTT with Sparkplug B remains the safer choice for SCADA-only telemetry.
Ecosystem gravity favours MQTT. SCADA, historians and cloud IoT services integrate MQTT and Sparkplug B natively. Zenoh has a REST plugin, bridges and multi-language APIs, but far fewer turnkey operator tools. Budget for a key-expression browser, a sample inspector and dashboards built from the admin space in the first six months.
The 1.x line still moves. Zenoh follows semantic versioning, yet minor releases have carried flagged breaking changes. Release 1.9.0 introduced a “Regions” change, and 1.10.0 changed source-info and shared-memory handoff APIs. Several useful features, including advanced publish/subscribe and the querier, shipped as unstable APIs first. Pin versions across routers, bridges and bindings, and upgrade cell by cell after a soak test.
rmw_zenoh versions are distro-specific. The ROS index lists separate rmw_zenoh versions per distribution, and the project has shipped at least one wire-breaking change for Jazzy. Mixed-distro fleets need an explicit compatibility check before they share a router, and a Zenoh router built for one rmw_zenoh release should not be assumed to match another.
Bridges lose semantics. MQTT retained messages, Sparkplug birth and death, DDS durability and deadline QoS do not map one to one onto Zenoh. The bridge carries bytes faithfully, but behavioural contracts stop at the bridge. If a consumer depends on such a contract, it must stay on the native protocol or you must re-implement the behaviour explicitly, for example with liveliness tokens and AdvancedPublisher history.
Discovery and topology surprises. Blocked multicast, mismatched Zenoh-Pico batch sizes in multicast peer mode, and a forgotten rmw_zenohd router all produce the same symptom: nobody hears anyone. Zenoh-Pico’s README warns that multicast does not negotiate transport parameters, so every node in a multicast group needs matching settings.
Timestamp and ordering hazards. Zenoh routers can stamp samples with hybrid logical clock timestamps, which storages use for ordering and conflict resolution. Device clocks that drift still corrupt analytics that rely on source time inside the payload. Run PTP where control or sequence-of-events analysis matters, and NTP everywhere else.
Namespace collisions are silent. Two teams publishing under the same prefix merge their data without errors. The registry and the namespace-prefix feature are the controls; there is no protocol-level fix.
Practical Recommendations
Start a Zenoh industrial IoT program where the strengths are undeniable: a cell that already mixes ROS 2 robots with MQTT or OPC UA telemetry, and where someone wants to query history and live state through one interface. Do not start by replacing a working SCADA broker. Prove the fabric on mixed traffic, then let it grow outward through bridges.
Design the namespace first, before code, and review it with OT, IT and robotics in the same room. Then stand up stateless cell routers with deny-by-default access control and TLS, add a plant router pair, and only then attach storages. Storages subscribe silently to whatever their key expression matches, so moving them after the namespace changes is expensive.
Instrument from day one. The router’s admin space and per-key metrics, added in 1.7, give you subscription counts, sample rates and drops. Wire them into your existing observability stack and alert on storage backpressure, not just router CPU. Finally, treat Zenoh as load-bearing infrastructure: pin versions, soak-test upgrades, and arrange commercial support with ZettaScale or a partner if production depends on it.
A pre-production checklist:
- Key-expression registry versioned in Git, with ISA-95 leading chunks and a data-class chunk.
- One stateless router per cell, a plant router pair, two endpoints configured on every client.
- Access control enabled with
default_permission: "deny"on every router facing another zone. - TLS or QUIC with mutual authentication on every inter-zone link.
- Storages duplicated on separate hosts, with restore tested.
- Bridges supervised in pairs, scoped, and restricted with allow lists.
- Zenoh, Zenoh-Pico, bindings and rmw_zenoh versions pinned and recorded per cell.
- PTP or disciplined NTP across cells, plus a runbook for discovery failures.
Frequently Asked Questions
Is Zenoh production-ready for industrial IoT in 2026?
Yes, Zenoh industrial IoT deployments are production-ready for mixed-protocol edge workloads, with operational caveats. Zenoh has shipped a 1.x line since October 2024, reaching 1.10.2 in late October 2026, and ROS 2 has treated it as a Tier 1 middleware since Kilted Kaiju in May 2025. The protocol and core libraries are mature. The gaps are ecosystem tooling, fewer SCADA integrations than MQTT, and minor releases that occasionally carry flagged breaking changes. Pilot it in one cell, pin versions, instrument the admin space and arrange support before it becomes load-bearing.
What is the difference between Zenoh and MQTT?
MQTT is a broker-centric publish/subscribe protocol: every message passes through a broker, and history needs an external historian. Zenoh supports publish/subscribe, distributed queries and storage in one protocol, and it can run peer to peer without a broker in the data path. MQTT with Sparkplug B has deeper SCADA support and state management. Zenoh suits mixed robotics, vision and telemetry traffic and query-heavy digital twins. Many plants run both, joined by the Zenoh MQTT bridge.
Is Zenoh replacing DDS in ROS 2?
Not as the default. Fast DDS remains the default middleware in ROS 2 Lyrical Luth, released in May 2026. However, rmw_zenoh has been a Tier 1 middleware since Kilted Kaiju and has binary releases for Humble, Jazzy, Kilted, Lyrical and Rolling. Teams choose it to escape multicast discovery storms, to cross subnets and Wi-Fi more reliably, and to integrate robots with a plant-wide Zenoh fabric. You switch per process with RMW_IMPLEMENTATION=rmw_zenoh_cpp and a running router.
Does rmw_zenoh need a Zenoh router?
By default, yes. The rmw_zenoh documentation says multicast discovery is disabled and nodes discover each other through the router’s gossip, so you start it with ros2 run rmw_zenoh_cpp rmw_zenohd. Once nodes are discovered, data flows directly between them rather than through the router. The project notes that manually launching the router may not be necessary in the future. In a plant, that router naturally becomes, or uplinks to, the cell router in the reference architecture.
Can Zenoh run on microcontrollers?
Yes, through Zenoh-Pico, a pure C implementation. Its documentation lists Zephyr, FreeRTOS-Plus-TCP, ESP-IDF, Arduino, MbedOS, OpenCR, Raspberry Pi Pico and others, over UDP, TCP or serial links depending on the platform. It runs in client mode against a router or in peer mode over UDP multicast. Constrained targets may need smaller batch and fragmentation buffers. Note that the full Rust stack, and anything built on it such as ZettaScale’s Hiroz, needs a standard library and does not target microcontrollers.
How do you secure a Zenoh deployment?
Use TLS or QUIC with certificates on every link that crosses a trust boundary, and mutual TLS between routers. Enable the router’s access control with a default of deny, and write rules over key expressions and message types such as put, declare_subscriber and query. Subjects can match certificate common names, usernames or network interfaces. Map cells to IEC 62443 zones with routers as conduit enforcement points, and confine edge applications with namespace prefixes so they cannot write outside their site.
Further Reading
- Industrial IoT communication protocols: an architecture guide for where Zenoh sits among MQTT, OPC UA, DDS and fieldbuses.
- Sparkplug B versus plain MQTT topic design before you decide how MQTT namespaces map into Zenoh key expressions.
- ROS 2 QoS profiles and DDS tuning for lossy Wi-Fi robot fleets for the DDS side of a mixed robot fleet.
- SROS2 and DDS Security for ROS 2 for certificate-based security on robots that keep a DDS RMW.
- Zenoh access control documentation for the full rule, subject and policy syntax.
- Open Robotics announcement of ROS 2 Kilted Kaiju for the Tier 1 Zenoh middleware status.
References
- Eclipse Zenoh, GitHub repository and release notes, versions 1.6 to 1.10.2. https://github.com/eclipse-zenoh/zenoh/releases
- Eclipse Zenoh-Pico, GitHub repository and releases, version 1.10.0 (August 2026). https://github.com/eclipse-zenoh/zenoh-pico
- Zenoh documentation, Access Control. https://zenoh.io/docs/manual/access-control/
- Zenoh documentation, Storage manager plugin. https://zenoh.io/docs/manual/plugin-storage-manager/
- Zenoh specification 1.0.0, Quality of Service. https://spec.zenoh.io/spec/1.0.0/concepts/qos.html
- Zenoh blog, Firesong 1.1.0 release (advanced publish/subscribe, liveliness). https://zenoh.io/blog/2024-12-12-zenoh-firesong-1.1.0/
- Zenoh blog, Gozuryu 1.3.3 release (namespace prefixes, multicast TTL, low-pass filter). https://zenoh.io/blog/2025-04-14-zenoh-gozuryu/
- Eclipse Zenoh MQTT plugin and bridge, README. https://github.com/eclipse-zenoh/zenoh-plugin-mqtt
- Eclipse Zenoh ROS 2 DDS plugin and bridge, README. https://github.com/eclipse-zenoh/zenoh-plugin-ros2dds
- ROS Index, rmw_zenoh repository summary. https://index.ros.org/r/rmw_zenoh
- Open Robotics, “ROS 2 Kilted Kaiju Released”, May 2025. https://www.openrobotics.org/blog/2025/5/23/ros-2-kilted-kaiju-released
- eProsima, “ROS 2 Lyrical Luth and 11 Years of Fast DDS as ROS 2 Default Middleware”, ROS Discourse, May 2026. https://discourse.openrobotics.org/t/ros-2-lyrical-luth-and-11-years-of-fast-dds-as-ros-2-default-middleware/55062
- W.-Y. Liang et al., “A Performance Study on the Throughput and Latency of Zenoh, MQTT, Kafka, and DDS”, arXiv 2303.09419, 2023. https://arxiv.org/abs/2303.09419
- D. P. Klüner et al., “Automotive Middleware Performance: Comparison of FastDDS, Zenoh and vSomeIP”, arXiv 2505.02734, 2025. https://arxiv.org/html/2505.02734v2
- ZettaScale, “Introducing Hiroz”, ROS Discourse, May 2026. https://discourse.openrobotics.org/t/introducing-hiroz-by-zettascale/55081
By Riju — about
