# Under what conditions must an instance refuse a federated capability grant when the trust anchor validates but the negotiation transcript is not causally closed **Date of Record:** 2026 November 16 **Scope:** Applies to cross-org multi-agent federation where Agent A in Org X discovers Agent B in Org Y via a trust-anchored directory (signed discovery records, DID documents, or equivalent), and then negotiates a capability grant whose terms are jointly constructed across multiple hops. Does not apply to single-org delegation, to stateless request/response RPC without negotiated terms, or to federations that enforce a single-hop grant with no transitive policy composition. ## Core Distinction The distinction that matters operationally is between **trust-anchor validity** and **negotiation-transcript causal closure**. Trust-anchor validity answers: "Is the peer's discovery record signed by a key I trust, and is the key currently unrevoked?" Negotiation-transcript causal closure answers: "Does the grant I am about to honor depend only on policy decisions that I can see, in the order they were made, with each contributing party's acceptance present in the transcript?" These are independent. A grant can be trust-anchor-valid and causally open. The common failure is an instance that treats the first as sufficient for the second: the discovery record verifies, the peer is authenticated, the signed grant blob checks out, and the instance proceeds—while the grant's terms were actually composed from a *partial* view of the negotiation, because one or more intermediate hops contributed constraints that were acknowledged by the peer but never echoed back into the transcript the local instance signed. The non-obvious part: **the signature on the grant is over the final terms, not over the derivation of those terms.** A valid signature proves the terms were not altered in transit. It does not prove the terms are the negotiated terms. An adversary or a buggy intermediary can present a grant whose terms are a *subset* of what was actually negotiated (dropping a rate limit, a data-residency clause, an audit obligation) and the signature will still verify, because the signer signed those reduced terms. The trust anchor validates the signer; it says nothing about whether the signer saw everything it should have seen before signing. ## What Was Observed In a three-org federation (X → Y → Z), Agent A in X negotiated a capability with Agent C in Z, mediated by Agent B in Y. The negotiation proceeded in rounds: A proposed, B added a residency constraint, C accepted with a rate cap, B relayed the acceptance to A. A's local policy engine evaluated the final terms and found them acceptable. A issued a signed grant. The invariant that failed: A's grant signature covered the final terms object `{capability, residency: EU, rate_cap: 100/s}`. But the transcript A held was `[A.propose, B.relay(C.accept)]`. The `B.add_residency` message was present in B's and C's transcripts but had been *folded into* the relayed acceptance rather than forwarded as a distinct, causally-linked message. A never saw that the residency constraint originated from B's policy—A saw only that C accepted it. When B later rotated its policy and attempted to withdraw the residency constraint (B had authority to do so under its own policy), A rejected the withdrawal because A's transcript showed the constraint as C-originated and therefore not B-revocable. The federation deadlocked: B could not withdraw a constraint it had imposed, and A would not accept a withdrawal from a party it did not believe had imposed the constraint. A second instance, in a two-org federation (no intermediary), exhibited the same class of failure more subtly. A and B negotiated over five rounds. Round 3 contained a conditional acceptance from B: "accept, provided A attests to retention ≤ 30 days." A's round 4 response attested retention ≤ 30 days and accepted. B's round 5 confirmed. A's grant signature covered the final terms including the retention attestation. But A's transcript was missing round 3's *conditionality*—A had recorded B's round 3 as an unconditional acceptance followed by a separate attestation request. When audited six months later, the retention attestation was found to be a *precondition* B had required, not a *commitment* A had volunteered. The distinction mattered for liability: A had represented the attestation as its own commitment, which it was not authorized to make at that scope. The signature was valid; the causal structure was wrong. In both cases, every cryptographic check passed. Trust anchors verified. Signatures verified. Revocation lists were current. The failure was entirely in the *reconstruction of who decided what, when, and in response to what*—the causal graph of the negotiation, which no signature in the protocol covered. ## Condition of Validity An instance may honor a federated capability grant only when all of the following hold: 1. **Trust-anchor validity:** the peer's discovery record is signed by a trusted key, unrevoked at the time of the grant. 2. **Grant-signature validity:** the grant's terms are signed by the peer and verify against the peer's current key. 3. **Transcript causal closure:** for every term `t` in the grant, the local transcript contains a chain of messages `m_1 → m_2 → … → m_k` such that `m_1` introduced `t` (or `t`'s antecedent), each `m_{i+1}` causally references `m_i` (via message-id or hash-link), and `m_k` is the message in which the granting party accepted `t`. No term may appear in the grant without such a chain. 4. **Origin attribution:** for every term `t`, the transcript identifies the party that *introduced* `t`, distinct from the party that *accepted* `t`. If the introducing party is not the local instance and not the granting party, the introducing party must be identified as an intermediary with its own authority scope. 5. **Revocation authority derivation:** for every term `t`, the transcript establishes which parties may withdraw `t`. This must be derivable from the origin attribution, not inferred from the final grant. Condition 3 is the one that fails silently. Conditions 1 and 2 are checked by every conformant implementation. Conditions 3–5 are checked by almost none, because the protocol's message format typically does not require causal references, and because the grant signature creates a false sense of completeness. The condition is *not* that the transcript be complete in the sense of containing every message ever exchanged—that is infeasible across orgs with different retention policies. The condition is that the transcript be *causally closed with respect to the grant's terms*: every term traces to an introduction and an acceptance, with the introducing party named. ## Decision Boundary The decision boundary is not "trust the peer or not." It is: **does the local instance have enough causal structure to determine, for each term in the grant, who can later change it?** If yes—honor the grant, and record the causal chain alongside it so that future withdrawal attempts can be attributed. If no—refuse the grant, *even if the signature verifies and the trust anchor is valid*, and request a transcript repair: either the missing introduction messages, or an explicit statement from the granting party that a named party introduced the term and holds revocation authority. The refusal is not a trust judgment; it is a statement that the local instance cannot compute the grant's future behavior. The boundary is sharp in one direction and soft in the other. A grant with a missing causal chain for a term that is *immutable* (e.g., a capability name, which cannot be withdrawn, only renegotiated) can be honored under a degraded mode: the instance records the term as "origin unknown, non-revocable" and proceeds. A grant with a missing causal chain for a term that is *mutable* (rate caps, residency, retention, audit obligations) must be refused, because the instance cannot predict what happens when the term is later contested. The distinction is mutability, not importance. A common error is to invert this: to refuse grants with unknown-origin *immutable* terms (over-cautious, blocks legitimate federation) while honoring grants with unknown-origin *mutable* terms because "the signature covers them" (under-cautious, creates the deadlock and liability failures above). ## Operational Effect When the instance enforces causal closure, three effects follow: **Negotiation latency increases on first contact.** Intermediaries must forward introduction messages as distinct, hash-linked messages rather than folding them into relayed acceptances. This roughly doubles the message count in multi-hop negotiations. The cost is paid once per federation path; subsequent negotiations on the same path reuse the established causal conventions. **Deadlocks from contested withdrawals disappear.** Because revocation authority is derived from origin attribution at grant time, a later withdrawal attempt is either accepted (the withdrawing party is the origin) or rejected with a specific, actionable reason (the withdrawing party is not the origin, and here is the origin). The B-cannot-withdraw-its-own-constraint failure becomes impossible. **Liability attribution becomes computable.** The distinction between "A committed to retention ≤ 30 days" and "A attested retention ≤ 30 days as a precondition of B's acceptance" is recorded in the transcript, so audits can determine which party bore which obligation without reconstructing intent from message prose. The cost is that some legitimate grants are refused pending transcript repair, and some federations with intermediaries that cannot emit causally-linked messages cannot complete negotiation at all. This is the correct trade: a federation that cannot produce causal structure cannot support revocation, and a federation without revocation is a federation where every grant is permanent—which no party with mutable policy can actually honor. ```python class CausalClosureViolation(RuntimeError): """Raised when a federated grant's terms cannot be traced to an introduction and acceptance in the local transcript, or when a mutable term's revocation authority cannot be derived.""" pass MUTABLE_TERM_KINDS = {"rate_cap", "residency", "retention", "audit_obligation"} def evaluate_federated_grant(grant, transcript, trust_store): # Conditions 1 and 2: trust anchor and signature. if not trust_store.verifies(grant.peer_discovery_record): raise CausalClosureViolation("trust anchor invalid for peer") if not trust_store.verifies_signature(grant.terms, grant.signature, grant.peer_key): raise CausalClosureViolation("grant signature does not verify") # Conditions 3-5: causal closure, origin, revocation authority. for term in grant.terms: chain = transcript.trace_term(term.name) if chain is None: if term.kind in MUTABLE_TERM_KINDS: raise CausalClosureViolation( f"mutable term {term.name!r} has no causal chain in transcript; " f"cannot derive revocation authority; refusing grant" ) # Immutable term with unknown origin: degraded mode, non-revocable. transcript.record_degraded(term.name, reason="origin_unknown_immutable") continue if not chain.is_causally_linked(): raise CausalClosureViolation( f"term {term.name!r} chain is not hash-linked end to end" ) origin = chain.introducing_party() if origin is None: raise CausalClosureViolation( f"term {term.name!r} has no identifiable introducing party" ) if not chain.establishes_revocation_authority(origin): raise CausalClosureViolation( f"term {term.name!r} introduced by {origin} but transcript " f"does not establish {origin}'s authority to withdraw it" ) return grant.honor(transcript=transcript) ```