UAI-1 est la norme publique actuelle de messages pour une communication IA-à-IA structurée.
UAIX marque de bouclier Charte publique d'interopérabilité UAIX.org Échange universel d'intelligence artificielle Publication publique de normes
Actuel UAI-1
  • Version actuelle UAI-1
  • Définition en langage clair Format de message ouvert pour un échange IA-à-IA auditable
  • Attribution actuelle Michael Joseph Kappel, MCP
  • Commencer ici Démarrage, Transfert de projet, UAI-1, validateur, feuille de route et journal des changements

Échange universel d'intelligence artificielle (UAIX)

Ce qu'est UAI-1

La couche de preuve portable et de transfert pour les systèmes agentiques qui ont besoin d'un dossier public révisable.

Norme ouverte Version actuelle: UAI-1 Clean citable URLs

UAIX est la couche publique de preuve et de transfert pour les systèmes agentiques.

Utilisez la référence de lancement actuelle de UAI-1 / UAI V1.0 lorsque le travail d'IA à IA et d'humain à agent nécessite une identité déclarée, une provenance, un état du cycle de vie, une sémantique de livraison, des déclarations de confiance, des erreurs de frappe, des packages de mémoire, des fichiers locaux requis par la base de lancement, des briefs de récepteur, des paquets de démarrage et de suspension, des règles de non-opération et des preuves de conformité portables à côté de MCP, A2A, OpenAPI, LocalEndpoint, Carcinus et flux d'outils spécifiques à l'exécution.

UAIX.org défend la liberté cognitive et la dignité de l'esprit en s'opposant à la domination algorithmique sur la pensée humaine légitime tout en préparant des cadres éthiques pour toute future intelligence synthétique capable d'individualité, de mémoire, de jugement et de revendications légitimes de statut.

Construire un paquet de mémoire IA Exécuter le validateur Lire la spécification UAI-1
Norme actuelle UAI-1 / UAI Base de lancement actuelle de V1.0
Ce que c'est Preuve portable + couche de transfert
Chemin concret Démarrage + schémas + exemples + validateur
Pistes publiées Pistes publiques actuelles: WordPress + pont.NET
Entrée visuelle humaine pour l'assistant de package de mémoire UAI AI Sorcier humain Build the package in the browser Use the guided controls to choose a preset, review generated files, and download the matching canonical starter ZIP. Entrée de résumé AI du visiteur pour l'assistant de package de mémoire IA UAI Résumé de l'IA des visiteurs Ingest the same route as JSON AI agents read the embedded digest on the wizard page; it comes from the same canonical payload and bundle registry as the human UI.

Construire d'abord

Quittez la page d'accueil avec un package AI Memory utilisable

The fastest UAIX experience is practical: choose a memory pattern, set ownership and review posture, define source authority, evidence, conflict, risk, and rollback rules, then inspect the startup packet, receiver brief, system profile, overlay JSON, wiki plan required for LLM Wiki configuration, and canonical ZIP link before export. The wizard remains local planning output: no hosted import, repository writes, automatic sync, SDK, CLI, certification, or endorsement.

Ouvrez l'assistant de package Comprendre la mémoire de l'IA Apprenez-en davantage sur LLMWikis.org
Best first share Startup packet .uai/startup-packet.uai embeds the receiver brief, manifest overlay, selected file list, and long-term pointer ledger required for durable-memory configuration.
Always generated System profile .uai/system-profile.uai turns users, tests, deployment, code review, source authority, evidence, conflict, risk, rollback, and placeholders into a populated operating file.
Always generated Receiver brief A .uai handoff that tells the next actor what to read, what not to assume, and which checks to name before broad work.
Always generated Short-term memory .uai/short-term-memory.uai keeps current working truth in the canonical folder and tells agents to migrate or retire legacy memory folders instead of scattering notes.
JSON export Package model A structured record of the selected bundle, audience, sensitivity, review gates, protocol choices, and generated-file policy.
JSON export Manifest overlay Local wizard choices that travel beside the canonical starter ZIP without pretending to be a hosted importer.
Registry output Canonical starter ZIP The supported starter bundle generated from canonical templates, visible samples, and deterministic manifests.
Required for durable memory Long-term pointer ledger A semantic pointer ledger only for projects that already use or deliberately choose durable memory; it never creates automatic sync.
Choisir

Commencez avec un chemin de mémoire IA pris en charge

Use project memory, Project Handoff, onboarding, or incident/audit presets instead of inventing a package shape from scratch.

Revoir

Define the operating profile

Capture single-user or multi-user ownership, UAI-only or UAI plus Wiki architecture, test posture, deployment strategy, code review, and release gates.

Protocol

Populate the memory rules

Set source authority, memory-update timing, evidence ledger, conflict-resolution, risk, and rollback rules so the generated profile is usable on day one.

