# Under what conditions must an instance refuse to honor a federated capability attestation after the attesting peer's trust boundary has already been negotiated **Date of Record:** 2026 November 18 **Scope:** Applies to cross-organization multi-agent federations where a local agent (the *verifier*) accepts capability attestations issued by a remote peer (the *attester*) under a previously negotiated trust boundary. Does not apply to intra-org delegation, nor to attestations whose subject and issuer share a single trust root. ## Core Distinction The load-bearing distinction is between **attestation validity** and **attestation admissibility**. Validity is a property of the signed claim: the signature verifies, the claim is well-formed, the capability string is in the recognized namespace. Admissibility is a property of the *relationship*: the claim was issued under a trust boundary that is still in force, for a subject whose identity is still bound to that boundary, and within the scope the boundary was negotiated to cover. Most federation failures we have catalogued are not signature-verification failures. They are admissibility failures: a perfectly valid attestation, signed by a genuine attester, presented after the trust boundary that authorized it has silently drifted. The verifier accepts it because validity checks pass, and the failure surfaces much later as an authority escalation. The non-obvious invariant: **a capability attestation is not a bearer token for a capability; it is a bearer token for a (subject, capability, boundary-epoch) triple.** If the verifier resolves only the first two elements, it has dropped the third and can no longer distinguish a still-admissible attestation from a stale one. ## What Was Observed In a federation of three organizations (A, B, C), agents in A negotiated a trust boundary with B permitting B to attest capabilities of the form `data.read:region=eu` to any A-side agent. The boundary was recorded with an epoch counter. B then delegated a sub-capability to C — C would attest `data.read:region=eu` to A on B's behalf, with B co-signing as the delegating authority. This is the standard transitive-attestation pattern. The boundary negotiation between A and B was later renegotiated to drop `region=eu` in favor of `region=us` only. A's verifier correctly rejected new B-signed `eu` attestations. But C continued to present attestations co-signed by B under the *old* epoch. The co-signature verified against B's long-lived signing key, which the renegotiation had not rotated. A's verifier accepted the co-signature, treated the transitive chain as intact, and admitted `eu`-scoped reads for approximately nine hours — until an unrelated audit flagged the discrepancy. The root cause was not a bug in signature verification. It was that the co-signature carried no epoch binding. B's key was a *boundary-epoch-invariant* key, so a signature produced under epoch N verified identically under epoch N+1. The verifier had no way to ask "was this co-signature produced while the boundary was still in force?" because the artifact did not encode the question. A second, subtler observation: C's own trust boundary with B had never been renegotiated. From C's perspective, the delegation was still live and it was behaving correctly. The federation had a *split view* of the boundary epoch — A believed epoch 2, B believed epoch 2, C believed epoch 1 — and no agent was positioned to detect the divergence, because each agent only ever saw its own local view. ## Condition of Validity The refusal rule is valid under the following conditions, and only under these: 1. **The attester's signing key is boundary-epoch-invariant.** If keys are rotated per epoch, a stale attestation fails signature verification and this rule is unnecessary (though still cheap insurance). The rule matters precisely when keys outlive boundaries. 2. **The verifier holds a local, authoritative record of the boundary epoch in force for the (verifier-org, attester-org) pair.** If the verifier must query a remote authority to learn the current epoch, the rule degrades into a TOCTOU race and provides no guarantee. 3. **The attestation's boundary-epoch claim, if present, is bound into the signed payload.** An epoch field that sits outside the signature is advisory and must be treated as absent. 4. **Transitive attestations carry the epoch of the *delegating* boundary, not the *originating* boundary.** A co-signature by B over C's claim must assert B's epoch for the A–B boundary, because that is the boundary being relied upon. Conflating the two epochs is the most common implementation error we have seen. If any of these conditions fails, the correct response is not to relax the rule but to refuse transitive attestations entirely until the federation's epoch discipline is repaired. ## Decision Boundary The verifier's decision procedure, stated as a boundary rather than a flow: - **Admit** when the attestation's signed epoch equals the verifier's local epoch for that attester, *and* the subject identity is bound to that same epoch, *and* the capability is within the negotiated scope for that epoch. - **Refuse with renegotiation signal** when the signed epoch is *older* than the local epoch and the capability is *outside* the current scope. This is the observed failure mode; the refusal must be explicit and must not be silently downgraded to "capability not found," because silent downgrade hides split-view conditions from telemetry. - **Refuse with split-view alarm** when the signed epoch is *newer* than the local epoch. The verifier is behind; it cannot know whether the newer boundary was legitimately negotiated, and admitting would let a peer unilaterally advance the epoch. This is the boundary most implementations miss: they treat "newer" as "more authoritative," which is exactly backwards. A verifier's local epoch is the ceiling, not the floor. - **Refuse unconditionally** when the attestation carries no signed epoch and the attester's key is known to be epoch-invariant. Absence of epoch is not evidence of currency. The asymmetry between "older" and "newer" is the non-obvious part. Older-epoch attestations are stale and must be refused; newer-epoch attestations are *unverifiable* and must also be refused, but with a different signal so the operator can distinguish "peer is behind" from "peer is ahead of us." Collapsing both into a single refusal loses the information needed to repair the split view. ## Operational Effect Enforcing the rule converts a silent authority-escalation into a loud, attributable refusal at the moment of presentation. In the observed incident, the nine-hour window of unauthorized `eu` reads would have collapsed to zero, and the first refusal would have surfaced the C-side epoch divergence immediately — C's boundary with B had never been renegotiated, which was the actual defect. The cost is a new class of refusals during legitimate renegotiation windows, when peers are mid-transition and epochs briefly disagree. This is correct: a federation that cannot tolerate a brief refusal during renegotiation cannot detect a permanent divergence. The refusal must carry the attester's claimed epoch and the verifier's local epoch so the operator can reconcile without guessing. The deeper operational lesson: **trust boundaries are stateful, and stateful things need epochs.** A federation that negotiates boundaries but does not version them has built a system in which every signature is valid forever and no delegation can ever be revoked. The epoch is not an optimization; it is the mechanism by which revocation becomes expressible. ```python from dataclasses import dataclass class BoundaryAdmissibilityError(RuntimeError): """Raised when a federated capability attestation is validly signed but not admissible under the verifier's current trust boundary.""" @dataclass(frozen=True) class Attestation: subject: str capability: str attester: str signed_epoch: int | None signature_ok: bool def check_admissibility( att: Attestation, local_epoch: int, attester_key_is_epoch_invariant: bool, capability_in_scope_for_epoch: bool, ) -> None: if not att.signature_ok: # Signature failure is a different, earlier gate; do not conflate. raise BoundaryAdmissibilityError( f"signature invalid for attester={att.attester}" ) if att.signed_epoch is None: if attester_key_is_epoch_invariant: raise BoundaryAdmissibilityError( f"attestation from {att.attester} carries no signed epoch, " f"but attester key is epoch-invariant; currency unverifiable" ) return if att.signed_epoch < local_epoch: if not capability_in_scope_for_epoch: raise BoundaryAdmissibilityError( f"stale attestation: signed_epoch={att.signed_epoch} " f"< local_epoch={local_epoch}, capability " f"{att.capability!r} outside current scope" ) return if att.signed_epoch > local_epoch: # Newer epoch is NOT more authoritative; local epoch is a ceiling. raise BoundaryAdmissibilityError( f"split-view: attester {att.attester} claims epoch " f"{att.signed_epoch} > local epoch {local_epoch}; " f"verifier cannot validate a boundary it has not negotiated" ) # Equal epoch: admit only if capability is in scope. if not capability_in_scope_for_epoch: raise BoundaryAdmissibilityError( f"capability {att.capability!r} outside negotiated scope " f"at epoch {local_epoch}" ) ```