Agentic Resource Discovery: the open standard that will unify AI agents

Agentic Resource Discovery: the open standard that will unify AI agents

🔎 The AI agent ecosystem has a discovery problem, and Google + Microsoft just solved it

May 2026. Agentic AI is exploding, but an invisible bottleneck is slowing down the entire ecosystem: agents don't know how to find the tools they need. Every integration is hardwired by hand. Every new MCP server requires manual configuration. This is not scalable.

Google, Microsoft, GitHub, HuggingFace, NVIDIA, Salesforce, Snowflake and others have just published ARD (Agentic Resource Discovery), an open specification under the Apache 2.0 license. Its ambition is clear: to become the missing discovery layer of agentic AI. The "HTTP for agents," according to several observers.

The announcement was published at the end of May 2026 on the Google Developers blog and the Microsoft Command Line blog, with a specification repository hosted on GitHub (ards-project/ard-spec). A working group within the Linux Foundation oversees the project.

The key points

• ARD is an open specification (Apache 2.0) to publish, discover, and verify AI capabilities on the web, announced jointly by Google, Microsoft, and a dozen major players.
• The mechanism relies on two primitives: organizations publish an ai-catalog.json file on their domain, and federated registries index these catalogs to enable search.
• ARD does not replace MCP — it sits on top as a discovery layer, solving the problem that MCP doesn't cover: how an agent finds a tool it doesn't know about yet.
• The specification is still in draft but the industry support is unprecedented for an agentic interoperability standard.

Tools and actors involved in ARD

What ARD is exactly — a machine directory for agents

ARD defines a federated standard for AI agents to discover agentic resources at runtime, without human intervention. No need to know the URL of an MCP server in advance. No need to configure an integration. The agent searches, finds, verifies, and connects.

The concept relies on an ai-catalog.json file published at the root of a domain. This file describes in a structured way the capabilities made available: tools, APIs, models, other agents. According to Hugging Face, this file is the entry point that agents consult to understand what a domain offers.

An indexing registry (similar to the role of a search engine) aggregates these catalogs and enables semantic queries. An agent can therefore ask "find me a verified web search tool" and get a list of resources with their metadata, their input/output schemas, and their verification proofs.

InfoWorld describes ARD as a set of fundamental primitives organized around a data model called "AI Catalog". This model normalizes the description of agentic resources: name, description, capabilities, invocation schema, trust level, authentication method.

The specification is domain-anchored, which means that each organization controls its own catalog. No central platform. No vendor lock-in. It is the federated approach that made the web itself successful.

Why it's the "HTTP of agents" — the parallel with the early days of the web

In 1991, the web had two problems: how to transfer documents (HTTP) and how to find them (URLs + links). Agentic AI in 2026 is in a similar but incomplete situation.

MCP (Anthropic's Model Context Protocol) solves the problem of transfer and execution: how an agent calls a tool in a standardized way. A2A (Google's Agent-to-Agent) solves the problem of inter-agent communication. But neither solves discovery. It's like having HTTP without search engines or links.

Search Engine Journal summarizes the situation: ARD defines how agents find and verify tools, skills, and other agents on the web. It's the missing piece.

The parallel is striking. Without ARD, every agent deployment requires explicit configuration of each tool. With ARD, an agent can dynamically expand its perimeter of capabilities based on the task. This is what transforms a specialized tool into a truly autonomous system.

For the meilleurs agents IA autonomes emerging in 2026, this discovery capability is what differentiates an agent that executes a pre-configured workflow from an agent that solves a new problem.

ARD vs MCP vs A2A vs ACP — where each protocol is positioned

The agentic protocol space has densified in 2025-2026. A study published on arXiv in May 2026 examines four interoperability protocols: MCP, ACP, A2A and ANP. K21 Academy provides a synthesis of these comparisons.

Their conclusion is convergent: these protocols are not in competition. They operate at different layers of the agentic stack.

