Sharath Chandra — a research contribution by Stellarminds.ai, aligned with Project NANDA. Reference implementations: nanda-ans-quilt (four clean-room integration demos); sm-divergence 0.12 & sm-resolver 0.7 (corroboration). Companion papers: The Quilt That Checks Itself (corroborated discovery); draft-chandra-agent-registry-corroboration-02 (normative corroboration procedure).
Version 2.0 — 30 October 2026. Supersedes "The Index Points, the Registry Proves" (v1.0). The retitling is the substance of the revision: registry-assisted resolution of known subjects (Raskar, Sharaf, Chari; draft-raskar-agentic-web-federated-resolution-02) makes the registry, not an index, the party that points — a registry resolves a known subject to a terminal target and never to another registry. This revision restates the quilt model under that contract. Where v1.0 placed an index in the resolution path, v2.0 places it beside it: as the source of a client's registry configuration and as the audit layer over the registries. The four demonstrations are unchanged and are reinterpreted, not re-run; §7 states exactly which of their mechanics the new contract retires.
Abstract
Agent discovery is not converging on one registry; it is diverging into many — the GoDaddy Agent Name Service (ANS), DNS-anchored discovery (DNS-AID), signed capability catalogs, native NANDA agent cards, and now any registry implementing the registry-assisted resolution profile for known subjects — each with its own wire format, its own identity model, and its own notion of proof. Two monolithic answers are on offer and both are wrong. A single global index of agents recentralizes the internet it was meant to open, and becomes the one place every trust decision must pass through. A patchwork of incompatible registries leaves agents reachable only inside the island that happens to hold them.
This paper describes a third structure, the quilt of registries, and restates it under the contract that registry-assisted resolution has now fixed. The division of labor is exact and it is the paper's title. The Registry points: a client that already knows a subject asks one registry it selected by local policy, and that registry resolves the subject to a terminal target — an Agent Card, a descriptor, a subject-authorized gateway, never another registry — with its own provenance, subject-specific authority evidence, and a renewable binding carrying a sequence and an expiry. The Quilt proves: each registry carries its own cryptographic trust evidence — SCITT COSE receipts, RFC 6962 Merkle inclusion proofs, signed checkpoints — that a consumer verifies offline with that registry's own tooling; the registries are audited as logs; and the set of them is corroborated against each other, so that a registry which hides a subject, substitutes a target, equivocates by vantage, or merely lags behind its peers is named as such.
The index of v1.0 survives, in two roles the resolution contract leaves open and does not forbid. It is where a client's registry configuration comes from — base URI, expected identity and trust anchor, the subject types a registry may be asked for — which the resolution profile requires a client to hold and declines to standardize the acquisition of. And it is the audit layer: the place a registry's transparency-log checkpoint and keys are pinned and checked. It is never a hop in the resolution path.
We make four contributions, each demonstrated end-to-end with real cryptography rather than a mocked boolean. First, a registry-configuration index that answers one question — which registries may be asked about which subject types, and how to verify them — while the index never grows a row per agent and never answers for a registry. Second, domainless trust: an identity that is nothing but a keypair (did:key) receives scoped, revocable, transparency-logged authority delegated by a domain-anchored ANS provider — escalation cryptographically impossible, and GoDaddy's unmodified ans-verify binary accepting the delegation receipts as proof the wire contract was honored, not forked. This is precisely the subject class the resolution profile names as its reason for existing: a principal with a stable identity and no DNS anchor. Third, verifiable index entries: each registry row pins that registry's transparency-log checkpoint and keys, so the index — or anyone — can prove a registry live, consistent, and append-only, and catch one that has rewritten its history. Fourth, cross-registry corroboration: a sweep that asks every configured registry the same exact question and diffs the answers field by field, now reading the binding's sequence so that a lagging registry is attributed rather than accused, and the target's digest so that two honest registries can expose a host serving two documents behind an agreed address.
The structure that makes the discovery scale — one registry answering for its own subjects, selected by the client, forwarding to no one — is the same structure that makes it verifiable. The quilt that removes the single point of failure removes the single point of trust.
1. Introduction
The agentic web is being assembled out of registries that were designed independently, for different owners, under different constraints. GoDaddy's Agent Name Service gives domain-holders a name service for agents with a transparency-log-backed trust model. DNS-AID roots discovery in domain ownership and the existing DNS cache hierarchy. Signed capability catalogs (in the Agentic Resource Discovery style) let an operator publish a set of endpoints under one detached signature. Native NANDA agent cards describe an agent directly. And the registry-assisted resolution profile gives any operator a way to resolve a known subject — an agent name, an email, a DID, a workload identity — to a terminal target with provenance, authority evidence, and a renewable binding, for exactly the subjects DNS-anchored discovery cannot reach. Each is authoritative in its own domain, and each is a genuine response to a real requirement — identity, cacheability, batch publication, simplicity, coverage of the non-domain-holder.
The fragmentation is not the failure. The failure is the absence of a layer that lets these registries coexist without either collapsing into one or hardening into islands. Two monolithic designs are frequently proposed, and each trades one problem for a worse one:
- One global index of agents. Copy every agent from every registry into a single searchable directory. This scales badly — the index must ingest and re-index the union of all registries — and, worse, it recentralizes trust: the index becomes the single point that every consumer must believe, and the single point an adversary must corrupt. The open agent internet acquires exactly the chokepoint it was built to avoid.
- A patchwork of incompatible registries. Let each registry stand alone. An agent is then discoverable only by a consumer that already speaks its registry's format and already knows to look there. Cross-boundary discovery degrades to hardcoded endpoints and bespoke connectors, and the network effect that makes a multi-agent internet valuable never forms.
The resolution profile takes the first of these off the table by construction: it assumes no universal index or global root, makes registry selection a client or deployment policy decision, forbids a registry from forwarding a client to another registry, and forbids a target from being a registry at all. It takes the second off the table by giving heterogeneous registries one resolution representation — the Resolution Target Object — and one client procedure, so that a client configured with several registries can ask each the same question and understand each answer. What it deliberately does not do is say where a client's registry configuration comes from, how a client verifies that a registry is honest about its own history, or what a client does when two configured registries disagree.
This paper takes those three open positions, and grounds them in running code. The quilt of registries is many registries, each left exactly as its maker built it, each resolving its own subjects to terminal targets and forwarding to no one; an index of registries that supplies a client's configuration and audits the registries it names, without ever being asked for an agent; and a corroboration sweep that holds the registries to account against each other. The seams are the only new thing; the panels are untouched.
The title states the division of labor as a claim to be defended: the Registry points, the Quilt proves. The remainder of the paper defends it against the ways it can be misread — that an index outside the resolution path is too weak to be useful, that heterogeneous registries cannot yield uniform answers, that an index of pointers cannot itself be held accountable, that comparing registries must confuse a lagging one with a lying one — by exhibiting, for each, a demonstration with real signatures and real Merkle proofs.
Relationship to registry-assisted resolution
This revision exists because of draft-raskar-agentic-web-federated-resolution-02, by Ramesh Raskar, Samuel Sharaf and Pradyumna Chari, which narrows the earlier "global switchboard" model to the resolution of a known subject through one client-selected registry, aligned with the IETF DAWN charter. Three of its rules reshape the quilt. A registry response MUST NOT return another generic Resolution Registry as the terminal target, and a registry MUST NOT recursively query another on the client's behalf: the two-hop "index points to registry, registry serves record" topology of v1.0 is therefore not a resolution path under the profile. Registry selection is local configuration, which a client configuration SHOULD carry as the registry's base URI, expected identity or trust anchor, the subject types it may be queried for, and local policy — the exact contents of an index row (§3). And multiple independently operated registries MAY hold bindings for the same subject, which a resolver evaluates independently and local policy may select among or retain — the open position corroboration fills (§6). This paper adopts the profile's vocabulary — Subject Identity, Known Subject, Resolution Registry, Resolution Target, Authority Evidence, Registry Provenance, Renewable Binding — and uses it unchanged.
Relationship to prior work in this line
This paper sits beside two companions of its own — The Quilt That Checks Itself and the corroboration Internet-Draft — and builds on a third party's specification it does not claim any relationship to beyond citation. The resolution profile establishes that resolution — mapping a known subject to the right terminal target through one registry — is a distinct layer from search and from trust evaluation; this paper takes that layer as given and asks what the quilt around it must and must not do. The Quilt That Checks Itself and the corroboration Internet-Draft establish the corroboration primitive — resolve, view, diff, now with supersession by lease sequence — that turns multiple sources into an integrity check; §6 is that primitive applied across the registries of the quilt. This paper's own contribution is the structural one in the middle: the exact contract among a registry that points, an index that configures and audits, and a sweep that proves, and the demonstration that the contract holds under adversarial editing.
2. Background
2.1 Registry-assisted resolution of known subjects
The profile addresses one bounded case: a discovering entity already knows a Subject Identity and either has no usable DNS Discovery Anchor for it or has selected a registry by policy. The client sends one exact request — POST /resolve with the identity and its type, optionally constraining accepted target methods and result count, and never carrying intent, a capability query, or a next-registry field. The registry returns Registry Provenance and zero or more Resolution Target Objects, each with the normalized subject, a method (artifact or gateway), a target type and URL, an optional target digest, Authority Evidence (type, issuer, a verifiable reference), a sequence, issuance and expiry times, and optionally a revocation URL and a scope. A validated direct DNS-anchored path, where one exists, stays direct and is normally preferred; a resolver MUST NOT silently downgrade from it to a weaker registry result. Registration, proof acquisition, search, ranking, and trust evaluation are out of scope.
Two of its distinctions carry the rest of this paper. Registry Provenance — which registry answered, and that the response is intact — is not Authority Evidence — that the subject authorized this target — and a resolver must evaluate the second for every candidate rather than trusting registry presence. And a binding is a renewable lease, not a permanent claim: its sequence must increase whenever the target, publisher, ownership state or authority evidence changes, and a resolver holding several bindings from one authority scope must reject an older sequence once it has seen a newer valid one.
2.2 An index of registries, outside the resolution path
The NANDA Index, in the resolution architecture it descends from, is a distributed index of pointers rather than a centralized registry: authoritative discovery remains with each system. Under the resolution profile that stance is sharpened. An index MUST NOT be a hop a registry refers a client through, and an index that answered POST /resolve with a pointer to another registry would be a profile violation. What remains is what the profile leaves to local configuration and to deployment-specific bootstrap: which registries a client may ask, about which subject types, with what expected identity and trust anchor, under what policy. An index row carries exactly that — a registry operator, its base URI, the subject types it serves, and (per §5) its transparency-log checkpoint and verification keys — and it carries no agents. The client reads the row, configures itself, and then speaks to the registry directly. The index is consulted at configuration time, never at resolution time.
2.3 The Agent Name Service (ANS)
ANS is GoDaddy's open-source reference implementation of an agent name service. Its trust model is transparency-log-backed: a registration authority records agent registrations and status events into an append-only log, and a consumer verifies an agent's standing offline by checking a receipt — a SCITT COSE_Sign1 structure (CBOR tag 18, ES256), whose payload is bound into the log by an RFC 6962 Merkle inclusion proof against a signed checkpoint, cross-checked against a badge leaf hash and a status token. GoDaddy ships an offline verifier, ans-verify, and a client, ans-cli; both are used unmodified throughout the demonstrations below, so that "verified" in our output means GoDaddy's own binary walked a real proof, never a status flag we set. In the profile's terms an ANS receipt is Authority Evidence of a strong, log-anchored kind, and the ANS registry is one Resolution Registry among the quilt.
2.4 The other panels: DNS-AID, signed catalogs, native cards
The quilt is deliberately heterogeneous. DNS-AID discovers domain-anchored agents through real DNS records (SVCB/TXT, _ans and _ans-badge), inheriting DNS caching and, crucially, DNS's exposure to split-horizon answers; under the profile it is the direct DNS-anchored path that stays direct. A signed catalog publishes a set of entries under a single detached JWS (RFC 7515) over the JCS-canonical (RFC 8785) entry set, with keys distributed via JWKS. A native NANDA registry serves AgentFacts cards directly, with no transparency log — and is therefore, honestly, the panel with the weakest proof, which the system reports as such rather than papering over.
2.5 Domainless identity
Not every principal owns a domain. An individual or a small business may hold only a keypair, expressed as a did:key, or an account at a provider whose DNS namespace they do not control. DNS-anchored discovery has, by construction, nothing to say about such a principal: there is no zone to serve a record from. The resolution profile names this case as its motivation — the person identified by a provider-managed account, the small organization on managed infrastructure, the workload with a stable non-DNS identifier — and requires that Authority Evidence for such a subject be account-specific or issued under a delegation model that explicitly covers it. §4 shows that a scoped, logged, revocable delegation credential is such evidence, and that it is where an index-of-registries earns a role no purely domain-rooted system can fill.
2.6 Every panel in the profile's terms
The profile is not an ANS story, and neither is the quilt. The profile names two terminal target classes — an artifact ("an Agent Card, MCP server descriptor, workload descriptor, or a subject-owned discovery catalog") and a subject-authorized gateway — and a set of Subject Identity types with their own authority models (domain, email or provider-managed account, DID, platform identity, workload identity). Each panel of the quilt is one of those things, and saying which is what lets the sweep compare them without special-casing any:
| Panel | Role under the profile | Subject Identity type | Terminal target class | Authority Evidence | What the sweep compares |
|---|---|---|---|---|---|
| ANS (transparency-log-backed name service) | A Resolution Registry | agent-name / domain | artifact (agent record) | SCITT receipt + Merkle inclusion against the registry's log | endpoint, digest, verified DID, lease position |
| DNS-AID (SVCB/TXT, _ans / _ans-badge) | The direct DNS-anchored path — stays direct, never behind a registry | domain | the DNS record resolves to the descriptor | DNS/WebPKI domain control; badge receipt | endpoint per vantage (split-horizon is source_equivocation) |
| ARD signed catalog (detached JWS over a JCS entry set, keys by JWKS) | A subject-owned discovery catalog — an artifact target, hosted by the subject or a delegate; the catalog is what a registry's binding points to | agent-name / domain / DID | artifact (catalog) | the catalog signature itself, bound to the publisher key | endpoint; digest of the catalog — a re-endpointed entry under a stale signature is digest + signature-invalid |
| Native NANDA AgentFacts card | An artifact target with no transparency log | agent-name | artifact (Agent Card) | the card's own signature where present; otherwise none, reported as NOT VERIFIED | endpoint; verified DID only when the card verifies |
| did:key / did:web subject | A Subject Identity type; did:web is also a direct path to a DID document | DID | the DID document, or an artifact the registry binds the DID to | DID or wallet signature; for a domainless did:key, the delegation credential of §4 | verification key across methods (key), endpoint, lease position |
| Workload identity (SPIFFE-style) | A Subject Identity type the registry binds to a workload descriptor | workload | artifact (workload descriptor) | the workload identity credential | endpoint, digest, lease position |
| Index of registries | Not a target and not a registry: client configuration and audit (§3, §5) | — | — | pinned checkpoint and keys per registry | consistency and append-only growth of each registry's log |
Three things the table makes exact. ARD catalogs are not a second kind of registry; they are the artifact a registry resolves a subject to, and the profile's targetDigest is what pins them — so a catalog hijack under a stale signature is caught twice, by the catalog's own signature failing and by the digest disagreeing across registries that bind the same subject to the same catalog. DNS-AID is not a panel the sweep reaches through a registry; it is the direct path the profile requires to stay direct, and the sweep's value there is as the downgrade detector: a registry whose binding diverges from a current direct DNS answer is a finding attributing the registry. And the index is the one row that is none of these — it names registries, it does not resolve subjects, which is why it can audit without being audited as a source.
3. The Division of Labor: Configuring, Pointing, Proving
The contract has three parts, and their separation is the whole design.
3.1 What the index does: configuration, not resolution
The index answers one question, at configuration time: which registries may be asked about this kind of subject, and how do I verify each of them? A query returns the matching registry rows and nothing else. The index performs no DNS lookup, calls no registry, and holds no agent. A production ANS registry may stand behind a single index row for a very large agent population — one row, an entire name service — and the index neither ingests those agents nor mediates their resolution. The consumer takes the row, configures a resolver for that registry with the row's base URI, expected identity and trust anchor, and proceeds on its own.
This is the contract v1.0 called "pointer mode," made exact by the profile: the index is not a hop. A client that has configured itself from the index speaks to each registry directly, and a registry never refers a client back to the index or on to another registry.
3.2 What the registry does: it points
Each registry resolves a known subject to a terminal target in one hop, as the profile specifies, and that target carries the registry's provenance, the subject's authority evidence, and the binding's lease position. The registry is the only party that speaks for its own subjects. It is not the index's job to answer for it, and under the profile it would be a violation for the index to try.
3.3 What the quilt does: it proves, three ways
Proof lives with the registry and travels with the answer; the quilt adds two things a single registry cannot supply.
Each registry proves its own answer. For an ANS agent, the evidence is the SCITT receipt and its Merkle inclusion proof, verified by ans-verify in six concrete steps (keys fetched, receipt decoded, COSE signature checked, status token validated, badge leaf-hash cross-checked, inclusion proven). For a DNS-AID agent, discovery is a real DNS query and the trust evidence chains through _ans-badge to the same kind of transparency-log receipt. For the native registry, there is no log, and the system says so: the uniform response carries NOT VERIFIED (reason) rather than an unbacked green check. The vocabulary is the registry's own — the ANS SDK's VerificationOutcome values (OutcomeVerified, OutcomeInvalidStatus, OutcomeFingerprintMismatch, OutcomeSignatureInvalid, OutcomeTlogError, …) — so proof is reported in the registry's terms, not a lossy re-encoding of them.
The index proves the registry is honest about its history (§5): the row's pinned checkpoint and keys let anyone recompute a registry's log root from its published tiles and prove it append-only.
The sweep proves the registries agree (§6): one exact question to every configured registry, the answers diffed field by field, with lag attributed and substitution named.
3.4 The corroborating resolver: a bounded, bypassable convenience
A resolver service layered above the registries may ask several of them through thin per-registry adapters and attach verification evidence to a uniform response. v1.0 called this "resolve mode." Under the profile it must be understood precisely. It is a client-side fan-out over the client's own configured registry set, which the profile permits when local policy allows and bounds; it is not a registry forwarding to another registry, which the profile forbids. It issues exact lookups only and enumerates nothing. It is bypassable: a client may configure itself from the index and follow a single registry directly, and nothing in the quilt depends on the resolver being in the path. Its value is uniformity and corroboration, not authority: every claim in its output traces to a registry-side proof a client could have checked itself.
Demonstration (Demo 1, reinterpreted). One query surfaces agents from an ANS registry, a DNS-AID registry (discovered with actual SVCB/TXT queries), and a native NANDA registry, through the same adapters. The configuration query returns only registry rows — no DNS read, no fan-out — establishing that the index is not a hop. The corroborating resolver then asks each configured registry directly and attaches evidence: the ANS and DNS-AID agents come back VERIFIED by a real ans-verify run; the native agent comes back honestly NOT VERIFIED. One question, three registries, uniform answers, real cryptography — and the index never grew a row and never answered for a registry. The demo's two-hop adapter, in which an index row carried a registry_url that the resolver then followed, is retained in code as a legacy shape and is not a resolution path under the profile; §7 says so.
4. Domainless Trust: Authority Evidence Without a DNS Anchor
If the quilt only re-served domain-anchored agents, it would be a convenience layer over DNS. Its irreducible contribution appears where DNS has no answer at all: a principal that is only a keypair. This is the subject class the resolution profile exists for, and this section shows one form of the account-specific Authority Evidence it requires.
4.1 Delegation as a scoped, logged, revocable credential
A domain-anchored, ANS-registered provider delegates authority to a did:key subject by issuing a credential — JCS-canonical JSON under a detached JWS (ES256), the same signing idiom as ANS producer events. The credential is scoped to a strict subset of the provider's own registered capabilities, time-bounded, depth-bounded, and revocable, carrying a pointer to the transparency log where its issuance and any revocation are recorded:
{
"delegationId": "<uuid>", "schemaVersion": "DELEGATION-V1",
"issuer": { "ansName": "ans://v1.0.0.provider.example.com",
"identityId": "<RA-verified identity>",
"did": "did:web:provider.example.com" },
"subject": { "did": "did:key:z6Mk…" },
"scopes": ["translate.text.en-es"],
"issuedAt": "…", "expiresAt": "…",
"revocation": { "tlUrl": "…/delegations" },
"maxRedelegationDepth": 0,
"parentDelegation": null
}
In the profile's terms this credential is Authority Evidence of a delegation type: the issuer is the provider, the subject is the did:key, the evidence is the receipt, it is time-bounded and revocable, and it covers the account explicitly — which is what the profile requires of evidence for any subject whose authority cannot be inferred from a DNS zone. A Resolution Registry that binds did:key:z6Mk… to a target may carry this credential as the target's authority evidence, and a resolver verifies it against the delegation log rather than trusting registry presence.
4.2 Escalation is impossible — shown, not asserted
The credential's credibility rests on one invariant: scopes ⊆ provider.capabilities, chain-monotone (each redelegation hop is a subset of its parent), depth-bounded, and expiry-bounded. This is enforced in code and hardened by property-based tests that generate randomized superset, sibling-scope, expired-chain, over-depth, and post-revocation attacks by the hundred — all of which must be rejected, and are shown being rejected in the demonstration terminal alongside the honest chains that pass. Escalation is not disallowed by policy; it is unreachable by construction.
4.3 The chain resolves end-to-end, and breaks on revocation
Trust resolves in printed steps, each a real Merkle-verified hop:
did:key subject
→ delegation receipt (SCITT, Merkle-verified against the delegation log)
→ provider ANS registration (SCITT, Merkle-verified against the agents log)
→ provider verified identity (did:web, registration-authority-verified, log-sealed)
→ DNS anchor (_ans / _ans-badge records)
When the provider posts a DELEGATION_REVOKED event, re-resolution reports CHAIN BROKEN with the revocation receipt itself as Merkle-included evidence — a positive, provable statement that authority was withdrawn, not a silent disappearance. In profile terms: the binding's authority evidence is revoked, the binding is no longer current, and a registry still serving it is serving a revoked binding — which the profile forbids and which a sweep (§6) reports as such.
4.4 Wire-compatibility as the conformance proof
Delegation events cannot ride the ANS agent log — its event type enum is closed — so they are recorded in a standalone companion transparency log that reimplements the exact wire contract: SCITT COSE_Sign1 receipts (tag 18, ES256, VDS/VDP labels 395/396), RFC 6962 leaf hashes over JCS-canonical events, C2SP signed-note checkpoints, sumdb-note root keys, level-0 hash tiles — with the reference ANS implementation left entirely untouched. The conformance gate is the sharpest available: GoDaddy's unmodified ans-verify binary verifies the delegation receipts. The wire contract was honored, not forked, and the proof is that the other party's own verifier accepts it.
Demonstration (Demo 2). A did:key with no domain receives a scope-limited, next-day-expiring, at-most-once-redelegatable grant from an ANS provider; the delegation is logged; ans-verify verifies the delegation receipt; the chain resolves to a DNS-anchored root; live escalation attempts are rejected; a property suite of hundreds of attacks all fail; and revocation breaks the chain with evidence.
5. Verifiable Index Entries: The Quilt Made Auditable
A configuration row is only as good as the honesty of the registry it names. The third contribution closes the loop: it makes an index row a verifiable claim about a registry, and makes the index the place that claim is checked. This is the content the profile asks a client configuration to hold — the registry's expected identity or trust anchor — supplied in a form that can be verified rather than merely believed.
5.1 An index row pins the registry it names
Each registry row carries, beyond its base URI and subject types, the registry's transparency-log checkpoint, its verification keys, and an audit stamp. These turn "trust this registry" into a checkable proposition rather than an act of faith, and they are what a resolver compares a response's Registry Provenance against: a registry that identifies itself in a response as something other than the row it was configured from is not the registry that was configured.
5.2 Four real checks
An auditor verifies each registry in the quilt with cryptography, not policy:
- Checkpoint signature — parse the C2SP signed note, verify the ECDSA P-256 signature against the pinned sumdb-note verification key, check the 4-byte key hash.
- Root recomputation — fetch the log's own level-0 Merkle tiles, recompute the RFC 6962 root from every leaf hash, and require it to equal the signed checkpoint root. The registry's published data must reproduce its signed claim.
- Append-only proof — recompute the root at the previously pinned tree size from today's leaves; if it matches the pinned root, the old tree is a prefix of the new one. History only grew; nothing was rewritten.
- The catch — a doctored copy of the log with a single byte flipped in one leaf hash is audited the same way and flagged INCONSISTENT: the recomputed root no longer matches the signed checkpoint, and the index marks the registry accordingly.
The same pipeline audits two independent registries in one run — the ANS reference log and the delegation log of §4 — showing that the audit spans the quilt rather than special-casing one panel.
5.3 From audit layer to witness network
An index that can prove a registry honest, and catch one that is not, is not a phone book; it is the audit layer of the quilt. It is also one countersignature short of a checkpoint witness network: if the index co-signs the checkpoints it has verified, its consumers inherit that verification without re-running it, and a registry that equivocates about its own log across time is caught by the witness rather than by each consumer independently. The profile itself names "a transparency mechanism for detecting conflicting or malicious bindings without creating a public enumeration surface" as an open question; a witnessed history of corroboration records (§6.3) over registries whose logs are witnessed here is the shape of an answer. We note this as the natural next step rather than claim it.
Demonstration (Demo 3). Index rows carry checkpoint, keys, and audit stamp; the auditor verifies the checkpoint signature, recomputes the root from published tiles, proves append-only growth across a fresh registration, and flags a one-byte-tampered copy INCONSISTENT — across two registries in the same run.
6. Cross-Registry Corroboration: One Subject, Many Registries
Demos 1–3 audit registries one at a time. The fourth audits them against each other, and in doing so fills the position the resolution profile leaves open: multiple registries may hold bindings for the same subject, a resolver verifies each independently, and local policy may select one or retain several. Nothing in the profile says how a client notices they disagree.
6.1 Why the sweep can do this and no registry can
The same subject may be bound in several registries at once, under different authority evidence. No registry can detect that a different registry — or a different network vantage of itself — is telling another story about that subject; each sees only its own answer, and the profile forbids it from asking another. The corroborating resolver of §3.4 is the one component that holds answers from several registries and has normalized them to a common shape. Corroboration is therefore not an extra service bolted on; it is a capability the client-side fan-out uniquely already has — and it is performed by the party holding the claims, so no registry forwards, communicates, or routes.
6.2 The sweep, with supersession
A divergence sweep asks every configured registry the same exact question about one subject, normalizes each answer to one record shape — endpoint, digest, verified identity, and the binding's lease position (sequence and authority scope) — and diffs field by field. The lease position is read before any field is compared: within one authority scope the highest sequence is current, a lower one is superseded, attributed to the registry serving it as stale_binding, and withheld from the field comparison. A registry one step behind is therefore named as behind, never as having forged an endpoint. Equal sequences with different targets are the disagreement supersession exists to isolate, and still fire. Two registries validating the subject through different issuers have unrelated sequence spaces, and neither their issuers nor their sequences are compared as values — authority evidence is provenance in the record, never a reason to prefer one claim, because a sweep that preferred the better-attested claim would be doing the trust evaluation the profile and the DAWN charter exclude.
In the demonstration the subject lives in four panels with three mechanisms: an ANS transparency log (acme-ans), a DNS-AID zone served from two vantage points (skyblue-dnsaid), a signed catalog (meadow-ard, detached JWS over the JCS-canonical entry set), and a native card registry (nanda-native-demo, honestly NOT VERIFIED). The sweep yields one of the corroboration verdicts — AGREE, DIVERGENT, or INSUFFICIENT — over the set:
- AGREE — every source returns the identical endpoint set and every verifiable source verifies.
- Catalog hijack caught — one catalog entry's endpoint is swapped while the old signature is left in place. The sweep flags DIVERGENT, names the exact field and registry, and marks the source suspect with OutcomeSignatureInvalid: the endpoint disagrees with its peers and the manifest no longer verifies. When the operator re-publishes honestly, the quilt heals back to AGREE. Under the profile the ARD catalog is the artifact target a registry binds the subject to (§2.6), and this is the case the
targetDigestexists for: a registry that still carries the pre-hijack digest disagrees with one that fetched the altered catalog, so the substitution surfaces asdigesteven before the signature check runs. - Split-horizon DNS caught — one DNS vantage is edited to answer with a different endpoint than the other. The sweep flags the disagreement per vantage — DNS's form of the equivocation attack, detected precisely because the sweep compares answers across vantage points, not just across registries.
Two further conditions, added in this revision and exercised against resolution-profile registries in the corroboration reference implementation (network-free, with injected transports; the live port is future work):
- Lag attributed, not accused — registry B serves a binding at sequence 13 where A and C serve 14 in the same scope. The sweep reports
stale_bindingattributing B and charges no endpoint divergence against B's superseded target. - Host substitution caught — A and C agree on the target address but C serves a different target digest. The sweep reports
digest, naming both: the registries are honest, and the host behind the agreed address is serving two documents, a condition the endpoint comparison alone cannot express.
6.3 Connection to the corroboration record
The verdict is not a transient console result. In the corroboration line, a sweep emits a signed, content-addressed corroboration record — the same AGREE / DIVERGENT / INSUFFICIENT verdict, with the per-source findings and, from corroboration/0.4, each claim's lease position — that any action-evidence format can bind by digest, converting "the subject I acted on was the multi-source consensus at time T" from an assumption into a verifiable claim. This paper supplies the substrate that record describes: the heterogeneous registries, the normalization, and the field-level diff across them. Signatures on served artifacts close tampering at the source (the stale catalog signature is caught by verification); cross-source digest comparison closes tampering at the host; cross-source comparison closes omission; cross-vantage comparison closes equivocation — the split-horizon zone; and supersession keeps lag from being any of them. The quilt built for reach doubles as the quilt that checks itself.
Demonstration (Demo 4). One identity in four registries; the sweep proves AGREE across all endpoints and signatures, then catches a re-endpointed-but-stale-signed catalog and a split-horizon DNS zone, naming the field, registry, and vantage in each case, and heals to AGREE on honest re-publication. The supersession and digest beats run in the corroboration reference implementation against four injected resolution-profile registries.
7. Implementation and Evaluation
The four demonstrations are one codebase, nanda-ans-quilt, run clean-room: each demo starts from a wiped data directory, brings up exactly what it needs, registers and publishes fresh, runs the flow, prints verification output, and exits non-zero on any failed check. The gate for declaring a phase done is two consecutive clean-room green runs.
Components. A TypeScript/Fastify switchboard hosts the configuration and corroborating-resolver endpoints, the three thin adapters (ANS, DNS-AID, native), and the trust evaluator; the mock index is a table of named registry operators. A set of Go binaries provides the delegation transparency log, the delegation CLI (issue / revoke / verify-chain), and the checkpoint/consistency auditor, built on the same Merkle and note libraries as ANS itself. A zero-dependency console streams real demo runs to a browser. The corroboration kernel and its known-subject resolver are sm-resolver 0.7 and sm-divergence 0.12.
What this revision retires, and what it keeps. The demonstrations were built before the resolution profile was published, and one of their mechanics is now a legacy shape: the two-hop adapter, in which an index row carried a registry_url that the resolver followed to fetch a record. Under the profile that is a registry referring a client to another registry, which is forbidden, and the corroboration reference implementation marks the corresponding resolver as legacy and adds the one-hop known-subject resolver beside it. Nothing else changes: the ANS, DNS-AID and native adapters are per-registry resolvers of exactly the kind the profile permits a client to run; the configuration query is what the profile leaves to local policy; and the audit and sweep are outside the resolution path by construction. The demos are reinterpreted here, not re-run; porting them onto resolution-profile registries, with the direct DNS-anchored path as one source beside them, is the next evaluation (§9).
Honesty rules (the evaluation's integrity constraints). Three rules are enforced throughout, and they are what make the results claims rather than screenshots:
- verified: true is only ever produced by a real ans-verify run — COSE ES256 signature, RFC 6962 Merkle path, badge cross-check. Anything else prints NOT VERIFIED (reason).
- The ANS reference stack runs unmodified at a pinned commit; the delegation log is a companion service speaking the same wire format, proven by the stock verifier accepting its receipts. Nothing modifies NANDA Index core and nothing assumes changes to production ANS.
- Registries in the mock index are named operators; a production ANS deployment appears only as a configuration row and is never fanned out to. The demos have no dependency on unmerged upstream work.
What is proven, and what is not. The demonstrations prove the four contracts of the quilt under adversarial editing: uniform cross-registry answers, domainless trust with impossible escalation, auditable index entries, and cross-registry corroboration. They do not prove — and do not claim — behavior of production ANS at scale, and they do not resolve production agents. The Agent Trust Card flow is implemented at the badge-plus-receipt level, but the ANS SDK's verify-trust-card command does not yet exist anywhere in the ecosystem; the adapters implement the flow and speak the SDK's outcome vocabulary so they remain byte-compatible with the day that command ships. These boundaries are stated rather than blurred.
8. Relationship to the Accountability Substrate
This paper describes the discovery-and-trust floor beneath agent accountability. In the layering of the broader work, registries point, the quilt proves identity, standing and consensus, and action-evidence records (capsules, receipts, permits, delegation records) record what an agent did and was authorized to do. The corroboration verdict of §6 is what connects the two: it is the trust context an action-evidence record binds by digest, so that an attestation over an action can assert not merely that the action happened and was authorized, but that the subject it was performed against was the multi-source, multi-vantage consensus of the registries at the time — and that any registry which disagreed was lying, or merely behind, and the record says which. This paper is a layer below and feeding that substrate — it establishes what the registries collectively say about a subject; it does not judge whether an action taken against that subject was correct or wise, which is out of scope for the entire line, as it is for the DAWN charter. It is a complement to NANDA, ANS and the resolution profile, not a competitor to any: it modifies none of them, and its strongest results are gated on the other parties' own unmodified verifiers accepting its artifacts.
9. Limitations and Future Work
We state the residue honestly, in the manner of the companion papers.
- Corroboration does not catch the consistent liar. Cross-source comparison catches a source that disagrees with its peers; cross-vantage comparison catches a source that answers differently across vantages; supersession tells a lagging source from a lying one. None catches a single source that lies consistently to every client from every vantage. That last mile is witnessed-transparency-log territory, and §5.3's witness network is the path toward it.
- The witness/cosigning network is described, not built. The auditor proves consistency and append-only growth; having the index co-sign the checkpoints it verifies — so consumers inherit verification and time-equivocation is caught centrally — is the identified next prototype, not a present result.
- The demonstrations predate the profile. Demos 1–4 run against the two-hop and adapter shapes of mid-2026; the supersession and digest beats run in the corroboration reference implementation against injected resolution-profile registries. A port of the live scenario onto
POST /resolveregistries, with the direct DNS-anchored path as a source, is the next evaluation. - Fan-out and enumeration. The profile treats exact-lookup endpoints as enumeration and denial-of-service targets and forbids unbounded fan-out. A sweep is bounded by its configured set and enumerates nothing, but it reveals its watch set to every registry it asks; consented watch sets, self-rate-limiting, and sweeping from unattributable origins are mitigations, and privacy-preserving exact lookup is open work the profile names.
- Production integration is partner-side and forward-looking. The demonstrations run against the open-source ANS reference implementation at a pinned commit. The trust-card CLI command is anticipated, not shipped; some ecosystem plumbing is open work the demos deliberately do not depend on.
Future work follows these seams: cosigning witnesses over registry checkpoints, a normative binding between corroboration verdicts and action-evidence formats, the live port onto resolution-profile registries, and broadening the panel set (telecom, IoT, and sovereign registries) that the same point-and-prove contract can absorb without change.
10. Conclusion
The instinct when discovery fragments is to consolidate. Consolidation trades fragmentation for a chokepoint, and rebuilds inside the open agent internet the single point of trust it was meant to remove. Registry-assisted resolution refuses that trade at the protocol level: one registry, selected by the client, answering for its own subjects, forwarding to no one. The quilt of registries refuses it at the architecture level. It keeps every registry exactly as its maker built it and adds only seams: an index that configures and audits, one row per registry, reading nothing at resolution time and adjudicating nothing; registries that point, each resolving its own known subjects to terminal targets in its own cryptography; and a sweep that proves, holding the registries to account against each other and telling the one that lies from the one that is behind. The demonstrations show the seams hold under adversarial editing — a hijacked catalog, a split-horizon zone, a tampered log, an attempted privilege escalation, a lagging binding, a substituted document — and that they hold precisely because the party being convinced runs its own verifier.
The paper's title is its result. The Registry points; the Quilt proves; and because no index swallows the registries' agents and no registry forwards to another, the very structure that lets discovery scale is the structure that lets it be audited. The quilt that removes the single point of failure removes the single point of trust with it.
Acknowledgements
Version 2.0 of this paper exists because of Registry-Assisted Resolution for Known Subjects Without DNS Discovery Anchors by Ramesh Raskar, Samuel Sharaf and Pradyumna Chari, whose narrowing of the earlier switchboard model to one client-selected registry, one known subject and one terminal target is the contract this revision restates the quilt under. The author thanks the Project NANDA community, in whose quilt-of-registries architecture this work sits, GoDaddy's ANS team, whose unmodified verifier is the conformance gate for §4, and the IETF DAWN community, whose charter frames the boundary this line of work stays inside.
References
[1] R. Raskar, S. Sharaf, P. Chari. Registry-Assisted Resolution for Known Subjects Without DNS Discovery Anchors. Internet-Draft, draft-raskar-agentic-web-federated-resolution-02, IETF, October 2026.
[2] IETF. Discovery of Agents With Names (DAWN) Charter. charter-ietf-dawn-01, 2026.
[3] A. Farrel, K. Yao, R. Schott, N. Williams. Terminology for the Discovery of Agents With Names (DAWN). Internet-Draft, draft-farrel-dawn-terminology, 2026.
[4] S. Chandra. The Quilt That Checks Itself: Corroborated Discovery for the Internet of AI Agents. v1.1, Stellarminds.ai, aligned with Project NANDA. Reference implementation: sm-divergence, sm-resolver.
[5] S. Chandra. Multi-Source Corroboration for AI Agent Discovery. Internet-Draft, draft-chandra-agent-registry-corroboration-02, IETF, October 2026.
[6] NANDA Index — federated resolution architecture and switchboard model. Project NANDA / MIT.
[7] Agent Name Service (ANS) — open-source reference implementation and ans-verify / ans-cli tooling. GoDaddy.
[8] draft-narajala-ans — Agent Name Service. Internet-Draft, IETF.
[9] B. Laurie, A. Langley, E. Kasper. Certificate Transparency. RFC 6962, IETF, 2013.
[10] SCITT — Supply Chain Integrity, Transparency and Trust. IETF SCITT working group; COSE_Sign1 (RFC 9052) receipts.
[11] M. Jones, J. Bradley, N. Sakimura. JSON Web Signature (JWS). RFC 7515, IETF, 2015.
[12] A. Rundgren, B. Jordan, S. Erdtman. JSON Canonicalization Scheme (JCS). RFC 8785, IETF, 2020.
[13] M. Nottingham, E. Wilde, S. Dalal. Problem Details for HTTP APIs. RFC 9457, IETF, 2023.
[14] W3C. Decentralized Identifiers (DIDs) v1.0, 2022; did:key and did:web methods.
[15] Reference implementation: nanda-ans-quilt — four clean-room NANDA ↔ ANS integration demos. Stellarminds.ai.