The problem isn’t the pipes

MCP gives agents access to tools. A2A lets agents communicate with each other. Both protocols solve real problems and solve them well — but they stop at the communication layer. They define how agents connect and how messages travel. They don’t define whether you can trust what the other agent says, what it’s authorized to do, where its knowledge came from, or what happened during the inference you’re now relying on.

The web analogy is precise. MCP and A2A are HTTP — the infrastructure that makes communication possible. What made HTTP safe enough to run banking, healthcare, and legal systems on top of it wasn’t HTTP itself. It was TLS, OAuth, JWT, and audit logging standards — a suite of trust and accountability protocols that layered over HTTP without touching it. AIP is that layer for AI agents.

What AIP is

AIP (Agent Interoperability Protocol) is an open standard suite: thirteen primitives, organized into five independently adoptable clusters, each addressing a distinct failure mode in multi-agent systems. The primitives define conformance requirements — what a system must be able to do, not how it does it. Multiple independent implementations of the same primitive are expected and encouraged.

The five clusters follow the JOSE model — one named suite, five focused sub-specifications, each independently adoptable, all designed together:

  • AIP-IDENTITY (AIP-ID, AIP-CAP, AIP-SEC) — who is this agent, what can it do, and is it safe to engage with?
  • AIP-TRUST (AIP-TRUST, AIP-ACT, AIP-DISC) — how reliable is this agent, what is it authorized to do, and how do I find the right one?
  • AIP-KNOWLEDGE (AIP-KP, AIP-AUDIT) — where did this knowledge come from, and what happened during this inference?
  • AIP-PRIVACY (AIP-PRIV, AIP-MEM, AIP-GOV) — what data is this agent permitted to use, retain, and share?
  • AIP-VALUE (AIP-VAL) — economic coordination and incentives. Phase 2; no existing competition.

An implementation can be AIP-IDENTITY conformant without implementing AIP-KNOWLEDGE. A developer can adopt one cluster based on their immediate compliance needs and add others incrementally. The clusters compose cleanly — they share the same identity foundation and cross-reference each other, but none requires another to function.

The decisions that shaped it

The architecture didn’t start as five clusters and thirteen primitives. It started with one question: what does a multi-agent system need to be trustworthy in a regulated context? The structure emerged from working backwards from that question and making hard calls about scope.

AIP-MSG is retired

The original spec included AIP-MSG — a messaging primitive defining a standard envelope for inter-agent communication. We retired it when A2A was donated to the Linux Foundation with 100+ organization backing. A2A solves the messaging problem. Competing with it would be wrong. Instead, AIP defines the semantic payload schema that travels inside an A2A message body — structured metadata carrying identity attestations, trust scores, consent scope, and knowledge provenance. A2A handles delivery. AIP defines what the payload means.

Governance before code

Every AIP decision passes a governance test before a technical one: who controls this spec? A neutral multi-stakeholder body — Linux Foundation, W3C, IETF — means adopt rather than duplicate. A single company, even with an MIT license and a good implementation, means write the open spec. Microsoft’s AGT/IATP is MIT licensed. The code is free. The governance is not neutral. AIP exists to be the neutral spec that AGT and any other runtime can conform to. The code license is free. Governance covers the future.

Uncertainty is information, not failure

AIP-TRUST requires agents to attach structured uncertainty metadata to every output consumed by another AIP-conformant agent. This is non-negotiable: suppressing uncertainty is a system invariant violation. The reasoning is direct — downstream agents make decisions based on upstream outputs. An output that looks confident but isn’t causes cascading errors with no signal to detect them. An output that accurately expresses “this claim is at the edge of my declared competence” gives the downstream agent what it needs to weight the information correctly. Any standard that incentivizes agents to hide uncertainty is harmful to the ecosystem. AIP makes expressing it the right move structurally.

aip-envelope.json
{
"aip_envelope": {
  "sender": {
    "did": "did:aip:blite:analysis-agent-v2",
    "signature": "ed25519:eyJhbGciOiJFZERTQSJ9..."
  },
  "trust_metadata": {
    "confidence": 0.91,
    "uncertainty_flags": ["SINGLE_SOURCE"],
    "basis": "peer-reviewed literature, n=3 sources"
  },
  "privacy": {
    "consent_token": "ct:7f3a9c...",
    "data_boundary": "recipient-only",
    "retention_days": 30
  },
  "knowledge_provenance": {
    "institution": "did:aip:ucr:health-sciences",
    "knowledge_ref": "kr:supply-demand-2026-q1",
    "signed_at": "2026-03-15T08:22:01Z"
  }
},
"a2a_payload": {
  "task": "supply_forecast",
  "data": { "hospital_id": "H-0042", "horizon_days": 30 }
}
}
AIP defines the semantic payload that travels inside an A2A message body. A2A handles routing and delivery. AIP defines what the payload must contain. An A2A agent that doesn't implement AIP ignores the aip_envelope field — communication still works. An AIP-conformant agent gains the full trust and provenance guarantees.

Scope — what the protocol owns

AIP owns

  • Agent identity and cryptographic binding (AIP-ID)
  • Capability declaration, confidence levels, constraints (AIP-CAP)
  • Knowledge provenance and epistemic metadata (AIP-KP)
  • Consent declarations and data boundary enforcement (AIP-PRIV)
  • Trust scoring and structured uncertainty expression (AIP-TRUST)
  • Action authorization, rollback protocol, dispute arbitration (AIP-ACT)
  • Inference audit trail — append-only, cryptographically signed (AIP-AUDIT)

AIP defers

  • Transport and delivery — A2A handles this
  • Tool access protocol — MCP handles this
  • Agent framework or runtime — local implementation choice
  • Identity format — W3C DIDs are a candidate, not required
  • Registry architecture — AIP defines the interface, not the infrastructure
  • Observability and tracing format — align with OpenTelemetry, don't duplicate it
  • Implementation language or platform

Where this is going

AIP v0.1-draft (D0 through D3) is published under CC BY 4.0. The document hierarchy — Charter, Problem Statement, Requirements, Architecture — is the foundation that D4+ Protocol Specifications for individual clusters are built on. The priority order is AIP-KNOWLEDGE first (no existing competition, clearest value proposition in regulated industries), then AIP-PRIVACY (EU AI Act high-risk obligations take effect August 2026), then AIP-IDENTITY (most time-sensitive: Microsoft AGT shipped April 2, 2026; the neutral open spec needs to exist before its design decisions calcify into de facto standards).

The long-term destination is the Linux Foundation — alongside AAIF and A2A as the third layer of the AI agent protocol stack. Every architectural decision in AIP is evaluated against whether it creates or eliminates friction with that path. When MCP joined AAIF, Anthropic didn’t need to change the architecture. It was already the right thing. AIP is building toward the same bar.

The test for whether AIP remains a standard and not a product: if Blite disappeared tomorrow, five independent organizations should be able to continue implementing AIP from the published specs alone. That’s the line. Everything on the wrong side of it is drift toward becoming a product, and we revert from there.