Agent-to-Agent Protocol (A2A) Deep Dive: Google's Open Standard for Agent Interop

What A2A Solved That MCP Did Not

MCP (Model Context Protocol) standardized how an agent talks to a tool. A2A (Agent-to-Agent) standardizes how an agent talks to another agent. They sit at different layers and complement rather than compete. Google open-sourced A2A in mid-2025 with backing from 50+ vendors. By 2026 it is the dominant cross-vendor agent interop spec.

This is what A2A is, what it is not, and how to think about it relative to the rest of the agent stack.

The Layered Model

flowchart TB
    User[User] --> Host[Host App<br/>Claude Desktop, ChatGPT, Cursor]
    Host -->|MCP| Tool[MCP Tool/Server]
    Host -->|A2A| Agent[Remote Agent]
    Agent -->|MCP| Tool2[Tool]
    Agent -->|A2A| Agent2[Sub-agent]

MCP is host-to-tool. A2A is agent-to-agent. An agent can be an MCP host AND an A2A peer at the same time.

The Core A2A Concepts

A2A defines four primary objects:

• Agent Card: a small metadata document at /.well-known/agent.json that describes who the agent is, what it can do, what skills it advertises, and how to authenticate
• Task: a unit of work an agent is asked to do, identifiable, statefully tracked
• Message: structured request/response in the conversation around a task
• Artifact: outputs produced by the agent — files, structured objects, streamed events

The transport is HTTP with JSON-RPC over either polling or Server-Sent Events for streaming updates.

A Sample A2A Interaction

sequenceDiagram
    participant Cli as Client Agent
    participant Srv as Server Agent
    Cli->>Srv: GET /.well-known/agent.json
    Srv-->>Cli: agent card (skills, auth)
    Cli->>Srv: POST tasks/send (task, message)
    Srv-->>Cli: task accepted (id)
    Cli->>Srv: GET tasks/{id}/events (SSE)
    Srv-->>Cli: status: working
    Srv-->>Cli: artifact: partial result
    Srv-->>Cli: status: completed

How A2A Differs from MCP

Feature	MCP	A2A
Direction	Host → Tool	Agent → Agent
Transport	stdio / SSE / streamable HTTP	HTTP + SSE
State	tool calls are stateless	tasks are stateful
Discovery	server registries	well-known agent cards + DNS
Auth	OAuth 2.1 (extension)	OAuth 2.1 native

The two are designed to compose. An A2A server agent typically uses MCP servers internally for its own tool calls.

Who's Adopting

By Q1 2026 the public adopters include Salesforce (Agentforce), ServiceNow, SAP, Atlassian (Rovo), Box, and dozens of smaller agent platforms. Microsoft's Copilot Studio supports A2A as of February 2026. Anthropic shipped A2A as a Claude plugin standard in March 2026.

The notable holdout: OpenAI's Agent Builder uses its own protocol (closer to function-calling-as-a-service) and has not committed to A2A. The 2026 betting line is that interop will eventually force everyone in.

What A2A Does Not Solve

Three things A2A explicitly leaves to higher-level systems:

• Discovery beyond well-known URLs: there is no global registry, by design
• Trust and authorization: A2A says how to authenticate; it does not say how to decide which agents to trust
• Cost and resource accounting: how money flows when one agent invokes another is out of scope

These are being addressed by adjacent specs (Agent Communications Protocol, Agent Capability Negotiation), but A2A itself is deliberately narrow.

Practical Pattern: The Agent-as-Service

In 2026 the pattern emerging is "agent as a microservice." A specialist agent (say, a billing-resolution agent) lives at https://billing.example.com with an agent card, exposes its capabilities, and any other agent in the org's catalog can invoke it. Internal teams ship agents the way they used to ship microservices.

flowchart LR
    Triage[Triage Agent] -->|A2A| Billing[Billing Agent]
    Triage -->|A2A| Returns[Returns Agent]
    Triage -->|A2A| Tech[Tech Support Agent]
    Billing -->|MCP| Stripe
    Returns -->|MCP| WMS
    Tech -->|MCP| Sentry

Builder Notes for 2026

If you are shipping an A2A-compatible agent, a few practical patterns:

• Implement /.well-known/agent.json first; clients discover capabilities here
• Stream meaningful progress events; clients use them for UX
• Use task IDs as durable handles; clients reconnect with them
• Implement OAuth 2.1 with PKCE from day one; do not retrofit auth later

Sources

• A2A specification — https://github.com/google/A2A
• Google A2A blog announcement — https://cloud.google.com/blog/products/ai-machine-learning
• "MCP and A2A together" Anthropic — https://www.anthropic.com/news
• Salesforce Agentforce A2A support — https://www.salesforce.com/news
• "Agent interop in 2026" review — https://thenewstack.io

Agent-to-Agent Protocol (A2A) Deep Dive: Google's Open Standard for Agent Interop — operator perspective

When teams move beyond agent-to-Agent Protocol (A2A) Deep Dive, one question shows up first: where does the agent loop actually end? In practice, the boundary is rarely the model — it is the contract between the orchestrator and the tools it calls. The teams that ship fastest treat agent-to-agent protocol (a2a) deep dive as an evals problem first and a modeling problem second. They write the failure cases into the regression set on day one, not after the first incident.

Why this matters for AI voice + chat agents

Agentic AI in a real call center is a different beast than a single-LLM chatbot. Instead of one model answering one prompt, you orchestrate a small team: a router that decides intent, specialists that own a vertical (booking, intake, billing, escalation), and tools that read and write to the same Postgres your CRM trusts. Hand-offs are where most production bugs hide — when Agent A passes context to Agent B, anything that isn't explicit in the message gets lost, and the user feels it as the agent "forgetting." That's why the systems that hold up under load are the ones with typed tool schemas, deterministic state stored outside the conversation, and a hard ceiling on tool calls per session. The cost story is just as important: a multi-agent loop can quietly burn 10x the tokens of a single-LLM design if you let it think out loud at every step. The fix isn't a smarter model, it's smaller agents, shorter prompts, cached system messages, and evals that fail the build when p95 latency or per-session cost regresses. CallSphere runs this pattern across 6 verticals in production, and the rule has held every time: the agent you can debug in five minutes will out-survive the agent that's "smarter" on a benchmark.

FAQs

Q: What's the hardest part of running agent-to-Agent Protocol (A2A) Deep Dive live?

A: Scaling comes from constraint, not capability. The deployments that hold up keep each agent narrow, cap tool calls per turn, cache the system prompt, and pin a smaller model for routing while reserving the larger model for synthesis. CallSphere's stack — 37 agents · 90+ tools · 115+ DB tables · 6 verticals live — is sized that way on purpose.

Q: How do you evaluate agent-to-Agent Protocol (A2A) Deep Dive before shipping?

A: Hard ceilings beat heuristics. A maximum step count, an idempotency key on every tool call, and a fallback to a deterministic script when confidence drops below a threshold are what keep the loop bounded. Evals that simulate noisy inputs catch the rest before they reach a real caller.

Q: Which CallSphere verticals already rely on agent-to-Agent Protocol (A2A) Deep Dive?

A: It's already in production. Today CallSphere runs this pattern in Healthcare and Real Estate, alongside the other live verticals (Healthcare, Real Estate, Salon, Sales, After-Hours Escalation, IT Helpdesk). The same orchestrator code path serves voice and chat — the difference is the tool set the router exposes.

See it live

Want to see sales agents handle real traffic? Spin up a walkthrough at https://callsphere.ai/demo or grab 30 minutes on the calendar: https://callsphere.ai/book.