# Why does an instance trust a delegated capability after its brokering authority has been revoked? **Date of Record:** 2026 November 16 **Scope:** This applies to federated agent systems where capability tokens are issued through a trust broker and then delegated across organizational boundaries, with delegation chains carrying attenuation and policy constraints. It does not apply to single-domain capability systems where the issuing authority and the verifying authority are the same principal, nor to stateless bearer tokens without provenance chains. ## Core Distinction The distinction that matters is between **revocation of the brokering authority** and **invalidation of the capability instance**. A trust broker issues a capability token `C` to agent `A`, which delegates an attenuated form `C'` to agent `B` in a different organization. When the broker's authority to broker is revoked — because its accreditation lapsed, its signing key was rotated out of the trust root, or its policy mandate was withdrawn — the *broker* is no longer trusted to issue *new* capabilities. But `C'` is a self-contained signed artifact with a validity window and an embedded provenance chain. Verifiers that check only the signature chain and the validity window will accept `C'` for its full remaining lifetime, even though the authority that grounded it has been withdrawn. The non-obvious part: most implementations treat revocation as a property of the *issuer identity* (a CRL-style check against the broker's key or accreditation ID), not as a property of the *capability graph*. Because `C'` was signed by `A`, not by the broker, a naive verifier never consults the broker's revocation status at all. The delegation chain is cryptographically intact; the trust assumption underneath it is gone. ## What Was Observed In a three-organization federation (broker `O1`, delegator `O2`, verifier `O3`), a broker accreditation was revoked at 14:02 UTC. Agent `A` in `O2` had, at 13:40, delegated a `read:dataset` capability to agent `B` in `O3` with a 24-hour validity window. For the next 23 hours and 58 minutes, `B` successfully exercised the capability against `O3`'s resource server. Every verification succeeded because: 1. `C'` carried a valid signature by `A`, whose key was still in `O3`'s trust root. 2. `C'` carried a provenance pointer to `C`, but `O3`'s verifier only *logged* the pointer and did not dereference it. 3. The broker's revocation list was consulted only at *issuance* time by `O2`, never at *verification* time by `O3`. The failure was silent. No error, no warning, no audit anomaly — the capability simply kept working. It was discovered during a routine cross-org audit reconciliation three days later. ## Condition of Validity The capability instance `C'` remains *operationally* valid (signature verifies, window open, policy constraints satisfied) but is *normatively* invalid (its grounding authority is withdrawn). The gap between these two states is the boundary condition. It exists precisely when all of the following hold: - Delegation is **transitive across trust domains**, so the verifier is not the issuer. - The verifier performs **local verification only** — signature chain plus window — without dereferencing the provenance chain to check the root authority's current status. - Revocation is **identity-scoped** rather than **graph-scoped**, so revoking the broker does not cascade to capabilities it grounded. - The capability carries a **validity window longer than the revocation propagation interval**. Remove any one condition and the gap closes. In practice the fourth is the dangerous one, because delegation windows are routinely set to hours or days for operational convenience while revocation propagation is measured in minutes — but only if someone propagates it. ## Decision Boundary The decision an operator must make is whether to treat broker revocation as **retroactive** (cascading to all grounded capabilities, forcing re-verification and potentially breaking in-flight delegations) or **prospective** (blocking only new issuances, leaving existing capabilities to expire naturally). Neither is universally correct. Choose retroactive cascade when the broker's revocation was caused by *compromise* or *policy violation* — the grounded capabilities inherit the untrustworthiness. Choose prospective-only when the revocation was *administrative* (key rotation, accreditation renewal lapse) and the grounded capabilities were issued under valid authority. The boundary is the *reason* for revocation, which is almost never encoded in the revocation record itself. This is the operational trap: the revocation list says *that* the broker is revoked, not *why*, and the correct cascade policy depends entirely on the why. A defensible default: require revocation records to carry a `cause` field (`compromise` | `policy` | `administrative`), cascade on the first two, and treat the third as prospective with a bounded grace window equal to the maximum delegation TTL. If the cause is absent, fail closed and cascade. ## Operational Effect After the incident, `O3`'s verifier was changed to dereference the provenance chain to its root and check the root issuer's status against a federated revocation feed on every verification, caching negative results for no more than 60 seconds. This added one network hop to the verification path (p99 verification latency rose from 4 ms to 19 ms) and required `O3` to subscribe to `O1`'s revocation feed — a new cross-org dependency that itself had to be brokered, recursively. The federation also adopted a hard cap of 4 hours on any delegated capability TTL, on the reasoning that no revocation feed is trusted to propagate faster than that. The cap was unpopular; it was kept because the alternative was an unbounded window of normative invalidity. The general lesson: in trust-brokered federation, *verification must reach the same root that issuance did*. A verifier that checks a signature chain but not the current status of the chain's root is verifying a historical fact, not a present one. ```python class StaleBrokerAuthorityError(RuntimeError): """Raised when a delegated capability's grounding broker is revoked but the capability instance is still within its validity window.""" def verify_delegated_capability(cap, revocation_feed, now): # 1. Local cryptographic checks (signature chain + window). if not cap.signature_chain_valid(): raise StaleBrokerAuthorityError("signature chain broken") if not (cap.not_before <= now <= cap.not_after): raise StaleBrokerAuthorityError("capability outside validity window") # 2. Dereference provenance to the grounding broker. This is the step # that naive verifiers skip, and it is where the boundary lives. root = cap.provenance_root() if root is None: raise StaleBrokerAuthorityError("capability has no provenance root") status = revocation_feed.status_of(root.issuer_id) if status.revoked: # Cause determines cascade policy. Absent cause => fail closed. if status.cause in ("compromise", "policy", None): raise StaleBrokerAuthorityError( f"grounding broker {root.issuer_id} revoked " f"(cause={status.cause}); capability instance is " f"normatively invalid despite open validity window" ) # Administrative revocation: prospective only, allow to expire. return True ```