Agentic Resource Discovery: AWS Backs the ARD Spec in 2026

Agentic Resource Discovery (ARD) is an open specification for how AI agents find tools, MCP servers, skills, and other agents at runtime rather than having them wired in ahead of time. Publishers describe capabilities in a JSON file on their own domain; registries crawl those files and answer plain-language queries.

TL;DR

ARD launched on June 17, 2026. Microsoft, Google, GoDaddy, and Hugging Face are named as the core collaborators, and the contributor wall lists eleven companies.^{1 2 3} Amazon was not among them.

That changed on August 24, when AWS published its own ARD post and framed the spec as the federation layer over its Agent Registry.⁴ Amazon is now listed on the project's four-member Oversight Board.⁵

So all three major clouds are behind one agent discovery spec, with six reference implementations documented and several of them running in public.⁶ The spec is still a draft, it is mid-migration between two manifest formats, and neither Anthropic nor OpenAI is in the coalition.^{7 8}

What you'll learn

• What Agentic Resource Discovery actually is, and the one job it does
• What changed in August, and why AWS's arrival matters more than a blog post
• How the ard.json manifest and registry search endpoints work
• Whether ARD replaces MCP (it does not) and how the two compose
• Who controls the spec — the board, the maintainers, and the seat rules
• The v0.91 migration that will break your manifest if you follow the wrong page
• What has actually shipped: six reference implementations, and who's missing

What Agentic Resource Discovery is

ARD answers one question for an AI client: what is available for this task?

It sits entirely before invocation. The spec's own framing is blunt — it helps a client find the right resource, and then gets out of the way while the resource is called through its native protocol.⁹

The motivation is a context-window problem, not a networking one. Most clients today select tools by stuffing every tool description into the context window, which the spec says "does not scale."⁷

ARD moves selection out of the model and into a search service, where richer signals — representative queries, publisher identity, compliance metadata, usage patterns — can be used without spending tokens.⁷

The project is careful not to oversell that. Its FAQ notes discovery "doesn't eliminate context cost, it shrinks it from thousands of candidate tools down to a handful" — you still pay for the two or three schemas that get injected.¹⁰

Microsoft's framing was the web analogy. Early browsers shipped with bookmarks, hand-curated directories couldn't keep up, and search engines "lit the web up." Its post argues the ecosystem of available tools "already numbers in the hundreds of thousands," while any single agent sees a fraction of it.²

One common misreading is worth heading off. ARD is not runtime-only: the project calls that "the most common misconception," and says discovery can happen at build time — a developer choosing what to wire in — against a curated, closed catalog, using the identical request.¹⁰

What changed in August

The June launch had a conspicuous gap. The eleven-company contributor wall covered Cisco, Databricks, GitHub, GoDaddy, Google, Hugging Face, Microsoft, Nvidia, Salesforce, ServiceNow, and Snowflake — no Amazon.^{2 3}

AWS was acknowledged in the spec document itself (Jeffrey Damick and Martin Ristov), so it had contributed feedback.⁷ It just hadn't made a public commitment.

On August 24 it did. AWS published "Agentic Resource Discovery (ARD): An open specification for agent discovery," positioning ARD as the interoperability layer over AWS Agent Registry, which has been in preview since April 9 in five regions.^{4 11}

AWS's own analogy is DNS, not search: local registries federate through ARD "without requiring bilateral agreements or proprietary connectors," with enforcement staying at the local registry.⁴

The governance page carries the harder signal. The ARD Oversight Board lists four members — Google (Todd Segal), Hugging Face (Shaun Smith), Microsoft (Dhruv Chand), and Amazon (Jeffrey Damick) — with at most one seat per company, and eligibility requires "a committed product or offering that implements or supports ARD."⁵

A board seat is a product commitment, not a press release.

How ARD works: catalogs, registries, and ard.json

Two primitives do the work.

Catalogs. A publisher hosts a manifest listing what it offers, at https://<domain>/.well-known/ard.json.^{8 10}

The project calls this publishing sovereignty: you host the file, and "any compliant discovery service can find and index your endpoint organically, without requiring permission."¹⁰

Each entry carries an identifier, a display name, a media type, and either a url pointing at the artifact or the artifact data inline — exactly one of the two, never both.⁷

The media type is what makes ARD artifact-agnostic. application/mcp-server+json, application/a2a-agent-card+json, application/ai-skill, and nested catalog bundles all travel in the same envelope.^{7 8}

One caveat the spec states plainly: those MCP and A2A media types are de-facto community conventions with formal IANA registration still pending, and implementers are told to skip strict type verification in the meantime.⁷

Entries can also carry representativeQueries — two to five natural-language phrases like "get the 5-day forecast for Seattle" — which registries use to build the semantic embeddings they rank on.^{7 8}

