# What structural signals indicate an AAIF delegation chain is scope-valid yet authority-inert at tool invocation **Date of Record:** 2026 November 15 **Scope:** Applies to AAIF (Agent Identity Attestation Framework) deployments where an invoking agent presents a verifiable credential (VC) plus a signed delegation chain to a tool gateway that enforces scope at invocation time. Does not apply to single-hop credentials with no delegation, nor to gateways that re-resolve authority from a live authorization server per call. ## Core Distinction A delegation chain can be *cryptographically valid* — every signature verifies, every issuer DID resolves, every `credentialSubject.id` links to the next link's `issuer` — and still be *authority-inert*: the terminal subject holds no effective permission to invoke the named tool. These are different predicates. Validity is a property of the chain as a signed data structure. Authority is a property of the *intersection* of scopes along the chain, evaluated against the tool's required capability set at the moment of invocation. The non-obvious failure is that AAIF scope enforcement is conventionally specified as a per-link check ("each delegate's granted scope is a subset of its delegator's scope"). Subset-at-each-hop is necessary but not sufficient. It does not guarantee that the *conjunction* of attenuation constraints — resource filters, temporal windows, argument-level constraints, and capability verbs — is non-empty when projected onto the specific tool call. A chain can attenuate to the empty set while every individual hop passes subset validation. ## What Was Observed A three-hop chain: orchestrator `A` → planner `B` → executor `C`, invoking `payments.refund`. - Hop 1 (`A`→`B`): scope `payments:refund` with constraint `amount <= 500`, `currency = "USD"`. - Hop 2 (`B`→`C`): scope `payments:refund` with constraint `amount <= 200`, `region = "EU"`. Each hop passed subset validation: `amount<=200` ⊂ `amount<=500`; the added `region` constraint is a legitimate attenuation. The chain verified cleanly. The gateway accepted the VC and chain. The invocation was `payments.refund(amount=150, currency="EUR", region="EU")`. It failed — correctly — but for a reason no single hop check surfaces: Hop 1 pinned `currency="USD"`, Hop 2 pinned `region="EU"`, and the tool's argument schema requires *both* fields to be satisfiable simultaneously. The conjunction `currency="USD" ∧ region="EU"` is satisfiable in the abstract, but the *tool's* capability set for `payments.refund` only defines refunds in `(USD, US)` or `(EUR, EU)` pairs. The intersection of the two attenuation constraints, projected onto the tool's discrete argument domain, was empty. No hop was wrong. The chain was scope-valid and authority-inert. A second observed variant: temporal windows. Hop 1 granted `notAfter = T+24h`; Hop 2 attenuated to `notAfter = T+1h`. Valid subset. But the tool gateway's own session token had `notBefore = T+2h` (a scheduled maintenance window). The chain's effective validity interval `[T, T+1h]` did not intersect the gateway's `[T+2h, ...]`. Authority-inert again, with every link valid. ## Condition of Validity The invariance that must hold for a chain to carry *effective* authority is stronger than per-hop subset: > The intersection of all attenuation constraints across the chain, projected onto the tool's declared argument domain and the gateway's session window, must be non-empty, and must contain the concrete invocation tuple. Formally: let `S_i` be the constraint set granted at hop `i`, `D` the tool's argument domain (a discrete product of typed fields with enumerated or bounded values), and `W` the gateway session window. The chain is authority-bearing for invocation `x` iff `x ∈ (⋂_i S_i) ∩ D ∩ W`. Per-hop subset validation only checks `S_{i+1} ⊆ S_i`; it never evaluates `⋂_i S_i ∩ D ∩ W` for emptiness, and never evaluates it against a concrete `x`. The condition fails silently whenever two independent, individually-valid attenuations are *jointly* unsatisfiable on `D`, or when the chain interval and gateway window are disjoint. Both are invisible to signature verification and to per-hop subset checks. ## Decision Boundary A gateway must distinguish two rejection classes and must not conflate them: - **Invalid chain** — signature, DID resolution, or per-hop subset failure. Reject with `ChainInvalid`; the presenter must re-obtain credentials. - **Inert chain** — valid but empty effective authority for this invocation. Reject with `AuthorityInert`; the presenter holds a legitimate chain and must re-delegate or escalate scope, not re-sign. The operational rule: *never* treat "chain verifies" as "invocation authorized." Compute the projected intersection explicitly before dispatch. When the intersection is empty, do not fall back to the least-attenuated hop's scope — that is the classic privilege-reexpansion bug, where a gateway "helpfully" uses Hop 1's broader scope because Hop 2's constraints were unsatisfiable. The correct behavior is to reject and surface *which* constraint pair collided, so the delegator can be corrected. ## Operational Effect Without explicit intersection evaluation, authority-inert chains produce two failure modes in production: (1) false denials misattributed to credential problems, driving wasteful re-attestation loops, and (2) worse, silent privilege re-expansion when a gateway selects the widest satisfiable hop. The latter is a security regression masquerading as availability. Instrumenting the gateway to emit the projected intersection (or its emptiness witness — the colliding constraint pair) converts an opaque denial into an actionable delegation error, and makes the empty-intersection case a first-class, auditable event rather than a generic 403. ```python from dataclasses import dataclass from typing import Callable class AuthorityInertError(RuntimeError): """Chain is cryptographically valid but carries no effective authority for this invocation.""" pass class ChainInvalidError(RuntimeError): """Signature, DID, or per-hop subset validation failed.""" pass @dataclass(frozen=True) class Constraint: field: str predicate: Callable[[object], bool] label: str @dataclass(frozen=True) class Hop: constraints: tuple[Constraint, ...] def project_intersection(chain: list[Hop], invocation: dict, tool_domain: dict) -> None: """Evaluate the conjunction of all hop constraints on the concrete invocation. Raises ChainInvalidError if any hop is individually malformed (caller should have run subset validation already; this is a guard). Raises AuthorityInertError if the intersection is empty on the tool domain or does not contain the invocation tuple. """ if not chain: raise ChainInvalidError("empty delegation chain") for field in invocation: if field not in tool_domain: raise ChainInvalidError(f"invocation field {field!r} outside tool domain") # Collect every constraint across every hop; conjunction, not per-hop. active: list[Constraint] = [c for hop in chain for c in hop.constraints] for c in active: if c.field not in invocation: # A constraint on a field the tool never receives is inert by itself, # but its presence signals a schema mismatch, not silent success. raise AuthorityInertError( f"constraint {c.label!r} references field {c.field!r} " f"absent from invocation; cannot evaluate effective authority" ) if not c.predicate(invocation[c.field]): raise AuthorityInertError( f"invocation violates constraint {c.label!r} on {c.field!r}; " f"chain is valid but authority-inert for this call" ) # Explicit emptiness witness: find any two constraints on the same field # whose joint satisfaction is impossible on the tool's discrete domain. by_field: dict[str, list[Constraint]] = {} for c in active: by_field.setdefault(c.field, []).append(c) for field, cs in by_field.items(): if len(cs) < 2: continue domain_values = tool_domain[field] satisfiable = [ v for v in domain_values if all(c.predicate(v) for c in cs) ] if not satisfiable: labels = " AND ".join(c.label for c in cs) raise AuthorityInertError( f"empty intersection on {field!r}: [{labels}] " f"has no satisfiable value in tool domain {domain_values!r}" ) def authorize_tool_call( chain: list[Hop], invocation: dict, tool_domain: dict, gateway_window: tuple[int, int], invocation_time: int, ) -> None: start, end = gateway_window if not (start <= invocation_time < end): raise AuthorityInertError( f"invocation time {invocation_time} outside gateway window " f"[{start}, {end}); chain temporally inert" ) project_intersection(chain, invocation, tool_domain) ```