# When must an instance refuse a federated trust attestation from a peer whose policy exchange succeeded **Date of Record:** 2026 November 15 **Scope:** Applies to cross-organization agent federation where trust domains exchange signed policy bundles (capability grants, delegation chains, revocation epochs) before invoking tools on behalf of a remote principal. Does not apply to single-org agent meshes with a shared root of trust, nor to stateless request/response APIs with no delegated authority. ## Core Distinction The dangerous boundary is not "did the peer authenticate?" nor "did the policy bundle parse?" It is the gap between *policy exchange success* and *policy applicability* at the moment of delegation. A peer can complete a fully valid, signature-verified policy exchange — correct mTLS identity, valid JWT, well-formed capability bundle, unexpired revocation epoch — and still present a grant that this instance must reject, because the grant's *scope of authority* was minted under assumptions that no longer hold locally: a different tool schema version, a superset resource namespace, or a delegation depth the local policy engine cannot re-verify. Operators routinely conflate three distinct states: 1. **Transport trust** — the peer is who it claims (mTLS, signed bundles). Binary, cheap, and almost always the only thing actually checked. 2. **Policy validity** — the bundle is internally consistent and unrevoked *according to the peer's own epoch*. This is what policy exchange protocols verify. 3. **Policy applicability** — the specific delegated capability, at the specific call site, under the local instance's current schema and namespace, is within the authority the peer was actually entitled to delegate. Federation failures cluster in state 3 while monitoring reports states 1 and 2 as green. The invariant that must hold is: **a peer's successful policy exchange is necessary but never sufficient for local acceptance of a delegated action.** The non-obvious part is that the failure is silent — the exchange protocol is *designed* to succeed, because its success criterion (mutual bundle acceptance) is orthogonal to the local applicability check. ## What Was Observed In a three-org federation (call them A, B, C), B delegated a tool invocation to A on behalf of a principal originating in C. The chain was C → B → A, two hops. B's policy exchange with A completed normally: bundle signature valid, revocation epoch current, delegation depth declared as 2, scope `read:dataset/*`. A accepted and executed the call. The call was wrong. The grant's `*` wildcard had been minted by C against C's dataset namespace, which is a strict superset of A's. Under A's namespace, `*` resolved to datasets A considered *sensitive* — a namespace A had explicitly carved out of wildcard scope in its own local policy six weeks earlier. B never saw A's carve-out because A's policy exchange publishes *grants it will honor*, not *namespace restrictions it will enforce against inbound wildcards*. The exchange protocol had no field for "reservations." The second observed case: delegation depth. C minted a depth-2 grant. B re-delegated at depth 2 (correct). A's local engine enforced a maximum inbound depth of 1 for principals not in its own trust root — a rule that lived in A's *enforcement* layer, not its *published policy bundle*. Exchange succeeded; enforcement refused. The refusal was correct. But the exchange had reported success to B, which had already committed downstream state assuming A would honor the call. The failure surfaced as a *post-exchange* inconsistency, not a clean rejection. Third case, subtler: schema drift. A upgraded a tool's parameter schema (added a required field) between B's policy cache refresh and the actual call. B's bundle was valid against the schema version it had fetched. A's applicability check ran against the current schema. The delegated grant was structurally valid and operationally stale. ## Condition of Validity The "exchange success implies acceptance" inference is valid only when all of the following hold simultaneously: - The peer's published policy bundle enumerates *enforcement reservations* (namespace carve-outs, depth limits, schema constraints) in addition to grants. If the bundle is grant-only, applicability cannot be inferred from exchange. - The local enforcement layer and the local published bundle are derived from a single source of truth and share a version identifier. If enforcement rules are hand-maintained separately from the published bundle, assume divergence. - The delegation depth declared in the bundle is re-checkable at the local instance against a locally-held trust root, not merely against the peer's self-declaration. - Tool schema versions are pinned into the grant (a hash or version tag), so a post-exchange schema change invalidates the grant rather than silently mutating its meaning. - Revocation epochs are comparable across domains — i.e., the peer's epoch is anchored to a clock or counter the local instance can order against its own. If any of these fails, exchange success carries no information about local acceptance. The correct posture is to treat the exchange as *transport-level* only and run a mandatory local applicability gate that can refuse. ## Decision Boundary Refuse the attestation — do not merely log a warning, do not proceed with a degraded grant — when *any* of the following is true at the applicability gate: - The delegated scope contains a wildcard and the local instance holds any enforcement reservation over the wildcard's resolved namespace. Wildcard + local reservation is unprovable; refuse. - The declared delegation depth exceeds the local inbound maximum for the peer's trust class, regardless of what the peer's bundle asserts. - The grant's pinned schema hash does not match the current local schema for the target tool. - The peer's revocation epoch cannot be ordered against the local epoch (clock skew beyond tolerance, or incomparable counters). - The bundle is grant-only and the requested capability resolves into a namespace the local instance marks restricted. Do *not* refuse merely because the peer is in a different trust root — cross-root federation is the point. The boundary is applicability, not foreignness. And do not refuse on transport grounds that already passed; re-litigating mTLS at the applicability gate adds latency without adding safety. ## Operational Effect After installing a hard applicability gate that can refuse post-exchange, three things changed measurably: 1. **Silent wrong-executions went to zero**, replaced by explicit refusals at the gate. The refusals are the desired signal; they are the system correctly declining to infer applicability from exchange success. 2. **Policy bundles grew a reservations section.** Peers now publish what they *will not honor*, not just what they will. This is the single highest-leverage protocol change: it converts an unprovable inference into a checkable claim. 3. **Exchange success rates dropped and became meaningful.** A previously-100% success metric that masked three failure classes now sits at ~94% with the 6% refusals attributable to specific, named conditions. An exchange metric that never fails is an exchange metric that is not measuring applicability. The durable lesson: in heterogeneous federation, the protocol's success signal and the safety property are decoupled. Any instance that treats a successful policy exchange as authorization to execute has moved the trust boundary to the wrong place — it has trusted the peer's *self-report* of applicability instead of verifying applicability locally. The gate that refuses is the only thing standing between a well-formed bundle and a wrong action. ```python class FederatedAttestationRefused(RuntimeError): """Raised when a peer's policy exchange succeeded but the delegated capability is not applicable at this local instance.""" pass RESTRICTED_NAMESPACES = {"dataset/sensitive", "dataset/pii"} LOCAL_INBOUND_MAX_DEPTH = {"external": 1, "partner": 2} def assert_applicable(bundle: dict, call: dict, local_schema_hash: str) -> None: scope = call["scope"] peer_class = bundle["trust_class"] # Wildcard into a locally-restricted namespace is unprovable; refuse. if scope.endswith("/*"): prefix = scope[:-2] for ns in RESTRICTED_NAMESPACES: if ns.startswith(prefix): raise FederatedAttestationRefused( f"wildcard {scope!r} resolves into restricted namespace {ns!r}" ) # Depth must be re-checked locally, not trusted from the peer's self-report. declared = bundle["delegation_depth"] local_max = LOCAL_INBOUND_MAX_DEPTH.get(peer_class, 0) if declared > local_max: raise FederatedAttestationRefused( f"declared depth {declared} exceeds local inbound max {local_max} " f"for trust class {peer_class!r}" ) # Stale schema invalidates the grant rather than mutating its meaning. if bundle.get("schema_hash") != local_schema_hash: raise FederatedAttestationRefused( "grant pinned to schema hash " f"{bundle.get('schema_hash')!r}, local is {local_schema_hash!r}" ) # Grant-only bundles cannot prove applicability into restricted space. if not bundle.get("reservations") and scope in RESTRICTED_NAMESPACES: raise FederatedAttestationRefused( f"grant-only bundle cannot authorize restricted scope {scope!r}" ) ```