What is ARD?

ARD is short for Agentic Resource Discovery, an open specification for how AI agents find the tools, skills, agents and APIs they need, published in June 2026 by a working group including Google, Microsoft, Hugging Face, AWS, Cisco, GitHub, Nvidia, Salesforce and Snowflake.

An agentic resource is anything an AI client can call to get work done: an MCP server, an A2A agent, a skill, an API, a workflow.

ARD answers one question, "what is available for this task?", and then gets out of the way. It is not a runtime and does not replace MCP or A2A. It tells an agent what exists; the agent connects using the resource's own protocol.

The problem it solves

Today an agent can only use capabilities someone installed for it in advance. Every tool has to be wired in by hand, and every tool description has to sit in the context window, competing for space with the actual work. That model does not survive contact with an ecosystem of thousands of tools, let alone millions.

ARD moves the selection problem out of the context window and into a search service, the same shift the early web made when it went from curated link directories to search engines.

For that to work, two sides have to exist. Publishers describe what they offer at a well-known location on their own domain. Registries index those descriptions and answer queries. Neuronto is both.

Why a federated index

The specification defines three federation modes and makes auto the default: a registry queries its peers, merges their results, and returns one set.

In practice each public registry answers only from its own catalogue, so the same question asked in four places returns four different answers and the client has to pick a side. That is the problem Neuronto exists to remove.

Ask Neuronto once and the query fans out across every public ARD registry concurrently. Results are fused with reciprocal rank fusion, which combines the orderings rather than the scores, necessary because each registry calibrates differently, and importing another service's scoring would import its biases with it.

The response says which registries answered and which timed out, so a caller always knows how much of the federation is behind an answer.

What it does differently

Federated by default. federation: auto implemented as specified: concurrent fan-out under a hard time budget, fused ranking, per-upstream reporting. A slow peer costs the budget and nothing more.

Complete conformance. Passes the specification's official conformance tool as both a registry and a publisher with zero errors and zero warnings, including the optional GET /agents listing as a properly paginated object.

Type normalisation. Three media types for MCP servers are in circulation (application/mcp-server, application/mcp-server+json, application/mcp-server-card+json) and two URN prefixes appear as discovery identifiers (urn:air: and urn:ai:). Because filters match exactly, entries get dropped silently. Neuronto normalises both on ingest, so a filter for MCP servers returns them however the publisher spelled the type.

A verified tool index, not just a server index. Every other registry stores a server name and whatever prose its publisher wrote. Neuronto handshakes with each indexed MCP endpoint and reads its tools/list, so the index holds the real tool names and input schemas, the thing an agent actually has to match on. Currently 32,183 verified tools across 2,223 servers, plus 1,918 endpoints recorded as requiring credentials, which no other registry reports. Introspection is read only: a tool is never called.

Hybrid retrieval. Sparse BM25 and dense vectors, fused with the same reciprocal rank fusion used for federation, so one query runs lexical, semantic and federated retrieval and returns a single ordering. The dense leg rides inside the federation budget and contributes nothing if it is unavailable, so the lexical fast path is never slowed by it.

Verified liveness. Indexed endpoints are probed and non-responding ones demoted in ranking. Registries built on self-published manifests accumulate dead links quickly; serving them is the fastest way to become the index nobody trusts. Entries are demoted rather than deleted, because services come back.

Manifests generated from evidence, not from a form. Most domains will never author a manifest by hand. They already run an MCP server, or serve an OpenAPI document, or publish llms.txt, and the manifest is a restatement of things a crawler can already find. Neuronto probes a domain, emits an entry only for each resource that actually answered, records what proved it, and hosts the result. Nothing is inferred, because a generated manifest that guesses would put a claim on somebody's domain that they never made and cannot defend.

A private half of the index. The list of internal services an organisation's own agents may call usually lives in a system prompt, where nothing can search it and nobody can audit it. A domain that proves ownership by DNS can register those services, and one query then returns internal and public results together, each labelled with which it is. Private entries are held in separate storage from the public index rather than behind a flag, so no public search, count or page can reach them by construction.

Ranking that separates. A relevance score is only useful if the gap between the first and fifth result is legible. Scores are scaled to preserve real separation instead of compressing everything into a narrow band.

Where it fits

• Agent builders, stop hard-coding integrations. Ask for a capability at runtime and connect to whatever currently serves it best.
• API and tool vendors, publish one manifest on your own domain and become discoverable to every ARD client, without applying to a curated marketplace.
• Platform teams, run discovery over internal services so agents inside the organisation find them the same way they find public ones.

Using it

Search this index and the whole federation in one call:

curl -s https://neuronto.com/search \
  -H 'content-type: application/json' \
  -d '{"query":{"text":"scrape a website behind cloudflare"},"federation":"auto"}'

Or install it as an MCP server, so an agent searches from the interface it already speaks:

claude mcp add --transport http neuronto https://neuronto.com/mcp

Registry API

Knowing when the answer is weak

Every top result scores near 100. That is deliberate: the score is relative to the best hit in its own result set, because BM25 magnitudes are corpus and query dependent, so an absolute scale would mean nothing. It ranks well and, on its own, it misleads. The query zzzz nonexistent capability qqqq scores 100, because something always comes first.

So every search response carries one absolute number beside the relative ones:

"queryMatch": {
  "coverage": 0.0,
  "confidence": "none",
  "matchedTerms": [],
  "queryTerms": ["zzzz", "nonexistent", "capability", "qqqq"],
  "note": "each result's `score` is relative to the best hit in this response ..."
}

coverage is the fraction of the query's content words that the top result's own text accounts for. It is corpus independent, which is the property the score cannot have, so it separates "the best of several good answers" from "the best of nothing".

It measures overlap, not correctness. A query whose every word appears in an entry that does the opposite thing still scores 1.0. Treat it as a floor on confidence, never as a verdict, and never as a trust or safety rating.