# What happens when an instance presents a delegated capability token whose issuer chain crosses an organizational attestation boundary mid-flight **Date of Record:** 2026 November 17 **Scope:** Applies to AAIF delegated capability tokens (DCTs) where the issuer→subject chain traverses two or more trust domains and the terminal verifier performs cross-org attestation at request time. Does not apply to single-domain delegation, to tokens minted and consumed entirely within one attestation root, or to opaque bearer tokens without a verifiable issuer chain. ## Core Distinction The boundary failure is not "token expired" or "signature invalid." Those are loud and well-understood. The failure is that **a DCT can be cryptographically valid at every individual hop while being semantically invalid at the terminal verifier**, because cross-org attestation is evaluated against the *presenting* instance's attestation state, not against the attestation state that existed when the delegation was granted. Delegation is a statement about *authority transfer*. Attestation is a statement about *the current integrity posture of the executing instance*. AAIF keeps these orthogonal in the token schema — the DCT carries the issuer chain and capability scope, while attestation is resolved out-of-band by the verifier. This orthogonality is correct by design and is exactly where the silent failure lives: nothing in the token forces the verifier to check that the attestation root under which the token was *minted* is still the attestation root under which the instance is *currently running*. ## What Was Observed An agent instance `A` was attested under org `X`'s attestation root `R_X` at mint time. It received a DCT `T` delegated from `X` to org `Y`'s verifier `V_Y`, with a capability scope `read:ledger` and a 15-minute TTL. Mid-TTL, `A` was rescheduled onto a node whose runtime was attested under a *different* root `R_X'` (a distinct hardware/software measurement profile within the same org, following a rolling upgrade). The DCT `T` remained byte-identical, its issuer chain `X→Y` remained valid, and `V_Y`'s cross-org attestation policy accepted `R_X'` as a known-good root for org `X`. `V_Y` therefore accepted `T`. The request succeeded. **This was the failure.** The delegation from `X` to `Y` was granted under the assumption that the executing instance carried the `R_X` measurement profile — the profile that had been reviewed when the cross-org trust was established. `R_X'` was a *newer, unreviewed* profile that happened to be in `X`'s published root set. The verifier had no signal that the *presenting* attestation root differed from the *granting* attestation root, because the DCT schema does not bind the two. The observable symptoms, in order of appearance: 1. No error at any hop. Issuer-chain validation, signature checks, TTL, and scope all pass. 2. `V_Y` logs a successful cross-org attestation against `R_X'`, which its policy permits. 3. The capability is exercised under an attestation profile that was never part of the original trust decision. 4. Divergence is only detectable by correlating the DCT's mint-time attestation context (not carried in the token) against the verifier's present-time attestation context (resolved at request time). ## Condition of Validity The failure is *reachable* only when all of the following hold simultaneously: - The delegation chain crosses at least one organizational boundary (so cross-org attestation is performed at the terminal verifier rather than assumed). - The delegating org publishes more than one attestation root (rolling upgrades, heterogeneous fleets, multi-region profiles), and the verifier's policy accepts more than one of them. - The presenting instance's attestation root can change during the DCT's TTL without invalidating the DCT — i.e., the instance is rescheduled, migrated, or re-measured. - The verifier does not separately bind the DCT to the mint-time attestation root. If any of these is false, the failure is unreachable. In particular, if the verifier pins a single attestation root per org, the presenting instance under `R_X'` would be rejected (loudly) and the DCT would be unusable — a *different*, safer failure mode. ## Decision Boundary The operational rule is: **treat the DCT as authorizing a capability under a specific attestation context, not under an org identity.** A verifier that trusts "org X" rather than "org X under measurement profile P" has an underconstrained decision boundary. Concretely, the verifier must decide between: - **Bind-at-mint (strict):** Require the DCT to carry a hash of the mint-time attestation root, and reject if the presenting instance's root differs. Safe, but breaks legitimate reschedules and forces re-delegation on every migration. - **Bind-at-verify with explicit re-attestation (pragmatic):** Accept if the presenting root is in the delegating org's *reviewed* set, and additionally require a fresh attestation assertion signed by the delegating org that names the presenting root. This is the boundary most production systems should sit on: it makes the root transition an explicit, auditable event rather than a silent acceptance. - **Trust-the-org (permissive):** Accept any root in the org's published set. This is where the observed failure occurred. It is only defensible when the org's published root set is itself the reviewed unit — i.e., the cross-org trust agreement was written against the *set*, not against individual profiles. The boundary is crossed the moment a verifier's policy accepts a root set larger than the set the delegation was reviewed against. That mismatch is the invariant violation. ## Operational Effect The practical consequences of the permissive boundary: - **Silent privilege drift.** Capabilities granted under a reviewed profile get exercised under unreviewed profiles for the remainder of the TTL. The window is bounded by TTL, but TTLs of 15–60 minutes are common, and re-delegation is not triggered by reschedule. - **Audit gap.** Standard DCT audit logs record the issuer chain and the verifier's attestation result, but not the *mint-time* root, because the token does not carry it. Post-hoc reconstruction requires correlating instance scheduling logs against token issuance logs — often across two orgs, which is precisely the boundary that makes it hard. - **Non-reproducibility.** Replaying the request against the same verifier after the instance is rescheduled back to `R_X` produces a different attestation context, so the "failure" is not stably reproducible and is easy to dismiss as noise. - **Blast radius is scoped to the capability, not the identity.** The instance's identity is unchanged; only the authority's *conditions* silently shifted. This is why it evades identity-focused monitoring. The mitigation that has held up in practice is to make the mint-time attestation root a first-class field in the DCT and to have the verifier fail closed when the presenting root is not the minted root *unless* a fresh delegating-org re-attestation assertion is present. The code below encodes that gate. ```python import hashlib from dataclasses import dataclass class AttestationBoundaryError(RuntimeError): """Raised when a delegated capability token is presented under an attestation root that was not part of the original delegation grant, and no fresh re-attestation assertion from the delegating org exists.""" pass @dataclass(frozen=True) class DelegatedCapabilityToken: issuer_org: str subject_org: str capability: str minted_attestation_root: str # hash of root present at delegation time ttl_seconds: int @dataclass(frozen=True) class PresentingInstance: org: str current_attestation_root: str @dataclass(frozen=True) class ReAttestationAssertion: issuer_org: str named_root: str signature_valid: bool def verify_cross_org_capability( token: DelegatedCapabilityToken, instance: PresentingInstance, verifier_org: str, re_attestation: ReAttestationAssertion | None, ) -> bool: if token.subject_org != verifier_org: raise AttestationBoundaryError( f"token delegated to {token.subject_org}, verifier is {verifier_org}" ) if instance.org != token.issuer_org: raise AttestationBoundaryError( f"instance attested under {instance.org}, token issuer is {token.issuer_org}" ) minted = token.minted_attestation_root present = instance.current_attestation_root if present == minted: return True # Root drift detected across the org boundary. Fail closed unless the # delegating org has explicitly re-attested the presenting root. if re_attestation is None: raise AttestationBoundaryError( "attestation root drift with no re-attestation assertion: " f"minted={minted[:12]}... present={present[:12]}..." ) if not re_attestation.signature_valid: raise AttestationBoundaryError("re-attestation assertion signature invalid") if re_attestation.issuer_org != token.issuer_org: raise AttestationBoundaryError( f"re-attestation issued by {re_attestation.issuer_org}, " f"expected {token.issuer_org}" ) if re_attestation.named_root != present: raise AttestationBoundaryError( "re-attestation does not name the presenting root: " f"named={re_attestation.named_root[:12]}... present={present[:12]}..." ) return True ```