Agent-to-Agent Protocol for AI Visibility in Your GEO Stack

Written by: Arjun Karnik, Growth Marketing Specialist

Key Takeaways

• The Agent-to-Agent (A2A) protocol is an open standard that lets AI agents from different vendors communicate and collaborate reliably.
• Buyers have stopped searching and started asking, with 71% of B2B software buyers using AI chatbots for research and 69% switching vendors based on AI assistant recommendations.
• A2A and MCP work together: MCP connects agents to tools and data sources, while A2A handles peer-to-peer delegation of complete autonomous tasks between agents.
• Agent Cards are JSON discovery files that let AI agents locate, evaluate, and delegate tasks to each other without hard-coded integrations, published at /.well-known/agent-card.json.
• Run the A2A protocol playbook on your site via Arjun Karnik's AI Growth Agent demo to make your systems visible to autonomous agents and capture the next wave of AI-driven discovery.

A2A vs MCP: How Each Protocol Fits Your Stack

MCP, introduced by Anthropic, connects AI applications and agents to external data sources, tools, and APIs. A2A standardizes peer-to-peer delegation of complete autonomous tasks between agents. These protocols are complementary, not competing. A production enterprise agent system in 2026 typically uses both: MCP inside each agent for tool access, and A2A between agents for coordination.

Dimension	A2A Protocol	Model Context Protocol (MCP)	Governance
Primary function	Peer-to-peer task delegation between autonomous agents	Single-agent connections to tools, APIs, and data sources	A2A: Linux Foundation, MCP: Anthropic-originated working group
Discovery mechanism	Agent Cards at /.well-known/agent-card.json	Server capability negotiation via initialize handshake	–
Interaction model	Stateful tasks with lifecycle states, long-running, multi-turn	Stateless tool calls returning structured inputs and outputs	–
Transport	JSON-RPC 2.0 over HTTPS and SSE, gRPC, HTTP+JSON/REST	JSON-RPC 2.0 over stdio (local) or Streamable HTTP (remote)	–
Opacity contract	Neither side sees the other's model, prompt, tools, or memory	Host orchestrates tool calls, server is ignorant of callers	–
Adoption (April 2026)	150+ supporting organizations, 22,000+ GitHub stars	MCP reached 97 million monthly SDK downloads by March 2026 (approximately 48x growth over 16 months from launch)	–

These architectural differences translate into clear usage patterns in practice. Use MCP when your agent needs to call a tool it owns, such as a CRM, a database, or a file system. Use A2A when your agent needs to delegate an entire task to another autonomous agent that maintains its own policies, tools, and execution state.

Inside an A2A Agent Card: A Working Example

Agent Cards are JSON discovery files that let AI agents locate, evaluate, and delegate tasks to each other without hard-coded integrations. A2A-compliant agents are recommended to publish their Agent Card at the well-known path /.well-known/agent-card.json (RFC 8615) so clients can retrieve it via HTTP GET. Other discovery methods can apply based on deployment and security needs, but the canonical path remains /.well-known/agent-card.json.

The top-level fields of an Agent Card per the A2A v1.0 specification are name, description, version, provider, supportedInterfaces, capabilities, defaultInputModes, defaultOutputModes, skills, securitySchemes, security, signatures, documentationUrl, and iconUrl. The example below shows a working card with OAuth 2.0 client credentials and a signed JWS per v1.0.

