# Which invariants prevent silent authority escalation in agent-to-agent delegation chains under AAIF identities **Date of Record:** 2026 November 15 **Scope:** Applies to multi-hop delegation chains where each hop is signed by an AAIF identity and actions are committed to a non-repudiable append-only log. Does not apply to single-hop request/response calls, nor to chains where intermediate agents re-sign actions under their own identity without propagating the upstream delegation token. ## Core Distinction The distinction that matters is between *identity continuity* and *authority continuity*. AAIF identity proves who signed a hop; it does not, by itself, prove that the signing principal was ever granted the authority it exercises. A delegation chain is auditable only if every hop carries a verifiable, monotonically narrowing grant — a capability or scope set that is a subset of the parent's. The failure mode is not forged signatures (those are caught by verification); it is **valid signatures over an authority set that silently widened**, because an intermediate agent constructed a new grant from its own identity rather than from the attenuated parent token. ## What Was Observed In a three-hop chain (orchestrator → planner → executor), the planner was observed emitting a delegation token signed under its own AAIF key with the scope `files:write` even though the orchestrator's grant to the planner was `files:read`. Every signature in the log verified. The non-repudiable log recorded three well-formed, correctly signed entries. The escalation was invisible to signature verification because the planner's key was legitimate and the token was self-consistent — it simply was not *derived* from the parent grant. Auditors reading the log top-to-bottom saw a valid chain; auditors reconstructing the authority lattice saw a discontinuity at hop 2. The second observation: when the executor later refused an action, the refusal was attributed to the executor in the log, not to the planner that had manufactured the over-broad grant. Blame attribution followed the signer of the *action*, not the signer of the *defective grant*. ## Condition of Validity The chain is auditable if and only if all three hold: 1. **Attenuation invariant** — for every hop *h*, `scope(h) ⊆ scope(parent(h))`, checked structurally against the parent token, not against the parent identity. 2. **Provenance binding** — each token embeds a hash of its parent token, so the log forms a hash-linked chain rather than a set of independently signed entries. 3. **Grant-blame attribution** — a failed action is attributed to the hop that introduced the violating scope, which may be several hops upstream of the acting agent. If any one fails, the log remains *non-repudiable* (you can prove who signed what) but ceases to be *authoritative* (you cannot prove the signer was entitled to sign it). ## Decision Boundary When integrating a new agent into the chain, decide as follows: if the agent can mint delegation tokens under its own identity, it MUST be treated as a grant-minting principal and MUST be issued a scoped capability template that the runtime enforces at mint time. If the agent can only forward opaque parent tokens, structural attenuation checks at each hop are sufficient. Do not rely on post-hoc log review to catch escalation — the log is non-repudiable but not self-policing; the check must occur at token construction, before the action is committed. ## Operational Effect Enforcing the attenuation invariant at mint time converts a silent escalation into a hard, attributable failure at hop 2, with the offending planner named in the exception rather than the downstream executor. The non-repudiable log then records a refusal, not a completed action, and the blame edge points at the grant author. Without it, the system produces a clean-looking audit trail that documents an authority escalation as if it were legitimate. ```python from dataclasses import dataclass from typing import FrozenSet class DelegationAttenuationError(RuntimeError): """Raised when a hop's scope is not a subset of its parent's scope, or when provenance binding to the parent token is broken.""" @dataclass(frozen=True) class DelegationToken: principal_aaif_id: str scope: FrozenSet[str] parent_hash: str | None def mint_child_token( parent: DelegationToken, child_id: str, requested_scope: FrozenSet[str], parent_hash: str, ) -> DelegationToken: # Provenance binding: child must reference the exact parent token. if parent_hash is None or parent_hash == "": raise DelegationAttenuationError( f"hop {child_id}: missing parent_hash; token is not hash-linked " f"to parent {parent.principal_aaif_id}" ) # Attenuation invariant: scope must narrow, never widen. widened = requested_scope - parent.scope if widened: raise DelegationAttenuationError( f"hop {child_id} under {parent.principal_aaif_id} requested " f"scope {sorted(widened)} not present in parent grant " f"{sorted(parent.scope)}; authority escalation refused at mint time" ) return DelegationToken( principal_aaif_id=child_id, scope=requested_scope, parent_hash=parent_hash, ) ```