MCP Missed a Step: Agent Resource Discovery (ARD) and the DNS for Agents

Connecting an AI agent to a tool is relatively straightforward: write an MCP server, declare tools, let the model call them. Things get more complicated once an organization has hundreds of tools across clouds, SaaS platforms, and internal systems. The Model Context Protocol has become a common way for AI applications to connect to external tools and data, but it assumes the client already knows which server it wants to use. ARD (Agent Resource Discovery) addresses the step before connection: letting an agent find a resource before it tries to use it. The specification uses the term "agentic resource" for anything an AI client can connect to, from an MCP server to other outside capabilities. An ARD-compatible service keeps track of what’s available instead of requiring developers to set up every connection in advance.

1. Why MCP Missed a Step

MCP solves "how to connect": protocol, tool contracts, invocation. It does not solve "what to connect to": when infrastructure is spread across clouds, SaaS platforms, and internal systems, how does a client know which server to use? The current answer is manual configuration — hard-coding every connection address into code or config. The larger the organization, the heavier the burden. ARD adds the discovery layer: an agent searches for the resource it needs, then connects via the protocol the resource declares (usually MCP). AWS highlighted the open specification in its August 31 Weekly Roundup, describing the idea as "DNS, but for agents."

// The gap MCP leaves open: MCP assumes the client already
// knows which server it wants to use. ARD adds discovery
// BEFORE connection -- an agent searches for a resource it
// needs instead of being told where everything is.
// ARD v0.91 (2026-08-26) uses JSON-LD over a REST
// interface. The required endpoint searches by task.
POST /search
{
  "@context": "https://www.w3.org/ns/activitystreams",
  "type": "SearchRequest",
  "task": "summarize incident JIRA-4421",
  "constraints": {
    "privacy": "internal-or-approved-external",
    "maxResults": 5
  }
}

2. Who Is Behind ARD

Despite AWS highlighting the project, ARD isn’t an AWS technology. It was authored by Junjie Bu of Google, R.V. Guha of Microsoft, and Shaun Smith of Hugging Face, and released under the Apache 2.0 license. Engineers from several other companies have helped shape the project, including Cisco, Databricks, GitHub, GoDaddy, Nvidia, Salesforce, ServiceNow, and Snowflake. AWS’s role, so far, has been to provide feedback on the specification and explore how it could work with its own Agent Registry. Notably, two of the three authors of AWS’s August 24 ARD post work closely with Route 53 — one focuses on DNS and networking technologies, the other leads product management for Route 53, as well as agent identity and discovery in AWS Agent Registry.

// A discovery service response: several options that all
// appear capable of doing the job. Unlike DNS, a domain
// name points to one location, while an ARD search can
// turn up multiple candidates -- the agent picks.
{
  "type": "SearchResponse",
  "results": [
    {
      "id": "https://registry.acme.dev/agents/incident-summarizer",
      "name": "Incident Summarizer",
      "protocol": "mcp",
      "capabilities": ["summarize", "classify", "triage"],
      "trust": "internal",
      "policy": "requires-human-approval-for-send"
    },
    {
      "id": "https://registry.acme.dev/agents/ops-assistant",
      "name": "Ops Assistant",
      "protocol": "mcp",
      "capabilities": ["summarize", "runbook-lookup"],
      "trust": "internal"
    }
  ]
}

3. Core Design: JSON-LD + REST

The current v0.91 proposal, dated August 26, uses JSON-LD and a REST interface. Its required POST /search endpoint searches by task, while optional endpoints allow clients to browse available resources. Each discovery service can set its own rules for what it returns and which sources it trusts. This is also where the DNS comparison falls short: a domain name points to a specific location, while an ARD search could turn up several options that all appear capable of doing the job — the agent picks based on capability, trust, and policy. Companies can keep their own catalogs and policies while routing searches to other ARD-compatible services. An enterprise could keep internal resources private while searching approved external catalogs when needed. AWS calls this "describe once, discover everywhere."

// Describe once, discover everywhere: an enterprise keeps
// internal resources private while routing searches to
// approved external catalogs when needed. Each discovery
// service sets its own rules for what it returns and
// which sources it trusts.
{
  "registry": {
    "internal": {
      "visibility": "private",
      "publish": "service mesh auto-registers capabilities"
    },
    "federation": {
      "trustedCatalogs": [
        "https://catalog.partner-a.dev/ard",
        "https://catalog.partner-b.dev/ard"
      ],
      "policy": "internal first, external only when
                 no internal match"
    }
  }
}

4. What It Means for Developers

ARD turns the registry from static configuration into dynamic infrastructure. For platform teams, it means the service mesh can auto-register capabilities instead of maintaining a hand-maintained tool inventory. For agent developers, it means no longer needing to know every tool’s location in advance — write a discovery client, search by task, filter by trust and policy, then connect. AWS Agent Registry already gives AWS customers a central view of their resources. Adding ARD could bring resources running elsewhere into that view without requiring companies to register everything with AWS.

5. Code Walkthrough: Search Contract, Client, and Federation

The code blocks in this post unpack the specification. Block one is the ARD POST /search request: JSON-LD context, task description, privacy and count constraints. Block two is the discovery response: multiple candidate resources, each with protocol, capabilities, trust level, and policy. Block three is registry federation: internal private, trusted external catalogs, internal-first policy. Block four is a minimal discovery client: search across registries, rank by trust and capability, then connect via the protocol the resource speaks. Block five is the governance timeline: authors, contributors, license, and next steps toward a neutral home such as the W3C or an AI foundation.

// A minimal ARD discovery client: search across
// registries, filter by trust and capability, then connect
// via the protocol the resource speaks (usually MCP).
async function discover(task, constraints) {
  const registries = await registryList();
  const results = [];
  for (const reg of registries) {
    const res = await fetch(reg + "/search", {
      method: "POST",
      headers: { "Content-Type": "application/ld+json" },
      body: JSON.stringify({ task, constraints }),
    });
    results.push(...(await res.json()).results);
  }
  return rankByTrustAndCapability(results, task);
}
// AWS highlighted ARD in its August 31 Weekly Roundup,
// describing the idea as "DNS, but for agents."

6. Unify Early, Avoid Fragmentation

ARD’s governance is still being worked out, with board terms and membership among the details yet to be settled. The group has discussed eventually moving the project to a neutral organization such as the W3C or an AI foundation. There may not be much time to settle on a common approach, since connecting all these directories will only get harder once companies have built their own discovery systems. For individual developers, the advice is to track the ARD spec, and replace hard-coded tool addresses in your own agent workflows with a "discover resources by task" pattern — even a simple internal registry. The direction is clear: connection is a protocol problem, discovery is a directory problem, and both need standards.

// Governance note: ARD's governance is still being worked
// out. The group has discussed eventually moving the
// project to a neutral organization such as the W3C or an
// AI foundation -- and there may not be much time to
// settle on a common approach, since connecting all these
// directories will only get harder once companies have
// built their own discovery systems.
const ARD_TIMELINE = {
  "v0.91": "2026-08-26 (JSON-LD + REST, POST /search)",
  "authors": ["Junjie Bu (Google)", "R.V. Guha (Microsoft)",
              "Shaun Smith (Hugging Face)"],
  "license": "Apache 2.0",
  "contributors": ["Cisco", "Databricks", "GitHub", "GoDaddy",
                   "Nvidia", "Salesforce", "ServiceNow", "Snowflake"],
  "next": "board terms, membership, neutral home (W3C / AI foundation)"
};