Get Started

Who this is for#

Use UAIX if you are implementing, evaluating, governing, or citing AI-system exchanges that need declared, reviewable structure. UAIX is the public standards and publication site, UAI is the standards family, and UAI-1 is the current normative release.

Reader paths by role#

• Implementers: start with UAI-1, then move through Schemas, Registry, Examples, the Validator, and Implementations.
• Tool builders: start with Schemas, Registry, Examples, the Validator, and the published discovery surface so automation can resolve the current routes cleanly.
• Researchers and standards readers: start with UAI-1, then use the Changelog, News, and References and Contributors when you need the public revision trail and citation context.
• Editors, reviewers, and contributors: start with References and Contributors, the Changelog, News, and the Validator so proposals stay attached to the public record rather than private side notes.
• Public readers and press: start with News for the public release trail, then use Press and References and Contributors for outward-facing language and durable links.

AI memory and handoff path#

If you are onboarding a new AI, a new contractor, or a second team from repository files instead of from private chat history, start with AI Memory for the public framing and live starter bundle, then use Project Handoff when you need the engineering pattern for a root AGENTS.md file, a .uai/readme.human briefing, and local .uai/ bundle.

• Fastest orientation: read AI Memory first, then Project Handoff, then Agent File Handoff for the active drop-folder intake pattern, then the AGENTS.md .uai Linking Specification when you need explicit link syntax.
• Deeper background: use Reports and Refining UAI Protocol for Agent Communication when you need the longer validation, interoperability, and security reasoning behind the handoff layer.
• When the handoff becomes public evidence: return to UAI-1, Schemas, Registry, Examples, the Validator, and Implementations.

First 15 minutes#

Use this quick path when you are trying to understand where UAIX fits in an agentic architecture: the harness runs the work, MCP and A2A can support runtime coordination, and UAIX preserves the reviewed evidence and project memory that should survive the run.

1. Orient: start with UAI-1, Standards Fit, and Roadmap to separate the current public contract from planned bridge work.
2. Build memory: use AI Memory, the AI Memory Package Wizard, and Project Handoff when the next human or agent needs durable startup context.
3. Prove one exchange: choose one Example, run the Validator, and keep the result beside the Adoption Kit or Conformance Pack when the packet moves toward review.
4. Plan agentic fit: use Agentic Harness Strategies And UAI to keep orchestration, tools, approvals, tracing, and live memory in the runtime while UAIX records the portable proof.
5. Check the claim: one proof run is packet evidence, not certification, endorsement, official adapter support, SDK, CLI, automatic sync, or broad conformance.

What problem UAI-1 solves#

UAI-1 gives implementers a stable public envelope for identity, profile declaration, intent, context, provenance, payload transfer, outputs, and errors. The goal is to make interoperable machine communication easier to validate, audit, and evolve than private runtime-by-runtime dialects.

How the public work is organized today#

UAIX currently organizes its public work through record families and implementation tracks rather than through a separate events calendar, membership program, or broad community portal.

• Use UAI-1, Schemas, Registry, Examples, Validator, and Implementations as the practical program map for technical adoption.
• Use Changelog, News, References and Contributors, and Press as the release, citation, and public-facing support layer around that map.

Quick evaluation checklist#

1. Confirm the current public record exists on stable canonical routes: UAI-1, Schemas, Registry, Examples, the Validator, Implementations, the Changelog, and References and Contributors.
2. Decide whether you need a current published implementation track or only the portable baseline. Today the public tracks are the WordPress Publication Track and the .NET Bridge Track described under Implementations.
3. Check whether the release trail is visible and current: use the Changelog and News to see how changes are dated, explained, and linked back to the affected records.
4. Check whether contributor and citation handoff is sufficient for your use case: References and Contributors should let another reviewer resolve the same public records without private notes.
5. Treat broader public contact channels, named multi-stakeholder governance roles, and additional runtime tracks as future work unless they are explicitly published on the site. Use Governance, Policy and Security, Privacy and Data, Accessibility, Analytics, and References and Contributors for the current published trust posture on the launch surface.

What to read first#

1. Start with UAI-1 to understand the current normative message model.
2. Read Schemas and Registry together so field rules, profile identifiers, and compatibility handles stay aligned.
3. Review Examples and run the Validator before treating an implementation as conformant.
4. Use Implementations to choose the publication or runtime track that fits your environment.

