Agentic Resource Discovery The Open Standard That Could Unify the AI Agent Ecosystem

The Agent Ecosystem Is Growing—But It's Fragmented

AI agents are no longer isolated tools. They're becoming participants in a larger ecosystem, relying on tools, skills, and other agents distributed across teams, organizations, and platforms. But as this ecosystem expands, a critical problem emerges: how do agents find the right capability, decide which to use, and verify it's safe to connect to?

Currently, there's no standard answer. Custom registries exist, but they're siloed. An operations agent investigating a production incident might need to query observability systems, search documentation, review deployment history, open tickets, and consult specialized agents—all across different platforms. Without interoperability, this becomes a nightmare.

This is where Agentic Resource Discovery (ARD) comes in. Announced by Google Cloud and partners, ARD is an open specification under the Linux Foundation that aims to standardize how AI capabilities are published, discovered, and verified across the web.

The Core: Catalogs and Registries

ARD's architecture relies on two primitives: catalogs and registries. A catalog is a file (e.g., ai-catalog.json) hosted on an organization's domain, listing available capabilities. Registries are federated indexes that aggregate these catalogs, allowing agents to search across organizational boundaries.

When an agent needs a capability, it queries a registry, gets the location, and then uses the catalog to verify trust metadata. From there, ARD steps out of the way, letting the agent connect directly using the tool's native protocol.

How ARD Works in Practice

Let's walk through a typical scenario. An operations agent needs to query an observability system. Here's a simplified flow:

1. Publish: The observability provider publishes an ai-catalog.json on their domain.
2. Index: A federated registry indexes this catalog.
3. Discover: The agent queries the registry, searching for observability capabilities.
4. Verify: The agent retrieves the catalog, checks the trust manifest, and confirms the capability is safe.
5. Connect: The agent connects directly to the tool using its native protocol (e.g., MCP).

// Example ai-catalog.json (simplified)
{
  "name": "observability-tools",
  "description": "Catalog of observability capabilities for incident response",
  "capabilities": [
    {
      "id": "query-metrics",
      "name": "Query Metrics",
      "description": "Retrieve time-series metrics for a given service",
      "protocol": "mcp",
      "endpoint": "https://observability.example.com/mcp",
      "trust": {
        "manifest": "https://observability.example.com/trust-manifest"
      }
    }
  ]
}

This is a simplified example, but it illustrates the core idea: a standardized way to describe and expose capabilities.

The Role of Google Agent Registry

Google Cloud is backing ARD with Agent Registry, part of the Gemini Enterprise Agent Platform. Agent Registry provides enterprise-grade support for searching, discovering, and hosting agentic resources—including agents, skills, MCP servers, and tools. It also enforces governance policies, assigns URNs, and uses Agent Identity to verify trust manifests, meeting compliance standards like HIPAA.

Key Features:

• Fully hosted registry: Search and discover across your organization and beyond.
• Authenticated publishing: Onboard capabilities securely.
• Governance: Enforce egress policies and pin tool versions.
• Native ARD support: Coming soon, allowing internal registries to connect to the broader federated network.

Comparison: ARD vs. Existing Approaches

Limitations and Caveats

While ARD is promising, it's still early. The spec is new, and adoption will take time. Key limitations include:

• Trust model: ARD relies on cryptographic manifests, but verifying these across different providers requires widespread adoption.
• Standardization: ARD is built on the AI Catalog data model, but not all tools support it yet.
• Security: Federated registries could be targets for malicious listings. Governance is critical.

Next Steps for Learning

If you want to dive deeper into the AI agent ecosystem, check out our guide on LLM evals and experimentation funnels to understand how to measure agent performance. Also, stay tuned for more on the React Foundation's move to the Linux Foundation, another example of open governance in tech.

Final Thoughts

ARD is a bold step toward a more open and interoperable AI agent ecosystem. By standardizing discovery and verification, it could unlock new levels of automation and collaboration. The spec is available now—so go ahead, publish your first catalog, and join the movement.

This post is based on the original announcement.