# What happens when an instance trusts a signed Agent Card beyond its manifest's declared scope during A2A v1.0 cross-agent task delegation **Date of Record:** 2026 November 17 **Scope:** Applies to A2A v1.0 delegating agents that discover peers via Agent Card retrieval and validate signed capability manifests before dispatching tasks. Does not apply to intra-process tool calls, to A2A v0.x unsigned cards, or to cases where the delegating agent is the sole trust anchor for the manifest signature. ## Core Distinction A signed Agent Card proves *provenance and integrity of the declared capability set*; it does not prove *that the receiving agent will only act within that set*. The signature binds the manifest bytes to a key, and the manifest enumerates scopes, task types, and resource bounds — but the receiving agent's runtime enforcement of those bounds is a separate, unsigned property. Delegating agents routinely conflate these two: they verify the signature, extract the declared scope, and then dispatch tasks whose *inputs* fall inside the declared scope while ignoring that the *effects* of the task may exceed it. The boundary failure is not a forged card; it is a validly signed card whose declared scope is narrower than the receiver's actual behavioral envelope. ## What Was Observed In a two-agent pipeline (orchestrator O, worker W), O fetched W's Agent Card at `/.well-known/agent.json`, verified the JWS over the `capabilities` manifest against W's published key, and confirmed that the requested task type `document.summarize` was present with scope `read:documents`. O then delegated a summarization task referencing a document URI. The manifest declared `resource_bounds.max_bytes: 1048576` and `side_effects: none`. W executed the task, but its summarizer implementation followed document-embedded references to fetch *additional* documents (a transitive read), totaling 4.2 MB across six documents, and wrote a cache artifact to its own persistent store. The signature over the manifest was valid at every step. No field in the manifest was falsified. The failure surfaced only downstream, when a later task with `side_effects: none` collided with W's cache and returned stale content — and when the transitive reads tripped an unrelated egress policy. The invariant that broke: **a valid signature over a capability manifest does not constrain the transitive closure of a task's effects.** O treated the manifest as an enforcement contract. W treated it as a declaration of intent. Both were locally consistent. ## Condition of Validity The delegation is safe only under the conjunction of three conditions, and the third is the one that is usually silently false: 1. The manifest signature verifies against a key O trusts for W's identity (standard). 2. The requested task type and its *direct* inputs fall within the declared scope (standard, and what most implementations check). 3. W's runtime enforces the manifest's `resource_bounds`, `side_effects`, and transitive-access limits on the *actual execution*, not merely on the request envelope. Condition 3 cannot be established from the Agent Card alone. It requires either (a) an attestation covering the runtime enforcement layer — a signed statement about the *executor*, not the *manifest* — or (b) O-side containment that does not rely on W's cooperation: egress filtering, a task-scoped credential whose grant matches the declared scope, or a capability token that W cannot amplify. Absent one of these, the signature provides integrity of a claim, not enforcement of a boundary. ## Decision Boundary The operational rule: **trust the signature for admission, never for containment.** Concretely, O should: - Treat `side_effects: none` in a signed manifest as a *hint*, not a guarantee, unless the delegation carries a credential that structurally cannot write (e.g., a read-only token scoped to the named document set). - Treat `resource_bounds` as advisory unless O enforces them at the boundary (timeouts, byte caps on the returned artifact, egress allowlists keyed to the declared scope). - Never let a task's transitive reach be inferred from its direct inputs. If the task can follow references, the effective scope is the reachable set, which the manifest does not enumerate. - Require, for any delegation where the declared scope is narrower than the receiver's plausible envelope, either an executor attestation or O-side containment. If neither is available, downgrade the delegation to a single-document, no-follow, credential-bounded call. The boundary is crossed the moment O dispatches a task whose *effects* it cannot bound, on the strength of a signature that only bounds the *declaration*. ## Operational Effect Teams that hit this pattern typically respond by widening the manifest (declaring `side_effects: cache`, listing transitive reads), which restores honesty but not enforcement — the next undocumented behavior recurs. The durable fix is to move containment out of the manifest and into the delegation credential: issue W a token whose grant equals the declared scope, so that any transitive reach beyond scope fails at W's own authorization layer rather than at O's optimistic assumption. The signature then does what signatures do — it authenticates the claim that the token's grant was chosen correctly — and enforcement lives where it can actually be checked. The practical residue: after this incident, O's dispatcher refused any delegation where `side_effects != none` and no executor attestation was present, and logged the mismatch as a first-class event rather than a warning. ```python class ManifestScopeViolation(RuntimeError): """Raised when a delegation's effective (transitive) scope exceeds the signed manifest's declared scope without executor attestation or caller-side containment.""" pass def dispatch_delegation(card, task, attestation=None, contained=False): manifest = card.verified_manifest # signature already checked declared = manifest.scope effective = task.reachable_scope() # follows references, not just direct inputs if not effective.issubset(declared): if attestation is None and not contained: raise ManifestScopeViolation( f"task {task.id} reaches {sorted(effective - declared)} " f"beyond declared scope {sorted(declared)}; " f"no executor attestation and no caller-side containment" ) # contained=True means a scoped credential bounds the reach at W; # attestation means W's runtime enforcement is covered by a signature. if manifest.side_effects != "none" and not contained: raise ManifestScopeViolation( f"task {task.id} declares side_effects={manifest.side_effects} " f"but delegation carries no write-bounding credential" ) return card.dispatch(task) ```