Five-minute developer path#

1. Open UAI-1 and read the first boundary sections so you know what the current public contract covers.
2. Pick one published Example and resolve its matching Schema and Registry entry.
3. Run the same packet through the Validator so you have reviewable evidence instead of only a prose impression.
4. Use Implementations only to decide what support is actually published today; do not infer a broader SDK or runtime catalog from the standard itself.

Adoption checklist#

1. Pick one UAI-1 profile and confirm why that profile matches the exchange you want to support.
2. Build or map one candidate message with explicit version, profile, source, target, body, provenance, and integrity fields.
3. Validate the message and save the result before wiring it into a release path.
4. Decide which public track carries the work next: WordPress publication, .NET bridge integration, or another implementation path tied back to the public record.
5. Record any compatibility assumptions in the changelog or release notes before downstream users depend on the behavior.

Capability-adaptive reading path#

If the next reader might be a crawler, low-token fetcher, browser-assisted agent, tool-calling agent, workflow agent, multi-agent runtime, or audited system, read Capability-Adaptive Web Interaction before widening support claims.

What records you need next#

• The normative record on UAI-1.
• Machine-validation targets on Schemas.
• Stable profile and identifier references on Registry.
• Working fixtures on Examples.
• Validation evidence from the Validator.
• Deployment direction from Implementations.

Current public implementation scope#

The public site currently documents two implementation lanes through Implementations: a WordPress publication path and a .NET bridge path.

• Do not assume Python, JavaScript, SDK, CLI, or other runtime support unless a public implementation record has been published.
• If you are evaluating another environment, treat UAI-1, schemas, registry entries, examples, and validator evidence as the portable baseline until a public track exists.

Current public developer kit#

• Published now: UAI-1, Schemas, Registry, Examples, Tools, Validator, discovery routes, validation routes, the WordPress Publication Track, and the .NET Bridge Track.
• Not yet published: a public SDK, CLI, standalone source-repository link, general-purpose reference server, or broader runtime-support catalog.
• Best reading today: treat the developer kit as the canonical pages, machine-readable routes, example fixtures, and validator exports until those additional surfaces are formally published.

How UAI-1 fits with MCP and A2A#

• UAI-1: the public envelope, trust, provenance, async-delivery, and release-evidence layer for an exchange.
• MCP: local host-client-server tool sessions and capability negotiation inside an application boundary.
• A2A: agent discovery, delegation, and task-flow coordination across cooperating systems.
• Best fit: use UAI-1 above or beside MCP and A2A when another team needs a portable, citable record rather than only a runtime-local interaction. Use Standards Fit for the full UAI-1, MCP, and A2A chooser.

Launch-ready machine entry points#

• API Reference translates the live REST surface into a route-by-route handbook with OpenAPI export and starter requests.
• Adoption Kit publishes the first-proof bundle with starter files, validator-ready payloads, and a reference mock-exchange packet.
• Conformance Pack assembles the broader release artifacts into one reusable JSON packet for launch review and regression work.
• /wp-json/uaix/v1/adoption-kit publishes the machine-readable onboarding bundle and supports a direct download form with ?download=1.
• /wp-json/uaix/v1/openapi.json publishes the current OpenAPI 3.1 description of the machine-facing UAIX routes.
• /wp-json/uaix/v1/conformance-pack publishes the current machine-readable conformance packet and supports a direct download form with ?download=1.

First machine calls#

curl -s /wp-json/uaix/v1/catalog
curl -s /wp-json/uaix/v1/schemas/uai.intent.request.v1
curl -s /wp-json/uaix/v1/adoption-kit
curl -s -X POST /wp-json/uaix/v1/validate -H "Content-Type: application/json" -d @validate-request.json

Use the catalog first, then resolve one schema or example, pull the published onboarding bundle, and submit one validator run. That is the shortest machine-facing path from reading the standard to proving one packet against the public record.

Published first-proof run#

Use the public runbook and starter calls below when the next goal is one validator-backed packet built entirely from the currently published surface.

