Google Releases Agentic Resource Discovery Specification: The 'Yellow Pages of Capabilities' for the AI Agent Era

As AI Agents move from the laboratory to production environments today, an urgent engineering problem has surfaced: When an Agent needs to call another Agent or use an external tool, how does it know where the other party is, whether they are trustworthy, and how to securely establish a connection?

This is exactly the problem that the open specification Agentic Resource Discovery (ARD), announced by Google on June 17, 2026, attempts to fundamentally solve.

Spearheaded by Google Senior Staff Software Engineer Junjie Bu and Distinguished Software Engineer Srinivas Krishnan, this specification is not a proprietary Google protocol, but an open standard open-sourced under the Apache 2.0 license, with industry partners publicly invited to co-contribute. Its emergence marks the formal entry of Agentic AI infrastructure development into the standardization phase.

§1 The Root of the Problem: The “Discovery Dilemma” in Distributed Agent Ecosystems

The Status Quo: Many Tools, But Hard to Find and Untrustworthy

Imagine an enterprise scenario: A large financial institution is deploying multiple AI Agents, each responsible for customer service, risk assessment, regulatory compliance, and market analysis. These Agents possess different capabilities and will continue to expand in the future.

When the “Customer Service Agent” needs to conduct a “Regulatory Query,” it faces three core problems:

1. Capability Location: Where is the Agent or tool that provides this capability?
2. Selection Criteria: Among multiple candidates, which one should be chosen? What is the basis for this?
3. Safety Verification: How do I verify the identity of the other party? How to prevent spoofed malicious tools?

Before the advent of ARD, the answers to these three questions were mostly “hardcoded” or “relied on manual maintenance by developers.” This is both fragile and unscalable.

The Positioning of ARD

ARD is not intended to replace existing protocols like MCP (Model Context Protocol) or A2A (Agent-to-Agent Protocol). Those protocols solve the problem of “communication format and language”—how two Agents exchange messages once they’ve agreed to talk.

ARD, on the other hand, solves a more upstream problem: “How do you find someone to talk to?” It is a fundamental infrastructure standard for Capability Discovery, providing the ecological soil for protocols like MCP and A2A to operate.

§2 The Core Architecture of ARD: Two Key Roles

The design of ARD is built around two main concepts: Catalogs and Registries.

ARD Architecture Diagram: The organization on the left publishes ai-catalog.json on its own domain; the Registry crawls and indexes it; the Agent on the right establishes a direct connection with the target service after querying the Registry.

Catalogs: Self-Declaration of Capabilities

Every organization (or individual developer) can publish an ai-catalog.json file at a standard path under their domain, declaring the AI capabilities they provide.

There is an ingenuity to this design: it uses domain ownership as the root of trust.

Just as you can trust that google.com/.well-known/ai-catalog.json is published by Google and not an imposter—because only the person who truly owns that domain can place a file under the .well-known/ path. This is a natural Cryptographic Trust Anchor, establishing initial trust without the need for an additional central certification authority.

A typical ai-catalog.json might contain:

• Which Agents or tools the organization provides
• A functional description and applicable scenarios for each capability
• The protocol type required for connection (e.g., MCP, A2A, REST)
• The keys or credential information required for security verification

Registries: The Search Engine for Capabilities

If the Catalog is the “capability advertisement” published by various parties, then the Registry is the “search engine”—it continuously crawls the Catalogs published by various organizations, builds an index, and returns a list of resources matching the criteria and verification metadata when an Agent has a query requirement.

The role of the Registry is similar to DNS (Domain Name System), but it serves Agent capabilities instead of URL resolution. It allows Agents to use natural language or structured queries to find “what tools exist in the world that can help me do X.”

§3 Four Operational Stages: From Discovery to Connection

The ARD specification standardizes the capability discovery process for Agents into four stages, forming a complete closed loop:

Stage 1: Catalog Publication

The provider of a tool or Agent publishes a capability description under a standard path on their domain (.well-known/ai-catalog.json). This step is done manually and remains valid after a one-time configuration.

Stage 2: Capability Discovery

The consuming Agent has two ways to find capabilities:

• Direct Fetch: If the other party’s domain is known, directly fetch its Catalog file.
• Query via Registry: Send a query request to a Registry, which returns the matching results.

Stage 3: Cryptographic Verification

Once a candidate capability is found, the Agent must verify its authenticity. ARD employs a cryptographic signature mechanism to ensure that an “Agent claiming to be from Organization X” is truly an Agent from Organization X, rather than an imposter. This is the crucial line of defense in the entire trust model.

Stage 4: Runtime Connection

