Google and Industry Partners Announce Agentic Resource Discovery Specification for AI Agents

Leela Kumili · rss · 2026-07-14 source ↗ Reader 🖥️

Agent Governance (Internal)Agent Tool Management API Products & Sprawl MCP (Model Context Protocol)Trust

Google and a broad coalition of industry partners have introduced the Agentic Resource Discovery (ARD) specification, an open, trust-and-verification-based discovery layer built on catalogs and registries that sits beneath execution protocols like MCP and OpenAPI, letting AI agents find and validate tools and services across organizational boundaries without claiming to replace authentication, authorization, or governance.

practical · expository — A launch/announcement news report describing a concrete, adoptable technical specification (with reference implementations and a published spec repo) rather than an argument for understanding a phenomenon. Classified expository because it is a fact-and-quote-driven report structured around the announcement, not built around the author's own argumentative throughline — the interpretive framing (why this matters, what it doesn't solve) comes almost entirely from quoted sources (Krishnan, Marsman) rather than the reporter.

Structure

Part	Role
Problem framing / motivation	context
Core constructs: catalogs and registries	evidence/mechanism
Trust and verification design	evidence
Reddit community reactions	complicating evidence / caveat
Industry backing and early implementations	evidence
Marsman's scope-limiting quote	conclusion / caveat
Availability and next steps	conclusion

Key terms

Agentic Resource Discovery (ARD)
An open discovery-layer standard letting AI agents publish, find, and verify tools, APIs, and services across organizational boundaries, deliberately layered beneath execution protocols rather than replacing them.
catalog (ai-catalog.json)
A machine-readable manifest an organization publishes within its own domain, describing its available capabilities — tools, APIs, skills, agent endpoints.
registry
An aggregator of many organizations' catalogs, letting agents search across them by task intent instead of relying on hardcoded integrations or static endpoint lists.
domain-based ownership and verification
ARD's trust mechanism: a discovered resource's authenticity is tied to control of its DNS domain, so an agent can validate who published a capability before establishing a connection.

Propositions

explicitARD is a discovery layer addressing an earlier stage of the agent-tool lifecycle than protocols like MCP, which define invocation — ARD is designed to be complementary across frameworks and providers, not a replacement.conf: high
explicitdevelopedThe specification's two core constructs are catalogs (a machine-readable ai-catalog.json manifest an organization publishes describing its tools/APIs/skills/endpoints) and registries (aggregators letting agents search across organizations by task intent instead of hardcoded integrations or static endpoint lists).conf: high
extendsMCP Is Making API Sprawl Worse · p5 — Van Boxtel speculated that agentic AI could power 'automated discovery pushing assets into service registries' as a future governance mechanism. ARD's catalog-and-registry design is a standardized, multi-vendor realization of exactly that speculative mechanism, now formalized as an open spec rather than a hoped-for capability.
extends ←Why Developer Portals Must Evolve in the AI Agent Age · p3 — The ARD spec's machine-readable catalog/registry constructs are essentially the concrete protocol-level implementation of the 'governed capability registry' this document argues portals should become.
explicitARD builds in domain-based ownership and verification so an agent can validate a discovered resource's authenticity before connecting, explicitly framed as a response to the enterprise need for governed, identity-backed discovery rather than 'find something that works.'conf: high
explicitARD does not replace authentication, authorization, governance, or organizational trust decisions, and the intended end-state is many separate, differently-scoped discovery services rather than one global catalog.conf: high
explicitThe spec launched with immediate, broad cross-vendor backing (Microsoft, GitHub, Hugging Face, Cisco, Databricks, GoDaddy, NVIDIA, Salesforce, ServiceNow, Snowflake) and at least two already-shipped implementations (GitHub's Agent Finder in Copilot, Hugging Face's Discover Tool), rather than being a single-company proposal.conf: high
extendsFighting Tool Sprawl: The Case for AI Tool Registries · p7 — Richards argued an enterprise tool registry must stay internal/organization-scoped because 'cross-organization standardization would be premature in a fast-moving, nascent space.' ARD's immediate, broad cross-vendor launch (Microsoft, GitHub, Hugging Face, Cisco, Databricks, and more, with two implementations already shipping) is the concrete cross-organizational standard Richards judged premature — extending the internal-registry thesis to the industry-wide case sooner than that piece anticipated.
implicitARD's practical usefulness will hinge less on the existence of the protocol itself and more on the quality, access, and pricing of the tools actually exposed through it.conf: medium

Arguments

ARD is designed to let agents discover and trust tools and services across organizational boundaries without requiring a single shared authority or replacing existing execution and identity layers. strength: medium

Explicit premises:

ARD occupies the discovery stage of the lifecycle, distinct from and complementary to execution protocols like MCP and OpenAPI (p1).
Catalogs and registries let agents search by task intent across organizations instead of relying on hardcoded integrations (p2).
Domain-based ownership and verification let an agent validate a resource's authenticity before connecting (p3).

Implicit premises:

Layering ARD strictly beneath execution protocols, rather than replacing them, is a deliberate adoption strategy: it can be added to existing MCP/OpenAPI deployments without migration cost.
A federated, multi-registry model (no single global catalog) trades a single point of control for resilience against any one vendor dominating discovery — at the cost of agents needing to know which registries to query.

Inferences:

If broadly adopted, ARD could reduce reliance on brittle, hardcoded agent-tool integrations industry-wide.
The catalog/registry infrastructure itself becomes new trust-critical infrastructure — and therefore a new target — mirroring the supply-chain risk history of software package registries (npm, PyPI).

Questions addressed

✅ How do AI agents discover tools, APIs, and services across organizational boundaries, as distinct from how they invoke them?
Via ARD's catalog-and-registry discovery layer, which is complementary to invocation protocols like MCP and OpenAPI rather than a replacement for them.
✅ Does ARD solve agent-tool trust and security end-to-end?
No — ARD provides domain-based ownership/verification for discovered resources, but explicitly does not replace authentication, authorization, governance, or organizational trust decisions.
✅ Will a single global agent-tool catalog emerge?
No — Marsman's framing anticipates many discovery services, each differentiated by what it indexes, whom it serves, and how it ranks results.

Gaps

incompleteThe announcement doesn't address how the catalog/registry infrastructure itself is protected from the supply-chain attacks (poisoning, typosquatting, compromised registries) that have repeatedly hit npm/PyPI-style registries — a risk this corpus has already flagged for AI tool registries generally.
Read next: The ARD spec's actual trust/verification mechanics (agenticresourcediscovery.org, github.com/ards-project/ard-spec) plus corpus material on tool-registry supply-chain risk.
incompleteMarsman's own framing — 'many discovery services, each defined by what it indexes, whom it serves, and how it ranks' — implicitly reproduces, one level up, the exact fragmentation problem tool registries were meant to solve: now an agent must first discover which discovery service to query. The article surfaces this framing without examining it.
Read next: Watch whether ARD's mentioned but undetailed 'federation model' actually resolves discovery-of-discovery fragmentation, or whether a registry-of-registries layer emerges.
incompleteThe piece is built entirely from a press release, partner blog posts, and two lightly-sourced Reddit comments — no adoption data, no independent technical assessment of the spec, and no timeline for when the 'reference implementations' mature into production-grade infrastructure.
Read next: Track actual adoption over the following months (number of published ai-catalog.json files, registries running on ARD, independent security review of the trust model) rather than relying on launch-week coverage.