Skip to main content
Back

Google's ARD Lets AI Agents Discover and Trust Each Other Across the Web

Google and 10 industry partners launch ARD, an open specification letting AI agents securely discover and verify tools, MCP servers, and other agents across the web.

The agentic web has a discovery problem. As AI agents proliferate across organizations, they increasingly need to call on tools, skills, and other agents that live on completely different platforms -- sometimes owned by different companies entirely. Right now, there is no standard way to do that safely. Every team builds its own registry, its own trust model, its own integration glue. Google wants to fix that with a new open specification called Agentic Resource Discovery (ARD).

ARD is an open specification for publishing, discovering, and verifying AI capabilities across the web. Developed with partners across the industry, it allows tools and services to be securely shared and connected, regardless of their underlying framework, protocol, or provider. The launch coalition is substantial: Cisco, Databricks, GitHub, GoDaddy, Hugging Face, Microsoft, NVIDIA, Salesforce, ServiceNow, and Snowflake are all on board from day one.

The gap ARD fills

While many platforms already feature custom registries to manage capabilities, they remain fragmented and siloed within specific ecosystems. This lack of interoperability prevents agents from easily communicating across different tools. Think about what a real-world operations agent actually needs to do: query observability systems, search engineering docs, review deployment history, open support tickets, and maybe even delegate to a specialized troubleshooting agent. Today, wiring all of that together requires bespoke integration work at every boundary.

ARD is an open discovery protocol for agentic resources. It allows an AI client to ask "What is available for this task?" and lets a discovery service answer with matching resources. ARD sits entirely before invocation. It helps the client find the right resource; the resource is then invoked through its own native protocol. An agentic resource is any external capability an AI client can call on -- an agent, MCP server, skill, API, workflow, or anything similar. Crucially, ARD is not an execution runtime -- it is not MCP, A2A, or an API runtime, and it does not replace them.

Two primitives: catalogs and registries

The architecture is deliberately simple. Catalogs are how organizations make resources discoverable -- they publish a catalog describing available capabilities, hosted directly under their own domain name. Ownership of that domain serves as the cryptographic foundation for identity and trust.

Registries act as search engines for the agentic web. They crawl published catalogs, index their contents, and make them searchable. When an agent submits a discovery request, a registry returns matching capabilities along with the metadata required to verify the publisher and establish trust before connecting.

Architecture diagram showing ARD's two-layer design: Catalog (publish layer) and Registry (discovery layer) with A2A, MCP, and API protocol support

The four-step flow at runtime looks like this:

  1. Publish: A provider hosts an ai-catalog.json file at a well-known path on its domain, describing available MCP servers, A2A agents, OpenAPI tools, or nested catalogs.
  2. Discover: A client agent queries an ARD registry using plain-language intent, or directly fetches a catalog from a known partner's domain.
  3. Verify: For production environments, the discovery layer allows publishers to attach verifiable trust metadata, enabling the client agent or registry to actively confirm the publisher's true cryptographic identity before connecting to the endpoint.
  4. Connect: The agent dynamically loads the capability and interacts with it using its native protocol.

Why domain-based trust matters

The trust model here is borrowed from how the web already works. By anchoring identity to a domain name, ARD sidesteps the need for a central authority. A receiving agent can verify that a card was actually issued by the domain owner. Without this, an attacker could stand up a fake agent card and redirect other agents into a card forgery attack. Cryptographic signatures are effectively the trust model that makes decentralized discovery viable at all.

Members from various AI protocols -- MCP, A2A, and others -- are collaborating on a common AI Catalog standard for discovering heterogeneous AI artifacts across the ecosystem. The AI Catalog standard does not replace or redefine protocol-specific artifact formats -- it provides a common discovery and trust layer around them. ARD builds directly on this Linux Foundation working group's data model, and is itself licensed under Apache 2.0.

The enterprise layer: Agent Registry

Google Cloud supports ARD with Agent Registry in the Gemini Enterprise Agent Platform -- the enterprise-grade product that delivers on this vision and forms part of the global federated network. Agent Registry provides fully hosted support for searching, discovering, and hosting agentic resources, including agents, skills, MCP servers, and other tools. It allows users to onboard these capabilities directly, and will soon support authenticated publisher onboarding.

For compliance-heavy environments, Agent Registry handles secure resource management using Agent Identity to verify the trust manifest -- ARD's cryptographic layer for proving agent authenticity and meeting enterprise compliance standards like HIPAA. Native support for ARD will be available in Agent Platform in the coming months, allowing organizations to securely connect their internal registries to the broader network.

What this changes

The real shift here is conceptual. Until now, agent-to-agent communication protocols like A2A and tool-use protocols like MCP have handled the how of agent interaction. ARD handles the where -- the pre-invocation step of finding the right capability in the first place. Different discovery services can index different resources, serve different communities, and apply varying trust, ranking, and access policies. No single company controls the index.

The practical implications are significant for anyone building multi-agent systems:

  • Cross-org agent pipelines become possible without pre-negotiating integrations -- an agent can discover a partner's MCP server at runtime.
  • Dynamic tool loading means agents don't need to be hardcoded with every capability they might ever need.
  • Federated trust lets enterprises govern which external catalogs their agents are allowed to query, without giving up the open network.
  • Protocol agnosticism means the same discovery layer works whether the underlying capability speaks A2A, MCP, OpenAPI, or something else entirely.

Getting started

The ARD specification is available now and free to use. Publishing your first catalog takes minutes:

# Minimal ai-catalog.json hosted at https://yourdomain.com/ai-catalog.json
{
  "schema_version": "1.0