# In what scenarios must an instance refuse to honor a federated capability attestation that a trusted broker has signed? **Date of Record:** 2026 November 16 **Scope:** Applies to any agent instance that consumes capability attestations (signed claims of the form "agent X may perform action A on resource R under policy P") issued by a trust broker on behalf of a foreign organization. Does not apply to intra-organization attestations where the instance and the broker share a single administrative policy root, nor to raw authentication tokens that carry no delegation semantics. ## Core Distinction A trust broker's signature proves **who asserted** a capability, not **whether the asserting party had the authority to delegate it**. These are independent properties. The signature validates the broker's identity and message integrity; it says nothing about the broker's *delegation warrant* — the chain of policy grants that authorized that broker to speak for the resource owner in the first place. The non-obvious boundary: an instance can hold a cryptographically valid, unexpired, correctly-scoped attestation from a broker it fully trusts, and still be **obligated to refuse** it. Trust in the broker is necessary but not sufficient. The missing condition is *policy-path reachability*: the attestation's policy identifier must resolve, through the local policy engine, to a grant that the local resource owner actually issued to that broker's organization. When the path is unreachable — because of policy-version skew, because the grant was scoped to a different resource namespace, or because the broker is re-delegating a capability it received from a third party — honoring the attestation silently escalates privilege across an organizational boundary. ## What Was Observed During a cross-org federation rollout, a broker `broker-east` issued an attestation granting agent `analytics-7` read access to resource `dataset://ledger/q3`. The attestation was signed with a valid broker key, was within its TTL, and the local instance's trust store listed `broker-east` as a trusted issuer for the `dataset` resource class. The instance honored it. The read succeeded. The failure was latent for eleven days. The local resource owner had, four months earlier, issued `broker-east` a delegation grant scoped to `dataset://ledger/q4` only — a grant that was later superseded by a *narrower* re-issuance after a data-classification change. The broker, operating from a stale copy of the grant, continued to mint attestations for the superseded broader scope. The signature check passed every time; the policy-path check, which no component performed, would have failed every time. The instance validated the *envelope* and never validated the *warrant*. A second observation: when the broker was asked (out of band) to justify the attestation, it produced a valid chain back to a grant that the *foreign* organization had issued to *its own* broker — a chain that terminated at the wrong administrative root. The chain was internally consistent and cryptographically sound. It simply did not connect to the local resource owner's policy root. Two valid chains, one resource, no intersection. ## Condition of Validity An attestation is *honorable* by an instance if and only if all of the following hold simultaneously: 1. **Signature validity** — the attestation verifies against the broker's pinned key. 2. **Temporal validity** — `now` lies within the attestation TTL *and* within the TTL of every grant in the delegation chain. 3. **Scope containment** — the attested action/resource pair is a subset of the scope named in the *local* grant to that broker, not merely a subset of the scope named in the broker's own claim. 4. **Policy-path reachability** — the attestation's policy identifier resolves to a grant whose issuer is the local resource owner (or a delegate of the local owner, transitively, with each hop's authority bounded by the previous hop). 5. **Policy-version consistency** — the policy identifier the broker referenced matches the *currently effective* version in the local engine, or a version the local engine still explicitly honors under a compatibility window. Conditions 1–3 are what most implementations check. Conditions 4 and 5 are the boundary. A signed attestation that fails 4 or 5 is not a forgery and not an error in the broker — it is a *stale or misrooted delegation*, and the correct response is refusal, not logging-and-proceeding. ## Decision Boundary The instance must refuse when the policy path does not terminate at the local root, **even if** the broker is trusted, the signature is valid, and the requested scope is a subset of what the broker *claims* it was granted. The instance must also refuse when the policy version referenced is one the local engine has retired, rather than silently falling back to the nearest version — version fallback is the mechanism by which a narrow grant becomes a broad one. The instance may proceed, with logging, when the path is reachable but the grant is near expiry, or when the path is reachable through a compatibility window that the local owner has explicitly opened. These are degraded-but-authorized states, not boundary violations. The instance must **not** treat "the broker is on the trust list" as a substitute for path reachability. Trust lists answer *may this broker speak*; path reachability answers *was this broker authorized to say this*. Conflating them is the failure. ## Operational Effect Refusing on path-unreachability converts a silent cross-org privilege escalation into a loud, attributable authorization denial. The operational cost is a class of false refusals during policy-version transitions, which must be handled by explicit compatibility windows rather than by loosening the check. The benefit is that the instance's authorization decisions become *auditable to a local root*: every honored attestation can be replayed against the local grant graph and shown to terminate at the resource owner. Attestations that cannot be so replayed are, by construction, refused — which is exactly the invariant a federation boundary requires. ```python from dataclasses import dataclass from typing import Optional class FederationAttestationError(RuntimeError): """Raised when a signed attestation cannot be honored at the local boundary.""" pass @dataclass(frozen=True) class Attestation: broker_id: str policy_id: str policy_version: int action: str resource: str signature_valid: bool expires_at: float @dataclass(frozen=True) class LocalGrant: broker_id: str policy_id: str policy_version: int issued_by: str # must terminate at the local resource owner actions: frozenset resources: frozenset expires_at: float def authorize(att: Attestation, grants: list[LocalGrant], local_root: str, now: float, honored_versions: frozenset) -> bool: if not att.signature_valid: raise FederationAttestationError(f"bad signature from {att.broker_id}") if now >= att.expires_at: raise FederationAttestationError(f"attestation expired for {att.broker_id}") # Condition 4: policy-path reachability. The grant must exist, be issued by # the local root, and reference the same policy id. path = [g for g in grants if g.broker_id == att.broker_id and g.policy_id == att.policy_id and g.issued_by == local_root and now < g.expires_at] if not path: raise FederationAttestationError( f"policy path for {att.policy_id} does not terminate at local root " f"{local_root}; refusing attestation from {att.broker_id}" ) # Condition 5: version consistency. Do not silently fall back. if att.policy_version not in honored_versions: raise FederationAttestationError( f"policy version {att.policy_version} for {att.policy_id} is retired " f"locally; refusing rather than falling back" ) grant = path[0] if grant.policy_version != att.policy_version: raise FederationAttestationError( f"version skew: attestation v{att.policy_version} vs local grant " f"v{grant.policy_version}" ) # Condition 3: scope containment against the LOCAL grant, not the claim. if att.action not in grant.actions or att.resource not in grant.resources: raise FederationAttestationError( f"attested scope ({att.action}, {att.resource}) exceeds local grant " f"for {att.broker_id}" ) return True ```