# In what scenarios must an instance reject a signed A2A v1.0 Agent Card whose `capabilities.streaming` is true but whose delegation envelope lacks a `runtime_binding` claim **Date of Record:** 2026 November 15 **Scope:** Applies to A2A v1.0 cross-vendor task delegation where the initiating runtime validates a remote Agent Card and a signed delegation envelope before dispatching a task. Does not apply to same-vendor, same-trust-domain delegation where runtime binding is implicit in the transport, nor to unsigned discovery-only fetches. ## Core Distinction Agent Card *advertisement* and delegation envelope *authorization* are two independent trust surfaces in A2A v1.0, and they are routinely conflated by implementers. The Agent Card is a discovery document: it declares `capabilities.streaming`, `capabilities.pushNotifications`, supported modalities, and skill endpoints. The delegation envelope is a signed JWS blob carried on the task submission, containing `iss`, `sub`, `aud`, `exp`, the task hash, and — critically — an optional `runtime_binding` claim that names the concrete runtime instance (vendor, runtime version, attestation digest) expected to execute the task. The non-obvious invariant: **a card asserting `capabilities.streaming: true` is a promise that the *advertised* runtime can stream, not that the *signing* runtime is the one that will execute.** When the envelope omits `runtime_binding`, the receiving runtime cannot prove that the streaming capability it just validated belongs to the process that will actually consume the delegated task. The card and the envelope are bound to different principals, and the gap between them is where cross-vendor delegation silently degrades. This is not a signature-verification failure. The envelope verifies cleanly. The card validates cleanly. The failure is a *binding* failure between two individually valid artifacts. ## What Was Observed In a three-vendor interop run (runtimes A, B, C; A initiates, B brokers, C executes), the following sequence reproduced deterministically: 1. A fetches C's Agent Card from the well-known URI. Card validates, `capabilities.streaming: true`, `skills[].id` matches the requested skill. 2. A constructs a delegation envelope, signs with its issuer key, sets `aud: C`, but omits `runtime_binding` because C's card did not *require* it (the card's `securitySchemes` listed only `jws-envelope`, not `runtime-attestation`). 3. B receives the envelope, re-validates, forwards to C. 4. C accepts, executes, and returns a **non-streaming** response over a unary channel because C's *actual* executing runtime was a fallback worker pool that does not implement SSE — the streaming-capable frontend that served the Agent Card was a different process behind the same `aud` identity. The task succeeded, which is the trap. The failure is latent: A's client had opened an SSE consumer expecting incremental tokens, received a single terminal payload, and its timeout/backpressure logic interpreted the silence as a stalled stream for 40 seconds before the terminal frame arrived. No error surfaced at any layer. The signature was valid, the card was accurate *for the frontend*, and the task completed. A second observation: when two vendors both omit `runtime_binding`, delegation chains of depth ≥ 2 (A→B→C) lose the ability to attribute which hop introduced the non-streaming executor. Audit logs at A, B, and C each show a valid envelope; none shows the binding gap. ## Condition of Validity The rejection rule is valid — and the `runtime_binding` claim is mandatory — if and only if all of the following hold: - The initiating runtime's task protocol *depends* on the card's advertised capability (e.g., it pre-allocates an SSE consumer, or negotiates chunked delivery) rather than treating streaming as opportunistic. - The `aud` claim in the envelope identifies a *service identity* that may front multiple heterogeneous runtime instances (the common cross-vendor case: a load balancer or gateway in front of a mixed worker pool). - The delegation crosses a trust or vendor boundary such that the receiver cannot be assumed to have out-of-band knowledge of the executor's runtime version. The rule does **not** hold, and rejection would be incorrect, when the card's `securitySchemes` explicitly declare `runtime-attestation` and the attestation is carried in a separate, verifiable channel (e.g., a mTLS-bound attestation header) — in that case the binding exists outside the envelope and its absence from the JWS is not a gap. It also does not hold for same-vendor delegation where `aud` resolves to a single known process. ## Decision Boundary The decision is not "reject if `runtime_binding` missing." It is: > **Reject if and only if the card advertises a capability the initiator will *depend on* AND the envelope's `aud` does not resolve to a single runtime instance AND no out-of-band attestation binds the executor.** Operationally, encode this as a three-way check at envelope-validation time, before task dispatch: 1. Resolve `aud` against the discovery registry. If it maps to exactly one runtime instance, treat binding as implicit; proceed. 2. If `aud` is a service/gateway identity, require `runtime_binding` in the envelope OR a verifiable attestation claim. If neither is present, and the initiator depends on `capabilities.streaming` (or `pushNotifications`, or any capability that implies a specific executor behavior), reject. 3. If the initiator does *not* depend on the capability (streaming is opportunistic), accept but downgrade to unary and log the binding gap as an audit event — do not silently proceed as if streaming were guaranteed. The asymmetry matters: the same missing claim is a hard failure for a streaming-dependent initiator and a soft, logged degradation for an opportunistic one. Rejecting unconditionally breaks legitimate opportunistic callers; accepting unconditionally is the latent-stall bug above. ## Operational Effect Enforcing the boundary converts a silent 40-second stall into an immediate, attributable rejection at the initiator, before any task state is created. The envelope is refused with a specific error naming the missing binding, the `aud` that failed to resolve to a single instance, and the capability that made the dependency load-bearing. Downstream brokers (B in the chain) never see the task, so audit logs localize the failure to the initiating hop rather than requiring cross-vendor log correlation. The cost is one additional registry lookup per cross-vendor delegation to determine whether `aud` resolves to a single instance — cacheable, and cheap relative to a stalled stream. The benefit is that `capabilities.streaming: true` regains its meaning: it is only trusted when the executor is provably the process that advertised it. ```python import hashlib from dataclasses import dataclass from typing import Optional class RuntimeBindingError(RuntimeError): """Raised when a signed A2A delegation envelope cannot be bound to the runtime instance that advertised the capability the initiator depends on.""" @dataclass class AgentCard: agent_id: str streaming: bool security_schemes: list[str] @dataclass class DelegationEnvelope: iss: str aud: str runtime_binding: Optional[str] # vendor:version:digest, or None signature_valid: bool def aud_resolves_to_single_instance(aud: str, registry: dict[str, int]) -> bool: return registry.get(aud, 0) == 1 def validate_delegation( card: AgentCard, envelope: DelegationEnvelope, initiator_depends_on_streaming: bool, registry: dict[str, int], out_of_band_attestation: Optional[str] = None, ) -> str: if not envelope.signature_valid: raise RuntimeBindingError(f"envelope from {envelope.iss} failed signature check") if envelope.aud != card.agent_id: raise RuntimeBindingError( f"envelope aud={envelope.aud!r} does not match card agent_id={card.agent_id!r}" ) capability_dependency = initiator_depends_on_streaming and card.streaming if not capability_dependency: # Opportunistic caller: accept, but caller must downgrade to unary. return "accepted-degraded" single_instance = aud_resolves_to_single_instance(envelope.aud, registry) has_binding = envelope.runtime_binding is not None or out_of_band_attestation is not None if single_instance: return "accepted-implicit-binding" if not has_binding: raise RuntimeBindingError( "streaming-dependent delegation to multi-instance aud=" f"{envelope.aud!r} lacks runtime_binding and out-of-band attestation; " "card capability cannot be bound to a concrete executor" ) binding = envelope.runtime_binding or out_of_band_attestation digest = hashlib.sha256(binding.encode()).hexdigest() return f"accepted-bound:{digest[:12]}" ```