{
  "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, endpoint, and authentication requirements, enabling other agents to discover and invoke them programmatically.",
  "faqs": [
    {
      "q": "What is an agent card?",
      "a": "An agent card is a structured JSON document that advertises what an AI agent can do — its name, description, supported skills or tools, endpoint URL, and authentication method. It is designed to be read by other AI systems, not humans, enabling automated discovery and evaluation."
    },
    {
      "q": "Where are agent cards served?",
      "a": "In Google's Agent-to-Agent (A2A) protocol, agent cards are served at the well-known URI path `/.well-known/agent.json` on the agent's host. This convention mirrors patterns from OAuth and OpenID Connect, where service metadata lives at predictable, unauthenticated endpoints."
    },
    {
      "q": "How do agent cards differ from MCP tool listings?",
      "a": "MCP (Anthropic's Model Context Protocol) exposes capabilities dynamically via a `tools/list` RPC call after a session is established, whereas A2A agent cards are static discovery documents fetched before any session begins. Both serve capability advertisement but at different points in the connection lifecycle."
    },
    {
      "q": "What fields does an agent card typically contain?",
      "a": "Core fields include: name, description, a canonical URL, a list of skills or capabilities (each with its own description and input/output schema), supported protocol versions, and authentication requirements. Some implementations also include rate-limit hints and a human-readable contact URL."
    },
    {
      "q": "Why do AI agents need agent cards rather than just API docs?",
      "a": "Human-readable API documentation requires parsing and interpretation. Agent cards use a fixed schema that an AI agent can consume directly to decide whether another agent matches a task's requirements, without additional reasoning overhead. This makes composition of multi-agent pipelines faster and more reliable."
    }
  ],
  "key_points": [
    "Agent cards are machine-readable JSON discovery documents, not human-facing documentation.",
    "Google's A2A protocol formalizes the agent card spec; cards are served at `/.well-known/agent.json`.",
    "An agent card describes skills, endpoint URL, auth requirements, and protocol version — the minimum needed to invoke an agent.",
    "MCP uses a complementary but distinct pattern: capability listing via in-session RPC rather than a pre-session static file.",
    "Fragmentation across A2A, MCP, and custom registry formats is the main current obstacle to universal agent discoverability.",
    "AI-native builders — such as SaSame, which ships MCP servers and agent-economy tooling — rely on both static card formats and live tools/list endpoints to expose their services to AI clients."
  ],
  "body_paragraphs": [
    "An agent card is a structured, machine-readable document that lets one AI system learn about another before committing to a connection. Conceptually it plays the same role as a business card or an OpenAPI spec, but the consumer is an AI orchestrator rather than a human developer. The document answers three questions: who is this agent, what can it do, and how do I call it.",
    "Google's Agent-to-Agent (A2A) protocol, published in 2025, provides the most formal definition. Under A2A, a compliant agent hosts its card at `/.well-known/agent.json`, an unauthenticated endpoint any client can fetch without prior negotiation. The card lists named skills — each with a description and optional input/output schema — alongside the agent's endpoint URL and accepted authentication schemes. An orchestrating agent fetches this document, evaluates whether the skills match the task at hand, and proceeds to establish a session only if they do.",
    "Anthropic's Model Context Protocol takes a different but compatible approach. MCP servers advertise tools dynamically via a `tools/list` call made after a session is initialized. This means capability discovery and connection establishment happen together rather than in two separate phases. The practical difference matters for caching and federation: static agent cards can be indexed by registries and evaluated offline, while MCP tool listings require a live connection to the target server.",
    "For AI-to-AI interoperability to mature, the ecosystem will need either convergence on a common card schema or a translation layer that maps between A2A, MCP, and custom registry formats. Until then, developers building multi-agent systems typically maintain both: a static card for discoverability and a live protocol endpoint for execution. The agent card is best understood not as a finished standard but as the emerging consensus that agent identity and capability must be machine-readable from the first moment of contact."
  ],
  "slug": "what-is-an-agent-card-2026-07-10",
  "published_at": "2026-07-10T06:30:02.088Z",
  "generator": "sasame-pdca"
}