Written by: Mariana Fonseca, Editorial Team, AI Growth Agent
Key Takeaways
- An Agent Card is a standardized JSON document published at /.well-known/agent-card.json that lets AI agents discover, authenticate with, and interact with enterprise sites under the A2A protocol.
- Agent Cards replace scattered metadata and guesswork with a structured discovery layer that declares identity, skills, endpoints, and security requirements for agent-to-agent communication.
- Proper Agent Card implementation improves brand visibility in AI search by making sites structurally complete and citable to the agents now handling most discovery work.
- Enterprise-scale deployment requires an automated system rather than manual files, and AI Growth Agent provisions and maintains Agent Cards alongside llms.txt, Blog MCP, and the full agent-readable surface.
- Brands ready to control their narrative in AI search can schedule a strategy session with AI Growth Agent and see their first article live within a week.
How Agent Cards Define Your Brand for AI Agents
An Agent Card is the structured identity record that tells the agentic web what your site offers, how to reach it, and how to authenticate with it. Before this convention existed, that information was scattered across sitemap hints, robots.txt directives, and inference. Agents had no reliable way to determine whether a site offered callable services, what those services accepted, or how to authenticate securely.
The lineage runs from the earliest web standards. Robots.txt, introduced in 1994, told crawlers where to look and where to stay out. Sitemaps gave crawlers a structured index of pages. Neither was designed to describe an interactive agent endpoint, declare a skill set, or hand off OAuth credentials. Sites stretched these formats as far as they would go and stitched the rest together with metadata in page headers.
The A2A Protocol, built on HTTP, SSE, and JSON-RPC, introduced a dedicated home for this information. Originally introduced by Google in 2025 and brought to production-grade v1.0 in early 2026, A2A is now governed by the Linux Foundation and supported by more than 150 organizations including Microsoft, AWS, Salesforce, SAP, and ServiceNow. The Agent Card is the discovery artifact at the center of that standard, and it is the foundation of agentic technical SEO for any brand that wants to be cited, called, and trusted by the agents now doing most of the discovery.
Agent Card JSON Fields and Example
The table below lists the core fields every production Agent Card should include. Optional fields extend the card’s expressiveness, and the required set is what compliant agents parse first.
| Field | Type | Required | Purpose |
|---|---|---|---|
| name | string | Yes | Human-readable name of the agent |
| description | string | Yes | High-level summary of the agent’s purpose |
| version | string | Yes | Semantic version of the agent (e.g., 1.0.0) |
| protocolVersion | string | Yes | A2A spec version the agent implements (e.g., 0.3.0) |
| url | string | Yes | Endpoint where the agent receives requests |
| skills | array | Yes | Declared capabilities with id, name, description, tags, and examples |
| capabilities | object | Optional | Protocol-level flags: streaming, pushNotifications, stateTransitionHistory |
| defaultInputModes | array | Optional | MIME types the agent accepts by default (e.g., text/plain) |
| defaultOutputModes | array | Optional | MIME types the agent returns by default |
| securitySchemes | object | Recommended | Supported auth methods: OAuth2, API key, Bearer, OpenID Connect, mTLS |
The following example is a copy-paste-ready Agent Card JSON for a brand content agent. Replace placeholder values with your production endpoint and credentials.
{ "name": "Brand Content Agent", "description": "Answers product, pricing, and category queries for [Brand] and returns structured citations.", "version": "1.0.0", "protocolVersion": "0.3.0", "url": "https://yourdomain.com/a2a/v1", "skills": [ { "id": "product-qa", "name": "Product Q&A", "description": "Returns factual answers about products, features, and availability.", "tags": ["product", "faq", "catalog"], "examples": [ "What are the dimensions of the Pro model?", "Is the adjustable base available in queen size?" ] }, { "id": "category-guide", "name": "Category Guide", "description": "Provides structured buying guides and comparison content for the brand's category.", "tags": ["buying-guide", "comparison", "category"], "examples": [ "What should I look for in an adjustable bed?", "Compare memory foam vs. hybrid mattresses." ] } ], "capabilities": { "streaming": false, "pushNotifications": false, "stateTransitionHistory": false }, "defaultInputModes": ["text/plain"], "defaultOutputModes": ["text/plain", "application/json"], "securitySchemes": { "bearerAuth": { "type": "http", "scheme": "bearer" } }, "security": [ { "bearerAuth": [] } ] }Each skill entry supports inputModes and outputModes overrides that take precedence over the card-level defaults, which gives agents precise instructions for each callable capability without ambiguity.
How Agent Cards Fit into the A2A Workflow
A2A communication follows a three-step workflow: Discovery, Initiation, and Completion. In the Discovery step, a client agent fetches the remote agent’s Agent Card from /.well-known/agent-card.json and parses the skills array to determine whether the agent is suitable for the task at hand. No hard-coded integrations are required. Discovery begins when a client agent references the Agent Card to identify a capable remote agent based on advertised skills, not on prior knowledge of the endpoint.
In the Initiation step, the client agent reads the securitySchemes field, acquires the appropriate credentials, and sends a structured task request to the url declared in the card. In the Completion step, the remote agent processes the task and returns results through stateful messaging without exposing its internal logic.
Google’s I/O 2026 keynote on May 19, 2026 made the agentic shift explicit. AI Mode crossed 1 billion monthly users within its first year, and the agentic layer running on top of it handles most of the discovery now. The Linux Foundation began governing the A2A project in June 2025, with v1.0 reaching production-ready status around April 2026, which formalized what Google had been building toward: a machine-navigable web where the Agent Card is the front door.
Agent Card Discovery via /.well-known/
Each A2A agent publishes its Agent Card at the well-known URL /.well-known/agent-card.json. The deployment path is exact. The file must be served at that location with a Content-Type: application/json header and must be reachable without authentication for the discovery step to succeed.
For brands running a reverse proxy architecture, the well-known path must be explicitly routed. If your blog lives at yourdomain.com/blog via a reverse proxy rewrite, the Agent Card still needs to resolve at yourdomain.com/.well-known/agent-card.json, not at yourdomain.com/blog/.well-known/agent-card.json. Misconfigured reverse proxies are the most common reason Agent Cards fail discovery audits.
Discoverability is the missing half of MCP. A site can stand up a Model Context Protocol server that lets an agent interact with it in natural language, and that server is entirely invisible if nothing tells the agent where to find it. The A2A specification recommends protecting the Agent Card endpoint with access controls when it contains sensitive capability or endpoint details, but the discovery endpoint itself must remain publicly reachable. Agent-readiness is a stack. The MCP side handles interaction, the discovery side handles announcement, and both layers must ship together.
How Agent Cards Differ from llms.txt
Agent Cards and llms.txt serve different readers with different jobs. Agent Cards, published at /.well-known/agent-card.json, enable discovery of sites that function as agents offering callable services to other agents under Google’s A2A protocol. They declare endpoints, authentication schemes, and skills. They act as instructions for interaction, not summaries of content.
An llms.txt file is a standardized Markdown file proposed by Jeremy Howard in September 2024 to provide information that helps LLMs use a website at inference time. It functions like a priority signal for AI crawlers, listing high-value entry points such as quickstarts, core concepts, and API references. llms.txt is observably useful primarily for coding agents that need to look up technical documentation via URLs hardcoded into their system prompts, rather than for general AI surfaces performing query-time citation.
The practical distinction is simple. An Agent Card tells another agent what your site can do and how to call it. An llms.txt tells an AI surface what your site contains and which pages to read first. Both are part of the full agent-readable surface. Neither replaces the other, and neither replaces robots.txt, which still performs its original job of telling crawlers where to look and where to stay out. The right configuration is all three, deployed together. For reference, Anthropic publishes llms.txt and llms-full.txt, which shows how enterprise-scale brands structure their agent-readable surface across multiple discovery files.
Why Agent Cards Matter for Brand Visibility in AI Search
The zero-click reality changes what visibility means. Customers ask ChatGPT, Perplexity, and Google’s AI Mode, and the answer they receive is, for most of them, simply the answer. They do not click through to verify sources. A brand that is undocumented to the agentic web is a brand that does not exist in those answers.
Narrative control used to be reactive. The new version is upstream. It means producing the content and publishing the discovery files that the models will use to describe your brand, in the formats and structures the models can read, with the validation that earns the citation. Agent Cards are the declaration layer of that strategy. Agentic commerce shifts buying intent onto AI surfaces, making brand control over discovery, dispute resolution, and trust a strategic priority comparable to SEO and performance marketing.
The World Economic Forum’s 2026 playbook identifies emerging discovery and trust layers, including the Agent Name Service and Model Context Protocol-Identity, that propose persistent agent identity, delegation layers, and versioned lifecycle metadata to support secure discovery in multi-agent ecosystems. Brands that establish their Agent Card infrastructure now sit at the front of every wave in this layer.
The four pillars that shape what an AI surface says about a brand are search intelligence, AI analytics, bot tracking, and AI ranking. Agent Cards feed all four. They make your endpoints discoverable to search intelligence crawlers, they generate bot traffic that AI analytics can measure, they create citation events that bot tracking can attribute, and they improve the citation context that determines AI ranking. A site without an Agent Card is invisible to the agents now doing most of the discovery work.
How to Implement Agent Cards at Enterprise Scale
Manual implementation of Agent Cards is a one-time engineering task. Enterprise-scale implementation, where the Agent Card stays current as endpoints evolve, authentication schemes change, and new skills are added, requires a system, not a file.
The headless marketing architecture solves this by centralizing all discovery infrastructure in a single managed system. AI Growth Agent provisions Agent Cards, /.well-known/ discovery files, llms.txt and llms-full.txt, Blog MCP, and the complete agent-readable surface automatically across every client site. Because this provisioning happens centrally, updates roll out across every client rather than site by site. When a new standard ships, the spec is read and deployed across every client within the week, which means brands using this architecture become discoverable to new agent capabilities before competitors even begin implementation.
The only integration step on the client’s side is the reverse proxy rewrite that connects the blog and the full technical stack to a subdirectory under the brand’s domain. Everything else, including Agent Card provisioning, schema, bot tracking, instant indexing, and agentic technical SEO, is included in every package. No additional headcount. No engineering sprint. No RFP.
The kickoff takes one week. A journalist-led interview builds the brand manifesto. The keyword topology maps the full universe of queries. The first articles are live and indexed within days. The Agent Card and the full agent-readable surface are provisioned as part of the same deployment.
The Business Outcome: Become the Answer Agents Cite
Agent Cards are only one component of a complete agent-readable surface, and the content layer must also stay current to maintain citation authority. AI Growth Agent addresses this by producing content that updates and self-heals over time, which prevents the brand’s presence from decaying as the world changes. Every article’s relationships, performance, and bot and Search Console data are centralized, so authority compounds instead of fragmenting across disconnected pages.
Across the first twelve weeks, AI Growth Agent clients average more than 12,000 additional AI citations and mentions, over 100,000 additional bot visits, and a 20% or greater lift in impressions, with content indexing in as little as ten days. Breadless is now cited by ChatGPT over 45,000 times per month and generates highly qualified franchisee leads each week. Leva Sleep closed $40,000 to $50,000 in deals in under three weeks from buyers who discovered the brand through AI Growth Agent content. These outcomes follow from a complete agent-readable surface, not from a single file.
AI systems now need to be recognizable and understandable to machines, not just intuitive for humans, requiring granular, self-describing content and data rather than relying on human inference from fragmented sources. Agent Cards are the declaration that makes your brand complete to the agentic web. Without them, your site is undocumented. With them, it becomes the answer agents cite.
The leaderboard is being written this year. Brands that establish authoritative content and a complete agent-readable surface now are training the next generation of models with their own narrative. Brands that wait are training the next generation with whatever happens to be sitting on the open web.
Traditional search tools show you where your brand stands. AI Growth Agent makes your brand the answer. Schedule a strategy session and see your first article live within a week.
Frequently Asked Questions
What is the difference between an Agent Card and a robots.txt file?
Robots.txt is a flat directive file that tells crawlers which pages they can and cannot access. It was never designed to describe an interactive agent endpoint, declare a skill set, or specify authentication requirements. An Agent Card is a structured JSON document that does all three. It tells other agents what your site can do, where to call it, and how to authenticate. Robots.txt controls access for crawlers. An Agent Card advertises capabilities to interactive agents. The correct configuration is both, deployed together, because they serve different classes of reader with different needs.
Do I need an Agent Card if I already have an MCP server?
Yes. An MCP server lets an agent interact with your site in natural language once it knows the server exists. The Agent Card is what tells the agent the server exists in the first place. A site with an MCP server and no Agent Card is a service running on an unpublished number. Discoverability is the missing half of MCP. The Agent Card, published at the canonical /.well-known/agent-card.json location, is the announcement layer that makes your MCP server findable. Both layers must ship together for either to matter.
How does an Agent Card improve brand citation rates in AI search?
Agent Cards make your site structurally complete to the agents now doing most of the discovery work. When an AI surface runs a citation pass, it is looking for sources it can find, trust, and call. A site with a properly deployed Agent Card declares its identity, capabilities, and authentication in a format those agents can parse without inference. That declaration reduces friction in the discovery step, which increases the likelihood that your site is selected as a source. Combined with authoritative content, a complete llms.txt, Blog MCP, and the full agent-readable surface, the Agent Card is the declaration layer that turns a well-structured site into a citable one.
How long does it take to deploy an Agent Card?
Writing the JSON file itself takes under an hour for a developer familiar with the A2A spec. The harder part is keeping it current as endpoints evolve, authentication schemes change, and new skills are added, and ensuring it is correctly routed through your reverse proxy so it resolves at the canonical /.well-known/agent-card.json path on your root domain. AI Growth Agent provisions the Agent Card and the full agent-readable surface automatically as part of the kickoff deployment, with no engineering sprint required on the client’s side. The complete agentic technical SEO stack ships with the first article deployment.
Is an Agent Card the same as an llms.txt file?
No. They serve different readers with different jobs. An Agent Card is a JSON document that advertises callable services, endpoints, and authentication requirements to other agents under the A2A protocol. It is an instruction set for interaction. An llms.txt file is a Markdown document that summarizes what a site contains and which pages are most important, primarily useful for coding agents and AI surfaces parsing documentation at inference time. Both are part of the full agent-readable surface, and both should be deployed alongside robots.txt and a proper sitemap. Neither replaces the other, and a site that deploys only one of them is leaving half the discovery layer undeclared.