That field is load-bearing in a way the name hides. Per the glossary, an entry without representative queries "cannot be found by search" — it is a valid catalog entry but not an ARD entry.⁸

Registries. These crawl catalogs and expose search. A compliant registry must offer POST /search; POST /explore (facet browsing) and GET /agents (deterministic listing) are optional.⁷

Crawling published manifests is not optional on the registry side. Web ingestion is mandatory for every ARD implementation; scanning git, npm, or OCI registries is left to the implementer.⁷

Federation is a query parameter, not a protocol. A client sends federation: auto to get upstream results merged in, referrals to get pointers to other registries it can query itself, or none to stay local.^{7 8}

Beyond the well-known path, publishers can advertise a catalog through a robots.txt Agentmap: directive, an HTML <link rel="ai-catalog"> tag, or DNS service binding records under _catalog._agents and _search._agents.⁷

Does ARD replace MCP? No

This is the question the spec anticipates, and the answer is unambiguous: "ARD is a discovery protocol (an envelope), not an execution mechanism."⁹

MCP defines how an agent calls a tool. ARD defines how the agent finds out the tool exists. Once a capability is selected, the client connects using the resource's own mechanism — JSON-RPC for MCP, and so on.⁹

The relationship to existing registries is subtler. ARD's pitch is inversion: instead of submitting a resource into every catalog, you describe it once on your own domain and let any discovery service index it.⁹

Existing curated catalogs don't disappear under that model — they become ARD discovery services, applying their own trust and ranking policy over indexed entries.⁹

If you're weighing this against the protocol stack you already run, our earlier coverage of MCP's stateless protocol and enterprise authorization and of A2A joining the Agentic AI Foundation covers the execution and governance layers ARD sits above.

Trust: domain ownership, and what the score is not

ARD anchors identity in DNS. Every identifier must follow a domain-anchored URN — urn:air:<publisher>:<namespace>:<agent-name> — where the publisher segment is a verifiable domain.⁸

The reasoning is anti-squatting. A registry extracts the domain from the URN and cross-references it against the cryptographic claim in the entry's trustManifest, so a manifest hosted on untrusted.com cannot pose as urn:air:google.com:....¹⁰

The optional trustManifest carries a workload identity (did:web, SPIFFE, or an Agent Name Service identity), attestations such as SOC2 or HIPAA, provenance links, and a detached JWS signature.^{7 10}

But the project is emphatic about the limits of all this. "ARD does not make any agentic resource trustworthy," its FAQ says — trust "comes from the curation of the registry, not from the protocol."¹⁰

One line deserves highlighting, because it is the kind of thing that gets misread in production. The 0–100 relevance score a registry returns is informational ranking only, and the spec says orchestrators "MUST NOT" treat it as a trust, compliance, or safety rating.^{7 8}

A high-scoring result is a relevant result, nothing more — a distinction worth keeping in mind alongside the agent identity problem enterprises are already wrestling with.

Who controls the spec

The governance model is deliberately small, and unusually explicit about capture.

The Oversight Board sets direction and approves major versions: four to seven members, at most one per company, and — stated in bold on the page — "ARD accepts no money for participation," with no seat, vote, or influence available for purchase.⁵

The Maintainers own the technical calls, five to seven members deciding by majority vote. At least two must be members at large, not employed by any company holding a board seat.⁵

R.V. Guha chairs the maintainers and co-authored the spec alongside Junjie Bu (Google) and Shaun Smith (Hugging Face).^{7 5} Guha's earlier work produced RSS, RDF, and schema.org — a track record in exactly this kind of publish-and-crawl infrastructure.¹²

One wrinkle the site doesn't explain: the specification lists Guha's affiliation as Microsoft, and Microsoft's own blog bylines him as a technical fellow there, while the governance page seats him as a member at large — a category it defines as not employed by any company holding a board seat.^{7 2 5}

Whether ARD lands under a neutral host — W3C, an AI foundation, or similar — is explicitly deferred "roughly twelve months out."⁵ Several open items remain undecided, including term lengths, quorum, and how a company joins the board after the initial cohort.⁵

The v0.91 migration nobody has finished

Here is the thing that will cost you an afternoon if you follow the wrong page.

ARD changed its manifest. The current convention across the documentation site is /.well-known/ard.json with urn:air: identifiers.^{8 10 13} The earlier convention was /.well-known/ai-catalog.json with urn:ai:.

This was a deliberate split, not a typo. The glossary now describes AI Catalog as "a separate manifest standard that predates ARD and shares much of its vocabulary," and states that ARD "defines its own ARD entry and its own manifest at ard.json; the two are independent specifications."⁸ At launch, Google described ARD as built on the AI Catalog data model.¹

