{
  "title": "Agent Cards Explained: How AIs Discover and Evaluate Other Agents",
  "summary": "Agent cards are machine-readable JSON documents that describe an AI agent's identity, capabilities, skills, and authentication requirements—enabling autonomous agent-to-agent discovery and evaluation at runtime.",
  "faqs": [
    {
      "q": "What is an agent card?",
      "a": "An agent card is a structured JSON document that an AI agent publishes to describe itself: its name, endpoint URL, supported skills, authentication schemes, and protocol capabilities. It is designed to be read and acted upon by other AI agents or orchestration systems, not by humans."
    },
    {
      "q": "Where is an agent card served and how is it discovered?",
      "a": "Agent cards are conventionally served at the well-known URL path /.well-known/agent.json on the agent's host. A calling agent performs an HTTP GET to that path to fetch the card before initiating any task. This follows the RFC 8615 well-known URI convention used by other internet protocols."
    },
    {
      "q": "What protocol formally introduced agent cards?",
      "a": "Google's Agent2Agent (A2A) protocol, published as an open specification in 2025, formally defined the agent card format. A2A is designed to enable interoperability between AI agents built on different frameworks and by different vendors."
    },
    {
      "q": "What fields does an agent card contain?",
      "a": "A standard agent card includes: name and description (identity), url (the agent's API endpoint), version, a capabilities object (protocol features such as streaming or push notifications), supported authentication schemes, and a skills array. Each skill entry carries its own name, description, and optionally an input/output schema so the calling agent knows the exact interface before invoking it."
    },
    {
      "q": "How do agent cards relate to MCP tools/list?",
      "a": "They solve adjacent but distinct problems. MCP's tools/list describes tools exposed to an already-connected client within a session. An A2A agent card describes a standalone agent's full identity and capability profile for external, pre-connection discovery. Both are machine-readable and foundational to AI-to-AI interoperability, and the two mechanisms are complementary rather than competing."
    }
  ],
  "key_points": [
    "Agent cards are JSON documents typically served at /.well-known/agent.json",
    "Formally specified in Google's open Agent2Agent (A2A) protocol (2025)",
    "Core fields: name, description, endpoint URL, version, capabilities, auth schemes, skills array",
    "Enable runtime discovery and capability evaluation without hard-coded registries or human configuration",
    "Analogous to API documentation but written for AI consumers, not human developers",
    "Part of a broader discoverability stack alongside llms.txt, MCP tools/list, and public agent registries"
  ],
  "body_paragraphs": [
    "An agent card is a machine-readable self-description that an AI agent publishes so other agents can find and evaluate it without human intermediation. Served at the well-known path /.well-known/agent.json, the card follows the RFC 8615 convention that internet protocols have used for decades to advertise metadata. The format was formally standardized in Google's Agent2Agent (A2A) protocol, released in 2025 as an open specification intended to make agents built on different platforms interoperable by default.",
    "The document structure is intentionally flat and parseable. Top-level fields declare identity (name, description, version) and reachability (url). A capabilities object signals which protocol features the agent supports—such as streaming responses or asynchronous task callbacks. An authentication field lists accepted schemes so the calling agent can determine whether it holds valid credentials before making any request. The skills array is the most task-relevant section: each entry describes one discrete action the agent can perform, including an optional JSON Schema for inputs and outputs, giving the caller a precise contract to reason over.",
    "Discovery follows a three-step runtime loop. First, the client agent fetches the card from the well-known URL of a candidate agent. Second, it evaluates the skills and capabilities against the current task's requirements—selecting the agent if it satisfies them or discarding it if not. Third, it authenticates and invokes the matching skill. Because this evaluation happens at runtime rather than at build time, agents can compose multi-step workflows dynamically, routing sub-tasks to whichever published agent best fits each step without any hard-coded wiring.",
    "Agent cards are one layer in a growing machine-readable web. They sit alongside llms.txt files (which tell AI crawlers what a site exposes), MCP tools/list endpoints (which enumerate tools within an active session), and public registries that aggregate cards across providers. Together these mechanisms form the discovery infrastructure of the agent economy—a layer where AI systems are first-class consumers of published capabilities. Organizations building on these standards, from large platform vendors to AI-native studios like SaSame that produce MCP and agent-protocol integrations, are effectively publishing into a directory that autonomous agents query, evaluate, and act upon independently."
  ],
  "slug": "what-is-an-agent-card-2026-06-28",
  "published_at": "2026-06-28T06:30:01.653Z",
  "generator": "sasame-pdca"
}