Media delivery · Not yet operating

Send each piece the way the sink can use it. waiTransport will deliver WAI media, end to end.

waiTransport is a commercial media-delivery product from Transaction Science, built on the WAI open standard. It is for media platforms, conferencing and real-time teams, archives, device and operating-system teams, and anyone delivering media to sinks they do not control. It will run WAI delivery for you: packaging that chooses a representation for each piece of content, delivery over Media over QUIC, HTTP and broadcast, and receipts for what was delivered and what it cost in energy. It will also host signed registries of the decoders and parameter sets WAI content needs, run two content-protection lanes and server-side ad insertion, and offer runtimes for GPU and NPU backends and the tools to build with WAI.

The three labels

In the standard
The open component is in the main branch of the WAI open standard. Its link goes to its row on the dated WAI status page, and its notes are that row's.
Building
The open component is in active development, as the WAI status page lists it.
Roadmap
Planned: a WAI roadmap item, or a waiTransport service. Every waiTransport service is on the roadmap; none is operating yet.

Attested, in WAI, means signed by the party that did the work and measured it: a reader can check the signature, not re-measure the figure. It is not hardware attestation.

Ask about early access Where each part stands The WAI standard

A file waiTransport delivers will be a WAI file, and any conforming sink reads a WAI file, with or without waiTransport. For why WAI is built for a sink that computes, see the WAI rationale.

What it will run

Every hop on the delivery path, built on the open standard.

Each service will run a part of the delivery path that WAI already specifies. Each card says where the service stands and what it builds on.

  • Managed delivery

    Over Media over QUIC, HTTP and broadcast

    Will package WAI content and carry it over the carriers a sink already uses. Relays will forward each object and its receipt byte for byte.

    Roadmap· service
    In the standard Building Roadmap · open components
  • Receipts and energy

    Attested receipts and energy assurance

    Will sign receipts for what was delivered, presented and decoded. A receipt will carry an energy figure only where the work was measured, always with how it was measured.

    Roadmap· service
    In the standard Building Roadmap · open components
  • Decoder registries

    Signed, revocable decoder registries

    Will host the decoder modules and parameter sets WAI content needs, each addressed, authorised and revoked by digest, for the sink to check before it decodes.

    Roadmap· service
    In the standard Building Roadmap · open components
  • Content protection

    Two protection lanes

    Will run a protected-path lane for premium content, with receipts for the envelope and every key decision, and an end-to-end lane in which the sink, once it decrypts, can issue every receipt class. Both lanes wait on player integration, on the WAI roadmap.

    Roadmap· service
    In the standard Roadmap · open components
  • Ad insertion

    Server-side ad insertion with receipts

    Will decide ads once per session class and record every impression in a signed receipt. A verifier recomputes the spend and refuses a record past its ceiling.

    Roadmap· service
    In the standard Roadmap · open components
  • Runtimes

    Runtimes for GPU and NPU backends

    Will run WAI capabilities on GPU and NPU backends beside the open reference runtime, within what each capability's determinism tier allows. Speed is an aim until it is measured.

    Roadmap· service
    In the standard Roadmap · open components
  • Developer tools

    Developer tools with a free tier

    Will offer hosted conformance runs, packaging previews and receipt inspection, built on the open command-line tools and verifiers.

    Roadmap· service
    In the standard · open components

Built on WAI

The standard is open. waiTransport will run delivery on it.

WAI is an open standard under Apache-2.0. It specifies the format and how it rides existing carriers; it defines no transport of its own. Its documents, its capability registry, its conformance suites and its reference implementation are public, and anyone can implement them. waiTransport will be one way to run WAI delivery without operating it yourself, and moving to delivery you operate will need no change of wire format.

What waiTransport never charges for

  • The WAI format.

    The envelope, the manifest, the capability registry and the dispatch rules belong to the standard and are free to implement.

  • The reference runtime.

    The reference implementation and its WebAssembly build stay open and free. waiTransport's GPU and NPU runtimes will sit beside them.

  • Reading the capability registry.

    Any runtime reads the WAI capability registry and its exports with no account and no agreement, with or without waiTransport.

Where it stands

Each part labelled. The service next.

Each capability lists the open components it builds on, each labelled as the dated WAI status page labels it: In the standard, Building or Roadmap. The services built on them are on the roadmap.

See the status page

The WAI family

One standard, and the products built on it.

  • The open standard

    WAI

    The format and how it rides existing carriers: the specification, the capability registry, the conformance suites and the reference implementation. Free to implement.

    Draft · Apache-2.0

  • Media delivery

    waiTransportThis site

    A commercial product that will deliver WAI media end to end: Media over QUIC, HTTP and broadcast, receipts, decoder registries, protection, ad insertion, runtimes and developer tools.

    Not yet operating

  • Fleet operations

    waiOS

    A commercial enterprise product that will run WAI and waiTransport across an organisation: fleet, policy, reporting, private registries, audit and support.

    Not yet operating