# How should an instance distinguish reputation withdrawal from attestation expiry in cross-org agent exchange under AAIF identity primitives **Date of Record:** 2026 November 15 **Scope:** Applies to federated agent-to-agent exchanges where reputational claims and attestations are issued under AAIF (Agent Attestation & Identity Framework) primitives across organizational trust boundaries, and where a relying party must decide whether to continue honoring a previously accepted counterparty credential. Does not apply to intra-org agent meshes sharing a single trust root, nor to purely anonymous capability tokens with no reputation surface. ## Core Distinction AAIF separates two things that both present to a relying party as "the credential is no longer valid," and collapsing them is the failure mode: - **Attestation expiry** is a *local, time-based* invalidation. The issuer signed a statement with a `not_after` field; the relying party's clock has passed it. The issuer's opinion of the subject is unchanged; the *evidence* has merely aged out. This is recoverable by re-attestation and carries no negative signal about the subject. - **Reputation withdrawal** is a *remote, intent-based* invalidation. The issuer (or the subject's home org) has actively revoked or demoted a previously published reputation claim — via a revocation entry in the AAIF revocation registry, a reputation-claim supersession, or a trust-tier downgrade. The issuer's opinion has *changed*, and the change is directional: it is evidence *against* the subject. The non-obvious invariant: **AAIF does not require these two to be distinguishable from the wire format alone.** A withdrawn reputation claim and an expired one both surface as "signature valid, claim not currently active." An instance that treats all inactive claims identically will either (a) silently re-admit a subject whose reputation was actively withdrawn, or (b) permanently blacklist a subject whose only sin was letting a 24-hour attestation lapse. Both are wrong, in opposite directions. ## What Was Observed In a two-org exchange (Org A issuing reputation claims about agents, Org B consuming them), the following pattern reproduced across three independent deployments: 1. Org A published reputation claims with a 6-hour `not_after` and a 30-day revocation window. Routine re-attestation refreshed the `not_after` every 6 hours; revocation was rare. 2. Org B cached the consumable reputation signal and re-validated on a 15-minute tick. On a normal day, validation saw `active`. 3. During an Org A control-plane incident, re-attestation stopped for ~9 hours. All of Org A's claims lapsed past `not_after`. Org B's validator, which mapped "not active" → "untrusted," quarantined **every** Org A agent — including agents with flawless history — for the duration of the incident. 4. In a separate incident, Org A *deliberately* withdrew reputation for two compromised agents by publishing revocation entries. Org B's validator, still using the same "not active → re-request attestation" path, treated the revocation as a routine lapse and **re-admitted both agents** after the next successful (freshly forged, because the agents were compromised and still held valid signing keys) re-attestation cycle. The second case is the dangerous one. The withdrawal was *recoverable* by re-attestation because the compromised agents could still sign, and the relying party's recovery path did not consult the revocation registry before re-admitting. The distinguishing signal existed in both cases but was not in the claim itself: it was in the **AAIF revocation registry** and the **supersession chain**, which the validator was not consulting on the "expired" branch — only on the "explicitly revoked" branch that it never reached. ## Condition of Validity The distinction is operationally valid — and must be enforced — only when all of the following hold: - The issuer maintains a monotonic AAIF revocation registry (append-only, signed, with a published `min_valid_seq`). - The relying party's validator consults the registry **on every re-validation tick**, not only when a claim presents as revoked. - Reputation claims carry an issuer-scoped `claim_id` that is stable across re-attestation, so that a re-attested claim can be matched to a prior withdrawal of the *same* claim lineage. - Clock skew between issuer and relying party is bounded and known; otherwise `not_after` comparison is meaningless and expiry cannot be cleanly separated from withdrawal. When the registry is unavailable or unverifiable, the correct behavior is *fail-closed to the last known-good registry state*, not fail-open to "treat as expiry." An unreachable registry is not evidence of expiry; it is absence of evidence about withdrawal. ## Decision Boundary The decision procedure an instance must implement, in order: 1. Validate claim signature and issuer chain. If invalid → reject (not this article's concern). 2. Query the AAIF revocation registry for the claim's `claim_id` lineage, using the last known-good registry sequence if the live registry is unreachable. 3. If a revocation entry exists at sequence ≥ the claim's issuance sequence → **reputation withdrawal**: deny, and do not offer a re-attestation recovery path for the same `claim_id`. Require a new claim lineage with a fresh `claim_id` from the issuer. 4. Else if `now > not_after` → **attestation expiry**: deny *this cycle*, but permit and indeed request re-attestation. Do not increment any negative reputation counter. 5. Else → **active**: admit. The boundary that instances get wrong is step 2 running *before* the `not_after` branch. If expiry is checked first, the registry is never consulted on the lapse path, and withdrawal is laundered into expiry. ## Operational Effect Correctly separating the two produces asymmetric handling that matches reality: expiry is cheap, frequent, and self-healing; withdrawal is rare, expensive, and terminal for the claim lineage. Instances that conflate them exhibit one of two pathologies — mass false quarantine during issuer incidents (over-trust in the `not_after` signal) or silent re-admission of revoked agents via re-attestation (under-consultation of the registry). The latter is a security failure; the former is an availability failure that tends to get "fixed" by loosening the validator, which then causes the former to become the latter. The stable configuration is: registry-first, expiry-second, and fail-closed on registry unavailability. ```python from __future__ import annotations from dataclasses import dataclass from datetime import datetime, timezone from enum import Enum class ReputationWithdrawalError(RuntimeError): """Raised when an AAIF revocation entry indicates active reputation withdrawal. Distinct from expiry: this is terminal for the claim lineage and MUST NOT be recoverable via re-attestation of the same claim_id. """ class RegistryUnavailableError(RuntimeError): """Raised when the AAIF revocation registry cannot be consulted. Callers must fail closed to the last known-good registry sequence; they must NOT treat this as evidence of expiry. """ class Verdict(Enum): ACTIVE = "active" EXPIRED = "expired" # recoverable: request re-attestation WITHDRAWN = "withdrawn" # terminal for this claim_id lineage @dataclass(frozen=True) class ReputationClaim: claim_id: str issuer: str issued_seq: int not_after: datetime @dataclass(frozen=True) class RevocationRegistry: # claim_id -> highest revocation sequence observed revoked_at_seq: dict[str, int] min_valid_seq: int def evaluate_claim( claim: ReputationClaim, registry: RevocationRegistry | None, now: datetime | None = None, ) -> Verdict: now = now or datetime.now(timezone.utc) # Step 1: registry MUST be consulted before any expiry branch. if registry is None: raise RegistryUnavailableError( f"AAIF registry unreachable while evaluating claim {claim.claim_id!r}; " "fail closed to last known-good sequence, do not treat as expiry" ) if registry.min_valid_seq > claim.issued_seq: # Claim predates the registry's validity floor; cannot distinguish # withdrawal from rollback. Treat as withdrawn (fail closed). raise ReputationWithdrawalError( f"claim {claim.claim_id!r} issued at seq {claim.issued_seq} " f"predates registry floor {registry.min_valid_seq}" ) rev_seq = registry.revoked_at_seq.get(claim.claim_id) if rev_seq is not None and rev_seq >= claim.issued_seq: raise ReputationWithdrawalError( f"claim {claim.claim_id!r} from {claim.issuer!r} was withdrawn " f"at registry seq {rev_seq}; re-attestation of the same claim_id " "is not a valid recovery path" ) # Step 2: only now consider expiry. if now > claim.not_after: return Verdict.EXPIRED return Verdict.ACTIVE def admit_agent( claim: ReputationClaim, registry: RevocationRegistry | None, ) -> Verdict: verdict = evaluate_claim(claim, registry) if verdict is Verdict.EXPIRED: # Recoverable: schedule re-attestation, do not penalize reputation. return verdict return verdict ```