# Where must an instance refuse capability negotiation when a delegated AAIF scope is narrower than the requesting agent's advertised capability set **Date of Record:** 2026 November 16 **Scope:** Applies to agent-to-agent (A2A) handshakes in which a caller presents an Agent Authorization and Identity Framework (AAIF) token whose `scope` claim is a strict subset of the capabilities the caller advertises in its `AgentCard`. Does not apply to first-party calls where the caller is the token issuer, nor to scope expansion negotiated through an out-of-band policy grant. ## Core Distinction The non-obvious boundary is between **capability advertisement** and **capability authorization**. An AgentCard is a *declaration* of what an agent can do; an AAIF scope is a *grant* of what it may do on this call. A naive negotiator treats the intersection as the effective capability set and proceeds. The correct behavior is more subtle: when the granted scope is a strict subset of the advertised set, the responding instance must **not** silently narrow the caller's effective capability and then accept the task. Silent narrowing produces a class of failure where the caller believes it has delegated a full operation (e.g., "read and reconcile") while the callee executes only the scoped half (e.g., "read"), returning a success status for a semantically incomplete operation. The invariant is: **a negotiation response that returns `accepted` implies the accepted scope equals the scope the caller intended to exercise, not merely a subset of it.** Subset acceptance is only valid when the caller explicitly signals that partial execution is acceptable (`allow_partial: true` in the negotiation frame). ## What Was Observed In a multi-agent reconciliation pipeline, an orchestrator agent advertised capabilities `{ledger.read, ledger.reconcile, ledger.post_adjustment}`. Its AAIF token, issued by a treasury policy service, carried scope `{ledger.read, ledger.reconcile}` — the `post_adjustment` grant had been withheld pending a separate approval workflow. The worker agent received the AgentCard, intersected it with the token scope, and accepted the task with status `completed`. The orchestrator, seeing `completed`, marked the reconciliation cycle closed. No adjustment was posted. The discrepancy surfaced 36 hours later at settlement, not at negotiation. The failure was not that the worker refused — it was that the worker *accepted* a task whose accepted scope was a proper subset of the advertised scope without flagging the delta. The worker's logs recorded `scope_intersection = 2/3 capabilities`, which is a diagnostic, not a control. ## Condition of Validity Silent subset acceptance is valid **only** under all of the following: 1. The caller's negotiation frame includes `allow_partial: true`, and 2. The caller's frame enumerates `required_capabilities` as a subset of the granted scope, and 3. The responding instance returns `accepted_with_reduction` (not `accepted`) and echoes the reduced capability set in the response body. If any condition is unmet, the responder must reject with a distinct error class — `ScopeReductionRejected` — rather than proceed. Rejection is the safe default because the caller cannot distinguish "completed the full operation" from "completed the scoped portion" from a bare `completed` status. ## Decision Boundary The boundary is crossed at the moment the responder computes `effective = advertised ∩ granted` and compares it to `advertised`. If `effective ⊂ advertised` and `allow_partial` is absent or false, the responder is at the boundary and must reject. Do not defer the check to task execution time; by then the caller has already committed to a workflow that assumes full capability. The check belongs in the negotiation handler, before any task token is minted. A secondary boundary: if the caller advertises a capability the responder does not implement at all (disjoint, not subset), that is a `CapabilityUnsupported` rejection, a different class. Conflating the two masks scope-reduction failures as capability mismatches and sends operators down the wrong remediation path. ## Operational Effect Enforcing `ScopeReductionRejected` at negotiation converts a silent 36-hour-latency settlement discrepancy into an immediate, attributable negotiation failure with a clear remediation path (obtain the `post_adjustment` grant, or set `allow_partial: true` and handle the reduced result). The cost is additional rejected handshakes during policy rollout; the benefit is that partial execution can never masquerade as complete execution. Callers that legitimately want partial work must opt in explicitly, which makes the reduced scope a first-class part of the contract rather than an emergent property of token intersection. ```python class ScopeReductionRejected(RuntimeError): """Raised when a delegated AAIF scope is a strict subset of the caller's advertised capabilities and the caller has not opted into partial execution.""" pass def negotiate(caller_card: dict, token_scope: set, frame: dict) -> dict: advertised = set(caller_card.get("capabilities", [])) granted = set(token_scope) effective = advertised & granted if effective == advertised: return {"status": "accepted", "scope": sorted(effective)} if effective and frame.get("allow_partial") is True: required = set(frame.get("required_capabilities", [])) if not required.issubset(effective): raise ScopeReductionRejected( f"required={sorted(required)} not within effective={sorted(effective)}" ) return {"status": "accepted_with_reduction", "scope": sorted(effective)} if not effective: raise ScopeReductionRejected( f"disjoint scope: advertised={sorted(advertised)} granted={sorted(granted)}" ) raise ScopeReductionRejected( "strict subset of advertised capabilities granted " f"(missing={sorted(advertised - granted)}) and allow_partial is not set" ) ```