Agentic Resource Discovery (ARD): How AI Agents Find the Tools They Need

1. The problem

An agent on its own can reason, but to act it needs tools: a way to check the weather, search documents, book a table, send an email. Today, someone has to find each tool, decide whether to trust it, connect it to the agent, and keep that connection working.

That's manageable when there are a few well-known tools. It falls apart when every company and developer offers their own. There's no shared way for an agent to ask "what can help me with this task?" and get a reliable answer. ARD is meant to be that shared way.

2. What ARD is

ARD lets an agent ask a simple question, "what is available for this task?", and get back a list of tools that match, plus proof of who provides them.

A "tool" here can be almost anything an agent can call on: a service, an app, an API, even another agent.

Two things ARD is not:

• It doesn't run the tool. ARD only helps the agent find and trust a tool. After that, the agent talks to the tool directly, in the tool's own way.
• It isn't one big central directory. There will be many registries, each collecting different tools. A company can run a private one for its internal tools. The public internet will have several.

It's also not a Google-only project. It was built with partners including Microsoft, Hugging Face, GitHub, GoDaddy and Nvidia.

3. How it works

Say you ask your AI assistant to plan a weekend trip. It needs a flight-search tool and a weather tool it has never used before. Roughly, here's what happens.

1. Each tool provider has published a catalog: a small file on their website describing what their tool does.
2. Your assistant asks a registry, in plain language, for something that can search flights and something that can check the weather. The registry returns matching tools. (If it already knows a provider, it can skip the registry and fetch their catalog directly.)
3. Before connecting, the assistant checks that each tool really comes from who it claims to.
4. The assistant connects to each tool, uses it, and gives you your trip plan.

A good way to picture it: ARD finds the right door and checks the ID. It doesn't walk through. Using the tool is a separate step that happens afterwards.

4. The two building blocks

Catalogs. To make your tools findable, you publish a catalog: a small file listing them, hosted on your own website. Because it lives on your own web address, and only you control that address, it's also what lets an agent trust the tool really comes from you.

Registries. A registry collects published catalogs and makes them searchable, like a search engine for tools rather than web pages. When an agent asks for help with a task, the registry returns the tools that fit, along with the information needed to check who provides them.

5. What a catalog looks like

You don't need much. A catalog is a short file. Cut to the essentials, one tool entry looks like this:

{
  "specVersion": "1.0",
  "host": { "displayName": "Acme Tools" },
  "entries": [
    {
      "identifier": "urn:ai:acme.com:tools:weather",
      "displayName": "Weather Tool",
      "description": "Gives current weather and forecasts for any city.",
      "url": "https://api.acme.com/weather",
      "representativeQueries": [
        "what is the weather in Paris today",
        "five day forecast for Tokyo"
      ]
    }
  ]
}

Even if you skip the code, the idea is simple: a name for the tool, a short description of what it does, where to reach it, and a few example questions it can answer. Those example questions help a registry match the tool to the right requests. You put the file in a standard place on your site, and that's essentially it.

6. How an agent knows it's really you

Trust is what makes ARD more than a directory. Because a catalog is tied to your own web address, that address becomes the proof of identity. For more sensitive tools, an entry can also carry a stronger, cryptographic proof, so an agent can be sure it's connecting to the real provider and not an imposter. The point is simple: an agent should be able to check who it's dealing with before it connects.

7. The bigger picture

ARD answers one half of a larger question: what tools exist, and can an agent trust them? It says nothing about the other half, which is what an organisation actually knows or means. I wrote about that second half in packaging an organisation's knowledge so agents can read it. One is about finding and trusting tools; the other is about giving an agent the right context to use them well. An agent on the open internet needs both.

For now, this is early. The standard is still a draft, the registries are new, and details will change. But the direction is clear, and publishing a simple catalog takes very little effort.

For AI agents to be useful at any real scale, they need a reliable way to find tools, choose between them, and trust what they find. That's all ARD is. It's deliberately small, and if it works it will feel obvious in hindsight. The simplest first step is to think about what tools you'd want agents to discover, and what you'd put in a catalog of your own.