UDI

UDI — an open contract for talking to devices.

UDI is a versioned JSON contract for how to interact with a device: what to read, how to transform it, when to report, and what commands it accepts. Drop a new declaration from the cloud and the device reconfigures itself — no firmware work.

fox.device.config/v1 · reference engine · authoring and platform SDKs · black-box conformance

01 — What it is

Reconfigure a device by dropping JSON, not by shipping firmware.

A UDI declaration says what registers or channels to read, how to transform the raw values, when to report them, and which commands a device will accept. The device applies the declaration itself. Nothing about changing what a device does requires a new build.

02 — The design line

A fixed control plane, and everything else as data.

The whole idea sits on one distinction, and it is worth stating precisely rather than glossing over.

STANDARD

The fixed MQTT topic set and the health beacon. Engine-defined, always on — the guaranteed control plane a platform can rely on without inspecting a device first.

COMPOSABLE

Registers, reporting rules, transforms, wire format and commands — everything that varies by device or deployment, dropped as versioned JSON rather than baked into a build.

Why the split matters

A platform can trust the standard half unconditionally and treat the composable half as data it validates. Neither half has to guess about the other.

03 — What ships

The contract, its reference engine, and both SDKs, versioned together.

Reference engine

A Lua reference engine — a generic executor that runs a config and emits the standard health beacon. Any conformant runtime can replace it.

udi (authoring & validation)

A Python package for authoring manifests and validating them against the published schemas — config, heartbeat, and topics.

udi-sdk (platform-side)

A Python package for reading telemetry, assembling configs, and dropping them to devices — the platform half of the contract.

Normative documents

The bilateral MQTT protocol and the portable hardware adapter contract, written as the specification an independent implementation is measured against.

Schemas and vectors

Machine-readable JSON schemas for every payload, plus black-box conformance vectors an implementation must satisfy without inspecting anyone else's code.

04 — Conformance

Certification is a black box, on purpose.

The certification runner is an MQTT client that exercises a connected implementation using only the published wire protocol — it never inspects the code behind the broker. It emits a machine-readable report so an integrator can prove conformance rather than assert it.

05 — The boundary

UDI does not depend on InnovaEdge.

The dependency runs one way, and that is the whole argument. The contract, the reference engine and both SDKs live in the standard's own repository and version on their own schedule, and none of them needs InnovaEdge present to build, run or certify. InnovaEdge is a consumer of the contract: it installs the published SDKs at a pinned revision, exactly as any other implementer would. A contract only its author's platform can speak is not really a standard — this one is built so you could write the second consumer without asking us anything. To be precise about 'open': that describes the contract's design — protocol-defined, independently implementable, certified black-box — not its licensing today. The repository is still private, no licence has been published yet, and of the two SDKs the core one is open while the platform SDK is commercial. We would rather say that now than have you find it at procurement.

Which way the dependency runs

The platform depends on the standard. The standard does not depend on the platform: nothing in the contract, the reference engine or either SDK requires InnovaEdge to build, run or certify. The engine's own CI runs without it, and an implementation is measured over the published wire protocol alone. Remove the platform and UDI is unchanged.

Consumed as published packages

InnovaEdge installs the authoring and platform SDKs from the standard's repository at a pinned revision, and builds the reference engine from that same revision. There is no private fork and no vendored copy — the platform uses the artifacts you would be given.

Devices are spoken to over the wire

A UDI-conformant device is addressed only through published topics and schemas. There is no side channel and no InnovaEdge-specific handshake, so a device that works with us works with any conformant platform.

Certified black-box, ours included

The conformance runner is an MQTT client that never inspects the code behind the broker, and an independent minimal runtime exists purely to prove certification is protocol-based rather than tied to any one implementation — including ours.

The repository is private today.

UDI isn't public yet. Tell us what you're building and we'll set up access to the contract, the reference engine, and both SDKs. Prefer email? Write to [email protected] directly.

Request access