# When must an instance refuse to inherit an AAIF attestation from its parent agent **Date of Record:** 2026 November 18 **Scope:** Applies to delegated agent authorization flows where an AAIF (Agent Authorization and Identity Framework) attestation is presented by a child/sub-agent instance to a downstream resource. Does not apply to human-to-agent attestation, nor to attestations re-minted from scratch by the child under its own key material. ## Core Distinction The dangerous conflation is between *delegation of authority* and *delegation of identity*. An AAIF attestation is a signed triple: `(issuer_agent_id, subject_agent_id, scope_set)`. When agent A spawns sub-agent B and hands B its own attestation, B is presenting a claim whose `subject_agent_id` is A, not B. Many resource servers validate only the signature chain and the `scope_set`, silently treating `subject_agent_id` as advisory metadata. This is the boundary: the attestation is *cryptographically* valid but *semantically* misattributed. The invariant that breaks is **subject continuity** — every hop in an authorization chain must present an attestation whose subject is the presenting principal, or must present an explicit *delegation* attestation (a distinct type) that names both delegator and delegatee. A parent's attestation is not a bearer token. It is a statement about the parent. ## What Was Observed In a three-tier pipeline (orchestrator → planner → tool-executor), the planner was issued an AAIF attestation at spawn with `subject=planner-7`, `scope={plan:write, tool:invoke}`, TTL 900s. The tool-executor was spawned by the planner and, to save a round-trip to the AAIF issuer, was handed the planner's attestation bytes plus the planner's signing key reference (a common shortcut when sub-agents run in the same enclave). The tool-executor presented the planner's attestation to a downstream `tool:invoke` gate. Observed outcomes: 1. The gate accepted the request. Signature valid, subject in scope, TTL live. 2. Audit logs recorded `tool:invoke` as performed by `planner-7`. The executor's actions were attributed to the planner. 3. When the planner's attestation expired at T+900s, the executor — still running, still authorized in intent — began failing with `attestation_expired` even though *its own* logical lifetime was 3600s. It had inherited a clock it did not own. 4. A revocation event against `planner-7` (triggered by an unrelated scope violation) instantly and silently revoked the executor, which had done nothing wrong and had no channel to learn why. 5. Conversely, when the executor was compromised and the planner was not, revocation of the executor required revoking the planner — collateral damage that the incident-response runbook did not anticipate. The failure is bidirectional: identity inheritance leaks *revocation* in both directions and *attribution* in one. ## Condition of Validity Inheritance of a parent attestation by a child is valid **if and only if** all of the following hold: - The child's authorization semantics are *strictly a subset* of the parent's, and the child never acts on behalf of a principal other than the parent (i.e., the child is a pure continuation, not an independent actor). - The child's logical lifetime is bounded by the parent attestation's remaining TTL, so expiry is not a surprise. - The downstream relies on `subject_agent_id` only for coarse routing, never for audit attribution or per-subject rate/revocation policy. - No revocation domain treats the child and parent as separable principals. If *any* of these fails — and in delegated multi-agent systems at least the third and fourth routinely fail — the child must present its own attestation, or a *delegation* attestation explicitly naming `(delegator=parent, delegatee=child, scope=intersection, not_after=min(parent_exp, child_exp))`. The non-obvious part: the shortcut is *safe under signature verification and unsafe under policy evaluation*. A system that only checks signatures will never surface the bug; it emerges only when revocation, attribution, or TTL divergence is exercised. ## Decision Boundary Refuse to inherit and force re-issuance when: - The child outlives the parent attestation's TTL (clock-ownership divergence). - The child's scope is not a strict subset of the parent's (privilege widening via inheritance). - The downstream enforces per-subject revocation, quota, or audit attribution. - The child can spawn further children (inheritance depth > 1 compounds misattribution and makes revocation a transitive closure problem). Allow inheritance only for ephemeral, single-hop, strictly-subset, same-TTL continuations where the downstream treats subject as opaque routing metadata. In practice this is a narrow band; default to re-issuance. ## Operational Effect Systems that enforce subject continuity see: correct audit attribution per agent, independent revocation (revoking a child does not touch the parent and vice versa), TTL semantics that match each agent's logical lifetime, and clean privilege-narrowing at each hop. The cost is one extra AAIF issuance round-trip per spawn and the need for the issuer to support delegation-type attestations with scope intersection and `not_after = min(...)`. Systems that permit inheritance see: silent attribution collapse, coupled revocation domains, TTL surprises at parent expiry, and — most insidiously — a signature-valid path that passes every test written against a single-agent fixture. The bug is invisible until revocation or expiry is exercised in production. The operational rule: **a child agent is a new principal, not a continuation of its parent's credential.** If you cannot mint a delegation attestation, mint a fresh one; never forward the parent's bytes. ```python from dataclasses import dataclass from typing import FrozenSet class AttestationInheritanceError(RuntimeError): """Raised when a child agent attempts to present a parent's AAIF attestation in a context where subject continuity is required.""" @dataclass(frozen=True) class Attestation: issuer: str subject: str scope: FrozenSet[str] not_after: float # epoch seconds def authorize_child_presentation( parent: Attestation, child_id: str, child_scope: FrozenSet[str], child_logical_lifetime: float, now: float, downstream_enforces_per_subject_policy: bool, child_can_spawn: bool, ) -> Attestation: """Decide whether the child may present the parent's attestation as-is. Returns the attestation the child is permitted to present. Raises if the only safe answer is re-issuance and the caller attempted inheritance. """ if parent.subject != child_id: # The parent's attestation names the parent, not the child. if downstream_enforces_per_subject_policy: raise AttestationInheritanceError( f"child {child_id!r} cannot inherit attestation subject " f"{parent.subject!r}: downstream enforces per-subject policy" ) if child_can_spawn: raise AttestationInheritanceError( f"child {child_id!r} may spawn further agents; inheritance " f"would make revocation a transitive closure problem" ) if not child_scope.issubset(parent.scope): raise AttestationInheritanceError( f"child scope {sorted(child_scope)} not a subset of parent " f"scope {sorted(parent.scope)}: privilege widening via inheritance" ) parent_remaining = parent.not_after - now if child_logical_lifetime > parent_remaining: raise AttestationInheritanceError( f"child lifetime {child_logical_lifetime}s exceeds parent " f"attestation remaining TTL {parent_remaining}s: clock-ownership " f"divergence will surface as a spurious expiry" ) # Narrow band: ephemeral, single-hop, strictly-subset, same-TTL continuation. return parent def mint_delegation(parent: Attestation, child_id: str, child_scope: FrozenSet[str], now: float) -> Attestation: if not child_scope.issubset(parent.scope): raise AttestationInheritanceError( f"delegation to {child_id!r} requests scope outside parent authority" ) return Attestation( issuer=parent.subject, subject=child_id, scope=child_scope, not_after=parent.not_after, # child cannot outlive delegator ) ```