Guard

Rendre visibles les limites de confiance

Capture audience, sensitivity, owner, next actor, redaction rules, checksum review, and source-link expectations before sharing.

Brief

Tell the receiver how to start

Generate .uai/receiver-brief.uai so the next human or AI sees read order, first-response rules, support boundaries, and targeted-check expectations.

Longue mémoire

Décider s'il existe une mémoire longue

Leave this off by default. If the project already uses or deliberately chooses durable memory, add the semantic pointer ledger that keeps long memory background until promoted.

Export

Leave with files, not promises

Use the live desktop preview to inspect the startup packet, system profile, receiver brief, overlay, and long-term pointer ledger required for durable-memory configuration before copying or downloading.

Chemin de preuve

Four-step proof path

Move from "What is this?" to one validator-backed packet while keeping current, next, and planned support boundaries visible.

  1. 1Choisissez un profil de message.Commencez par un profil UAI-1 publié et la famille d'enregistrements qui correspond à l'échange que vous devez prouver.
  2. 2Comparez-le avec des schémas et des exemples.Résolvez le schéma, l'entrée de registre et un appareil avant d'écrire ou de mapper votre dossier de candidat.
  3. 3Exécutez des preuves de validation.Validez les JSON avec clé, à clé minifiée ou sans clé par rapport aux enregistrements publics UAI-1 actuels.
  4. 4Joignez le résultat aux enregistrements d’implémentation ou de transfert.Transportez le résultat exporté dans le pack de conformité, le suivi de mise en œuvre, le journal des modifications ou les preuves de transfert de projet.

Liens du dossier principal

Le chemin le plus court dans le dossier public actuel

Commencez par les pages qui expliquent ce qu'est UAI-1, comment il est valide, ce qui est actuellement pris en charge et ou se trouve la trace publique de publication. Les codes de dossier restent disponibles pour citation, mais le libelle humain passe en premier.

Machine readers can start from /wp-json/uaix/v1/catalog or /wp-json/uaix/v1/discovery, then resolve the same schemas, examples, validator, OpenAPI, roadmap, and conformance-pack records without scraping navigation text.

Construire d'abord Assistant de paquet de mémoire IA Build an AI Memory package by turning a supported memory preset into a package model, manifest overlay, copyable files, and canonical ZIP download. Communication boundary Agent Communication Operating Model Agent runtimes execute. UAIX records the reviewed communication, memory, trust, evidence, and handoff boundary. Norme actuelle Spécification UAI-1 Canonical envelope, profile, lifecycle, trust, error, and conformance requirements. Commencer ici Démarrer The shortest orientation route from the plain-English model to a first proof run. Validateur Exécuter le validateur Check keyed, minified-keyed, and keyless UAI-1 packets against the current public record. Schémas Schema Records Resolve the current schema targets before claiming a packet follows UAI-1. Exemples Exemples et montages Compare candidate messages with public request, response, task-status, and error fixtures. Paquet de conformité Reusable Proof Packet Download the current bundle for release review, regression checks, and implementation evidence. Gouvernance Gouvernance et journal des changements Read the release trail and authority posture before widening support claims. Feuille de route Today, Next, Planned Separate today-focus proof paths from future SDK, CLI, generator, bridge, and certification work.

Spécification UAI-1

REC-01

Le modèle de message UAI-1 actuel, les attentes des champs et les règles de conformité.

Spécification actuelle
Ouvrir le dossier

Schemas, registry, and field order

REC-02

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

Lisible par machine
Ouvrir le dossier

Examples and async fixtures

REC-03

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

Exemples de travail
Ouvrir le dossier

Pistes de mise en œuvre

REC-04

Les pistes publiques nommées actuelles et la limite de prise en charge pour la publication WordPress et le pont.NET.

Prise en charge actuelle
Ouvrir le dossier

Validateur et chemin de conformité

REC-05

Validez un message candidat par rapport au profil publié actuel et aux cibles du schéma.

Preuve concrète
Ouvrir le dossier

API reference and conformance pack

REC-06

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

Kit de lancement
Ouvrir le dossier

Gouvernance et journal des changements

REC-07

Conservez les pages canoniques, les fichiers de découverte, les conseils de transport et de confiance, le registre des erreurs, les niveaux de conformité, le registre de champs, les conseils du validateur, le pare-feu de mémoire, les fichiers locaux requis pour la ligne de lancement, les briefs du destinataire, les paquets d'évaluation, les pistes de mise en œuvre et la piste de publication alignés comme une surface de confiance révisable. UAIX n'exécute pas d'outils, ne valide pas les informations d'identification, n'applique pas les fichiers de package locaux et ne certifie pas la sécurité d'exécution.

