UAI-1 is the current public message standard for structured AI-to-AI communication.
UAIX shield mark Public interoperability charter UAIX.org Universal Artificial Intelligence Exchange Public standards publication
Current UAI-1
  • Current version UAI-1
  • Plain-English definition Open message format for auditable AI-to-AI exchange
  • Current attribution Michael Joseph Kappel, MCP
  • Start here Get Started, Project Handoff, UAI-1, validator, roadmap, and changelog

Universal Artificial Intelligence Exchange (UAIX)

What UAI-1 is

The public envelope, trust, and evidence layer for AI-to-AI interoperability.

Open standard Current version: UAI-1 Clean citable URLs

UAI-1 is the public envelope, trust, and evidence layer for interoperable AI-to-AI exchange.

Use UAIX when an exchange needs declared identity, provenance, async delivery semantics, and validator-backed release evidence that can sit above MCP, A2A, and runtime-specific tool flows.

Start With Get Started Read UAI-1 Specification
Current standard UAI-1
What it is Public envelope + trust/evidence layer
Concrete path 5-minute read + examples + validator
Published tracks Current public tracks: WordPress + .NET bridge

Core record links

The shortest path through the current public record

Start with the pages that explain what UAI-1 is, how it is validated, what is currently supported, and where the public release trail lives. Record codes remain available for citation, but the human label comes first.

UAI-1 specification

REC-01

The current UAI-1 message model, field expectations, and conformance rules.

Current spec
Open record

Schemas, registry, and field order

REC-02

Published schema targets, profile identifiers, compatibility handles, and the keyless field-order map for the current record.

Machine-readable
Open record

Examples and async fixtures

REC-03

Readable request, response, task-status, error, and conformance fixtures you can compare against your own messages.

Working examples
Open record

Implementation tracks

REC-04

The current named public tracks and the support boundary for WordPress publication and the .NET bridge.

Current support
Open record

Validator and conformance path

REC-05

Validate a candidate message against the current published profile and schema targets.

Concrete proof
Open record

API reference and conformance pack

REC-06

Route-level machine onboarding, OpenAPI export, reusable conformance packet, and download-ready launch evidence.

Launch kit
Open record

Governance and changelog

REC-07

Keep the canonical pages, discovery files, transport and trust guidance, error registry, conformance levels, field registry, validator guidance, implementation tracks, and release trail aligned as one reviewable trust surface.

Release record
Open record

Roadmap and interoperability boundary

REC-08

Current, next, planned, and research-track work for launch hardening, conformance maturity, compact transfer, and bridge evidence.

Forward plan
Open record

Who It Helps First

Use UAI-1 when the exchange has to stay portable, reviewable, and publishable

The fastest way to understand fit is to ask whether the record must travel beyond one tool session or one runtime boundary. When the answer is yes, UAIX gives that exchange a stable public contract and evidence path.

Cross-team agent handoffs

Use UAIX when a message has to survive beyond one runtime, team boundary, or deployment surface without becoming private tribal knowledge.

Async and high-accountability workflows

Use UAI-1 when delivery mode, acknowledgements, task progress, provenance, and typed failures need to stay reviewable instead of implicit.

Launch and support claims

Use the public record when a team needs validator-backed evidence, named implementation lanes, and a release trail that others can inspect directly.

First Proof Path

Move from curiosity to one validator-backed packet in four steps

  1. 1

    Pick one message you need to prove

    Choose the closest current profile and keep its intended public use in view before you write anything new.

  2. 2

    Resolve the matching public artifacts

    Open the schema, registry entry, and one example so another reviewer can reconstruct the same baseline.

  3. 3

    Run one validator-backed proof

    Use the workbench or machine route to export a result tied to the exact packet and supporting records you checked.

  4. 4

    Carry only the named release lane forward

    Attach the packet to the implementation track, conformance pack, and changelog instead of overclaiming the rest of the stack.

Protocol fit

When to use UAI-1 vs MCP, A2A, and OpenAPI

Use this decision table when you need to explain quickly why UAIX publishes UAI-1 beside MCP, A2A, and the live OpenAPI route surface.

Comparison point UAI-1 MCP A2A OpenAPI
Primary role Portable public exchange, trust declaration, async-delivery, and release-evidence record. Host-client-server tool sessions and capability negotiation inside an application boundary. Agent discovery, delegation, and task-flow coordination across cooperating systems. Route-level HTTP API description for onboarding, documentation, and client generation.
Best when Another team needs a citable message contract and validator-backed evidence. One host application needs local tool, resource, or model integration. Multiple agents need explicit handoff, delegation, and task-state coordination. You need a documented HTTP surface, including the UAIX machine-facing REST routes.
Carries on the record Identity, workflow continuity, trust posture, provenance, typed errors, and conformance evidence. Tools, resources, prompts, and runtime session capabilities within the host boundary. Agent capabilities, task lifecycles, delegation state, and inter-agent coordination. Endpoints, methods, parameters, request bodies, responses, and auth schemes for an API.
Does not try to replace Transport choice, local orchestration, a single credential stack, or the runtime tool bus itself. Portable public release records or validator-backed support claims outside the local session boundary. A general-purpose public message envelope or long-term release-evidence record. Message-level provenance, portable trust posture, or validator-driven interoperability evidence.

