Alpha v0.1.0-alpha is due 18 Dec 2026: simulation-verified, not yet tested on physical hardware. What works today

An open protocol for any device

Make hardware brainless.

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.

Apache-2.0 codeCC-BY-4.0 specRuns in simulation today

One brain · 20 devices Open protocol

Core running · 12 of 20 leases heldset

ZRiO brain Mind + Core · 20 devices plugged in · simulated 23:00:00
Watch it run

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

        Today, every device thinks for itself.

        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.

        QuestionConnected devices todayWith ZRiO
        How a device joinsThrough a vendor’s app, account or hubIt announces one manifest
        How you talk to itA different API for every vendorOne open protocol: fourteen message types
        Where the logic livesInside each device and its vendor’s cloudIn one brain you run, next to the devices
        A model on the control pathIncreasingly, through assistants and integrationsNever. Models write programs; the Core runs them
        When a vendor’s cloud goes awayDevices can stop workingNothing changes: commands stay on your network
        “Why did that switch on?”Check each app’s historyOne journal names the rule, the reading and the time
        When the brain goes quietDepends on each deviceEvery actuator falls to its declared safe state

        How it works

        The model thinks once. The program runs a million times.

        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

        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.

        Core · the part that stays put

        Checks, signs and runs them

        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

        Do what they’re told, within limits

        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

        1. 01Askin plain words
        2. 02Writea typed program
        3. 03Verifyeight checks
        4. 04Signexact bytes, ed25519
        5. 05Runin the Core and on devices
        6. 06Journalevery state change

        The protocol

        One protocol. Any device.

        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.

        1. Part 1

          Envelope

          Every message carries its sender, a hybrid-logical-clock time and a sequence number, so a device acts on a repeat only once.

        2. Part 2

          Manifest

          How a device describes itself: attributes, units, limits, safe states and leases. No free-text descriptions.

        3. Part 3

          Instruction set

          Fourteen message types, and every command is idempotent. There is no TOGGLE, because sending a toggle twice undoes it.

        dimmer-living-1 · manifestannounced when it plugs in
        
          "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.

        • Core → devicedescribe
        • Device → Coremanifest
        • Core → deviceread
        • Device → Corereport
        • Core → deviceset
        • Device → Coreack
        • Core → devicepulse
        • Core → deviceramp
        • Core → devicehold
        • Core → devicesubscribe
        • Device → Coreemit
        • Core → devicelimit
        • Core → devicelease
        • Core → devicefailsafe

        Spec 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

        A model can write anything. Only the Core can sign it.

        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.

        1. V1

          Everything it names exists

          Devices, attributes, types and units, checked against what the devices announced.

          JSON Schema + registry
        2. V2

          Only what it was granted

          Every capability it uses is both granted to it and offered by the device.

          set containment
        3. V3

          Inside every limit

          Values and ramp rates within each device’s limits; no condition always or never true.

          interval arithmetic
        4. V4

          No two rules fight

          Two rules writing one attribute at the same moment need an explicit priority.

          pairwise overlap
        5. V5

          No rule triggers itself

          A chain from a rule, through an attribute, back to that rule is an error.

          Tarjan SCC
        6. V6

          Fast loops on the device

          Anything that must react in under 200 ms runs on the device, and has to fit.

          placement pass
        7. V7

          Everything can fall safely

          Every actuator has a safe state, and no lease outlives the device’s maximum.

          manifest lookup
        8. V8

          Yesterday, replayed

          Replayed against the last 24 hours of the journal: no limit breached, nothing switched too often.

          deterministic replay

        Signed 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

        If the brain goes quiet, every device goes safe.

        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 device
        • LEASEControl is borrowed, and it runs out
        • FAILSAFEEvery actuator to its declared safe state

        Core 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

          Models change every few months.Firmware shouldn’t have to.

          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

          Build the body. Skip the brain.

          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 partner
          • One firmware for every device

            A 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.

          • Your limits, on your silicon

            LIMIT, LEASE and FAILSAFE run in the firmware, beneath anything a brain can say. Programs can narrow your limits; nothing can widen them.

          • Prove it with conformance cases

            Pass the published cases and your device speaks ZRiO, with no app or cloud of your own to build.

          Status

          What works today, and what doesn’t yet.

          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.

          Today, in simulation

          • Twenty simulated devices plugged in, each its own MQTT 5 client
          • A repeated message acts onceS1
          • An out-of-limit command is refused by the Core and by the device, and both are on recordS2
          • Stop the Core and every leased actuator falls to its safe state; a restart reconcilesS3
          • A network partition puts devices in failsafe; they reconcile when it healsS4
          • Device twins rebuilt from the journal match the live viewS7
          • Twenty devices at 1 Hz for 30 minutes: nothing dropped, Core peak 11.1 MBS8
          • The Mind reads every plugged-in device and resolves everyday names, or refuses them
          • The ESP32-S3 firmware boots in QEMU on every change

          In the alpha · 18 Dec

          • The program language: triggers, conditions, absolute-value actions
          • The verifier’s checks, with verify-before-sign
          • Signing and staged deployment
          • The Mind writing programs from plain requests
          • Reflex tables on the device
          • Emulator tests in QEMU and Wokwi

          After the alpha

          • Testing on physical hardware, from early 2027
          • Local open-weight models in the Mind
          • A dedicated brain appliance
          • Bridges to Matter and existing ecosystems
          • A shared library of verified skills

          FAQ

          Fair questions.

          What is ZRiO, exactly?

          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.

          Which devices can plug in?

          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.

          When can I use it?

          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.

          What happens when the AI gets something wrong?

          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.

          Does it stop working when the internet does?

          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.

          What if the brain itself crashes?

          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.

          Which models does it use?

          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.

          Is it open source?

          The code is Apache-2.0 and the specification text is CC-BY-4.0. The repository opens at release.

          I make hardware. What would working together look like?

          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.

          Be first to plug in.

          Join the alpha list, and we’ll email you when v0.1.0 lands, with exactly what it can and can’t do.