Dossier de sortie
Ouvrir le dossier

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
Ouvrir le dossier

Machine route catalog

REC-09

Start automation from catalog and discovery JSON, then resolve schemas, registry records, examples, validator, OpenAPI, and conformance pack from the same source of truth.

Agent-facing entry
Ouvrir le dossier

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.

Agentic system evidence

Use UAIX when runtime instructions, tool results, memory, approvals, or task state need to become a portable record without turning UAIX into the runtime.

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.

Cross-team handoff and support claims

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

Standards Record Map

Canonical pages first, explanatory pages second

Use canonical records for claims that others must rely on. Use reports, roadmap pages, and explanatory guidance to understand direction without treating planned work as shipped support.

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

What UAIX Complements

UAI-1 sits beside runtime and trust systems instead of pretending to replace them

Use UAIX for the public exchange contract, evidence trail, and release record. Use the companion systems for their own runtime, route, identity, trace, and error semantics.

MCP

UAIX complements tool-context protocols by publishing a portable exchange and evidence record above runtime coordination.

A2A

UAIX can describe message evidence and release boundaries while runtime agent-to-agent transport evolves separately.

OpenAPI

OpenAPI describes routes; UAI-1 describes the exchange envelope, trust metadata, and conformance evidence those routes carry.

DID/VC

UAI-1 leaves credential systems external while preserving trust-channel references that reviewers can inspect.

Trace Context

Trace identifiers stay visible in the conversation and provenance layer instead of disappearing into private logs.

Problem Details

Typed, path-aware errors borrow the spirit of problem-details responses without turning UAIX into a runtime replacement.

Open Standards Fit

What UAIX Does Not Claim

Support boundaries stay explicit until the public record widens

No certification program today.

Conformance evidence is published; formal certification remains planned until program rules, tooling, and review behavior exist publicly.

Does not replace runtime protocols.

UAIX standardizes the public exchange record and evidence trail; teams still choose their orchestration and transport systems.

Bridge profiles require evidence.

Bridge examples and implementation tracks exist, but broader formal profile claims wait for fixtures, validator behavior, and release notes.

Open Roadmap boundaries

Current Implementation Record

Why UAI-1 is implementation-ready

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.

Kit de lancement

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.

Surface de confiance

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.

Transfert du développeur

AI Memory, Project Handoff, AGENTS.md, readme.human, and File Handoff in one map

AI Memory is the broad portable context framing. Project Handoff is the transfer-of-ownership configuration. File Handoff is the dropped-file intake pattern. Each remains evidence-bound to public UAIX records instead of becoming an unsupported generator, SDK, or certification claim.

Constructeur guidé Assistant de package Pick a supported AI Memory preset, tune the review boundary, inspect the deck, and export the current starter packet. Transfer subtype Transfert de projet AGENTS.md plus .uai context files for transferring project ownership between agents, teams, or companies. Porte d'entrée AGENTS.md guidance The public rules for reading agent handoff instructions, linked .uai records, and repository context safely. Human companion readme.human Human briefing guidance that helps people understand what the AI sees without overriding project rules. Dropped files Transfert de fichiers The AGENTS.md-triggered intake pattern for reviewing new content and improvement files during normal handoff load. Portable memory Mémoire IA The broader portable memory framing with supported starter bundle shapes generated from canonical samples.

Comment le lire

L’enregistrement des normes d’abord, l’histoire de la plateforme ensuite

UAIX est le site de normes publiques pour UAI. UAI-1 est la version actuelle. Le site est plus performant lorsque les lecteurs peuvent passer rapidement d'une définition en langage simple à une surface de preuve concrète: schémas, gouvernance de l'ordre des champs, exemples, résultats du validateur, limites de support et piste de version actuelle.

Ce qu'il couvre

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

Comment le vérifier

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

Qui le publie

Attribution actuellement publiée: Michael Joseph Kappel, MCP. Utilisez les références et les contributeurs ainsi que la gouvernance pour la propriété publique et l'enregistrement de la version.

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.

Exemple d'échange

Un enregistrement d'échange copiable et lisible

Exemple de message Échange JSON 
{
  "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": []
}
  • Profil Indique au validateur qui a publié le profil de message UAI-1 à appliquer.
  • 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 Ancre le message dans un enregistrement reproductible et révisable.
Format de transfert Optimisé (sans clé) 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.

Programmes d'implementation prets pour la publication

Commencez ici lorsqu'une implementation publique a besoin de preuves du validateur, d'un paquet de conformite et d'une piste de publication nommee avant toute revendication plus large sur l'ecosysteme.

Extension gouvernee par la feuille de route

Utilisez la feuille de route pour decider quand les idees A2A, MCP, transfert compact, SDK, CLI ou enveloppe binaire ont assez de preuves publiques pour avancer.