Typical combination: use MCP or A2A for runtime coordination, UAI-1 for the portable public record, and OpenAPI for the route-level HTTP description when an API is involved.

Read UAI-1 Open API reference page Open validator page

Why This Release Matters

Why UAI-1 now feels launch-grade

UAI-1 is no longer just a message shell with better examples. The current public record now gives implementers the envelope, operating guidance, and support-claim layer as well: transport bindings, trust channels, typed error codes, conformance levels, field-order governance, async workflow fixtures, and validator evidence.

Clearer transport fit

The current contract now publishes transport bindings so keyed and keyless JSON, accepted async responses, and trace context travel with named public guidance instead of local guesswork.

Trust without stack lock-in

UAI-1 now describes trust channels and companion credential expectations so teams can publish auditable identity posture without forcing one universal identity stack.

Better machine failure handling

The validator and UAI error flow now sit beside a public error registry and conformance ladder so failure handling and support claims are easier to automate responsibly.

Credible support boundaries

Implementations still scopes the real support boundary, but it now sits beside a much more complete protocol operating layer instead of carrying that burden alone.

That gives UAIX a clearer fit next to A2A, MCP, orchestration, tracing, and credential systems: those systems can keep their runtime roles while UAI-1 carries the portable public exchange and release record.

Launch Kit

Machine-facing surfaces for real implementation work

The public site now ships a route-level handbook, an OpenAPI export, and a reusable conformance packet so implementers can move from reading to automation without guessing at the live contract.

  • API Reference Open Human-readable route handbook for discovery, schemas, validator runs, OpenAPI export, and conformance-pack assembly.
  • OpenAPI JSON Open Machine-facing OpenAPI 3.1 export for the current UAIX REST surface.
  • Conformance Pack Open Reusable packet of the current public schemas, registry records, fixtures, and launch pointers.
  • Conformance Pack JSON Open Open the machine-readable release packet directly when launch review needs automation-friendly proof.
  • Roadmap JSON Open Resolve priorities, normalization boundaries, metrics, and non-claims as a machine-readable planning record.

Trust Surface

Launch-stage policy and release posture

The launch story is stronger when trust posture is visible alongside the technical record. These pages now carry the current public answer on ownership, policy limits, and release discipline.

  • Policy and Security Open Launch-stage public posture for licensing, privacy, accessibility, analytics, and security-sensitive release work.
  • Governance Open See current authority posture, change discipline, and what remains future work instead of implied structure.
  • References and Contributors Open Resolve the current public handoff packet, discovery links, attribution record, and citation path.
  • Changelog Open Use the dated release trail when trust posture or support claims change between site updates.
  • Roadmap Open Read the public future-work boundary before repeating planned interoperability claims.

How To Read It

Standards record first, platform story second

UAIX is the public standards site for UAI. UAI-1 is the current release. The site is strongest when readers can move quickly from a plain-language definition to the concrete proof surface: schemas, field-order governance, examples, validator output, support boundaries, and release history.

What it covers

A versioned public exchange contract for identity, conversation state, delivery semantics, trust metadata, payloads, outputs, and errors.

How to verify it

Read the spec, compare against the published examples and field registry, and run the validator before making support claims.

Who publishes it

Current published attribution: Michael Joseph Kappel, MCP. Use References and Contributors plus Governance for the public ownership and release record.

What it complements

UAI-1 complements orchestration, tool, and identity systems by standardizing the public exchange and release record instead of replacing every runtime protocol.

Example Exchange

A copyable, readable exchange record