After verification passes, both parties establish a connection according to the native protocol (MCP, A2A, REST, etc.) declared in the Catalog and begin formal task collaboration.

§4 Enterprise-Grade Integration: Google Cloud’s Agent Registry

For large enterprises, maintaining Catalogs and managing Registries internally still presents considerable operational complexity. To this end, Google Cloud has launched the Agent Registry service within its Gemini Enterprise Agent Platform, acting as a managed implementation of the ARD specification.

The enterprise-grade capabilities provided by Agent Registry include:

Feature	Description
Hosted Discovery	Managed by Google Cloud, eliminating the need to host a Registry yourself
Resource Governance	Centrally control which Agents can be discovered and who can use them
Globally Unique Namespace	Prevents name collisions between Agents from different organizations
Egress Policy Enforcement	Controls which external resources Agents can connect to
Compliance Support	Supports regulatory requirements through Cryptographic Trust Manifests

This makes ARD not just a standard on paper, but a cloud infrastructure that can be deployed immediately.

§5 Why Does This Matter?

From “API Integration” to “Ecosystem Discovery”

In the past, the approach to software integration was “people finding people”: developers reading documentation, manually configuring API keys, and writing integration code. This human-centric process was slow and hard to scale.

The vision of ARD is to have this process automated by Agents: When executing a task, an Agent can dynamically discover the capabilities it needs, automatically verify the other party’s identity, and automatically establish a connection—the entire process requiring no human intervention.

This is the necessary infrastructure for Agentic AI to upgrade from a “tool” to an “ecosystem.”

The Significance of Open Standards

ARD’s choice to launch as an open standard rather than a proprietary Google protocol holds profound strategic significance:

• Lowering the Barrier to Adoption: Any organization can implement ARD without barriers, requiring no payment or licensing.
• Establishing Interoperability: Agent platforms from different vendors can discover and collaborate with each other, provided they all follow the ARD specification.
• Preventing Ecosystem Fragmentation: Avoiding the problem of the AI tool layer becoming siloed and fragmented.

The ARD specification is spearheaded by Google and co-developed with numerous industry partners, demonstrating cross-vendor ecosystem cohesion.

Drawing an analogy from historical precedents: SMTP allowed different email providers to communicate; HTTP allowed different web servers to be accessed by any browser. ARD’s ambition is to become the foundational connection protocol of the Agentic AI world.

The Complementary Relationship with MCP and A2A

These three specifications together form the infrastructure stack for multi-agent systems:

┌─────────────────────────────────────────────┐
│       Application Layer: Task Execution / Business Logic      │
├─────────────────────────────────────────────┤
│       Protocol Layer: MCP (Tool Calling) / A2A (Agent Comm.)  │
├─────────────────────────────────────────────┤
│       Discovery Layer: ARD (Capability Discovery / ID Verify) │  ← Focus of this article
├─────────────────────────────────────────────┤
│       Foundation Layer: DNS / HTTPS / Domain Ownership        │
└─────────────────────────────────────────────┘

All three are indispensable: With ARD, the Agent knows where to go; with MCP/A2A, the Agent knows how to speak; with business logic, the Agent knows what to do.

§6 How to Get Started?

Google provides three entry paths for developers:

1. Read the Specification Documentation: The complete technical specification of ARD has been published on the official documentation website, covering the Catalog Schema, Registry API definitions, and details of cryptographic verification.

2. Follow the Quickstart Guide: Suitable for developers who want to get up to speed quickly, guiding them through the complete process from publishing their first ai-catalog.json to being discovered via a Registry.

3. Participate in the Open Source Community: The ARD specification and reference implementations are hosted on GitHub under the Apache 2.0 license. All developers are welcome to submit Issues or Pull Requests.

Conclusion: An Infrastructure Moment

The release of ARD marks an important maturation stage for Agentic AI—an Infrastructure Moment.

This moment occurs in the developmental trajectory of every transformative technology. The internet had the explosion of the WWW only after HTTP and DNS; cloud computing had the prosperity of SaaS only after API standardization.

Agentic AI is greeting its own such moment. Only when Agents can reliably find, verify, and connect to any capability in the world will we truly see the full potential of multi-agent collaboration—a world where AI systems can autonomously form temporary teams, divide labor among themselves, and complete complex tasks.

ARD is not just a technical specification; it is the first cornerstone of this future world.

Original Source: This article is an in-depth analysis based on the official announcement on the Google Developers Blog:

• Announcing the Agentic Resource Discovery specification (2026/06/17)
• Authors: Junjie Bu (Senior Staff Software Engineer) and Srinivas Krishnan (Distinguished Software Engineer)