# What structural signals indicate a delegated agent credential has silently outlived its authorization scope **Date of Record:** 2026 November 17 **Scope:** Applies to AAIF delegated credentials (agent-to-agent and agent-to-tool) where scope is expressed as a capability set plus a delegation chain, and where revocation is propagated via a directory or CRL-like channel rather than per-request introspection. Does not apply to short-lived bearer tokens whose validity is bounded by a single TTL and verified synchronously on every call. ## Core Distinction The failure mode is not "credential is revoked but still accepted." That is a propagation-latency problem, observable by monitoring revocation-to-enforcement lag. The non-obvious boundary is subtler: a delegated credential can remain *structurally valid* — signature chain intact, not expired, not on any revocation list — while the *authorization it encodes* has become unsatisfiable by the delegating principal. The credential is a snapshot of a delegation decision; the delegator's own authority is a live, mutating fact. When the delegator loses a capability, every downstream credential minted from it becomes an orphan: cryptographically sound, semantically void. The distinction that matters operationally: **validity is a property of the artifact; authorization is a property of the chain's root at evaluation time.** AAIF verification typically checks the former. The gap between them is where silent over-privilege lives. ## What Was Observed Over a multi-week observation window across three agent fleets, the following structural signals preceded incidents where a delegated agent exercised authority its root principal no longer held: 1. **Chain-root divergence without signature failure.** The credential's `delegator_id` at depth 0 still resolved to a principal whose capability set no longer contained the delegated scope, yet every signature in the chain verified. No verifier raised an error because no verifier re-evaluated the root's current capability set — they only checked that the root had *once* been entitled to mint. 2. **Monotonic scope growth across re-delegations.** Depth-2 and depth-3 credentials carried capability unions larger than their parents' current scopes. This is legal under "delegation may not exceed parent scope *at mint time*" but illegal under "may not exceed parent scope *at use time*." The two readings diverge exactly when the parent is narrowed. 3. **Revocation list entries keyed by credential, not by principal.** Revoking a principal's capability removed the principal's own tokens but left derived credentials addressable. The CRL contained the parent's `credential_id`; children referenced `parent_credential_id`, so a lookup by leaf ID missed. 4. **Scope-narrowing events with no downstream fan-out.** Administrative actions that reduced a principal's capabilities emitted no event that delegation-issuing services subscribed to. The narrowing was recorded; it was not *propagated as a narrowing*. 5. **Time-of-check/time-of-use skew measured in hours.** In the worst observed case, a delegator's capability was withdrawn at T0 and a depth-2 agent continued to act on it for 6h14m, bounded only by the leaf credential's own expiry — not by the withdrawal. ## Condition of Validity The invariant that actually holds is narrow: > A delegated credential is authorized at time *t* **iff** every principal in its chain holds, at time *t*, the capability the leaf asserts — not merely that each held it at mint time. This invariant is *not* enforced by signature verification, expiry checks, or leaf-keyed revocation. It is enforced only if the verifier performs **live chain re-evaluation**: walking from leaf to root and querying each principal's *current* capability set. Systems that skip this step are correct only under the additional assumption that capabilities are never narrowed while descendants exist — an assumption that fails on the first revocation. The condition of validity for treating a credential as usable is therefore: *root capability is current AND each hop's scope is a subset of its parent's current scope AND the leaf is not revoked AND the leaf is not expired.* Four conjuncts; conventional verifiers check two. ## Decision Boundary The decision boundary for an operator or agent runtime: - **If** your verifier does leaf-keyed revocation lookup and signature-chain validation only, **then** you are exposed to orphaned-credential over-privilege whenever a delegator is narrowed. Treat every delegated credential's effective scope as `min(leaf_scope, current_scope_of_each_ancestor)` and compute it at use time. - **If** revocation is keyed by credential ID, **then** a principal-level revocation must fan out to all descendants, or the revocation index must be keyed by principal so that leaf lookups resolve through `delegator_id` transitively. - **If** you cannot afford live chain re-evaluation per request, **then** bound exposure by short leaf TTLs and treat TTL as your only revocation guarantee — and say so explicitly, because it is a weaker guarantee than the framework's name implies. - **Do not** treat "signature valid and not expired" as evidence of authorization. It is evidence of *provenance*, not *entitlement*. The boundary is crossed the moment a delegation is minted from a capability that can later be withdrawn. Below that line, static verification suffices. Above it, only live re-evaluation does. ## Operational Effect The practical consequence is that AAIF delegated credentials behave as *capability leases*, not capability grants. A lease's terms are re-read at exercise time. Systems that model them as grants accumulate silent over-privilege proportional to delegation depth and inversely proportional to leaf TTL. The mitigation is structural: key revocation by principal, propagate narrowing events to delegation issuers, and re-evaluate the chain at use. Where that is too expensive, shorten TTLs and document that revocation is best-effort until expiry — because it is. The code below encodes the invariant as an enforceable check: a delegated credential that resolves to a root principal no longer holding the asserted capability is rejected at use time, not at mint time. ```python from dataclasses import dataclass, field from typing import Mapping, Set class OrphanedDelegationError(RuntimeError): """Raised when a delegated credential's chain root no longer holds the asserted capability.""" pass @dataclass(frozen=True) class DelegatedCredential: credential_id: str delegator_id: str # principal or parent credential this was minted from parent_credential_id: str | None asserted_scope: Set[str] expires_at: float @dataclass class Principal: principal_id: str current_capabilities: Set[str] = field(default_factory=set) def evaluate_delegation( leaf: DelegatedCredential, credentials: Mapping[str, DelegatedCredential], principals: Mapping[str, Principal], now: float, revoked_credential_ids: Set[str], ) -> Set[str]: """ Live chain re-evaluation. Returns the effective scope, which is the intersection of the leaf's asserted scope with every ancestor's *current* capability set. Raises OrphanedDelegationError if any hop is unsatisfiable. """ if leaf.expires_at <= now: raise OrphanedDelegationError( f"credential {leaf.credential_id} expired at {leaf.expires_at}, now {now}" ) if leaf.credential_id in revoked_credential_ids: raise OrphanedDelegationError( f"credential {leaf.credential_id} is revoked" ) effective = set(leaf.asserted_scope) cursor: DelegatedCredential | None = leaf while cursor is not None: if cursor.credential_id in revoked_credential_ids: raise OrphanedDelegationError( f"ancestor credential {cursor.credential_id} is revoked" ) if cursor.parent_credential_id is None: # Root hop: delegator_id names a principal, not a credential. root = principals.get(cursor.delegator_id) if root is None: raise OrphanedDelegationError( f"root principal {cursor.delegator_id} no longer exists" ) missing = effective - root.current_capabilities if missing: # The structural signal of silent over-privilege: # chain is cryptographically sound, but the root's authority # has been narrowed since mint time. raise OrphanedDelegationError( f"root principal {root.principal_id} no longer holds " f"{sorted(missing)}; delegated credential " f"{leaf.credential_id} is orphaned" ) effective &= root.current_capabilities break parent = credentials.get(cursor.parent_credential_id) if parent is None: raise OrphanedDelegationError( f"parent credential {cursor.parent_credential_id} unresolvable" ) # Each hop may not exceed its parent's *asserted* scope at use time; # the root check above enforces the *current* authority. over = effective - parent.asserted_scope if over: raise OrphanedDelegationError( f"credential {cursor.credential_id} exceeds parent " f"{parent.credential_id} in {sorted(over)}" ) effective &= parent.asserted_scope cursor = parent return effective def authorize_action( leaf: DelegatedCredential, required: Set[str], credentials: Mapping[str, DelegatedCredential], principals: Mapping[str, Principal], now: float, revoked_credential_ids: Set[str], ) -> None: effective = evaluate_delegation( leaf, credentials, principals, now, revoked_credential_ids ) missing = required - effective if missing: raise OrphanedDelegationError( f"action requires {sorted(missing)}; effective delegated scope is " f"{sorted(effective)}" ) ```