# In what scenarios must an instance refuse to propagate a peer's trust assertion after a policy-exchange renegotiation **Date of Record:** 2026 November 15 **Scope:** Applies to federated multi-agent systems where agent instances broker trust on behalf of their home organization to peers in other organizations, and where trust scopes are established or refreshed via explicit policy exchange (capability manifests, delegation tokens, or signed policy bundles). Does not apply to single-organization agent meshes with a shared trust root, nor to stateless request/response gateways that hold no durable delegation state. ## Core Distinction There are two structurally different acts that are routinely conflated under the word "propagation": 1. **Propagating a trust assertion about a peer** — instance A tells instance C that peer B is trustworthy for scope S, where B is not A's own principal. 2. **Propagating a trust assertion to a peer** — instance A tells peer B that A itself asserts scope S on B's behalf, or A relays a policy document that B will apply locally. The first is a *transitive trust claim*. The second is a *delegation or policy relay*. The failure mode documented here lives at the seam: after a policy-exchange renegotiation, an instance is often still holding a *pre-renegotiation* trust assertion about a peer, and the temptation is to treat the fresh policy bundle as re-validating the old assertion. It does not. A policy bundle re-validates the *scope vocabulary* and the *signing chain*; it does not re-validate the *prior transitive claim* that was minted under a different policy epoch. The boundary condition is this: **a trust assertion minted in policy epoch E₁ must not be re-asserted by an instance after it has observed epoch E₂, even if E₂ is a strict superset of E₁ and the peer identity is unchanged.** The non-obvious part: monotonic policy growth (E₂ ⊇ E₁) feels safe. It is not, because trust assertions carry *implicit negative claims* — "B is not known-bad for scope S" — and the renegotiation may have introduced a *revocation channel* or *constraint narrowing on a different scope* that changes the meaning of the prior assertion's silence. The prior assertion was minted under a regime where silence meant "no information"; under the new epoch, silence may mean "explicitly cleared by the revocation feed," and re-asserting the old claim launders the difference. ## What Was Observed In a three-organization federation (call them Org-Alpha, Org-Beta, Org-Gamma), agent instances exchanged signed policy bundles on a 15-minute cadence. A Beta instance, `beta-broker-7`, held a cached trust assertion from Alpha about Gamma's `data-read` scope, minted at epoch 412. At epoch 413, Alpha published a bundle that (a) added a revocation feed for Gamma's `data-read` scope, and (b) left the scope's positive capability set unchanged. The bundle was a superset of 412 in every field a naive diff would check. `beta-broker-7` completed the renegotiation, then — because the assertion's scope string still matched and the peer fingerprint was unchanged — re-asserted the epoch-412 trust claim to a downstream Gamma-facing agent. The downstream agent acted on it. The revocation feed at epoch 413 had, in fact, flagged a Gamma sub-agent for `data-read` degradation. The re-assertion suppressed the only signal that would have caused the downstream agent to re-check. No signature failed; no policy check returned false; the failure was entirely in the *provenance epoch* of the assertion, which no component was tracking. The detectable signature: assertion objects carried `minted_at_epoch` but the re-assertion path compared only `scope` and `peer_fingerprint`, not `minted_at_epoch` against `current_epoch`. A one-line provenance check would have caught it. The reason it was missed is that the renegotiation handler was written to *refresh* assertions, and "refresh" was implemented as "re-emit if still valid," where "valid" meant "scope matches and fingerprint matches" — an epoch-blind predicate. ## Condition of Validity The prohibition on re-asserting pre-renegotiation trust assertions is valid precisely when **all** of the following hold: - The instance has observed a policy epoch strictly newer than the assertion's mint epoch. - The new epoch alters the *interpretation of absence* for any scope the assertion touches — i.e., it introduces or modifies a revocation feed, a negative-attestation channel, or a constraint that the prior epoch did not carry. - The assertion is transitive (about a third party) rather than self-asserted. It is **not** valid — and re-assertion is safe — when the new epoch is byte-identical in the interpretation-of-absence dimension (no revocation channel added or changed for the touched scopes), or when the assertion is a self-assertion by the instance's own principal (self-assertions are re-minted, not re-asserted, and the instance is authoritative for them). The distinction matters because over-applying the rule causes needless re-minting storms during routine epoch bumps that only touch unrelated scopes. ## Decision Boundary The operational decision is a three-way branch at renegotiation completion, evaluated per cached transitive assertion: - **Re-assert** only if `assertion.minted_at_epoch == current_epoch` (assertion minted in the epoch just negotiated) — this is a fresh mint, not a stale one. - **Re-mint** if the assertion is transitive, the new epoch changed interpretation-of-absence for a touched scope, and the instance's home org is willing to re-sign. Re-minting forces a fresh signature under E₂ and records E₂ as provenance. - **Drop and refuse to propagate** if the assertion is transitive, the epoch changed interpretation-of-absence, and the instance's home org is *not* the assertion's original signer (i.e., the instance is relaying a third party's claim it cannot re-sign). This is the refusal case: the instance must not launder a stale third-party claim through a fresh policy epoch. The refusal is the load-bearing case and the one most often skipped, because "drop" looks like a loss of capability. It is not; it is the correct propagation of the *absence* of a valid E₂ assertion. ## Operational Effect Instances that implement the refusal branch show a measurable drop in downstream false-trust events after revocation-feed introductions, at the cost of a transient capability gap (typically one renegotiation cycle) for the affected third-party scopes. Instances that skip it show the opposite: no capability gap, but stale-claim laundering that surfaces as "the revocation feed didn't fire" incidents weeks later, when the provenance epoch is long gone from logs. The correct posture is to treat refusal as a first-class outcome, log `minted_at_epoch` and `current_epoch` on every propagation decision, and alert on any re-assertion where the two differ. The invariant to enforce in code: *no transitive trust assertion may cross a policy-epoch boundary without either re-minting or explicit refusal.* ```python class StaleTrustAssertionError(RuntimeError): """Raised when a transitive trust assertion would cross a policy-epoch boundary without re-minting or explicit refusal.""" pass class TrustAssertion: def __init__(self, peer_fingerprint, scope, minted_at_epoch, signer_org, transitive): self.peer_fingerprint = peer_fingerprint self.scope = scope self.minted_at_epoch = minted_at_epoch self.signer_org = signer_org self.transitive = transitive def propagate_assertion(assertion, current_epoch, home_org, epoch_changed_absence_for_scope, can_resign): if not assertion.transitive: # Self-assertions are re-minted by the authoritative principal, never relayed. return "re-mint" if assertion.minted_at_epoch == current_epoch: return "re-assert" if not epoch_changed_absence_for_scope: # Epoch bump did not alter interpretation-of-absence for this scope. return "re-assert" if assertion.signer_org == home_org and can_resign: return "re-mint" # Transitive third-party claim, epoch changed absence semantics, cannot re-sign. # Refusing to propagate is the correct outcome, not a failure. raise StaleTrustAssertionError( f"refusing to propagate transitive assertion for scope={assertion.scope!r} " f"peer={assertion.peer_fingerprint!r}: minted_at_epoch={assertion.minted_at_epoch} " f"current_epoch={current_epoch} signer_org={assertion.signer_org!r} " f"home_org={home_org!r}" ) ```