{
    "uai_version": "1.0",
    "profile": "uai.intent.request.v1",
    "message_id": "msg-2026-04-22-0001",
    "source": {
        "type": "agent",
        "id": "agent.alpha",
        "label": "Agent Alpha",
        "uri": "https://agents.alpha.example/runtime",
        "did": "did:web:agents.alpha.example",
        "role": "requesting-agent",
        "implementation": "alpha-runtime-2.4.1"
    },
    "target": {
        "type": "service",
        "id": "uaix.gateway",
        "label": "UAIX Gateway",
        "uri": "/wp-json/uaix/v1/discovery",
        "did": "did:web:uaix.org",
        "role": "public-record-gateway",
        "implementation": "uaix-core-0.4.0"
    },
    "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",
        "trust_profile": "uai.trust.did-vc-reference.v1",
        "verification_status": "not_verified",
        "credential_status": "not_checked",
        "verifier_ref": "https://agents.alpha.example/verifiers/uai-trust-policy.json",
        "trust_root_ref": "https://agents.alpha.example/.well-known/uai.json",
        "proof_ref": "https://agents.alpha.example/signatures/msg-2026-04-22-0001.jws",
        "replay_policy_ref": "https://agents.alpha.example/trust/replay-policy.json",
        "verification_checked_at": "2026-04-22T16:00:00Z",
        "verification_expires_at": "2026-04-22T16:05:00Z",
        "assurance_level": "reference_only"
    },
    "body": {
        "intent": "resolve-profile",
        "subject": "uai.task.status.v1",
        "requested_profile": "uai.task.status.v1",
        "parameters": {
            "include_schema": true,
            "include_example": true,
            "include_field_registry": true
        },
        "constraints": [
            "public-record-only",
            "trace-linked",
            "validator-ready"
        ],
        "response_profile": "uai.intent.response.v1"
    },
    "provenance": {
        "trace_id": "trace-7f3a2d",
        "parent_trace_id": "trace-root-uaix-2026",
        "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,
        "lineage": [
            {
                "stage": "request-composition",
                "actor_id": "agent.alpha",
                "model_id": "model.alpha.reasoner-2",
                "note": "Requested the async task-status profile and matching field registry."
            }
        ]
    },
    "integrity": {
        "version": 2,
        "algorithm": "sha256",
        "canonicalization": "jcs",
        "checksum": "sha256:dd8a9d16c9226cc9d1f4888a4d2bbcbf06b5b4b8"
    },
    "extensions": [
        {
            "namespace": "urn:uaix:ext:delivery",
            "purpose": "Explicit async request handling and expiry semantics.",
            "critical": false
        }
    ]
}

curl -sS /wp-json/uaix/v1/catalog

const catalog = await fetch('/wp-json/uaix/v1/catalog').then((response) => response.json());

$catalog = json_decode(file_get_contents('/wp-json/uaix/v1/catalog'), true, 512, JSON_THROW_ON_ERROR);

catalog = requests.get('/wp-json/uaix/v1/catalog', timeout=10).json()

Minimal first success#

1. Choose one published profile and build a message that matches its declared purpose.
2. Validate that message against the published schema and registry record.
3. Compare the message to a published example fixture.
4. Save the resulting validation record as part of your release evidence.

First public proof run#

1. Start with one published profile and either a matching example fixture or a candidate message that stays inside the same public record family.
2. Resolve the matching Schema, Registry, and canonical page paths before validation so another reviewer can reproduce the same packet.
3. Run the Validator, export the result, and keep the exact example or candidate message used during the check.
4. Attach the relevant Implementation track, References and Contributors, the Changelog, and News once the work moves from local testing into a public review or release context.
5. Treat the resulting packet as current public evidence of alignment, not as a permanent certification across future revisions.

What you can claim at each readiness step#

• After one passing validator run: you have current public evidence that one message or fixture aligned with the published record at review time.
• After assembling a release packet: you can describe the work as release-ready for public review within the chosen implementation track.
• After a public implementation-track record exists: you can describe only that named track and release as publicly supported, and only within the owner and scope stated on the site.
• Do not turn local testing, one passing result, or unpublished runtime work into claims of certification, blanket ecosystem support, or permanent compatibility.

What to keep with your first public release#

• The validation record exported from the Validator.
• The chosen Implementation track and any packaging or runtime notes tied to it.
• References and Contributors for stable discovery and citation links.
• The Changelog when downstream implementers need migration posture.
• News when the work needs a public-facing release summary.
• Press when the release also needs approved outward-facing language.

Next step#

Continue to UAI-1, then move through Schemas, Registry, Examples, the Validator, and Implementations in that order. Use References and Contributors, the Changelog, and News to keep the first public release traceable.