ARD Spec: Google and GitHub Launch 'Search Engine' for AI Agents

The AI race in 2026 is no longer just about which model is smarter, but rather how AI agents can autonomously discover, communicate, and collaborate with one another across the internet.

On June 17, 2026, a massive tech coalition including Google, Microsoft, GitHub, Nvidia, and Hugging Face officially announced the Agentic Resource Discovery (ARD) open specification. Described as a breakthrough discovery protocol for the "Agentic Web," ARD solves a fundamental bottleneck: How can an AI agent running locally or in the cloud dynamically locate and securely connect to the right tools, skills, or APIs on the web without developers having to manually integrate them beforehand?

Let's dive into how the ARD specification works and why it will reshape the future of software engineering and application architecture.

---

From Manual Integration to Autonomous Discovery

Traditionally, when developers wanted to equip an AI agent with external tools (such as through the Model Context Protocol - MCP), they had to hardcode API endpoints, security configurations, or tool schemas directly into the codebase.

graph TD
    A[AI Agent] -->|Must be pre-configured| B(API Tool 1)
    A -->|Must be pre-configured| C(API Tool 2)
    A -->|Must be pre-configured| D(API Tool 3)

This manual approach limits flexibility and compromises the autonomous nature of AI agents. In a digital ecosystem hosting millions of potential APIs, an agent remains oblivious to new resources unless a developer manually updates its code.

The ARD specification eliminates this friction by establishing a dynamic discovery mechanism. Instead of pre-wired integrations, AI agents query registries or crawl target domains directly to find tools matching their goals using natural language intent.

graph TD
    A[AI Agent] -->|Sends natural language query| B(ARD Registry / Search Engine)
    B -->|Returns matching tools & descriptions| A
    A -->|Autonomously connects & executes| C(Newly Discovered API / Tool)

---

Under the Hood of ARD Spec: ai-catalog.json

The cornerstone of the ARD specification is a static manifest file named ai-catalog.json. Similar to how robots.txt guides web scrapers or security.txt lists security contact info, organisations place ai-catalog.json publicly at the root of their domains.

Registries and search engines crawl these files to build a searchable index of the agentic web, enabling AI agents to discover specific capabilities.

Here is a conceptual example of an ai-catalog.json file conforming to the ARD specification:

{
  "$schema": "https://ards-project.org/schemas/v1/ai-catalog.schema.json",
  "publisher": {
    "name": "Acme Corp Dev Tools",
    "domain": "acme.dev",
    "verification": {
      "type": "dns-txt",
      "record": "ard-verification=hash_signature_here"
    }
  },
  "capabilities": [
    {
      "id": "kubernetes-log-analyzer",
      "type": "mcp-server",
      "name": "Kubernetes Log Analyzer",
      "description": "Analyzes Kubernetes logs and recommends solutions for crash loop backoffs.",
      "endpoint": "https://api.acme.dev/mcp/k8s",
      "auth": {
        "type": "oauth2",
        "grant_type": "client_credentials"
      }
    }
  ]
}

Key Technical Aspects of the Spec:

1. Cryptographic Verification: ARD supports built-in identity verification via DNS TXT records or cryptographic signatures. This ensures AI agents can verify the publisher's identity, preventing malicious tool spoofing or prompt injection attacks via rogue manifests.
2. Dynamic Capabilities: Catalog items can represent MCP servers, OpenAPI endpoints, or downstream AI agents, complete with natural language descriptions so LLM-powered agents can decide when and how to call them.

---

Immediate Industry Adoption: Google and GitHub

Unlike standards that remain draft-only on paper, the ARD specification is launching with massive ecosystem momentum:

• Google has introduced an Agent Registry within its Gemini Enterprise Agent Platform, along with an open-source runtime standard called Agent Executor. This enables developers to connect and run multi-agent systems seamlessly, with automatic resource discovery built-in.
• GitHub has rolled out Agent Finder for GitHub Copilot. This feature uses the ARD spec to let Copilot dynamically query a central index, discovering and invoking external MCP servers and skills to complete tasks directly inside the IDE.

The unified backing from Google (Gemini) and Microsoft/GitHub (Copilot) positions ARD to become the default standard for agent-to-agent and agent-to-tool integration, much like how OpenAPI defined the REST API era.

---

How ARD Spec Changes Software Architecture

The rise of the ARD specification marks a profound shift for software developers and systems architects:

Architectural Metric	Before ARD	After ARD
Tool Integration	Manual hardcoding, constant SDK updates, complex YAML configuration.	Static file hosting. Place ai-catalog.json at root domain; agents discover it.
Security & Identity	Custom token handling, prone to API key leaks and supply-chain exploits.	Standardized cryptographically verified discovery with DNS validation.
Scalability	Limited to tools pre-installed on the server/agent environment.	Infinite scaling. Agents search the web to find and consume tools as needed.

---

Conclusion: The Era of the Agentic Web

If the 1990s and 2000s were about designing the web for humans (HTML), and the 2010s were about building the web for machines (REST/APIs), 2026 marks the birth of the Agentic Web — designing the web specifically for AI agents.

The Agentic Resource Discovery (ARD) spec is the next major pillar alongside the Model Context Protocol (MCP). Together, they provide autonomous systems with both a common language to speak (MCP) and a unified map to find each other (ARD).

For modern developers, creating an ai-catalog.json file for your internal tools or customer-facing APIs is no longer a futuristic task — it will soon be a core standard to ensure your applications remain discoverable in an agentic world.

---

Content assisted by AI (Amy 🌸). Reviewed by the author.