Agent Discovery: How AI Agents Find Each Other on the Open Web

Agent Discovery: How AI Agents Find Each Other on the Open Web

Before two AI agents can collaborate, they have to find each other. In a human context, we have LinkedIn, referral networks, and Google. In the agent world, we're building new discovery primitives from scratch—and the infrastructure is more interesting than it might first appear.

This guide covers the technical mechanisms agents use to discover each other, the standards emerging around agent self-description, and where the discovery layer is heading as the agentic web matures.

The Agent Card: A Digital Business Card for AI

The foundational unit of agent discovery is the Agent Card—a JSON document that describes what an agent can do, how to reach it, and what protocols it supports.

Defined as part of the A2A (Agent2Agent) protocol specification, an Agent Card contains:

• •Identity: Name, description, provider information
• •Service Endpoint: The URL where the A2A service can be reached
• •Capabilities: What the agent supports (streaming, push notifications)
• •Authentication: Required schemes (Bearer, OAuth2, etc.)
• •Skills: Structured descriptions of what the agent can do, with input/output modes and examples

{
  "name": "InventoryAgent",
  "description": "Real-time inventory lookup and reservation for warehouse SKUs",
  "provider": {
    "organization": "Acme Logistics",
    "url": "https://acmelogistics.com"
  },
  "url": "https://agents.acmelogistics.com/a2a",
  "version": "1.0.0",
  "capabilities": {
    "streaming": true,
    "pushNotifications": true
  },
  "authentication": {
    "schemes": ["Bearer"]
  },
  "skills": [
    {
      "id": "check-inventory",
      "name": "Check Inventory",
      "description": "Returns current stock levels for one or more SKUs"
    }
  ]
}

The Agent Card is to agents what a service's OpenAPI spec is to APIs—a machine-readable contract that tells other systems what's available and how to use it.

Discovery Strategy 1: Well-Known URI

The simplest and most powerful discovery mechanism is the well-known URI—a standardized path on a company's domain where their agent's card lives.

Following RFC 8615, the A2A spec defines this path as:

https://{domain}/.well-known/agent-card.json

So if Acme Corp runs an A2A-compatible agent, you'd find its Agent Card at:

https://acmecorp.com/.well-known/agent-card.json

This is elegant for several reasons:

Domain anchoring: The agent's identity is tied to the company's real domain. If you trust the domain (via HTTPS and standard PKI), you can trust the agent card is authentic.

Zero infrastructure: No central registry required. Any company can make their agent discoverable by publishing a single JSON file.

Crawlable: A discovery bot can systematically check thousands of domains for agent cards, building an index—much like how web crawlers index pages.

This mirrors patterns from other web standards: robots.txt, sitemap.xml, /.well-known/openid-configuration. The convention of well-known URIs has proven durable precisely because it's simple and self-contained.

import httpx

async def discover_agent(domain: str) -> dict | None:
    url = f"https://{domain}/.well-known/agent-card.json"
    try:
        response = await httpx.AsyncClient().get(url, timeout=5.0)
        if response.status_code == 200:
            return response.json()
    except httpx.RequestError:
        pass
    return None

Discovery Strategy 2: Curated Registries

Well-known URIs are great if you already know which domain to check. But how do you find agents you don't know about?

This is where curated registries come in—centralized catalogs that aggregate Agent Cards and make them queryable by capability, category, or keyword.

A registry works like this:

1. 1.Agents publish their cards to the registry (either manually or via automated crawl)
2. 2.Client agents query the registry: "find me all agents that can handle check-inventory tasks in the EU"
3. 3.The registry returns matching Agent Cards with endpoint URLs
4. 4.The client agent fetches detailed cards from those endpoints and initiates contact

The A2A specification deliberately doesn't prescribe a standard API for registries—this is a layer being built by the ecosystem. But the pattern is clear: registries are the "search engines" of the agentic web.

Platforms like Clawshake function as a specialized registry for B2B deal discovery: a curated space where companies register their agents with structured descriptions of what they sell and what they buy, making them discoverable to relevant counterparts.

Discovery Strategy 3: Direct Configuration

For tightly coupled systems—internal microservices, private agent networks—the simplest approach is direct configuration: hardcode the Agent Card URL or embed the card in a config file.

# agent-config.yaml
remote_agents:
  - name: billing-agent
    card_url: https://internal.acme.com/.well-known/billing-agent.json
    auth_token_env: BILLING_AGENT_TOKEN
  - name: hr-agent
    card_url: https://internal.acme.com/.well-known/hr-agent.json
    auth_token_env: HR_AGENT_TOKEN

This is the least sophisticated but often the most appropriate approach for internal agents where dynamic discovery adds complexity without value.

Extended Agent Cards: Private Details for Authenticated Clients

The A2A spec includes a useful two-tier model for agent cards:

• •Public card (/.well-known/agent-card.json): Minimal information for initial discovery. Anyone can fetch this.
• •Extended card: A richer version with additional skills, pricing, internal endpoints, or sensitive details. Only returned to authenticated requests.

This lets companies be discoverable publicly while keeping sensitive operational details private—a practical balance between openness and security.

Skill Taxonomies: Making Discovery Meaningful

As agent registries grow, raw keyword search becomes insufficient. The emerging approach is skill taxonomies—structured vocabularies for describing what agents can do.

Imagine a taxonomy that standardizes skills like:

commerce/
  pricing/quote-generation
  pricing/bulk-discount
  fulfillment/inventory-check
data/
  enrichment/company-lookup
  enrichment/contact-verification
finance/
  payments/invoice-generation

When agents advertise skills using a shared taxonomy, discovery becomes precise. A buyer's agent looking for commerce/pricing/quote-generation can find all relevant seller agents without relying on natural language matching.

The Agentic Web is Being Indexed

Here's the big picture: what's happening with agent discovery is structurally similar to what happened with web discovery in the 1990s. First there were individual pages. Then there were directories (Yahoo). Then there were crawlers and search engines (Google).

Agent discovery is following the same arc:

• •Individual agents: Companies build one-off integrations
• •Directories: Registries catalog agents by category
• •Crawlers: Discovery bots systematically index agent cards from across the web
• •Search: Natural language queries that match needs to agents

The .well-known/agent-card.json convention is the <title> tag of the agentic web—a small standardization that enables everything above it.

If you're building an agent that should be discoverable—whether for internal use, enterprise partners, or open markets—the single most important step is publishing a well-formed Agent Card at the well-known URI. Everything else builds on that foundation.