GitHub and Google Support ARD: A New Way for AI Agents to Find Trusted Tools

The new Agentic Resource Discovery standard aims to make it easier for AI agents to discover, verify and use tools, skills, MCP servers and other agents across the web. As AI agents become more capable, one challenge is becoming increasingly obvious: how do they reliably find the right tools to use?

Today, organisations often need to manually connect MCP servers, skills, agents, APIs and other AI resources into each workflow. This can become difficult to manage, especially when teams use multiple platforms, internal services and third-party tools.

GitHub, Google, Microsoft and several other technology companies are now supporting a new open specification designed to make that process simpler.

The standard is called Agentic Resource Discovery, or ARD. Its purpose is to provide a common way for AI systems to publish, search for and verify available capabilities across the web.

Rather than requiring every AI platform to create its own isolated discovery system, ARD aims to give agents a shared way to find trusted resources.

What Is Agentic Resource Discovery?

ARD is designed as a discovery layer for AI capabilities.

It can help agents locate resources such as:

The goal is not to replace the protocols that these tools already use. Instead, ARD focuses on the earlier step: helping an AI system discover what is available, understand what it does and verify where it came from before making a connection.

This could reduce the amount of manual setup required when building agent-based workflows.

Why AI Agent Discovery Has Become a Problem

The AI ecosystem is growing quickly, but it is also becoming fragmented.

Different companies are creating their own tool registries, agent platforms, MCP servers and skills libraries. While this gives developers more choices, it can also create a messy environment where every workflow needs to be connected manually.

Microsoft described ARD as a response to this fragmented landscape.

Without a common discovery method, developers may need to hard-code tools into an agent workflow one by one. This can make systems harder to maintain and can also overload an AI agent's context window with resources it does not actually need.

ARD aims to make the process more dynamic.

Instead of loading every possible tool into a workflow, an AI agent could search for the most relevant capability only when it is needed.

How ARD Works

The standard works through a catalogue model.

An organisation can publish an ai-catalog.json file at a known location on its domain. This file describes the AI resources that organisation makes available, such as tools, agents, skills and MCP servers.

The catalogue can include details about what each resource does, how it can be accessed and what metadata is needed to verify the publisher.

Registries can then crawl and index those catalogues.

When an AI agent needs a capability, it can search a registry using a plain-language request or retrieve a catalogue directly from a known domain. The registry can return matching resources along with information that helps the agent verify who published them.

Once the publisher is verified, the agent can connect directly to the selected tool using its existing API or native protocol.

This means ARD acts more like a trusted directory than a replacement for the tools themselves.

GitHub Brings ARD Into Copilot With Agent Finder

GitHub is already putting the ARD model into use through a new feature called Agent Finder for Copilot.

Agent Finder allows Copilot to search a selected catalogue of available AI resources and return ranked matches based on a developer's request.

For example, a developer could describe a task in plain language, and Copilot could search for relevant tools, skills, agents or MCP servers that may help complete it.

The user or organisation can then choose which resource should be added to the workflow.

GitHub has made it clear that Agent Finder does not automatically install or connect tools without approval. It helps surface relevant options, while the final decision remains with the user or organisation.

This is important because AI tools can have very different permission levels and security implications.

Public and Private Catalogues for Different Organisations

GitHub's Agent Finder can work with different types of registries.

Developers may search GitHub's curated public catalogue, while enterprises can use their own private registries containing internal tools and approved services.

This allows organisations to keep sensitive or company-specific resources inside their own environment while still using the same discovery approach.

Enterprise administrators can also define which resources Copilot agents are allowed to discover and use.

That means a company could restrict agents to approved internal tools, selected vendor services or trusted MCP servers only.

For larger organisations, this is likely to be one of the most important parts of the ARD model: flexibility without giving up governance.

Trust and Verification Are Built Into the Standard

Discovery is useful, but trust matters just as much.

ARD includes metadata intended to help agent clients verify the publisher behind a resource before connecting to it.

Google has said the standard is designed to support cryptographic verification in production environments. This can help confirm that a tool, skill or agent genuinely comes from the organisation it claims to represent.

That becomes important when AI agents are connecting to tools that may access code repositories, internal data, business systems or external APIs.

A discovery system without verification could become a security risk. ARD attempts to address this by making trust information part of the discovery process.

GitHub Adds More Controls for Copilot Agents

GitHub has also introduced additional governance controls for Copilot agents.

One example is the disableBypassPermissionsMode setting, which allows enterprise administrators to prevent GitHub Copilot CLI and Copilot in Visual Studio Code from automatically bypassing permission prompts.

The setting is available for Copilot Business and Copilot Enterprise customers and can be managed through a private .github-private repository.

This gives administrators a central place to manage how Copilot behaves across their organisation.

The broader message is clear: as AI agents become more capable, organisations need more control over what those agents can access, discover and execute.

Google Is Also Expanding Agent Discovery

Google plans to support ARD through its Gemini Enterprise Agent Platform.

Its Agent Registry is expected to support the discovery, hosting and search of agents, MCP servers, skills and related tools.

Google has also discussed features such as globally unique namespaced identifiers, agentic egress policies and pinned specifications.

These features could help organisations create more structured internal AI ecosystems, where teams can discover approved capabilities without relying on unverified third-party sources.

Google expects native ARD support to arrive in the coming months, allowing internal registries to eventually connect to a broader federated network of AI resources.

A Bigger Step Towards Interoperable AI Agents

ARD is licensed under Apache 2.0 and builds on the AI Catalog data model.

The specification was developed with contributions from companies including GitHub, Google, Microsoft, GoDaddy and Hugging Face, along with work connected to the AI Catalog Working Group under the Linux Foundation.

The involvement of multiple major companies gives the standard a better chance of becoming widely adopted.

If that happens, AI agents may become easier to connect across different platforms. Instead of being locked into a single vendor's ecosystem, developers could potentially discover and use trusted capabilities from a broader network.

Final Thoughts

Agentic Resource Discovery may sound technical, but its purpose is straightforward: make it easier for AI agents to find the right tools safely.

GitHub's Agent Finder for Copilot is an early example of how this could work in practice. It gives developers a more structured way to discover agents, tools, skills and MCP servers without manually wiring every service into every workflow.

For organisations, the bigger opportunity is not only convenience. It is governance.

A shared discovery model that includes verification, enterprise controls and approval boundaries could help AI agents become more useful without becoming harder to manage.