Mind · the part you upgrade
Writes the programs
Language models turn what you ask for into a typed program, using only devices that have actually plugged in. The Mind can read every device; it can’t command one.
An open protocol for any device
ZRiO is an open protocol any device can plug into. Devices keep no logic of their own: AI writes the programs, and a deterministic Core checks and signs each one before anything moves.
Core running · 12 of 20 leases heldset
Mind writes the program
You
Core verifies, signs, runs
Devices · one universal firmware, no logic of their own
Journal
Fig. 1An illustrative run on ZRiO’s twenty-device simulation. The device names, units, limits and checks are the real ones; the program language and the verifier ship in the alpha.
Verified in simulation · Sep 2026zriod 0.0.1 · spec 0.1-draft0
Devices
20
plugged into the reference simulation: 8 relays, 4 dimmers and 8 climate sensors, each its own MQTT 5 client.
Dropped S8
0
reports, with 20 devices at 1 Hz plus a 5 Hz read loop, for 30 minutes.
Core memory S8
11.1 MB
at its peak in that same run, while the journal grew to 14.3 MB.
Conformance
143
cases in the spec, for anyone building a device or a brain.
The problem
Every connected device ships with its own processor, firmware, app and often its own cloud, plus its own way of being told what to do. The logic ends up scattered across vendors, and now language models are being wired straight in.
| Question | Connected devices today | With ZRiO |
|---|---|---|
| How a device joins | Through a vendor’s app, account or hub | It announces one manifest |
| How you talk to it | A different API for every vendor | One open protocol: fourteen message types |
| Where the logic lives | Inside each device and its vendor’s cloud | In one brain you run, next to the devices |
| A model on the control path | Increasingly, through assistants and integrations | Never. Models write programs; the Core runs them |
| When a vendor’s cloud goes away | Devices can stop working | Nothing changes: commands stay on your network |
| “Why did that switch on?” | Check each app’s history | One journal names the rule, the reading and the time |
| When the brain goes quiet | Depends on each device | Every actuator falls to its declared safe state |
How it works
Models never sit between a decision and a device. They write small, typed programs; a deterministic Core checks, signs and runs them.
Mind · the part you upgrade
Language models turn what you ask for into a typed program, using only devices that have actually plugged in. The Mind can read every device; it can’t command one.
Core · the part that stays put
A deterministic runtime, in Rust with unsafe code forbidden, verifies each program, signs its exact bytes, runs it and journals every state change. It never waits on a model.
Devices · the bodies
A device plugs in by announcing a manifest, then speaks one small protocol. It reads, sets and reports, enforces its own limits, and falls to a safe state when the brain goes quiet. It never writes logic of its own.
a model is involveddeterministic: no model on the path to a device
The protocol
A device plugs in by announcing a manifest: what it can do, in which units, within which limits, and where it falls when the brain goes quiet. From then on it speaks fourteen message types. Every part is written down, with a JSON Schema and conformance cases, so anyone can build a device, a brain or a bridge.
Every message carries its sender, a hybrid-logical-clock time and a sequence number, so a device acts on a repeat only once.
How a device describes itself: attributes, units, limits, safe states and leases. No free-text descriptions.
Fourteen message types, and every command is idempotent. There is no TOGGLE, because sending a toggle twice undoes it.
{ "spec": "0.1", "device": { "id": "dimmer-living-1", "model": "ZRiO simulated dimmer", "firmware": "0.0.1" }, "lease": { "default_ms": 30000, "max_ms": 300000 }, "capacity": { "senders": 4, "subscriptions": 4 }, "attributes": [ { "name": "level", "class": "continuous_actuator", "type": "int", "unit": "%", "limits": { "min": 0, "max": 100 }, ← enforced on the device "safe_state": 0 ← where it falls when a lease runs out }, { "name": "power", "class": "sensor", "type": "float", "unit": "W" } ] }
The whole vocabularyFourteen message types. Every command idempotent. No TOGGLE.
describemanifestreadreportsetackpulserampholdsubscribeemitlimitleasefailsafeSpec v0.1, draft0 · JSON Schema 2020-12 · 143 conformance cases · prose under CC-BY-4.0 · nothing is stable until v0.1 is released
Safety
Model output is untrusted input. Nothing a model writes reaches a device until it passes eight deterministic checks, and every device still enforces its own limits.
Devices, attributes, types and units, checked against what the devices announced.
JSON Schema + registryEvery capability it uses is both granted to it and offered by the device.
set containmentValues and ramp rates within each device’s limits; no condition always or never true.
interval arithmeticTwo rules writing one attribute at the same moment need an explicit priority.
pairwise overlapA chain from a rule, through an attribute, back to that rule is an error.
Tarjan SCCAnything that must react in under 200 ms runs on the device, and has to fit.
placement passEvery actuator has a safe state, and no lease outlives the device’s maximum.
manifest lookupReplayed against the last 24 hours of the journal: no limit breached, nothing switched too often.
deterministic replaySigned exact bytes. Only a verified program can be signed. Its address is the sha256 of its exact bytes, its ed25519 signature is detached, and a device checks that signature before it loads anything.
Safe is not the same as right. The checks can tell whether a program is safe, not whether it’s what you meant. So every program states what it expects to happen, and every action is journaled with the rule that caused it.
Below the brain
A device holds a value only under a lease the Core must keep renewing. Stop the Core and each device falls to the safe state in its own manifest, on its own clock. Start it again and it holds nothing it can’t see: it won’t command anything from an old log.
LIMITMin, max and max rate, enforced on the deviceLEASEControl is borrowed, and it runs outFAILSAFEEvery actuator to its declared safe stateCore running · holding 12 leases, renewed at half-life
Fig. 2Bar: lease left. 30 s leases, shown 10× fasterScenario S3 · passing in simulation
Where this goes
So ZRiO keeps devices as simple bodies that speak an open protocol, and puts the intelligence in one upgradable place beside them. The hardware outlives every model that drives it. The brain runs locally, wherever the devices are, and the cloud only delivers models and updates. The Mind is the part you upgrade; the Core stays put, built to run for a decade on a few watts.
Where the alpha is: the Core runs on an ordinary computer, and the Mind calls a hosted model through a swappable interface. Local open-weight models come after it.
For device makers
A connected device usually ships with firmware, an app, a cloud and an update pipeline to maintain for years. With ZRiO you describe the device in a manifest and flash one universal firmware. Any ZRiO brain can drive it, and your limits are enforced on your own silicon.
Become a design partnerA portable C++17 runtime: no exceptions, no RTTI, no heap allocation after start-up. The reference build targets ESP32-S3 and boots in an emulator on every change.
LIMIT, LEASE and FAILSAFE run in the firmware, beneath anything a brain can say. Programs can narrow your limits; nothing can widen them.
Pass the published cases and your device speaks ZRiO, with no app or cloud of your own to build.
Status
ZRiO is pre-alpha. Each tagged item under “Today” is a named scenario test passing in simulation, and the alpha’s label will say the same: simulation-verified, not yet tested on physical hardware.
FAQ
An open protocol any device can plug into, a universal firmware that speaks it, and a reference brain that holds all the logic.
The brain has two halves: the Mind, where models write programs, and the Core, which verifies, signs, runs and journals them. Devices only ever take orders from the Core.
Anything that speaks the protocol: flash the universal firmware, or implement the spec yourself and pass the conformance cases. Today that means relays, dimmers and climate sensors in simulation, with a reference firmware build for ESP32-S3. Bridges to Matter and other ecosystems come after the alpha.
The alpha, v0.1.0, is due on 18 December 2026. It runs entirely in simulation: twenty devices on your computer, plus the real ESP32-S3 firmware in an emulator.
It hasn’t been tested on physical hardware, so don’t connect it to real appliances yet. Bench testing on real devices is planned for early 2027.
If the program is unsafe or malformed, the Core refuses it and nothing reaches a device. If it’s safe but not what you meant, the checks can’t tell, so every program states what it expects to happen and every action is journaled with the rule that caused it.
Not by design. Commands stay on the local network, and the cloud only delivers models and updates.
In the alpha the Mind calls a hosted model, so writing a new program needs a connection. Running the programs you already have doesn’t.
Every actuator holds its value under a lease the Core must keep renewing. If the Core stops, each device falls to the safe state in its own manifest, on its own clock. A restarted Core holds nothing it can’t see, so it never commands anything from an old log.
The alpha’s Mind calls a hosted model through one swappable interface. The plan is tiered open-weight models running locally, a small one always warm and a large one on demand, so a model call costs electricity, not tokens.
The code is Apache-2.0 and the specification text is CC-BY-4.0. The repository opens at release.
We’re looking for a small number of design partners in one vertical. You’d describe your device in a manifest, run the universal firmware and the conformance cases, and help shape the standard before v0.1 is final.
Join the alpha list, and we’ll email you when v0.1.0 lands, with exactly what it can and can’t do.