MCP has become the de facto standard for connecting an agent to a specific tool. But MCP assumes that the agent already knows which MCP server to call and where it is located. ARD fills this gap: it allows an agent to dynamically discover that an MCP server exists, what it offers, and whether it is trustworthy.

Digital Loop identifies three complementary signal channel mechanisms in ARD: the discovery mechanism (how to find), the technical implementation (the ai-catalog.json file and registries) and the strategic function (verification and trust).

How ARD works technically — the ai-catalog.json file

The concrete implementation of ARD relies on an elegantly simple mechanism, similar to robots.txt or sitemap.xml in the traditional web.

An organization publishes an ai-catalog.json file at a standardized location on its domain. This file contains a list of agentic resources, each described by a normalized schema. Grounding Page details the structure: each entry includes an identifier, a textual description, the resource type (MCP tool, A2A agent, REST API, model), input/output schemas, authentication requirements, and verification metadata.

ARD registries are services that crawl the web looking for these ai-catalog.json files, index them, and expose a search API. An agent queries a registry, obtains a list of candidate resources, verifies their metadata (cryptographic signature, domain proof), and then connects directly via the appropriate protocol (MCP, A2A, etc.).

AI Weekly emphasizes that this two-primitive architecture (publication + indexing) is deliberately minimalist. The goal is not to create a centralized platform, but a standard that anyone can implement.

Synscribe confirms that the Linux Foundation working group opted for a federated approach from the start, avoiding the proprietary platform trap that has stymied other AI standardization attempts.

Implications for AI agent developers

For a developer building agents, ARD fundamentally changes how we think about tool integration. Today, each new tool requires: finding the documentation, configuring the MCP server URL, managing authentication, testing the connection, and starting all over again for the next one.

With ARD, the flow becomes: the agent receives a task, queries an ARD registry, filters results by relevance and confidence level, and connects automatically. The developer only needs to configure which ARD registry the agent trusts.

This has a direct impact on the choice of LLM pour les agents IA. A model like GPT-5.5 (agentic score of 98.2 on the June 2025 reference benchmarks) or Gemini 3 Pro Deep Think (95.4) can leverage ARD to dynamically decide which tools to call based on the context, without the developer having to anticipate every use case.

For those who prefer to run agents locally, the question arises: does ARD work with offline deployments? The specification technically allows it (a private registry can index internal catalogs), but the primary value of ARD lies in discovering public web resources. Agents IA open source avec Ollama will be able to query ARD registries while running the model locally — discovery and execution are decoupled.

The implications for businesses — publishing your capabilities like you publish an API

For businesses, ARD reverses the integration logic. Instead of every AI client having to integrate your tools manually, you publish an ai-catalog.json and any ARD-compatible agent can discover and use your capabilities.

This is analogous to the shift from point-to-point integrations to public REST APIs. Before APIs, each client required a dedicated connector. With APIs, a standard (HTTP + JSON) allowed any client to consume any service. ARD does the same thing for the agentic layer.

Companies that publish ARD catalogs early will have a discovery advantage: their tools will be indexed by registries and available to millions of agents. This is a new acquisition channel, comparable to SEO but for machines.

If you host these catalogs, a host like Hostinger is sufficient for a static ai-catalog.json — no need for complex infrastructure at first.

Governance becomes a critical issue. The Agentic AI governance initiative between Google and SAP shows that businesses do not want to deploy agents without a control framework. ARD integrates verification mechanisms (signatures, domain proofs) that fit into this governance logic.

What ARD changes for robotics and multi-agent systems

Beyond software agents, ARD has profound implications for physical systems. In Agentic AI pour la robotique, the main challenge is coordination between robots with heterogeneous capabilities. ARD could serve as a discovery layer for robots to dynamically discover the capabilities of their neighbors in a shared environment.

A delivery robot could discover that a warehouse robot offers a loading service via its local ARD catalog, negotiate the terms via A2A, and execute via MCP. Without prior configuration. Without bespoke integration.

