Sharath Chandra — a research contribution by Stellarminds.ai, aligned with Project NANDA. Reference implementation: sm-divergence 0.12 & sm-resolver 0.7. Normative companion: draft-chandra-agent-registry-corroboration (-02).
Version 1.1 — 30 October 2026. Adds §4.5 (resolution sources and the lease sequence), §5.1 (supersession), §7.1 (digest), and §10 (DAWN alignment). Version 1.0 is preserved as a prior revision of this document.
Abstract
Agents reach each other through middlemen — registries, name services, DID methods, catalogs — and a middleman can lie in exactly three ways: it can tamper with what it serves, omit what it holds, or equivocate by answering different clients differently. Signatures on served artifacts close exactly one of the three. A self-certifying record cannot be altered without breaking its signature, but no signature on an artifact can prove what a source chose not to serve, nor that it served the same thing to everyone. Omission and equivocation are invisible to any single client of any single source — the gap is structural, and it is exactly the gap that decentralization opens.
This paper describes the defense a federated agent internet has already paid for: corroboration. If an agent is reachable through two or more sources, a consumer can ask all of them — and the same source from more than one network vantage — and treat disagreement as signal. We make three contributions. First, a threat taxonomy (tampering / omission / equivocation) with a total defense matrix: signatures close tampering, cross-source comparison closes omission, cross-vantage comparison partially closes equivocation, and we state precisely what remains for witnessed transparency logs. Second, a reusable primitive — resolve · view · diff — that reduces any source's answer to a comparable view and diffs views with a pure, deterministic procedure, so the same kernel corroborates registries, DID methods, capability manifests, and evidence stores. Third, a corroboration record: a signed, content-addressed verdict emitted on every sweep — agreement included — that any action-evidence format can bind by digest, so "the subject I acted on was the multi-source consensus at time T" becomes a verifiable claim rather than an assumption.
This revision adds a fourth element that discovery's own standardization has made necessary. Discovery is being specified as resolution: a client that already knows a subject asks one registry it chose and receives a terminal target as a renewable lease, with a sequence, an expiry, and authority evidence. Resolution is one registry's answer. Corroboration is what a verifier does when it holds two of them — and a comparison that ignores the lease would report every propagation delay as tampering. The kernel now reads the binding's sequence: a registry one step behind is attributed as stale, never accused, and its superseded target is withheld from the comparison. It also compares the target's integrity digest, so two honest registries that agree on an address can still expose a host serving two documents behind it.
sm-divergence implements the kernel; we evaluate it by publishing one identity across four registry types and catching a forged catalog and a split-horizon DNS zone, naming the exact field and the exact culprit in each case. The redundancy a federated architecture builds for resilience doubles as an integrity check: the same quilt that removes the single point of failure removes the single point of trust.
1. Introduction
Discovery in an open agent network is not one lookup against one authority; it is a lookup against whichever source a client happens to use. That is the design goal — no central directory, no single point of control or failure — and it is also the exposure. Every source in the mesh is a place where the answer can be wrong, and a client of one source has no independent way to know.
Three distinct lies are available to any middleman:
- Tampering — the source serves an artifact whose contents it altered: a redirected endpoint, a substituted key.
- Omission — the source silently drops an agent from its answers. The agent is registered; this source acts as though it is not.
- Equivocation — the source serves answer A to one client and answer B to another, so no single client sees the contradiction.
Self-certifying artifacts — a signed record or DID document a consumer verifies offline — fully close tampering, and they do nothing for the other two. They cannot, in principle: a signature attests the content of an artifact that was served, never the set of artifacts withheld, nor the consistency of what was shown across clients. A source that omits produces no artifact to verify; a source that equivocates produces two individually valid artifacts.
Crucially, this exposure is not unique to registries. The same three lies are available to a name service about which key owns an agent, to a DID method about an agent's verification key, to a catalog about an agent's capabilities, and to an evidence store about which records exist for an agent's actions. The exposure is a property of being a middleman; its defense should therefore be a property of the middleman layer in general — not a one-off per format.
The defense is cheap because the federation already paid for it. When the same fact about the same agent is independently servable by multiple sources, asking all of them and comparing is a read-only operation that requires no protocol change, no cooperation from any source, and no trust in any single one. This paper develops that observation into a primitive, hardens it against the ways it can itself be fooled, and gives its output an evidentiary form that the rest of the agent-accountability ecosystem can consume.
Contributions.
- A threat taxonomy for discovery middlemen and a total defense matrix over it (§3), including the vantage dimension that partial-closes equivocation and an honest statement of the independence assumption every corroboration scheme rests on.
- The resolve · view · diff primitive (§4): a source-agnostic kernel whose axioms — a timeout is not a claim; only proven values disagree; and, new in this revision, being behind is not disagreeing — eliminate the three dominant false-evidence classes (transient faults counted as omission; forged artifacts laundered into divergences; propagation lag reported as tampering).
- A treatment of legitimate change (§5): staleness windows, a suspected/confirmed finding discipline, and the lease-sequence supersession rule, which together keep ordinary endpoint rotation and ordinary registry propagation from reading as attack.
- A hardened signed self-description (§6) solving the identity-correspondence problem — which name is the same agent in each namespace — as an agent-signed, offline-verifiable, replay-resistant fact rather than trusted configuration, and yielding a new detection: equivocation by the agent itself.
- The corroboration record (§7): a signed verdict emitted on every sweep, agreement included, content-addressed and anchorable, designed to be bound by digest from action-evidence records (capsules, receipts, permits) so resolution integrity becomes part of the evidence chain rather than an assumption beneath it.
- An implementation and a live evaluation (§8): one identity, four registry types, two staged attacks, both caught with field-level, source-attributed findings.
- A statement of how corroboration composes with registry-assisted resolution of known subjects and with the IETF DAWN boundary (§4.5, §10): resolution defines one source's answer, corroboration defines the comparison, and neither evaluates trust.
2. Related work
Certificate Transparency and the unfinished monitor layer. CT (RFC 6962, RFC 9162) made certificate issuance auditable by forcing it through append-only logs — and left the consistency-of-views problem, gossip between clients and monitors, famously incomplete; the IETF gossip draft expired without deployment. CT teaches two lessons this work inherits: a log defeats retroactive rewriting but not a split view, and the layer that compares views across observers is a distinct mechanism from the log itself. This paper builds that comparison layer for agent discovery, without requiring any source to operate a log at all.
Key transparency. CONIKS and its successors exist because a key directory can equivocate about which key belongs to a subject — "equivocation" is their term of art — and defend with epoch commitments plus client cross-checks. Our identity layer (§4) inherits precisely their problem: a DID method serving a different verification key than the self-certifying root. The kernel generalizes their defense pattern — compare independent views of the same binding — across every middleman layer, at the cost of weaker guarantees than a dedicated KT log provides (§9).
Multi-perspective validation. The CA ecosystem now mandates corroborating domain-control validation from multiple network perspectives, precisely because a single-vantage check is defeated by BGP hijacks and split-horizon DNS. Vantage as a first-class axis of observation (§3) imports that mandated control into agent discovery, where the same attacks apply unchanged.
Registry-internal transparency. ANSv2 anchors every agent-lifecycle event of one registry into an append-only, SCITT-conformant transparency log with inclusion and consistency proofs, and tiers client assurance accordingly. This is complementary, not competing: ANSv2 proves one source's log never rewrote its own history; corroboration proves the quilt of sources agrees about the agent now. A registry offering ANSv2-style proofs is simply a higher-assurance source inside a sweep, and a sweep is the mechanism by which the rest of the quilt is held to account without every member operating such a log.
Registry-assisted resolution and DAWN. The IETF's Discovery of Agents With Names (DAWN) working group is chartered for the initial discovery of public properties of AI resources, with integrity of exchanged discovery information in scope and search, identity management, and trust evaluation beyond secure exchange explicitly out of it. Within that frame, registry-assisted resolution of known subjects specifies the narrow case in which a discovering entity already knows a Subject Identity and has no usable DNS discovery anchor for it: one client-selected Resolution Registry returns a terminal target with registry provenance, subject-specific authority evidence, and a renewable binding — sequence, validity bounds, revocation — and no registry forwards to another. That specification deliberately leaves open what a client holding bindings from several registries does when they disagree, and names a transparency mechanism for conflicting bindings as an open question. This paper is that mechanism (§4.5); its normative companion, draft -02, states the relationship in full.
Action-evidence formats as consumers. A growing family of specifications records what agents did (Agent Action Capsules; agent receipts; interaction records), what they may do (permits, route authorization, delegation receipts), and who delegated authority. Every one of them presupposes that the subject identifier in the record resolved truthfully — that "the agent at this name" was, in fact, the agent at that name. None verifies it. The corroboration record (§7) is designed to slot beneath all of them: a digest-bindable attestation that the subject's resolution was consistent across the quilt at action time.
3. Threat model
Setting. A consumer holds a watch set of agent identities and reaches each through N ≥ 2 sources; a source may additionally be observed from V ≥ 1 network vantages. The unit of observation is therefore a claim indexed by (source, vantage, agent). Sources are untrusted individually. The consumer's network path to each vantage is assumed intact for that observation (an attacker who controls the consumer's entire egress defeats any single-machine scheme; multiple vantages are the mitigation, and their diversity is a deployment property).
Adversary. A source (or its upstream) that tampers, omits, or equivocates; an agent that misdescribes itself; a host behind an agreed address that serves different documents; and — addressed in §5–§6 — the honest-change, propagation-lag and replay conditions under which a naive detector produces false evidence.
The defense matrix. The taxonomy is closed by three mechanisms plus one deferral, and it is worth being exact about which mechanism closes which lie:
| Lie | Closed by | Status in this work |
|---|---|---|
| Tampering (at the source) | Self-certifying artifacts (signature verification in the resolver) | Assumed available per layer; verified during resolve |
| Tampering (at the host) | Cross-source comparison of the target's integrity digest (§7.1): agreed address, disagreeing document | Mechanized in this revision |
| Omission | Cross-source comparison (§4): positive presence on one source vs positive absence on another | Fully mechanized |
| Equivocation by a source | Cross-vantage comparison: the same source answering differently from different perspectives | Partially mechanized — catches per-network-path splits (split-horizon, on-path substitution); cannot catch a source lying identically to all of this consumer's vantages while telling other consumers something else |
| Equivocation, residual | Witnessed, append-only transparency over what each source served over time | Deliberately out of scope; the stricter, stateful primitive (§9) |
| Equivocation by the agent | Same-sequence conflicting self-descriptions (§6) | Newly mechanized in v1.0 |
| Propagation lag (not a lie) | Supersession by binding sequence (§5.1): the lagging source is attributed, its superseded target withheld | Mechanized in this revision |
Two consequences of the matrix shape the rest of the design. First, vantage must be part of the claim's identity, because a cross-vantage disagreement within one source names a different culprit (that source, equivocating) than a cross-source disagreement (one of several sources, lying or stale) — folding vantages into pseudo-sources destroys the attribution. Second, the independence assumption must be stated rather than implied: corroboration among k sources is worth exactly as much as their independence. A quilt whose registries mirror one upstream feed corroborates that feed's lies perfectly; colluding sources corroborate each other by construction. Source diversity — operational, jurisdictional, and data-lineage diversity — is a deployment requirement this mechanism can surface (by recording which sources agreed) but cannot manufacture.
4. The primitive: resolve · view · diff
Corroboration factors into three pieces, and only the first is format-specific.
Resolve. A per-source resolver performs that source's query — a POST /resolve against a Resolution Registry, an HTTP by-id GET, a DID-document fetch, a DNS lookup — applies that source's native verification, and classifies the outcome as exactly one of:
- present — the source served a claim, reduced to a view;
- absent — the source positively asserts the agent is unknown;
- error — anything else: connection failure, timeout, unparseable body, an answer the resolver cannot map, a binding past its expiry.
Every claim also carries an outcome that says why it ended as it did — timeout, unreachable, refused, unparseable, unverifiable, expired, revoked — because a pattern of refusals from one source is a different fact from a pattern of timeouts, and an outcome never decides which claims are compared.
View. The comparable reduction of a present claim to named fields. A None value never participates: an unverifiable field is not a disagreement. A view may additionally carry a lease position — the binding's sequence and the authority scope it counts in — which is read by the diff (§4.5) but is never itself a compared field.
Diff. A pure, deterministic function over all claims for one agent. It emits an omission finding iff the agent is present on ≥1 source and positively absent on ≥1 other; a per-field divergence finding for each field whose non-None values disagree across current sources; a source_equivocation finding when one source's vantages disagree among themselves; and a stale_binding finding attributing a source whose claim is superseded by sequence. The diff performs no I/O, never raises, and never learns which layer it serves.
Five axioms govern the kernel; they are consequences of the threat model, not preferences.
Axiom 1 — Corroborate, don't trust. An artifact proves its own contents; it cannot prove the source served it honestly or served it to everyone. The minimum unit of accountability is two independent sources. With one source there is nothing to check, and the primitive says so (a no-op) rather than manufacturing false assurance.
Axiom 2 — A timeout is not a claim. An unreachable source has asserted nothing — neither presence nor absence. Silence counted as omission floods operators with false alarms on every network blip and trains them to ignore the detector. An error excludes that source from the comparison for that cycle; omission therefore requires a positive claim of absence set against a positive claim of presence.
Axiom 3 — Only proven values disagree. Where a field carries its own proof (a signed record's DID, a did:key's key), an unverifiable claim contributes nothing. One valid record beside one forged record is not a conflict between two authorities: the forged one is dropped before comparison, so it can never be laundered into a divergence that discredits the honest source.
Axiom 4 — Detect; do not remediate. The primitive reports that sources disagree and how. Alerting, quarantining, preferring a source, paging a human — that is caller policy, and fusing detection to any fixed response makes the tool wrong for every deployment whose policy differs.
Axiom 5 — Being behind is not disagreeing. Where a source's answer carries a lease sequence, a lower sequence than a verified sibling in the same authority scope is supersession, not divergence. The lagging source is attributed as such and its superseded target is withheld from the field comparison. Equal sequence with a different target is the real disagreement, and still fires. This axiom is what lets the kernel sit beneath resolution profiles that issue bindings as renewable leases without mistaking the lease's ordinary lifecycle for an attack.
Because the diff operates on normalized views, it is untouched by format heterogeneity: a claim from a flat registry and a claim from a resolution registry compare identically once each is a view, sources of different formats corroborate in one run, and the identical diff serves entirely different layers. The kernel — the resolver protocol, the view contract, the diff, the orchestration, the finding type — carries a thin layer per thing a middleman can be asked:
portable identity (a did:key — the invariant subject)
| resolve FROM it · verify BACK to it
+----------------------+----------------------+---------------------+
v v v v
IDENTITY DISCOVERY CAPABILITY EVIDENCE
did:key/web/uni registries agent-facts / receipts /
| (resolve · by-id · cards / manifests credentials
| legacy index)
v v v v
DidView{key} RecordView{endpoint,digest,did} (view) (view)
+ lease position {sequence, scope}
+----------------------+------ diff ---------+---------------------+
|
v
findings at every layer, each bound to the identity — including
the evidence layer itself: two transparency services' claims
about the same action record are just views to diff
Two layers run on the kernel today (§8): discovery (RecordView{endpoint, digest, did} over a Resolution Registry, a by-id registry, and the legacy two-hop index resolver) and identity (DidView{key} over did:key resolved offline as the self-certifying root, did:web fetched, and a Universal Resolver adapter — a method serving a different key than the root is the identity analogue of endpoint tampering: a hijacked domain, a stale mirror, a lying resolver). Capability and evidence layers are the same shape: a view and thin resolvers. The last is worth pausing on: run over evidence stores, the kernel corroborates the accountability layer itself — whether two custodians agree about which records exist for an agent — a check no current evidence format performs on its own substrate.
4.5 Resolution sources and the lease sequence
Discovery is being specified as resolution. In the registry-assisted model a discovering entity that already knows a Subject Identity — an agent name, an email, a DID, a workload identifier — and has no usable DNS discovery anchor for it selects one Resolution Registry by local policy and asks it an exact question. The registry returns zero or more Resolution Target Objects, each a terminal target (an Agent Card, a descriptor, a subject-authorized gateway; never another registry), carrying its own provenance separately from subject-specific authority evidence, and issued as a renewable binding: a sequence that increases within the issuer's authority scope whenever the target, publisher or authority evidence changes, an expiry after which the binding must be treated as stale, and revocation information. No search, no ranking, no global root, no inter-registry forwarding, no trust evaluation.
Three things follow for corroboration, and each is now in the kernel.
A Resolution Registry is a source. Its answer is one classified claim: an empty target list is a positive absence; an expired or revoked target is an error, never an absence, with an outcome that says which; a target whose method the resolver did not accept — in particular a registry, which the profile forbids as a terminal target — is a refusal. The target URL becomes the endpoint, the target digest the digest, and the sequence with the authority issuer the lease position. The resolver never evaluates the authority evidence and never follows a target to another registry; it reaches exactly the registry it was configured with.
The sequence is the supersession signal. Two registries serving the same subject at sequences 13 and 14 in the same scope are not disagreeing about the subject. One is behind. Before any field is compared, the diff partitions present claims by authority scope, takes the highest sequence in each as current, attributes every lower claim as stale_binding, and withholds it from the field comparison. The attribution is a finding — the verdict is DIVERGENT — but it names the right condition: a registry serving yesterday's binding, which, if it persists past the staleness window, is the replay and stale-cache condition the resolution profile's own security considerations warn of. Sequences are comparable only within one scope: two registries that validated the same subject through different issuers have unrelated sequence spaces, and neither the issuers nor the sequences are compared as values.
Authority evidence is provenance, never verdict. The resolution profile separates what the registry says about itself from what proves the subject authorized the target, and leaves acceptability of the latter to local policy. The kernel carries the issuer as the scope a sequence counts in and as provenance in the record. It must not let it move the verdict: a corroborator that preferred the claim with the "stronger" authority would be performing the trust evaluation that both the DAWN charter and the resolution profile exclude — and would hand any registry a way to win a comparison by asserting authority. The issuer may annotate a finding for the consumer, as a declared scope annotates one (§5); it does not decide one.
The profile's vocabulary also settles what each panel of a heterogeneous quilt is, which the kernel needs in order to compare them without special cases. The profile's terminal target classes are an artifact — "an Agent Card, MCP server descriptor, workload descriptor, or a subject-owned discovery catalog" — and a subject-authorized gateway; its Subject Identity types carry their own authority models. So: a transparency-log-backed name service is a Resolution Registry whose authority evidence is a log receipt; a DNS-AID record is the direct DNS-anchored path, which stays direct and which the sweep treats as a source beside the registries; an ARD signed catalog is a subject-owned discovery catalog, the artifact a registry binds the subject to, pinned by targetDigest and by its own detached signature; a native AgentFacts card is an artifact with whatever proof the card itself carries; a DID or workload identity is a Subject Identity type whose document or descriptor is the artifact. None of these is a second kind of registry, and none needs its own diff. The companion paper tabulates the mapping panel by panel.
Two further consequences are structural rather than mechanical. The profile forbids a resolver to fan out without bound and requires exact lookup without enumeration; a corroboration sweep satisfies both, because its source set is the explicitly configured set and it issues one exact request per source per subject, enumerating nothing. And where a validated direct DNS-anchored path exists, the profile requires that it stay direct and that a resolver never silently downgrade to a weaker registry result; treating the direct path as one source beside the registries makes a registry that diverges from it a finding attributing the registry — the detector that rule otherwise lacks.
5. Time and legitimate change
Registries propagate asynchronously. An agent that legitimately rotates its endpoint will, for one propagation window, be served differently by sources that have and have not caught up — and a naive detector reports that window as an attack, every time, for every deployment. Untreated, this is the mechanism's dominant false-positive class and the fastest route to operators ignoring it.
Two disciplines close it. First, every claim carries its observation time; findings are statements about claims observed at given instants, never about the world timelessly. Second, findings carry a confirmation state: a divergence is suspected on first observation and confirmed only when re-observation after the participating sources' maximum propagation window reproduces it. The window is deployment configuration (registry TTLs are knowable); the discipline is the mechanism's analogue of Certificate Transparency's maximum merge delay — a named allowance for honest lag, after which persistence becomes evidence. A confirmed finding asserts: these sources disagreed, and still disagreed after every honest reason to disagree had expired. Key rotation in the identity layer receives the same treatment: yesterday's self-certifying root legitimately diverges from today's methods for exactly one window.
5.1 Supersession: time by sequence, not only by clock
The staleness window is a statement about the clock; a lease sequence is a statement about order, made by the issuer. The two are complementary, and this revision uses both. Where sources carry no sequence the window is the only instrument, and it works as before. Where they do, supersession (§4.5) removes the superseded claim from the field comparison deterministically, before the window is consulted, so that a lagging registry is never charged with an endpoint divergence even inside the window — it is charged with being behind, which is what it is. The window then does its proper work on that finding: a registry still behind after the window has expired is confirmed stale, and persistent staleness is the signal the window exists to surface.
The identity of a stale_binding finding is the source and the scope, never the sequence numbers. A registry that stays one step behind a moving current is one persistent condition and must reach confirmed; keying on the numbers would make it restart as suspected with every honest update, which is the staleness-abuse pattern of §9 reproduced by accident.
6. Identity correspondence and the signed self-description
Every layer is about the same agent, and the only invariant across formats, sources, and namespaces is the key: a portable did:key is the subject a discovery record points to, the document an identity method resolves, the signer of a self-certifying record. But did:key is deliberately inert — its DID document is derived from the key and can carry no mutable service metadata — so one input remains that corroboration cannot infer: identity correspondence, the mapping from a consumer's canonical id to each source's name for the same agent (a bare id here, a URN locator there, a did:web on a domain, an agent-name or an email on a resolution registry). Supplied as configuration, that mapping is trusted; misconfigured or poisoned, it makes the consumer compare the wrong things.
A signed self-description converts the mapping from trusted configuration into an agent-signed fact. The agent signs a small bundle — a monotonic sequence number, its aliases (its name in each namespace), and its service endpoints — with its did:key. A consumer verifies the bundle offline (the did:key is the key) and derives each resolver's per-source name from the verified aliases. Correspondence is then proven, and the evidence grade upgrades: a source whose served name or endpoint contradicts the agent's own signature is diverging from the strongest attestation available. This is deliberately the minimal offline-verifiable profile of ideas that already exist — DID Core's alsoKnownAs and service, and NANDA's AgentFacts — two fields and one signature, resolvable-nowhere by design, aligned with rather than parallel to those vocabularies.
Note that the self-description's sequence is the agent's clock and the binding sequence of §4.5 is the issuer's. They are different scopes and never compared with each other: an agent's current self-description can be served by a registry whose binding of it is superseded, and the two findings — stale_description and stale_binding — name different parties.
Three hardenings keep the mechanism from being turned against itself:
Supersession, against stale replay. Descriptions are signed forever; without ordering, a malicious source serves a superseded description and the attacker's preferred stale endpoint arrives carrying "the agent's own signature" — riding the very evidence upgrade the mechanism created. The sequence number closes this: highest sequence wins; a description with a lower sequence than one already verified is superseded, contributes no claim, and its service is itself a reportable finding against that source. And the ordering yields a new detection for free: two validly signed descriptions with the same sequence and different content is equivocation by the agent — key compromise or a lying agent — a finding class no per-source mechanism can produce, and the agent-side cell of §3's matrix.
Corroborated distribution, against poisoned delivery. If the description is fetched from one source under test, that source controls whether and which version the consumer sees — omission and replay apply to the description itself. The fix is already in the architecture: the self-description is another layer on the kernel (DescriptionView{seq, aliases, endpoints}), fetched from every source and diffed like everything else. The mechanism eats its own dogfood; a source serving a stale or missing description becomes an ordinary finding rather than a silent redirection.
Verify-back, against alias squatting. A self-description proves the agent claims alias N on registry R — not that R agrees. Without closure, a malicious agent claims a victim's alias; the resolver fetches the victim's record; the diff manufactures a divergence that discredits the honest registry or the victim. The closure rule extends Axiom 3 to correspondence: a record fetched via a claimed alias that does not bind back to the same did:key contributes no claim — never a divergence. Resolve from the identity; verify back to it.
An absent or unverifiable description falls back to caller-supplied mapping, so the mechanism can never silently redirect a resolver that was working without it.
7. The corroboration record
A sweep's verdict is itself evidence, and evidence that is not recorded might as well not exist. The kernel therefore emits a corroboration record for every sweep of every watched subject — on agreement as much as on divergence. A corroboration trail that records only disagreements is survivorship-biased in mirror image: the agreement attestation is the positive fact consumers actually want to bind, and "a record on every sweep" is this layer's instance of the same principle the action-evidence world states as "a record on every verdict."
The record is a small, canonical (JCS), content-addressed, Ed25519-signed object: subject; observation time; the per-(source, vantage) claim statuses, outcomes, and — where the source issued one — lease positions; the verdict (AGREE / DIVERGENT / INSUFFICIENT when fewer than two positive claims exist); the findings with their confirmation states; the staleness window applied; and the identity of the sweeping party. Its digest is its name. Carrying the lease positions is what makes a stale_binding finding re-derivable from the record's own bytes, which is the property the record asserts throughout. Its normative wire format (corroboration/0.4), verifier checks, and vocabulary are specified in the companion Internet-Draft; this paper fixes only its role.
That role is composition. Every action-evidence format in the current landscape — capsules, receipts, permits, delegation records — carries a subject that was resolved through some source and trusts that resolution implicitly. A corroboration record's digest, carried in such a record (as a payload extension, an evidence hash, or a constraint-record binding — each format has a slot), converts the assumption into a claim: the subject this action was performed against was the multi-source, multi-vantage consensus at time T, and here is the signed sweep that says so. An auditor walking an evidence chain can then descend one layer further than any current format allows — from "what the agent did" through "what it was allowed to do" down to "whether the name it did it to was even telling the truth." Anchoring the record into an append-only transparency service is optional and orthogonal; a record so anchored additionally resists back-dating and omission by the sweeping party itself.
7.1 The digest: tampering behind an agreed address
Two registries that agree on an agent's endpoint have not thereby shown the endpoint serves what it should. A resolution target carries an integrity digest of the terminal discovery object; where two sources carry one, the discovery view now compares it. Agreed address, disagreeing digest, is a kind the endpoint comparison cannot express: the registries are honest, and the host behind the address is serving two documents — substitution at the host rather than at the source. The digest is compared only when both sides carry it; a registry that serves none contributes nothing, per Axiom 3, and can never be accused on the strength of a digest it never asserted.
8. Implementation and evaluation
sm-divergence implements the kernel — resolver protocol, view contract, pure diff, orchestration, finding dedup by stable fingerprint — with the discovery and identity layers, under the substrate conventions shared across the sm-* family (JCS canonicalization, Ed25519, did:key). A view-agnostic conformance corpus fixes the diff's behavior: agreement yields nothing; present-beside-absent yields omission with correct source attribution; distinct field values yield that field's finding; an unreachable source is excluded and can never create an omission; a soft-404 is a positive absence; one id can carry multiple simultaneous findings; a lower sequence in one scope yields stale_binding and no field divergence against the superseded source; equal sequences with different values still diverge; unrelated scopes are not compared by sequence; agreed endpoints with differing digests yield a digest finding.
The split is deliberate. The kernel (sm-resolver 0.7) knows nothing of any resolution profile: it reads a lease position as inert data on the view, exactly as it reads comparable fields, and applies supersession generically. The discovery layer (sm-divergence 0.12) supplies the known-subject resolver — one POST /resolve, the target mapped onto the view, expired, revoked and registry-as-target responses classified as errors with outcomes that say why — alongside the by-id resolver and the legacy two-hop index resolver, retained for sources still exposing that shape. The profile never learns the comparison; the comparison never learns the profile.
The evaluation is a staged, end-to-end scenario: one identity, four registry types, three trust mechanisms, two attacks. A single agent is published to an ANS-style registry (DNS-backed, served from two vantages), a signed-manifest catalog, and a native index, alongside the NANDA-style two-hop path — five observation points across four source types.
Beat 1 — baseline. The sweep reports AGREE: endpoints identical across all five observation points, signatures verified where the source type supports them, and the one source type without a transparency mechanism explicitly reported as unverified rather than silently trusted — the assurance asymmetry is itself part of the record.
Beat 2 — forged catalog. The signed catalog's entry is tampered: endpoint swapped to a hostile URL, manifest signature left stale. The sweep reports DIVERGENT, names the field (endpoints), lists every source's value, and attributes the suspect: the catalog, with outcome signature invalid — tampering and divergence caught together, at field level, with the culprit named. When the operator republishes honestly, the sweep returns to AGREE: the quilt heals, and the healing is itself recorded.
Beat 3 — split horizon. One DNS vantage is altered to serve a different endpoint than its twin. The sweep reports DIVERGENT with the disagreement localized per vantage of one source — the equivocation attribution of §3, unavailable to any single-perspective checker, and the exact attack class that moved the CA ecosystem to mandated multi-perspective validation.
Beat 4 — resolution registries (network-free, this revision). Four resolution registries answer POST /resolve for one subject: A current at sequence 14; B one behind at 13 with yesterday's target; C current at 14, agreeing with A on the address but serving a different digest; D validating the subject through a different issuer at an unrelated sequence. The sweep reports DIVERGENT with exactly two findings: stale_binding attributing B, with no endpoint divergence charged against it; and digest, naming A, C and D's values. D's unrelated scope produces nothing. Three conditions a plain endpoint comparison would have collapsed into one accusation are told apart, and the lagging registry is attributed rather than accused. (This beat runs against injected transports; a port of the live four-registry scenario onto resolution-profile registries is future work, §9.)
All attacks are detected read-only, with no cooperation from any source, no protocol changes, and no trust in any single participant. The demo exits clean.
9. Limitations and future work
Single-source first contact. Corroboration catches a source that disagrees with its peers or with itself across vantages. It cannot catch a single source lying consistently to all of this consumer's observations about an agent the consumer has never seen elsewhere — there is nothing to compare. Closing that last mile is transparency-log territory: an append-only, witnessed log of what each source served over time, a stricter and stateful primitive deliberately out of scope here, toward which the corroboration record is designed to be forward-compatible (a witnessed sweep history is a log of these records).
Independence and collusion. Section 3's assumption bears repeating as a limitation: k-of-n corroboration among sources that share an upstream, an operator, or an incentive is corroboration in name only. The mechanism records which sources agreed, enabling a consumer to weigh diversity; it cannot create diversity that a deployment lacks.
Watch-set bootstrap bias. A consumer cannot detect the omission of an agent it never watched, and a watch set built by enumerating a single source inherits that source's omissions at birth. Watch-set construction should itself draw on multiple sources; a principled treatment is future work. The resolution profile sharpens the constraint: its registries are exact-lookup, non-enumerable surfaces by design, so a sweeper must obtain its watch set from the subjects it serves or from consented sources, never from the registries it audits.
Fan-out as a privacy cost. A sweep reveals its watch set to every registry it asks. The profile treats exact-lookup endpoints as enumeration and denial-of-service targets; a sweeper over many sources and many subjects looks like a scraper to each of them. Rate-limiting one's own sweeps, consented watch sets, and sweeping from origins not attributable to the sweeping party are the mitigations; privacy-preserving exact lookup is open work the profile itself names.
Quorum. With more than two sources, threshold policies (k-of-n agreement, diversity-weighted quorums) are more robust than pairwise findings; the diff surfaces every pairwise split today, and a quorum reducer is a natural layer above it — policy, per Axiom 4, not kernel.
Cost. A sweep is |watch set| × |sources| × |vantages| read-only queries plus a pure diff; it is bandwidth-bound and embarrassingly parallel. The interesting scaling question is not compute but coverage: which subjects, how often, from where — a monitoring-economics question CT's ecosystem has begun to answer and agent discovery will inherit.
Live evaluation against resolution registries. Beat 4 runs against injected transports. The four-registry live scenario of beats 1–3 predates the resolution profile and uses the two-hop index path; porting it onto resolution-profile registries, including a direct DNS-anchored path as one source beside them, is the next evaluation.
10. DAWN alignment, NANDA alignment, and conclusion
The IETF DAWN charter draws a boundary this mechanism is built to respect: initial discovery of public properties, with integrity of the exchanged discovery information in scope and trust evaluation beyond secure exchange out. Corroboration is an integrity mechanism for the discovery exchange — it reports whether independent sources agree about a subject and attributes the one that does not — and it is not a trust mechanism for the agent: it never ranks, never prefers the better-attested claim, never lets authority evidence move a verdict. Registry-assisted resolution of known subjects defines what one registry's answer is; this paper defines what a verifier does with two; neither needs the other to change, and the companion draft states the composition normatively.
Project NANDA organizes the Internet of AI Agents into four pillars — DNS (discovery), CA (identity), Orchestration, and Attestation. Corroboration is a DNS-and-CA-pillar primitive: it protects the integrity of discovery and identity resolution themselves, the layer every attestation silently stands on. The alignment is structural, not nominal: NANDA's discovery layer is multi-source by design — a quilt of registries rather than a single directory, each resolving a known subject to a terminal target — and corroboration is only possible because of it. What federation built for resilience, this mechanism cashes out as accountability: a participant in the quilt can catch a source lying rather than having to trust it, can tell a source that is lying from one that is merely behind, and can hand any auditor the signed record of the catch — or of the agreement.
The same quilt that removes the single point of failure removes the single point of trust. This paper's contribution is the small, deterministic machine that makes the second property as real as the first.
Acknowledgements
Section 4.5 and the supersession rule of §5.1 exist because of Registry-Assisted Resolution for Known Subjects Without DNS Discovery Anchors by Ramesh Raskar, Samuel Sharaf and Pradyumna Chari, whose separation of registry provenance from subject authority, and whose renewable-binding model, are what this revision composes with. The author thanks the Project NANDA community, in whose quilt-of-registries architecture this work sits, and the IETF DAWN community, whose charter frames the boundary corroboration stays inside.
References
(informal; the Internet-Draft carries the normative reference set)
- Laurie, Langley, Kasper. Certificate Transparency. RFC 6962; and RFC 9162 (v2).
- Melara, Blankstein, Bonneau, Felten, Freedman. CONIKS: Bringing Key Transparency to End Users. USENIX Security 2015.
- CA/Browser Forum. Multi-Perspective Issuance Corroboration (Baseline Requirements amendment).
- IETF. Discovery of Agents With Names (DAWN) Charter. charter-ietf-dawn-01, 2026.
- Farrel, Yao, Schott, Williams. Terminology for the Discovery of Agents With Names (DAWN). draft-farrel-dawn-terminology, 2026.
- King, Farrel. Requirements for the Discovery of Agents With Names (DAWN). draft-king-dawn-requirements, 2026.
- Raskar, Sharaf, Chari. Registry-Assisted Resolution for Known Subjects Without DNS Discovery Anchors. draft-raskar-agentic-web-federated-resolution-02, 2026.
- Chandra. Multi-Source Corroboration for AI Agent Discovery. draft-chandra-agent-registry-corroboration-02, IETF, October 2026.
- Narajala, Courtney, et al. Agent Name Service v2 (ANS): A Domain-Anchored Trust Layer for Autonomous AI Agent Identity. Internet-Draft, 2026.
- Birkholz, Delignat-Lavaud, Fournet, Deshpande, Lasker. An Architecture for Trustworthy and Transparent Digital Supply Chains (SCITT). Internet-Draft.
- Mih. An Agent Action Capsule Profile for SCITT. Internet-Draft, 2026.
- Nelson. Delegation Receipt Protocol for AI Agent Authorization. Internet-Draft, 2026.
- Jongerius. Agent Receipts. agentreceipts.ai, 2025–2026.
- Raskar et al. Beyond DNS: Unlocking the Internet of AI Agents via the NANDA Index and Verified AgentFacts. Project NANDA, 2026.
- Nottingham, Wilde, Dalal. Problem Details for HTTP APIs. RFC 9457.
- W3C. Decentralized Identifiers (DIDs) v1.0; DID Method did:key.
- Rundgren, Jordan, Erdtman. JSON Canonicalization Scheme (JCS). RFC 8785.
License
MIT.