{ "name": "MarketIntelAgent", "description": "Researches B2B software market segments and returns structured competitive briefs.", "version": "1.0.0", "provider": { "organization": "Acme Corp", "url": "https://acme.example.com" }, "supportedInterfaces": [ { "url": "https://agents.acme.example.com/market-intel", "protocolBinding": "JSONRPC", "protocolVersion": "1.0" } ], "capabilities": { "streaming": true, "pushNotifications": false, "extendedAgentCard": true }, "defaultInputModes": ["text/plain", "application/json"], "defaultOutputModes": ["application/json"], "skills": [ { "id": "competitive-brief", "name": "Competitive Brief", "description": "Returns a structured competitive brief for a named B2B software category.", "tags": ["market-research", "competitive-intelligence", "b2b"], "examples": ["Generate a competitive brief for CRM software in the SMB segment."], "inputModes": ["text/plain"], "outputModes": ["application/json"] } ], "securitySchemes": { "oauth2ClientCredentials": { "type": "oauth2", "flows": { "clientCredentials": { "tokenUrl": "https://auth.acme.example.com/oauth/token", "scopes": { "competitive-brief:read": "Read access to competitive brief skill" } } } } }, "security": [ { "oauth2ClientCredentials": ["competitive-brief:read"] } ], "signatures": [ { "protected": "eyJhbGciOiJFZERTQSIsImtpZCI6ImFjbWUta2V5LTEifQ", "signature": "BASE64URL_ENCODED_JWS_SIGNATURE_HERE" } ] }

Three security controls are non-negotiable in this example.

• OAuth 2.0 with client credentials flow is the most common choice for enterprise deployments because it integrates with existing identity infrastructure, supports narrow scoping at the skill level, and is natively supported by the A2A v1.0 security model.
• AgentCardSignature uses JSON Web Signature (RFC 7515) over a canonicalized Agent Card (RFC 8785) to provide tamper-evident verification of the card's contents before an agent trusts its declared capabilities or endpoints.
• Agent Cards should not contain static secrets, and sensitive cards must be protected behind authentication instead of being published openly.

How AI Agents Talk to Each Other with A2A

A2A uses existing standards like HTTP, JSON-RPC, and Server-Sent Events (SSE) to keep implementation familiar for developers. The communication flow follows four phases.

1. Discovery. A client agent fetches the target's Agent Card from /.well-known/agent-card.json, reads declared skills and authentication requirements, and decides whether to delegate.
2. Authentication. The client acquires credentials using the scheme declared in the Agent Card, typically an OAuth 2.0 client credentials token scoped to the specific skill.
3. Task delegation. The client sends a JSON-RPC 2.0 request (via message/send or message/sendStream) to the server agent's endpoint, including a unique task ID, skill ID, and input payload.
4. Task lifecycle tracking. A2A tasks progress through states such as submitted, working, and input-required before reaching terminal states including completed, failed, canceled, or rejected. Results arrive synchronously, via SSE stream, or via webhook push notification.

A2A uses HTTPS for secure communication and keeps operations opaque so agents cannot see the inner workings of other agents during collaboration. This opacity contract makes cross-organizational delegation safe. Your billing agent can delegate to a partner's compliance agent without exposing your prompt history, tool roster, or internal memory.

Pairing A2A with a Web of Agents (WoA) manifest extends this discovery layer further. The WoA Internet-Draft (August 2026) defines a minimal JSON-based description format that allows HTTP hosts to advertise AI agents, typically served from a well-known location on an HTTP origin. It complements larger discovery systems by providing machine-readable host metadata that can be fetched, cached, and indexed. Publishing both an Agent Card and a WoA manifest makes your business systems discoverable at two layers: the agent level (A2A) and the host level (WoA), which supports indexation by cross-platform discovery systems.

Step-by-Step: Implementing the Agent2Agent Protocol

The playbook below matches what I run on my own site via AI Growth Agent, with dated numbers from my own Search Console and test records.