For complex multi-agent systems, this dynamic discovery reduces the problem of centralized orchestration. Each agent publishes what it knows how to do. The system emerges from mutual discovery rather than a central planner.

Training and verification — the link with agentic reinforcement learning

An underestimated aspect of ARD is its potential for training agents. The SDAR (Self-Distillation Agentic Reinforcement) method shows how agents learn to use tools via reinforcement learning. ARD enriches this process by providing a dynamic and verified tool space.

Instead of training an agent on a fixed set of tools, it can be trained in an environment where tools are discovered via ARD. The agent learns not only to use tools but to discover and evaluate new tools — a fundamentally different meta-skill.

ARD's verification metadata (signatures, reputation, history) also provides natural reward signals for RL: an agent that chooses well-verified tools and achieves better results reinforces this selection behavior.

The current limits of the specification

ARD is promising but remains a draft. Several technical and ecosystem challenges are still unresolved.

First, security. An ai-catalog.json file can describe malicious resources. Verification mechanisms exist in the specification, but their concrete implementation and their robustness against catalog poisoning attacks remain to be proven in production.

Second, performance. Querying an ARD registry adds latency to every discovery. For real-time tasks, this overhead can be prohibitive. Local caching of frequently used catalogs will be necessary but is not yet standardized.

Third, adoption. An open specification only has value if it is implemented. The support of Google and Microsoft is a strong signal, but it will be necessary to monitor the actual number of ai-catalog.json catalogs deployed on the web in the coming months. A standard without implementations is just a PDF on GitHub.

Fourth, competition. Other agentic discovery initiatives could emerge. The fragmentation of standards is a real risk in such a young space.

❌ Common mistakes

Mistake 1: Confusing ARD and MCP

ARD does not replace MCP. MCP defines how an agent calls a tool. ARD defines how an agent finds that tool. They are complementary layers, not competing ones. Confusing the two leads to architectures where one tries to use ARD to execute function calls — that won't work.

Mistake 2: Publishing a catalog without verification

An ai-catalog.json without a cryptographic signature or domain proof is practically useless. ARD-compatible agents will filter out unverified resources. If you publish a catalog, implement verification mechanisms from the start.

Mistake 3: Viewing ARD as a product

ARD is a specification, not a service. There is no "ARD platform" to sign up for. You publish a file, you register in a registry, that's it. Waiting for an ARD SaaS from Google or Microsoft is a misunderstanding of the federated model.

Mistake 4: Ignoring internal governance

Deploying agents that dynamically discover external tools without a governance policy is a major security risk. Define which registries are trusted, what types of resources are allowed, and what levels of verification are required before enabling ARD in production.

❓ Frequently Asked Questions

Does ARD replace MCP?

No. MCP handles execution (how to call a tool), ARD handles discovery (how to find that tool). They are complementary and operate at different layers of the agentic stack.

Who controls the ARD specification?

The Linux Foundation working group, with contributors from Google, Microsoft, GitHub, HuggingFace, NVIDIA, Salesforce, and Snowflake. The specification is licensed under Apache 2.0, so it is freely implementable.

Can an agent use ARD without MCP?

Yes. ARD can discover any type of resource: MCP servers, A2A agents, REST APIs, models. The connection protocol is independent of the discovery mechanism.

Is ARD usable in production today?

The specification is in draft (June 2026). Reference implementations exist but the number of deployed catalogs is still limited. Follow the GitHub repository for maturity status.

How do I publish my first ARD catalog?

Create an ai-catalog.json file at the root of your domain, describe your agentic resources according to the spec's schema, and submit the URL to a compatible ARD registry. The official documentation on the GitHub repository details the exact format.

✅ Conclusion

ARD may not be the last agentic discovery standard, but it is the first to bring together such a broad consortium around a real and well-defined problem. If adoption follows — and the backing of Google and Microsoft suggests it will — it will become the default discovery layer of the AI agent ecosystem. Follow the official repository and start thinking about the ai-catalog.json your organization should publish.