The sink is a computer.
So every hop can optimize.
.WAI™ is an open container and capability-dispatch envelope. A WAI file names the capability each piece of content needs — a standard codec, an integer learned codec, or instructions the sink replays — and a conforming sink rebuilds it. The representation is chosen per piece, and receipts record what was received.
Split and choose.
Each object names its own capability, so a stream changes representation from one piece to the next.
- In the standard
- per-object capabilities, multi-rendition envelopes, content-hashed segmentation whose deduplication a verifier recomputes, a packaging policy with scene cuts, an integer video encoder, and packages with a stage index, a signed receipt and HLS, DASH and Media over QUIC views
Select, don't rewrite.
A conforming relay preserves each WAI envelope and each receipt it forwards, byte for byte.
- In the standard
- relay preservation, a binding to Media over QUIC (an IETF Internet-Draft) with one envelope per object, and one manifest generation per session class
- In the standard
- a deriving edge that rebuilds content and signs its own step
Rebuild and prove.
The sink rebuilds from instructions, state or coded samples.
- In the standard
- worlds, films, feeds, avatars, score, spatial audio, haptics and 4D splats; integer codecs whose conformance requires byte-identical output; and an enhancement layer bound to its base
- In the standard
- staged delivery: refinements that arrive after the base, each linked to it by hash
- In the standard
- staged delivery rebuilt in the browser, stage by stage
WAI defines no transport and no delivery network; it rides existing carriers. A sink decodes each capability with the decoder it registered for it. Every era of delivery changed the pipe; WAI changes the cargo. The status page dates each label above.
The Pipeline
A sink that computes can be told what to run.
WAI treats the receiver as a computer. The file names the capability each piece of content needs, the sink dispatches it by a fixed algorithm and rebuilds the content, and a receipt records what arrived. The four steps below are in the standard.
The file says what to run.
The manifest names the capability and an optional fallback. A neural capability also names the prior it decodes against.
The same steps at every sink.
Run the named capability, else the fallback, else report the file inert. Six numbered steps, below.
The sink makes the output.
Standard codecs decode their canonical bytes. Integer codecs and instruction formats rebuild the same state, samples or per-frame identity on every machine. A world model pins its action trace, not its frames; a spatial-audio mix is exact given the sources' decoded samples.
What arrived is on record.
A BLAKE3 content hash per object and an Ed25519-signed receipt per group, forwarded unaltered by conforming relays. A receipt attests bytes; it does not interpret them.
Split the content. Send a base, then refinements.
Because each object names its own capability, an encoder can split content into pieces, choose a representation for each, and send a base before the refinements that follow it — for on-demand and live delivery alike. What the standard does here, as the status page lists it:
- In the standard
- One WAI envelope per Media over QUIC object, so a live track changes capability from one object to the next; multi-rendition envelopes, each entry with its own id, payload digest and model pin; content-hashed segments under a signed segment map; an enhancement layer carried with, and bound to, exactly one base; a pinned binary payload format for each integer codec, with a cost a sink reads before it decodes; and staged delivery, refinements as separate objects after their base, each linked to it by hash.
Every conforming sink MUST implement these six steps. In a WAI1 envelope, wire version 1.0, a fallback names a second decoder for the same payload; alternate content travels as renditions in a multi-rendition envelope. Both are in the standard.
Neural condition. Zeroth condition. Same dispatch.
The neural condition regenerates the media from a compact conditioning payload against a prior the sink already holds; the envelope names the prior and does not carry it. The prior's identity is named, not left vague: a pinned prior carries a content hash and a determinism contract. A capability whose pinned determinism contract is integer-exact reproduces byte-for-byte on every machine; a float neural decode is exact only on the same build and cannot back replicate; a perceptual capability declares a similarity threshold instead.
The zeroth condition dispatches to registered standard codecs: PNG (W3C Recommendation, Third Edition), FLAC (RFC 9639) and zstd (RFC 8878) at the mandatory floor; AVIF (the AOMedia specification, built on HEIF and MIAF-conforming), JPEG XL (ISO/IEC 18181), JPEG (ITU-T T.81), Opus (RFC 6716) and AV1 (AOMedia) in the recommended set.
WAI dispatches to standard codecs and also defines integer codecs whose conformance requires byte-identical output on every machine. Each capability owner owns its payload format; the envelope is unchanged when new capabilities register. All of this is in the standard.
WAI Quantum
Quantum circuits you can run anywhere, and check.
Free and open source, with no account. One engine is behind Quantum Studio in the browser and on the desktop, the command line, the packages for Python, JavaScript and Rust, the MCP server for agents and the job service, so a program gives the same answer wherever it runs, with a signed receipt.
The Anatomy
Correctness in the types.
WAI states its assumptions in the file: who decodes, what fidelity is contracted, and which model the conditioning is shaped for. The envelope and the manifest carry those invariants, and one dispatch algorithm reads them. Everything in this section is in the standard unless it says otherwise.
Bytes 0..4 MUST be ASCII WAI1. A reader MUST reject any file whose first four bytes differ. All multi-byte integers little-endian. The manifest is UTF-8 JSON with no insignificant whitespace, preserving key insertion order so files round-trip byte-identically.
media is informational; the capability is authoritative. replicate is the only intent with normative reconstruction semantics at wire version 1.0. target is informational; the payload is self-describing per the codec's own format. security describes an encrypted payload, which the sink recovers before dispatch.
Named, not supplied.
The capability string is what the sink dispatches on. wai.image.jxl means the payload is libjxl bytes; the sink either has libjxl wired up or falls back. WAI does not embed the decoder.
No re-framing.
For a standard codec the payload bytes are exactly what it normally emits — a JXL file, an Opus stream, a PNG — with no wrapping. Conformance is checked per capability class: byte-identical output for the integer and fixed-point classes, and each standard's own criterion for codecs whose standard defines a tolerance.
Named, never shipped.
A neural capability names a model the sink must already hold — the envelope never carries the weights, exactly as .mp3 ships no decoder. But it does name which one: a bit-exact capability pins the prior by content hash plus a determinism contract; a perceptual one pins a similarity threshold. Identity, not transport.
No silent fallthrough.
If the sink has neither the primary capability nor the declared fallback, the file is inert at this sink and the dispatch returns a clear missing-capability error. No silent reinterpretation, no first-payload assumption on major-version mismatch.
Reject unknown major.
The wai field is MAJOR.MINOR. A reader MUST reject an unknown MAJOR. A reader MUST accept an unknown MINOR by ignoring fields it does not understand. A registered capability's payload format is fixed forever.
Fallback becomes executable.
The WAI2 envelope, wire version 1.1, adds a rendition table that carries every declared capability's payload in one envelope. The sink picks by deployer policy — quality against latency, native against WebNN, bandwidth headroom.
Send the base first.
An enhancement layer rides as a WAI2 companion, bound to exactly one base rendition. Staged delivery — WAI-native refinements as separate objects after their base — is in the standard, and runs in the browser.
A figure and its class, signed together.
WAI names how an energy figure was acquired with one of four acquisition classes: CalibratedInstrument and OnChipCounter (each with a declared uncertainty), ModelBased, or Estimator. An energy claim signs an object's figure together with its class, and decode receipts carry the class as a signed label beside their figure. HwShunt is legacy and never emitted. Unmetered work reads as not metered.
Decrypt, then dispatch.
A manifest's security field marks an encrypted payload. The capability, media and conditioning fields still describe the plaintext codec, and the sink recovers the plaintext before it runs the dispatch algorithm.
The output, its tier, its energy, one signature.
What WAI binds together: the reconstruction a file pins, the determinism tier its decode meets, a measured energy figure labelled with how it was obtained, and one signature over the same reproducible output. Typed determinism tiers, the energy acquisition classes with their declared uncertainty, and a signed energy claim per object are in the standard, and so are labelled JWP leaves and energy measurement reports.
The Spec
A mandatory floor. A recommended set. Registered capabilities.
Every conforming sink MUST implement the mandatory floor — PNG, FLAC, zstd. The mandatory floor guarantees that a file encoded to a floor codec opens at every conforming sink; there is no floor codec for video. The recommended set is SHOULD-implement; other capabilities are OPTIONAL and registered. Each capability owns its payload format, and the envelope is unchanged when new capabilities are added. Every capability on this page is in the standard unless it says otherwise.
PNG (W3C Recommendation, Third Edition)
lossless image
FLAC (RFC 9639)
lossless audio
zstd (RFC 8878)
compressed bytes
The codecs in the floor and the recommended set are each licensed royalty-free by the body that publishes them. Every capability in the codec registry carries a licence class a deployer can filter on in code. Broadcast and streaming codecs are registered too, each licence-classified, never a default, and decoded by the sink's own libraries; an enhancement layer rides as a companion bound to exactly one base.
These are WAI's own codecs. Each decodes in integer arithmetic, so its conformance requires the same output bytes on every machine.
Each neural capability names a model the sink must already hold; the capability owner defines the payload. A float neural decode is exact only on the same build and cannot back replicate. The inter-frame video capabilities decode through the ONNX runtime on native sinks; a browser sink that cannot host the temporal network declares wai.neural.video_bmshj2018 for the video media class.
Each rebuilt capability registers its own payload format and an equivalence criterion over WAI's fixed-point floor; the verify-half entries rebuild nothing and carry signed receipts. Reference-implementation receipt kinds (not registered): wai.quantum.cal.*, wai.quantum.cal.spectroscopy / .robust_ff, wai.quantum.cal.noise_learn (sealed as wai.quantum.calibration), wai.quantum.mitigate, wai.quantum.decode, wai.quantum.compile, wai.quantum.rearrange, wai.quantum.qbom, wai.quantum.toolchain. Each seals a signed receipt in the reference implementation and runs on a demo page; see the WAI demos index.
Each linked extension is in the standard, with Draft status; its name links to its text, mirrored on this site from wai/extensions/ in the source tree. Every extension, by topic.
A registered payload format is fixed for good.
A WAI payload always corresponds to exactly one capability. For a standard codec the payload bytes are the canonical bytes that codec emits; for a WAI integer codec they are the bitstream its registration defines. Conformance is checked per capability class: byte-identical output for the integer and fixed-point classes, and each standard's own criterion for codecs whose standard defines a tolerance. New capabilities are added by registration; existing capabilities MUST NOT be redefined, and removing or repurposing one requires a new MAJOR.
The Reference Implementation
One reference implementation. Many expected.
Transaction Science ships wai-rs in Rust as the reference. It builds as lib, cdylib, and staticlib so the C ABI in src/ffi.rs drops in as libwai.dylib / .so / .dll and can be called from any language. For standard codecs the crate calls each codec's own library; WAI's integer codecs are implemented in the crate and also build to WASM. Conformance is checked per capability class: byte-identical output for the integer and fixed-point classes, and each standard's own criterion for codecs whose standard defines a tolerance. Every library, tool and suite: Libraries and tools.
The carriage test (cargo test --test carriage) carries every capability in the codec registry through the full envelope, byte-identically, and checks dispatch, fidelity tier and licence class. Decode is tested for the capabilities the reference implementation decodes; broadcast, immersive and volumetric registrations are decoded by the sink's own libraries. Byte-identical decoding of the integer paths is checked in CI on macOS arm64, Linux x86-64 and Linux arm64; each workflow shows its current status.
Calls standard codecs, defines integer ones
For standard codecs the reference implementation calls each codec's own library — libjxl, libopus, libFLAC, dav1d, libzstd, liblzma and others. WAI's integer codecs are its own, implemented in the crate in integer arithmetic.
Conformance per class
A conforming encoder MUST emit containers that any conforming sink can read. A decode is checked by its capability's class: byte-identical output for the integer and fixed-point classes, and each standard's own criterion where that standard defines a tolerance.
Drop-in C ABI
cdylib / staticlib with a stable C FFI surface in src/ffi.rs. Any language with a C FFI can read and write WAI envelopes without re-implementing the manifest parser or the dispatch.
Apache-2.0
The specification and the wai-rs reference implementation are Apache-2.0. The codecs in the mandatory floor and the recommended set are each licensed royalty-free by the body that publishes them, and every capability in the codec registry carries a licence class a deployer can filter on in code.
A standard with one implementation has one failure mode.
The reference implementation is a starting point, not the standard. The carriage test, the golden vectors for the integer paths and the cargo-class corpora are in the tree, so a second implementation in another language checks itself against them. The spec, the vectors and the harness are the invitation.
Governance
Apache-2.0. Reference, not certified.
WAI is a Draft standard with an Apache-2.0 reference implementation. Byte-identical decoding of the integer paths is checked in CI on macOS arm64, Linux x86-64 and Linux arm64, and each workflow shows its current status. The standard is its documents, its registered capability table and the tests that check an implementation against them — not any brand.
Apache-2.0, with a licence class per codec
The specification and reference implementation are Apache-2.0. The codecs in the mandatory floor and the recommended set are each licensed royalty-free by the body that publishes them, and every capability in the codec registry carries a licence class a deployer can filter on in code.
Frozen wire format
The container (§2) and manifest schema (§3) are frozen for all of v1.x. The magic bytes WAI1 and WAI2 are stable; sinks dispatch by magic. Removing or repurposing a registered capability requires a new MAJOR version.
Capability registry
New capabilities MAY be added in any MINOR revision. Once a capability string is registered for a codec, its payload format is fixed forever. The registry is the ledger; the entries are append-only by design.
Forkable, but conformance-gated
Permissive licensing means anyone can fork. A fork whose output diverges fails the conformance check for that capability's class — the carriage test, and byte-identical output on the integer paths — and the divergence is reviewable. Forking is allowed; silent drift isn't.
Ingest, not compete
Codec work from open and private efforts is registered with the licence class it carries. The registry is a coordination surface: a capability names the work, and the sink runs whichever implementation it registered for it.
The WAI status page lists what the standard does, area by area, each linked to its text and its conformance. Companion implementations carry their own licence. What is open, and what the licence grants: Open by design.
The protocol's identity is its documents and its registry.
"WAI" is a name on a set of documents and a Rust crate. The documents define the envelope, the manifest schema, the dispatch algorithm, and the registered capability table; the carriage test and the integer-path vectors check an implementation against them. Strip the name off the whole stack and nothing about how it works changes.
The WAI family
An open standard, and the products built on it.
WAI is the open standard: its documents, its capability registry, its conformance suites and its reference implementation, under Apache-2.0. Transaction Science's commercial products are built on it, each on its own site. They do not change the standard, and the standard does not depend on them.
-
The open standard
WAI This site
The format and how it rides existing carriers: the specification, the capability registry, the conformance suites, and the reference implementation with its command line, libraries and verifiers. Free to implement.
Draft · Apache-2.0
-
Media work
waiTransport
Transaction Science's media work on WAI, from the relay to the receipt: live rooms over Media over QUIC, and signed receipts with measured energy that anyone can check with open code.
Commercial
-
Fleet operations
waiOS
waiTransport's enterprise fleet operation, running WAI across an organisation: fleet key logs, policy, energy reporting, private registries, compliance and provenance, and room policies and metering.
Commercial
Steward, not owner
The standard has no owner by construction. Publishing the specification, shipping the reference implementation and keeping the conformance suites honest is stewardship. Anyone can implement WAI, mirror its capability registry or build a product on it. The products sit beside the standard, never inside the envelope, the manifest, the capability registry or the dispatch rules. What is open, and what that means