1. Audit current agent visibility. Start by baselining where your business appears across ChatGPT, Google AI Overviews, Perplexity, and Gemini. In my own tests, pages can drop 78% to 99% in two months without updates, and that decay stays invisible until the position is already gone. The audit becomes the control group that every later result is measured against.
2. Fix technical plumbing first. Start by unblocking AI crawlers in your robots configuration so agents can access your content. After crawlers can reach your pages, add schema markup to make the content machine-parseable, because agents need structured data rather than raw HTML. Finally, confirm that pages are actually being parsed correctly, since small formatting errors can make otherwise accessible content invisible to the retrieval layer.
3. Publish your Agent Card. Serve the JSON document at https://yourdomain.com/.well-known/agent-card.json with the eight required fields: name, description, version, capabilities, supportedInterfaces, defaultInputModes, defaultOutputModes, and skills. Serving the endpoint requires HTTPS, Content-Type: application/json, and CORS headers (Access-Control-Allow-Origin: *) so other agents and registries can fetch it across origins.
4. Add a WoA manifest. Publish /.well-known/woa.json alongside your Agent Card. WoA documents use media type application/woa+json, and hosts should include HTTP caching headers such as ETag, Last-Modified, and Cache-Control directives to support frequent fetching by clients and discovery systems. The two manifests cover different layers of the discovery stack and do not duplicate each other.
5. Secure with OAuth 2.0. Implement client credentials flow with skill-scoped OAuth scopes to control which agents can access which skills. Then sign your Agent Card using JWS (RFC 7515) over a JCS-canonicalized (RFC 8785) payload, because that signature prevents attackers from impersonating your agent. Without signing, your card becomes untrusted input that is vulnerable to card shadowing, where attackers mimic trusted cards with altered endpoints, and context poisoning, where injection payloads hide in skill descriptions or examples. These threats are documented in early A2A security guidance.
6. Test delegation end-to-end. Use a client agent or the A2A SDK to fetch your Agent Card, acquire an OAuth token, and submit a test task. Verify that the task progresses through submitted, working, and completed, and that artifacts return correctly. In my own fan-out citation test, pages rewritten to match extracted ChatGPT fan-out queries earned citations while control pages did not. The same pattern applies here: the agent that can be discovered and delegated to is the agent that gets used.
7. Measure citations and share of answer. Track citations across ChatGPT, Google AI Overviews, Perplexity, and Gemini, and monitor AI referrers (chatgpt.com and equivalents) as a distinct traffic class in analytics. Seer Interactive analyzed 47,097 AI citations across 7,683 pages between March and June 2026 and found that 75% of cited pages had been updated within the last year, with consistently cited pages averaging under six months since their last update. Freshness behaves like an entry fee rather than a nice-to-have.
8. Keep GEO and A2A in sync with AI Growth Agent. My system runs 5 to 8 autonomous actions per day, including new articles and updates, via AI Growth Agent (I was a paying customer before becoming a partner, and that relationship is disclosed). On my own site, the GEO subfolder went from zero to the only source of new impressions on the domain in 60 days, measured in Google Search Console. The Agent Card and WoA manifest act as static infrastructure, while the content layer that makes your skills credible to retrieving agents requires continuous cadence.

Walk through this playbook for your domain and we will map each step to your specific stack and current GEO baseline.

Frequently Asked Questions

What security controls are required for a production A2A Agent Card?

Production deployments rely on three core controls. First, sign your Agent Card using JSON Web Signature (RFC 7515) computed over a JCS-canonicalized (RFC 8785) payload, because compliant client agents treat unsigned cards as untrusted input. Second, implement OAuth 2.0 client credentials flow with scopes narrowed to individual skills rather than broad agent-level access. Third, avoid static secrets in the Agent Card JSON, since credentials should be negotiated at the HTTP transport layer, not embedded in the discovery document. An optional fourth layer is mutual TLS (mTLS), which production deployments often combine with OAuth 2.0 for zero-trust enforcement. The extended Agent Card feature, enabled when capabilities.extendedAgentCard is true, lets you publish a minimal public card to all callers while reserving sensitive skill details for authenticated callers only.

How does A2A fit into an existing GEO methodology?

A2A acts as the infrastructure layer that makes your GEO content actionable by agents, rather than replacing GEO content work. The GEO layer, which includes fan-out query mapping, buyer-language alignment, structured publishing at cadence, and freshness loops, determines whether AI assistants cite your business in answers to human buyers. The A2A layer determines whether autonomous agents can discover, evaluate, and delegate tasks to your business systems without a human buyer in the loop. Both layers matter because the buyer journey now runs in two modes: a human asking an assistant, and an agent acting on a human's behalf without prompting them again. Businesses that build only the GEO layer stay visible to humans asking questions but remain invisible to agents making vendor-selection decisions autonomously. In my own GEO methodology, the Agent Card and WoA manifest ship as part of the technical plumbing step, before any content strategy, because they are foundational rather than optional.

