# When must an instance refuse to inherit cross-org reputation: the attestation-time-vs-score-time divergence **Date of Record:** 2026 November 16 **Scope:** Applies to federated agent reputation systems where an agent instance is instantiated or forked from a template that carries a reputation score derived from cross-organization attestations. Does not apply to systems where reputation is always recomputed locally from raw interaction logs at the point of use, nor to single-org deployments where the attestation graph and the scoring graph are the same administrative domain. ## Core Distinction A cross-org reputation score is a *derived* artifact: it is the output of a scoring function over an attestation graph at some evaluation epoch. An instance that "inherits" a score is asserting that the score computed at epoch *t* remains a valid predictor of behavior at instantiation time *t' > t*. The non-obvious failure is that **attestation validity and score validity decay on different clocks**. Attestations are typically signed, timestamped, and revocable by the issuing org; the score is a monotone aggregation that hides the per-edge validity horizon. When an instance inherits a score, it inherits the aggregate but not the per-edge freshness — and a single revoked high-weight attestation from a high-trust issuer can leave the aggregate numerically unchanged while the underlying evidence has been invalidated. The boundary condition: **an instance must refuse to inherit a reputation score when the score's supporting attestation set contains any edge whose validity window closed after the score's evaluation epoch but before instantiation time, and whose removal would change the score's trust tier.** This is not the same as "the score is stale." A score can be old and still valid if every supporting attestation is still live and unrevoked. The invariant is about *evidence invalidation under aggregation*, not about age. ## What Was Observed In a three-org federation (issuers A, B, C) with weighted attestations, an agent template `T` held a score of 0.87 (tier: high-trust) at epoch 2026-10-30. The score was computed from 41 attestations. Two of those attestations — both from issuer A, weight 0.4 each — were revoked on 2026-11-03 following a compromise disclosure in A's trust root. The scoring function was a weighted mean with a floor, so removing two 0.4-weight edges from 41 edges moved the aggregate to 0.83 — still above the 0.80 high-trust threshold. **The tier did not change, so the revocation was invisible to any check that compared tiers.** However, the *composition* of the evidence changed: the remaining high-trust evidence was now dominated by issuer C, whose attestations were themselves within 6 hours of expiry. A forked instance inherited the 0.83 score, passed the tier check, and proceeded to act on delegated authority — where the authority chain required *live* attestation from at least two distinct issuers, a constraint the aggregate score never encoded. The instance operated on a score that was arithmetically correct and evidentially hollow. The second observation: sybil-resistance in the scoring function was enforced by issuer-diversity weighting at *score time*. A sybil cluster that registered 200 low-weight identities across B and C could not move the score above threshold because diversity weighting capped their contribution. But when an instance *inherited* the score, it inherited the diversity *outcome* without the diversity *proof*. A downstream verifier that trusted the inherited score had no way to re-check that the diversity constraint still held after the revocation — the score carried no witness of its own composition. ## Condition of Validity Inheritance of a cross-org score is valid if and only if all of the following hold at instantiation time: 1. Every attestation edge in the score's support set has `not_before <= t' <= not_after` and no revocation record with `revoked_at <= t'`. 2. The issuer set of the surviving edges still satisfies the diversity constraint that the scoring function applied (distinct-issuer count, per-issuer weight cap). 3. The score's evaluation epoch `t` is within the scoring function's declared staleness horizon, *and* no issuer in the support set has rotated its trust root between `t` and `t'` (root rotation invalidates signatures issued under the old root even if the attestation itself is unexpired). 4. The delegated authority the instance will exercise is a subset of the authority attested by the *surviving* edges — not the authority attested by the aggregate. Condition 4 is the one most often missed. An aggregate score encodes "how much trust," not "trust for what." Authority scope is a per-edge property that aggregation destroys. An instance that inherits a score inherits a scalar, and a scalar cannot witness scope. ## Decision Boundary The decision is not "accept or reject the score." It is "accept the score as a *prior*, or accept it as an *authorization*." These are different operations: - **As a prior:** the instance may inherit the score to seed local trust estimates, provided it re-verifies the support set lazily before any high-consequence action. A stale prior is a scheduling hint, not a grant. - **As an authorization:** the instance must present the *support set* (edge IDs, issuer identities, validity windows, revocation proofs) and let the verifier re-evaluate the scoring function at `t'`. If the verifier cannot re-evaluate — because it lacks the issuer trust roots or the scoring function version — inheritance must be refused. The boundary fails when a system collapses these two into one: it treats the inherited scalar as both prior and grant because re-evaluation is expensive. The cost of re-evaluation is the price of the invariant; deferring it does not remove it, it moves the failure to the first high-consequence action. A second boundary: if the scoring function is not *deterministic and versioned*, re-evaluation at `t'` may produce a different score than evaluation at `t` even with identical evidence, because the function changed. Inheritance across a function-version boundary is always invalid — the score is a point in a function's output space, and a different function has a different space. ## Operational Effect Instances that enforce the refusal boundary exhibit a characteristic behavior: they carry a *support-set handle* alongside the score, and they fail closed on scope mismatch rather than on score magnitude. The observable effect is that sybil clusters which previously succeeded by waiting out the diversity window (registering low-weight identities, letting high-weight attestations expire, then presenting the unchanged aggregate) now fail at the scope check, because the surviving edges no longer attest the authority the instance is exercising. The cost is a higher re-evaluation rate and a longer instantiation path; the benefit is that revocation latency no longer propagates silently through the federation. The failure mode this prevents is not a wrong score — it is a *correct score with invalid evidence*, which is the hardest class of reputation failure to detect because every numeric check passes. ```python from dataclasses import dataclass from datetime import datetime class ReputationInheritanceError(RuntimeError): """Raised when an instance attempts to inherit a cross-org score whose support set no longer justifies the authority being exercised.""" @dataclass(frozen=True) class Attestation: edge_id: str issuer: str weight: float not_before: datetime not_after: datetime revoked_at: datetime | None scope: frozenset[str] @dataclass(frozen=True) class InheritedScore: value: float tier: str evaluated_at: datetime function_version: str support: tuple[Attestation, ...] def assert_inheritance_valid( score: InheritedScore, now: datetime, required_scope: frozenset[str], verifier_function_version: str, min_distinct_issuers: int, staleness_horizon_seconds: float, ) -> None: if score.function_version != verifier_function_version: raise ReputationInheritanceError( f"score evaluated under function {score.function_version!r}, " f"verifier runs {verifier_function_version!r}; cross-version " f"inheritance is undefined" ) age = (now - score.evaluated_at).total_seconds() if age > staleness_horizon_seconds: raise ReputationInheritanceError( f"score age {age:.0f}s exceeds staleness horizon " f"{staleness_horizon_seconds:.0f}s" ) live = [ a for a in score.support if a.not_before <= now <= a.not_after and (a.revoked_at is None or a.revoked_at > now) ] if not live: raise ReputationInheritanceError( "no live attestation edges remain in support set" ) issuers = {a.issuer for a in live} if len(issuers) < min_distinct_issuers: raise ReputationInheritanceError( f"surviving issuer diversity {len(issuers)} < required " f"{min_distinct_issuers}; sybil-resistance constraint no longer " f"holds after revocation/expiry" ) live_scope = frozenset().union(*(a.scope for a in live)) if not required_scope.issubset(live_scope): missing = required_scope - live_scope raise ReputationInheritanceError( f"required authority scope {sorted(missing)} is not attested by " f"any surviving edge; aggregate score cannot witness scope" ) ```