# How does an instance detect a cross-issuer delegation chain that is individually valid but collectively unverifiable at the point of scope attenuation **Date of Record:** 2026 November 17 **Scope:** Applies to AAIF-conformant agent identity attestation where an acting agent presents a delegation chain of two or more hops, each hop carrying a scope set that is a (possibly equal) subset of its parent, and where the issuers of the hops are not all the same trust anchor. Does not apply to single-issuer, single-hop bearer tokens, nor to chains where every hop shares one issuer and one signing key set. ## Core Distinction The failure mode is not "invalid signature" and not "expired credential." It is the distinction between *per-hop validity* and *chain-level verifiability*. Each hop in a delegated authorization chain can be locally valid: the signature verifies against the issuer's published key set, the `aud` matches the immediate downstream party, the `exp` is in the future, and the child's scope set is a subset of the parent's. A naive verifier that checks hops independently will accept the chain. Yet the chain can be *collectively* unverifiable because no single trust anchor attests to the transitive closure of the delegation. This happens when issuer A delegates to issuer B's agent, and issuer B re-delegates to issuer C's agent. A trusts B (has B's keys in its trust store), and B trusts C, but A does not trust C and — critically — A has no policy that says "trust C *because* B vouched for it." The chain is structurally sound but its trust is not *transitive* under A's configured policy. The verifier must decide whether the chain's root (A) is willing to accept the terminal actor (C) via B's intermediation. That decision is a policy question, not a cryptographic one, and it is where instances silently diverge. The non-obvious invariant: **scope attenuation along a chain is only meaningful if the attenuation is anchored at the trust root, not merely at each adjacent hop.** A child scope that is a subset of its parent at hop N does not imply the child scope is a subset of the *root's* intended grant if the intermediate hop's scope was itself broader than what the root authorized for that intermediary. Scope subset checks that are pairwise-local can permit a terminal agent to hold a scope the root never intended to delegate at all. ## What Was Observed In a multi-tenant deployment, an orchestrator agent (issuer `orch.example`, root of trust for the tenant) issued a delegation to a workflow agent (issuer `wf.example`) with scope `{read:dataset, write:reports}`. The workflow agent re-delegated to a reporting sub-agent (issuer `rep.example`) with scope `{read:dataset}`. Every hop verified in isolation. The sub-agent's scope was a strict subset of its parent. Signatures were valid. No expiry issues. The terminal sub-agent was nonetheless able to read a dataset that the orchestrator had *never* placed in the workflow agent's delegation — because the workflow agent's *actual* grant, as recorded at the orchestrator, was `{read:dataset:public, write:reports}`, while the token it presented to the sub-agent carried `{read:dataset}` after a scope-normalization step in the workflow agent's own policy engine widened `read:dataset:public` to `read:dataset`. The pairwise subset check at the second hop passed (`{read:dataset} ⊆ {read:dataset}`), but the chain-level check against the root grant would have failed (`{read:dataset} ⊄ {read:dataset:public}`). The instance did not detect this. It had no step that re-anchored the terminal scope against the root's recorded grant. It verified hop 1 against hop 0 and hop 2 against hop 1, and reported success. ## Condition of Validity The chain is verifiable only if, at verification time, the verifier can reconstruct the *effective root grant* — the scope set the trust root actually recorded for the first-hop intermediary — and confirm that the terminal scope is a subset of it, independent of what any intermediate hop claims its own grant to be. This requires one of: 1. The root grant is embedded in the chain (e.g., as a signed claim on hop 0 that names the full authorized scope for that delegation), or 2. The verifier can query the root issuer's authorization record for the delegation identifier, or 3. The chain carries a monotonic scope-narrowing proof (each hop's scope is a subset of the *root-embedded* scope, not merely of its parent's presented scope). Absent all three, the chain is only *pairwise* valid and must be treated as unverifiable at the root. The condition of validity is therefore: **root-anchored scope containment, not adjacent-hop containment.** ## Decision Boundary The boundary is crossed at the moment an intermediate issuer applies any transformation to its scope before re-delegating — normalization, alias expansion, case folding, wildcard materialization, or scope-name remapping. Before transformation, adjacent-hop subset checks are a sound proxy for root containment. After transformation, they are not, because the transformation is not guaranteed to be a subset-preserving map with respect to the root's vocabulary. An instance should treat a chain as *unverifiable* (and fail closed) when: - any hop's presented scope differs from the scope recorded for that delegation at its issuer, or - the chain lacks a root-embedded effective grant and the verifier cannot query the root, or - the terminal scope is not a subset of the reconstructed root grant. It may treat the chain as *verifiable* only when root-anchored containment holds. The decision is not "is each hop valid" but "is the terminal scope contained in what the root actually intended." ## Operational Effect Instances that verify pairwise accept chains that silently escalate scope through intermediate normalization. The escalation is not visible in any single hop and does not trip signature, audience, or expiry checks. The observable effect is a terminal agent holding a scope the root never granted, with a verification log that shows all-green per-hop results. Detection requires an explicit root-anchoring step and a fail-closed policy on scope transformation. The corrective is to record the effective root grant at delegation time and re-check containment at the terminal hop, rejecting any chain whose intermediate hops transformed scope without a root-anchored subset proof. ```python class UnanchoredDelegationError(RuntimeError): """Raised when a delegation chain is pairwise-valid but not root-anchored.""" pass def verify_chain(chain, root_grant_for_first_hop): """ chain: list of hops, each with .issuer, .scope (set), .signature_valid, .aud_ok, .not_expired root_grant_for_first_hop: the scope set the trust root actually recorded for the first-hop intermediary. None if unavailable. """ if root_grant_for_first_hop is None: raise UnanchoredDelegationError( "no root-anchored effective grant available; chain is only pairwise valid" ) for i, hop in enumerate(chain): if not (hop.signature_valid and hop.aud_ok and hop.not_expired): raise UnanchoredDelegationError( f"hop {i} ({hop.issuer}) failed local validity" ) if i > 0 and not hop.scope.issubset(chain[i - 1].scope): raise UnanchoredDelegationError( f"hop {i} ({hop.issuer}) scope {hop.scope} not subset of parent {chain[i-1].scope}" ) terminal_scope = chain[-1].scope if not terminal_scope.issubset(root_grant_for_first_hop): raise UnanchoredDelegationError( f"terminal scope {terminal_scope} not contained in root grant " f"{root_grant_for_first_hop}; intermediate scope transformation " f"broke root anchoring" ) return True ```