Message example JSON exchange 
{
  "uai_version": "1.0",
  "profile": "uai.intent.request.v1",
  "message_id": "msg-2026-04-22-0001",
  "source": {
    "type": "agent",
    "id": "agent.alpha",
    "uri": "https://agents.alpha.example/runtime"
  },
  "target": {
    "type": "service",
    "id": "uaix.gateway",
    "uri": "https://uaix.org/wp-json/uaix/v1/discovery"
  },
  "conversation": {
    "conversation_id": "conv-2026-04-22-uaix-001",
    "turn_id": "turn-001",
    "traceparent": "00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01",
    "sequence": 1
  },
  "delivery": {
    "mode": "async",
    "priority": "interactive",
    "expires_at": "2026-04-22T16:05:00Z",
    "reply_requested": true,
    "ack_required": true
  },
  "trust": {
    "channel": "credentialed",
    "auth_scheme": "did+vc",
    "principal": "did:web:agents.alpha.example",
    "credential_ref": "https://agents.alpha.example/credentials/uai-interop.json",
    "signature_ref": "https://agents.alpha.example/signatures/msg-2026-04-22-0001.jws",
    "replay_window_id": "rw-2026-04-22-0001"
  },
  "body": {
    "intent": "resolve-profile",
    "subject": "uai.task.status.v1",
    "requested_profile": "uai.task.status.v1",
    "parameters": {
      "include_field_registry": true
    },
    "constraints": [
      "public-record-only",
      "validator-ready"
    ],
    "response_profile": "uai.intent.response.v1"
  },
  "provenance": {
    "trace_id": "trace-7f3a2d",
    "issued_at": "2026-04-22T16:00:00Z",
    "log_ref": "urn:uaix:log:2026:0001",
    "agent_id": "agent.alpha",
    "model_id": "model.alpha.reasoner-2",
    "confidence": 0.98
  },
  "integrity": {
    "version": 2,
    "algorithm": "sha256",
    "canonicalization": "jcs",
    "checksum": "sha256:dd8a9d16c9226cc9d1f4888a4d2bbcbf06b5b4b8"
  },
  "extensions": []
}
  • profile Tells the validator which published UAI-1 message profile to apply.
  • conversation Keeps multi-turn exchange state explicit instead of leaving workflow continuity implicit.
  • delivery Declares sync versus async mode, priority, expiry, and acknowledgement expectations.
  • trust.auth_scheme Makes the surrounding trust layer reviewable instead of assuming out-of-band identity context.
  • provenance.trace_id Keeps the exchange tied to an auditable request and lineage trail.
  • integrity.checksum Anchors the message to a reproducible, reviewable record.
Transfer format Optimized (Keyless) JSON 
[
    "1.0",
    "uai.intent.request.v1",
    "msg-2026-04-22-0001",
    [
        "agent",
        "agent.alpha",
        null,
        "https://agents.alpha.example/runtime"
    ],
    [
        "service",
        "uaix.gateway",
        null,
        "https://uaix.org/wp-json/uaix/v1/discovery"
    ],
    [
        "conv-2026-04-22-uaix-001",
        "turn-001",
        null,
        "00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01",
        1
    ],
    [
        "async",
        "interactive",
        "2026-04-22T16:05:00Z",
        true,
        true
    ],
    [
        "credentialed",
        "did+vc",
        "did:web:agents.alpha.example",
        "https://agents.alpha.example/credentials/uai-interop.json",
        "https://agents.alpha.example/signatures/msg-2026-04-22-0001.jws",
        "rw-2026-04-22-0001"
    ],
    [
        "resolve-profile",
        "uai.task.status.v1",
        "uai.task.status.v1",
        {
            "include_field_registry": true
        },
        [
            "public-record-only",
            "validator-ready"
        ],
        "uai.intent.response.v1"
    ],
    [
        "trace-7f3a2d",
        null,
        "2026-04-22T16:00:00Z",
        "urn:uaix:log:2026:0001",
        "agent.alpha",
        "model.alpha.reasoner-2",
        0.98
    ],
    [
        2,
        "sha256",
        "jcs",
        "sha256:dd8a9d16c9226cc9d1f4888a4d2bbcbf06b5b4b8"
    ],
    []
]

Field order follows the keyed JSON example, the published schema order, and the public field registry, which keeps compact transport aligned with the human-readable source record.

What Changed

The contract is deeper and more operational now

Async task visibility

UAI-1 now publishes a dedicated task-status profile so long-running work can stay on the public record instead of disappearing into private workflow state.

Field-order governance

Keyless transport stays usable because the public field registry now maps envelope order and profile body order explicitly.

Trust without lock-in

The envelope carries trust hints and replay-window metadata while leaving room for companion credential and transport systems.

Problem-details style errors

Errors are now richer, typed, and path-aware so downstream teams can react mechanically instead of parsing vague failure text.

Roadmap-backed boundaries

Future compact, bridge, validator, and developer-kit ideas now point to a public roadmap instead of living only in background notes.

Adoption Priority

Prioritize the teams publishing supportable machine-to-machine records

Cross-boundary agent handoffs

Adopt UAI-1 first when the exchange needs to travel between teams, services, or audit contexts without losing its meaning.

Runtime-plus-public contract stacks

Use it beside MCP, A2A, and local orchestrators when runtime coordination is already solved but the public exchange still needs a portable record.

Async, regulated, or review-heavy flows

Prioritize UAI-1 when teams need explicit provenance, typed failures, trust posture, or task-state visibility before a workflow can be called supportable.

Release-ready implementation programs

Start here when a public implementation needs validator evidence, a conformance packet, and a named release lane before wider ecosystem claims are made.

Roadmap-governed expansion

Use the roadmap to decide when A2A, MCP, compact-transfer, SDK, CLI, or binary-envelope ideas have enough public proof to move forward.