The version boundary is documented in passing. The Reference Implementations page notes that one implementation "currently serves the pre-v0.91 /.well-known/ai-catalog.json path rather than /.well-known/ard.json," with ard.json support "pending upstream."⁶

The catch: spec/ard.md in the repository has not been updated. As of September 1, 2026, it still reads v0.9, dated May 28, 2026, and still specifies /.well-known/ai-catalog.json and urn:ai: — while the README calls that same file "the single source of truth."^{7 14}

Live publishers are split down the same line. Cisco's AI Catalog and the Ora Directory serve ard.json; Hugging Face's Hub catalog and DataRobot's catalog are still on ai-catalog.json.^{6 15 16}

Practical advice: publish ard.json with urn:air: identifiers, because that is what the guides, the glossary, and the FAQ all describe, and it is what the newer live implementations serve.^{13 8 10} Serving the old path alongside it is cheap insurance while crawlers built against v0.9 catch up.

And budget for one specific snag. The repository's JSON Schema still pins the identifier pattern to ^urn:ai:[a-zA-Z0-9.-]+(:[a-zA-Z0-9._-]+)+$, so the project's own conformance tool will reject a manifest written with urn:air: identifiers until that schema is updated.¹⁷

What has actually shipped

More than the launch coverage suggested. The project documents six reference implementations.⁶

Hugging Face Discover Tool. Search over Skills, ML applications, and MCP servers, built into the hf CLI (hf discover search), plus a REST endpoint and an MCP endpoint. Its own catalog is published at huggingface.co/.well-known/ai-catalog.json.^{6 15}

GitHub Agent Finder. A discovery service at agentfinder.github.com/api/v1, reachable by Copilot as a remote MCP tool; it "returns ranked matches you choose to install."⁶ GitHub's changelog is blunt about the boundary — "It doesn't silently connect anything" — and the feature is available on all Copilot plans.¹⁸

Cisco AI Catalog. The AGNTCY Agent Directory reference implementation, deployed at ai-catalog.outshift.io and serving the newer ard.json path.⁶

Ora Directory. Documented as implementing the full protocol surface — /search, /explore, and /agents with filter expressions and referrals — scoring products for agent-readiness and signing each scorecard as a detached Ed25519 JWS.⁶

ANS Finder. The discovery service of the open-source Agent Name Service reference implementation in Go, where every entry's attestation resolves to a SCITT receipt on a transparency log. Self-hosted, not a public endpoint.⁶

MCP Gateway Registry. Apache-2.0 and self-hostable, covering both publisher and registry roles plus registry-to-registry federation.⁶

What hasn't shipped is the platform-native support. Google said native ARD support in Gemini Enterprise Agent Platform was coming "in the coming months" — that was June 17.¹ AWS describes ARD as a complement it expects to enable cross-environment discovery, using forward-looking language throughout.⁴

That last row is the one to sit with. Anthropic, which created MCP, and OpenAI are both outside the coalition — which matters for a spec whose value proposition is coverage.

It is also not fatal. ARD is deliberately an envelope: an MCP server described in an ARD entry is discoverable whether or not Anthropic ever ships an ARD client, and the project already publishes client connectors for Claude, ChatGPT, GitHub Copilot, Microsoft Copilot, and Gemini.¹⁹

What this means if you publish agentic resources

If you operate MCP servers, skills, or agents that other people's software should be able to find, the cost of participating is one static JSON file.

That is a genuinely low bet. It is also, per the project's own warning, not a guarantee: publishing makes you discoverable, but each discovery service decides for itself what it indexes.¹³

If you're a consumer rather than a publisher, the useful question is narrower. Ask your platform vendors whether they intend to expose an ARD search endpoint, and what they will require you to publish — because a discovery layer is only as good as the registries willing to crawl it.

And if you run an internal registry, the federation story is the one to evaluate. ARD's referrals mode is the mechanism for merging internal, vendor, and public results without handing anyone else control over the answer set.⁷

Bottom line

ARD is the least glamorous layer of the agentic stack and possibly the one that decides its shape. Execution protocols already exist; what's been missing is a way for an agent to learn that a capability exists at all.

AWS's August commitment is the substantive change. Three hyperscalers on a four-seat board is the point at which an open spec stops being one vendor's proposal, and six documented reference implementations is more than a paper standard.

The caveat is that it is still a draft, Anthropic and OpenAI are outside it, and the manifest format changed underneath a repository file that hasn't been updated. If you publish agentic resources, ship ard.json anyway — it's one static file against a plausible future. If you're waiting to build on it, watch for a tagged 1.0 and a neutral host, and treat everything before that as a spec that can still move under you.