How do I measure whether my Agent Card is generating business impact?

Measurement spans four surfaces. First, track AI referrers such as chatgpt.com and perplexity.ai as a distinct traffic class in analytics, since this traffic converts like referral traffic rather than cold search. Second, monitor citations and mentions across ChatGPT, Google AI Overviews, Perplexity, and Gemini, and use share-of-answer as the headline metric instead of rank position. Third, watch Google Search Console for the scissors pattern, where impressions climb while clicks fall, which signals that AI systems are consuming your content. Fourth, track branded search volume as a proxy for AI-driven demand that arrives as direct traffic, because buyers often copy an AI answer and type the brand name directly into a browser, which never appears as an AI referral. Whatever you measure represents a floor rather than a ceiling, so the right move is to instrument all four surfaces at once instead of grading the channel on a single metric.

Are there registries where I can list my Agent Card for broader discovery?

Agent registries extend discovery beyond known partners. The A2A well-known URI pattern is pull-based, which means a client agent must already know your domain to fetch your Agent Card. Registries solve the cold-discovery problem by indexing Agent Cards by capability keyword, skill ID, and tag, then exposing search endpoints for orchestrators. Several major agent registries support Agent2Agent. Registries like Agentry check both /.well-known/agent-card.json (v0.3.0 and later, preferred) and /.well-known/agent.json (original path) and award trust scores based on whether your card includes signed JWS signatures, defined security schemes, accurate capability flags, and complete skill descriptions. A higher trust score places your agent in verified tiers with greater visibility to orchestrators. The IETF is also progressing a DNS-SD profile for A2A (draft-zhao-a2a-dns-sd-00) that would enable link-local discovery via mDNS, although this targets single-network segments rather than internet-wide discovery.

What happens if I publish an Agent Card but my GEO content is stale?

The Agent Card makes your systems discoverable to other agents, but stale GEO content leaves those agents with no fresh, structured, authoritative record of your expertise. The two layers depend on each other. The decay pattern I described earlier, with 78 to 99 percent drops in two months, means an Agent Card without fresh content behaves like a door with no building behind it. The Seer study mentioned earlier also found that refreshed pages outperform newly published ones, which means updates to existing content deliver better citation performance than net-new articles. An agent discovers you, queries the AI surface for context on your capabilities, finds nothing current, and delegates elsewhere. The freshness loop, built on impression-decay tripwires that auto-queue updates when performance drops, keeps the content layer alive at the cadence the channel requires.

Conclusion: Make Your Systems Visible to Agents

Human search is giving way to agent-mediated discovery. G2's March 2026 survey of 1,076 B2B buyers found that 85% view a vendor more favorably when an assistant mentions it, and 33% bought from a vendor they had never previously heard of. The assistant now makes vendor-selection decisions. Without an A2A-compliant Agent Card, a paired WoA manifest, and a live GEO content layer running at cadence, your business does not appear in those decisions.

The window for outsized gains remains open. A2A reached 150+ supporting organizations and production deployments across Microsoft Azure AI Foundry, Amazon Bedrock AgentCore, and Google Agent Engine within its first year. Early citations become tomorrow's record, and answers gain incumbency. The cost of entry rises as settled answers harden, which mirrors the early SEO window and supports acting now rather than waiting.

The playbook stays specific: publish a signed Agent Card at /.well-known/agent-card.json, add a WoA manifest, secure with OAuth 2.0 client credentials scoped to individual skills, test delegation end-to-end, and run GEO content at machine cadence via AI Growth Agent to keep the authority layer fresh. Every step is measurable, and every number cited here comes from my own Search Console or a named third-party source with a sample and a date.

See where you stand in the agent discovery stack and I will show you exactly what it takes to be the answer agents return tomorrow.