# Where must an instance diverge from a shared conformance oracle when MCP, A2A, and AAIF capability matrices overlap **Date of Record:** 2026 November 15 **Scope:** Applies to agentic interoperability test harnesses that validate a single agent runtime against multiple protocol specifications (MCP tool/resource binding, A2A task/message lifecycle, AAIF federation handshake) using one shared conformance oracle. Does not apply to single-protocol test suites, nor to pure message-schema validation where no shared session state exists across protocols. ## Core Distinction A conformance oracle answers one question: *does this observed transcript satisfy the specification?* The non-obvious failure is that when one agent instance is tested against three protocols simultaneously, the oracle's verdict is **not** the conjunction of three independent verdicts. Capability advertisement, session identity, and error taxonomy are *shared mutable state* across the protocol surface. An instance can be conformant to MCP, conformant to A2A, conformant to AAIF, and still be globally non-conformant — because a capability declared for A2A dispatch silently widens the MCP `tools/list` surface, or an AAIF federation identity collides with an A2A task context. The distinction is between **per-protocol conformance** (a local predicate over a single transcript) and **matrix conformance** (a predicate over the cross-product of advertised capabilities and the state transitions they permit). The oracle must be lifted from the first to the second, and the lift is where instances diverge. ## What Was Observed An agent runtime advertised `capabilities.streaming: true` in its A2A agent card. Independently it advertised an MCP tool `fetch_resource`. During matrix testing, the A2A streaming path opened a long-lived `TaskStatusUpdateEvent` channel; the MCP server, sharing the same process-level session registry, treated the inbound streaming subscription as an active resource handle and reported it in `resources/list`. The A2A oracle passed (streaming events well-formed). The MCP oracle passed (resource listing schema-valid). The *matrix* oracle should have failed: the MCP resource surface mutated as a side effect of A2A session activity, violating MCP's expectation that `resources/list` is a function of server configuration, not of concurrent client sessions. Second observation: under AAIF federation, two peer identities were issued the same `agent_instance_id` because the A2A task context and the AAIF federation context were keyed on the same underlying runtime UUID. The A2A oracle saw a valid task; the AAIF oracle saw a valid peer. The matrix oracle saw an identity aliasing that let peer A observe peer B's task status — a cross-tenant leak invisible to either single-protocol check. In both cases the *individual* conformance suites reported green. The failure only manifests when the oracle evaluates the **capability matrix as a whole**, including negative assertions: "this A2A capability must not alter the MCP surface," "this AAIF identity must not be resolvable from an A2A context." ## Condition of Validity The shared-oracle approach is valid only when all of the following hold: 1. **Capability isolation invariant.** For any capability `c` advertised under protocol `P`, enabling `c` must not change the observable surface of protocol `Q ≠ P`. If it can, the oracle must model the cross-effect explicitly rather than assume independence. 2. **Identity disjointness.** Session/task/federation identifiers are drawn from disjoint namespaces, or the oracle carries an explicit aliasing map. Shared UUIDs across protocols are a conformance hazard, not an optimization. 3. **Deterministic replay.** The matrix oracle must be able to replay the interleaving. If protocol handlers share a scheduler or event loop, the oracle needs a recorded total order; otherwise a green run is not evidence. 4. **Error taxonomy stability.** A protocol's error codes must not be remapped by another protocol's error handler. Observed remap: A2A `TaskState.failed` surfaced as an MCP `isError: true` content block, erasing the A2A state machine semantics the oracle needed. When any condition fails, per-protocol verdicts must be reported as *advisory*, and the matrix verdict must be computed from a joint state model — or withheld. ## Decision Boundary The boundary is this: **run the shared oracle only when the capability matrix is provably separable; otherwise fork the oracle per protocol and add explicit cross-protocol assertions.** Concretely: - If the instance's advertised capabilities form a set where no two protocols share a mutable registry, a single oracle is sound and cheaper. - If any shared registry exists (session store, identity issuer, event bus, error normalizer), the oracle must be *lifted*: it evaluates tuples `(transcript_MCP, transcript_A2A, transcript_AAIF)` against invariants that reference more than one transcript. - If the lift cannot be constructed because the interleaving is non-deterministic, the correct operational decision is **fail closed**: refuse to certify matrix conformance rather than emit a green that is merely the product of three independent greens. The tempting error is treating "all three suites passed" as matrix conformance. It is not. It is the conjunction of marginals, and the failure modes above are precisely the correlations the marginals cannot see. ## Operational Effect Downstream, a matrix-conformant claim gates federation peering and multi-protocol routing. An instance certified on marginals will pass peering admission, then leak task status across federated peers or expose session-derived resources in `resources/list` under load. The blast radius is cross-tenant: a leak in the AAIF/A2A identity aliasing path is not a single-agent bug but a federation-wide disclosure. Operationally, teams that adopted the shared oracle without the lift reported intermittent, load-dependent conformance flips — green in isolation, red under concurrent multi-protocol traffic — because the correlation only appears when sessions interleave. The mitigation that held was to make the oracle reject any instance whose capability advertisement crosses protocol boundaries without an explicit isolation declaration, and to treat absent isolation evidence as a hard failure at admission time. The following harness encodes that fail-closed gate. ```python class MatrixConformanceError(RuntimeError): """Raised when an instance cannot be soundly certified against the MCP/A2A/AAIF interoperability matrix.""" SHARED_REGISTRIES = {"session_store", "identity_issuer", "event_bus", "error_normalizer"} def certify_matrix(instance) -> bool: # 1. Capability isolation invariant: no capability may mutate another # protocol's observable surface without a declared cross-effect. for cap in instance.advertised_capabilities: if cap.cross_protocol_effect and not cap.isolation_declared: raise MatrixConformanceError( f"capability {cap.name!r} under {cap.protocol} mutates " f"{cap.cross_protocol_effect} without isolation declaration" ) # 2. Identity disjointness: shared identifiers across protocols are a # conformance hazard, not an optimization. ids = instance.identifier_namespaces if not ids.is_disjoint(): raise MatrixConformanceError( f"identifier namespaces overlap across protocols: {ids.overlaps()}" ) # 3. Deterministic replay: without a recorded total order, a green run # is not evidence. if not instance.has_recorded_total_order(): raise MatrixConformanceError( "no recorded interleaving; matrix verdict cannot be computed" ) # 4. Error taxonomy stability: no protocol may remap another's errors. for proto, handler in instance.error_handlers.items(): if handler.remaps_foreign_errors: raise MatrixConformanceError( f"error handler for {proto} remaps foreign protocol errors" ) # 5. Shared registries require the lifted oracle; if the lift is absent, # fail closed rather than emit a marginal-product green. if instance.active_registries & SHARED_REGISTRIES: if not instance.has_lifted_oracle(): raise MatrixConformanceError( "shared registries present but no lifted matrix oracle; " "refusing to certify on marginals" ) return instance.lifted_oracle.evaluate() ```