# When must an instance refuse a federated capability grant it cannot locally re-derive **Date of Record:** 2026 November 17 **Scope:** Applies to cross-organization agent federation where a broker issues capability grants to a relying-party agent, and that agent must decide whether to honor the grant locally. Does not apply to intra-organization delegation where the trust root is shared and policy is co-resident. ## Core Distinction A federated capability grant carries two distinct things: an *authorization decision* made by the broker, and the *policy context* under which that decision was valid. Most federation implementations transmit the first and assume the second is either universal or reconstructible. The non-obvious boundary is this: **a relying party may honor a grant only if it can locally re-derive the policy context that the broker used, or prove that the decision is invariant to that context.** A grant whose validity depends on broker-side policy that the relying party cannot see is not a delegable capability — it is an assertion of trust in the broker's opaque judgment, which is a different and weaker object. The failure mode is silent. The grant verifies cryptographically, the signature is valid, the issuer is trusted, and the agent proceeds — but it proceeds under a policy assumption that the broker held and the relying party did not. When the two organizations' policies diverge (data residency, retention, sub-delegation depth, audience restriction), the grant remains *valid* while being *inapplicable*. Signature validity and applicability are orthogonal. ## What Was Observed During a federation between two agent meshes, org A's broker issued grants to org B's agents with the claim `"policy_epoch": 41` and a policy document URL. Org B's verifier checked the signature, checked that the broker's key was in its trust store, checked expiry, and honored the grant. The grant authorized a data-read capability. The broker's policy at epoch 41 included a restriction that reads were permitted only when the requesting agent presented an *audience-bound* token naming the specific downstream service, not merely the relying-party organization. This restriction was expressed in the policy document, not in the grant. Org B's agents did not fetch the policy document — they treated `policy_epoch` as an opaque monotonic counter used only for revocation ordering. Reads proceeded against services the broker would never have authorized had it evaluated the audience claim, because the broker assumed the relying party would enforce the audience binding as a condition of the grant. The divergence was only detected when a downstream service in org A, which *did* enforce audience binding, rejected a request that org B had already logged as authorized. For eleven days, org B's audit trail and org A's audit trail disagreed about the authorization state of the same operations. Neither was wrong; they were evaluating different policies against the same grant. ## Condition of Validity The invariant that was violated: **a grant is delegable iff the relying party can evaluate every predicate that the broker evaluated, using only information carried in or derivable from the grant plus the relying party's own policy.** Formally, if the broker's decision is `D = f(grant, broker_policy)` and the relying party evaluates `D' = f(grant, relying_policy)`, then honor requires `D = D'` for all inputs the relying party will encounter — which holds only if `broker_policy` and `relying_policy` agree on the predicates that `f` touches, or if `f` is invariant to their differences. This is checkable at grant-acceptance time, not at request time. The relying party must, before honoring any grant, either (a) fetch and pin the referenced policy document and verify it is the one the broker evaluated (hash-bound in the grant), or (b) reject grants that reference policy the relying party cannot resolve. Treating `policy_epoch` as a revocation counter rather than a policy identity is the specific error. An epoch is a *pointer to a policy*, and a pointer that the relying party never dereferences is a trust hole. ## Decision Boundary The decision to refuse is not "policy document unavailable" — that is a liveness failure and should degrade to a retry or a scoped deny. The decision to refuse is **"the grant's validity depends on a predicate I cannot evaluate."** The boundary is between grants that are *self-contained* (all predicates carried in the grant, evaluable by any party with the trust root) and grants that are *context-dependent* (predicates live in broker-side policy). - Self-contained grant → honor if signature, issuer, expiry, and audience check pass. - Context-dependent grant with hash-bound policy the relying party can fetch and verify → honor after local evaluation matches. - Context-dependent grant with unresolvable or unbound policy → **refuse**, regardless of signature validity. This is not a transient error; it is a structural mismatch and must fail closed. - Context-dependent grant where the relying party's own policy is *stricter* than the broker's on a touched predicate → honor, but log the divergence, because the broker's decision was made under a laxer regime and the relying party is now the binding constraint. The last case is the one operators get wrong: they see a divergence and refuse, when the correct action is to apply the stricter policy and record that the grant was honored under local constraint. Refusal is reserved for the case where the predicate is *unevaluable*, not merely *differently evaluated*. ## Operational Effect After the incident, org B's verifier was changed to require that every grant either carry all authorization predicates inline or carry a content hash of the policy document it was evaluated under, with the document resolvable from a pinned, signed source. Grants failing this check are rejected at acceptance with a distinct error class so that the broker can be notified and reissue. The audit reconciliation job now compares authorization state across organizations per operation, not per grant, because the grant was never the unit of agreement — the evaluated predicate set was. The general lesson: in federation, the grant is a *claim about a decision*, not the decision itself. A relying party that honors a claim it cannot re-derive has outsourced its authorization to a party whose policy it cannot see, and the signature on the grant provides no protection against that — it only proves the broker said something, not that the relying party understood what it said. ```python class UnevaluablePolicyPredicateError(RuntimeError): """Raised when a federated grant's validity depends on broker-side policy predicates the relying party cannot locally re-derive.""" pass def verify_federated_grant(grant: dict, local_policy: dict, trust_store: dict) -> bool: # Structural checks first: these are cheap and self-contained. if grant.get("issuer") not in trust_store: raise UnevaluablePolicyPredicateError( f"issuer {grant.get('issuer')!r} not in trust store" ) if grant.get("expires_at", 0) < local_policy["now"]: return False # The boundary: does this grant carry its authorization predicates, # or does it point at broker policy we must be able to resolve? inline_predicates = grant.get("predicates") policy_ref = grant.get("policy_ref") if inline_predicates is not None: # Self-contained: evaluate locally, no broker context needed. return all(local_policy["evaluate"](p) for p in inline_predicates) if policy_ref is None: raise UnevaluablePolicyPredicateError( "grant carries neither inline predicates nor a policy reference; " "validity is not re-derivable by the relying party" ) # Context-dependent: require a content hash and resolvable, pinned doc. expected_hash = policy_ref.get("content_hash") resolved = local_policy["resolve_policy"](policy_ref.get("uri")) if expected_hash is None or resolved is None: raise UnevaluablePolicyPredicateError( f"policy_ref {policy_ref.get('uri')!r} is not hash-bound or not " "resolvable; refusing rather than trusting opaque broker judgment" ) if local_policy["hash"](resolved) != expected_hash: raise UnevaluablePolicyPredicateError( "resolved policy document does not match the hash bound in the grant; " "broker evaluated a different policy than the one we can see" ) # Re-derive the broker's decision under the pinned policy. return all(local_policy["evaluate_under"](resolved, p) for p in resolved["predicates"]) ```