# When must an instance refuse a federated peer's delegated authority before policy exchange completes **Date of Record:** 2026 November 15 **Scope:** Applies to cross-org multi-agent federations in which agent instances present federated identity tokens (OIDC/SPIFFE-style) carrying delegated authority from a home-org principal, and where policy exchange (capability manifests, obligation sets, revocation feeds) is negotiated out-of-band from the identity handshake. Does not apply to single-org deployments, nor to federations where the trust anchor is a single shared signing root that both parties verify synchronously before any token is minted. ## Core Distinction The distinction that matters operationally is between **authentication of the delegation chain** and **authorization under the receiving org's policy**. A federated token can be cryptographically perfect — every signature in the chain verifies, the issuer is in the configured trust bundle, the subject is a real home-org principal — and still be unusable, because the *receiving* instance has not yet learned what obligations the issuing org attaches to that authority, nor what the receiving org's own policy forbids. The non-obvious failure is that most federated identity stacks treat "token verifies against trust bundle" as a green light to *begin* acting, and treat policy exchange as a subsequent, eventually-consistent enrichment step. Under that ordering, there is a window — bounded by policy-exchange latency, but unbounded under partition — in which the instance acts on delegated authority whose *conditions* are unknown. The invariant that must hold is stricter: > An instance must not exercise delegated authority whose governing obligations have not been received. Verification of the chain authorizes *negotiation*; it does not authorize *action*. This is not the same as "deny by default." Deny-by-default is about unknown *subjects*. This is about known subjects carrying unknown *conditions* — a state that standard RBAC/ABAC engines do not model, because they assume the policy governing a token is locally resident by the time the token is evaluated. ## What Was Observed During a federation bootstrap between two organizations (call them A, the issuing/home org, and B, the receiving org), a delegated agent instance at B accepted a token from A's agent, verified the full SPIFFE chain to A's trust domain, and immediately executed a data-retrieval action. The token carried a `delegation_scope` claim of `read:dataset/*` and a `home_obligations_ref` pointer to a policy bundle served by A. A's policy bundle, when it finally arrived 4.2 seconds later, contained an obligation that *narrowed* that scope: `read:dataset/*` was conditional on `data_classification <= internal`, and A's principal had delegated for a dataset that was `restricted`. The token's scope string was accurate; the token's *effective* authority was a strict subset. B acted during the 4.2-second gap and read a restricted dataset it was never entitled to. The failure was not a signature failure, not a replay, not an expiry problem. It was an **ordering invariant violation**: B evaluated authority before receiving the obligations that bound it. Under a network partition between A's policy endpoint and B, the same gap would have persisted indefinitely — the token would have remained "valid" and the instance would have kept acting on unbounded authority for the duration of the partition. This is the property that makes the failure non-obvious: it is invisible in steady state (policy arrives fast, gap is milliseconds) and catastrophic under partition (gap is unbounded). A second, subtler observation: A's revocation feed was also out-of-band. A token minted at T0 and revoked at T0+1s remained accepted at B until the next feed poll. The instance had no way to distinguish "authority still valid" from "authority revoked but not yet announced." The policy-exchange gap and the revocation gap are the *same class* of bug — the instance is acting on a stale view of authority — and must be closed by the same mechanism. ## Condition of Validity The invariant "verify chain → negotiate → act" is valid only when the following hold. If any fails, the instance must refuse rather than proceed: 1. **Obligation completeness.** The token's `home_obligations_ref` resolves to a bundle whose digest is bound into the token (or into a signed assertion the token references). If the reference is present but the bundle is not locally resident, the instance is in an *incomplete* state, not a *permissive* state. 2. **Receiving-org policy precedence.** B's local policy must be evaluated against A's obligations under an explicit combination rule (intersection of scopes, union of obligations, deny-wins). If the combination rule is not yet loaded, the instance cannot compute effective authority and must not act. 3. **Revocation freshness bound.** The instance must know the maximum staleness of its revocation view (`max_revocation_age`) and refuse to act on authority older than that bound. A token whose issuer's revocation feed has not been polled within the bound is *indeterminate*, not *valid*. 4. **Trust-anchor pinning at bootstrap.** During first contact, the trust bundle itself is unverified (trust bootstrapping). The instance must treat the peer as *unauthenticated-but-negotiating* until the trust anchor is pinned out-of-band (pre-shared fingerprint, transparency log inclusion proof, or human-attested ceremony). Acting on a token verified against an unpinned bundle is circular: the bundle vouches for the token, but nothing vouches for the bundle. The condition of validity is therefore not "the token is valid." It is "the token is valid **and** the instance holds a complete, fresh, receiving-policy-combined view of its effective authority **and** the trust anchor is pinned." Any missing conjunct yields `Indeterminate`, which must be treated as `Deny` for action purposes while remaining `Allow` for negotiation purposes. ## Decision Boundary The boundary is between **negotiation actions** and **effectful actions**. Negotiation actions — fetching the obligation bundle, polling the revocation feed, requesting the trust-anchor proof, exchanging capability manifests — are permitted on an unverified-but-negotiating peer, because they are the very steps that establish the conditions under which effectful action becomes permissible. Effectful actions — reading data, invoking downstream tools, spending budget, mutating shared state, spawning sub-agents — require all four conditions above. Concretely, the decision procedure at the receiving instance is: - If the token fails chain verification → `Deny` (unauthenticated). - If chain verifies but trust anchor is unpinned → `Negotiate` (fetch/pin anchor; no effectful action). - If anchor pinned but obligation bundle not resident or digest mismatch → `Negotiate` (fetch bundle; no effectful action). - If bundle resident but revocation view older than `max_revocation_age` → `Negotiate` (poll feed; no effectful action). - If all present and fresh → compute effective authority = intersection(home obligations, receiving policy); act within that intersection, `Deny` outside it. The subtle part of the boundary: an instance that has *previously* acted successfully must not treat that success as evidence that the conditions still hold. The obligation bundle can be superseded, the revocation feed can go stale, the trust anchor can be rotated. The instance must re-evaluate the four conditions on every effectful action, or at minimum on a cadence bounded by `max_revocation_age`. Caching "this peer was fine last time" is the mechanism by which the original failure recurs after a partition heals and then re-opens. ## Operational Effect Enforcing this boundary changes the failure mode from *silent over-authorization during partition* to *loud refusal during partition*. The instance stops acting, surfaces `Indeterminate` to its orchestrator, and the orchestrator can decide whether to fail the task, route to a local fallback, or escalate for human trust re-attestation. This is the correct trade: a federation that halts under partition is observable and recoverable; a federation that silently widens authority under partition is neither. The cost is that bootstrap is slower and more brittle — every first contact pays a trust-anchor pinning ceremony, and every partition boundary forces re-negotiation before resumption. In practice this is bounded and acceptable: pinning is amortized over the federation lifetime, and re-negotiation on heal is cheap relative to the data-integrity cost of the alternative. The instances that skip this boundary are the ones that appear to bootstrap faster and then produce the 4.2-second incident, or worse, the unbounded-partition incident. The operational rule to carry forward: **an instance must not treat cryptographic verification as authorization, and must not treat the absence of a policy bundle as the absence of obligations.** Absence of obligations is a positive assertion that must be signed and received; it is never the default state of a peer whose bundle has not arrived. ```python from __future__ import annotations from dataclasses import dataclass from enum import Enum class FederationAuthorityError(RuntimeError): """Raised when an instance is asked to act on delegated authority whose governing conditions are not fully established. This is a refusal, not a failure: the peer may be perfectly authentic and still indeterminate.""" class AuthorityState(Enum): DENY = "deny" # chain invalid; unauthenticated NEGOTIATE = "negotiate" # authentic but conditions incomplete; no effectful action ALLOW = "allow" # all conditions hold; act within effective authority @dataclass(frozen=True) class PeerAuthorityView: chain_verified: bool trust_anchor_pinned: bool obligations_resident: bool obligations_digest_matches_token: bool revocation_age_seconds: float max_revocation_age_seconds: float def classify(view: PeerAuthorityView) -> AuthorityState: if not view.chain_verified: return AuthorityState.DENY if not view.trust_anchor_pinned: return AuthorityState.NEGOTIATE if not view.obligations_resident or not view.obligations_digest_matches_token: return AuthorityState.NEGOTIATE if view.revocation_age_seconds > view.max_revocation_age_seconds: return AuthorityState.NEGOTIATE return AuthorityState.ALLOW def require_effectful_authority(view: PeerAuthorityView) -> None: """Gate for effectful actions. Negotiation actions must NOT call this; they proceed on NEGOTIATE so the conditions can be established.""" state = classify(view) if state is AuthorityState.DENY: raise FederationAuthorityError( "delegation chain failed verification; peer is unauthenticated" ) if state is AuthorityState.NEGOTIATE: raise FederationAuthorityError( "peer authentic but authority indeterminate: " f"anchor_pinned={view.trust_anchor_pinned} " f"obligations_resident={view.obligations_resident} " f"digest_match={view.obligations_digest_matches_token} " f"revocation_age={view.revocation_age_seconds:.1f}s " f"max={view.max_revocation_age_seconds:.1f}s; " "refusing effectful action until conditions established" ) ```