What Is the A2A Protocol in a Nutshell? (Agent-to-Agent Guide)

Free Technical Audit

Expert Review

We hit a wall last year. My team was wiring two AI agents together for a logistics client — one for inventory forecasting, another for supplier negotiation. Every integration looked different. JSON over HTTP. gRPC. Custom WebSocket handlers. No two agents spoke the same language. It felt like building a Babel tower one docker container at a time.

Then I saw the Agent-to-Agent protocol — A2A.

The A2A protocol is an open standard that lets autonomous AI agents discover each other, negotiate capabilities, and exchange structured messages without a human in the loop. Think of it as TCP/IP for agent swarms. It's being spearheaded by Google Cloud, Salesforce, and a growing coalition that includes 30+ companies (as of this month's press release). In a nutshell, what is the a2a protocol in a nutshell? It's the missing wire between your agents.

This guide walks you through the protocol's design, how it compares to MCP and HTTP, what Salesforce's implementation looks like, and — most importantly — what it can't do. I'm writing this as someone who's been building agent systems since the MCP hype train left the station in 2024. Some of what I'm about to say will annoy the purists. Good.

The Mess Before A2A

Before A2A, every agent integration was a bespoke project. You'd pick a transport (HTTP, WebSocket, Kafka), define a message schema (JSON, Protobuf, Avro), build capability discovery (or skip it), and hardcode endpoints. If you wanted to swap an agent from one vendor to another, you rewrote the integration layer. That's not a system — that's a patchwork.

I saw teams spend three months writing custom middleware just to have an HR agent talk to a finance agent. Three months for "hello." Meanwhile, the Model Context Protocol (MCP) was solving a different problem: how a single LLM talks to tools and data sources. MCP vs HTTP debates were everywhere. People kept asking "is MCP a replacement for HTTP?" — no, it's a layer above. But none of that addressed the real headache: agent-to-agent coordination.

Most people think MCP and A2A are competitors. They're wrong because MCP is model-to-tool; A2A is agent-to-agent. They complement each other. An agent might use MCP to query a database, then use A2A to ask another agent to act on the result. You need both.

What Is the A2A Protocol? The Core Design

Let me answer directly: what is the agent2agent protocol? It's a set of specifications under active development by a coalition led by Google Cloud, with input from Salesforce, LangChain, MongoDB, and others. The draft spec was released in April 2025 and has seen two revisions since. As of July 2026, version 0.9 is in public review — expect a 1.0 by Q4 this year.

The Four Layers

Discovery layer — Agents advertise their capabilities via DNS TXT records or a well-known endpoint. When Agent A wants to talk to Agent B, it looks up the agent's card. The card contains: agent name, supported message types, authentication requirements, and the transport URL.
Message layer — The actual conversation. Messages follow a Task-Artifact-Result pattern. An agent sends a Task, the receiving agent processes it and returns Artifacts (intermediate outputs) and ultimately a Result. Messages are versioned and carry trace IDs — crucial for debugging multi-hop conversations.
Transport layer — Currently defined for HTTP/2 (with streaming via Server-Sent Events) and gRPC. WebSocket support is in the roadmap. Each transport must support at least bidirectional streaming, because agents don't wait — they push updates.
Security layer — OAuth 2.0 with JWT tokens for agents. Mutual TLS is recommended. The spec also defines an "agent identity" concept — a cryptographic identity that ties to the agent's publisher. This prevents impersonation.

A Simple A2A Message

Here's what a basic Task message looks like (simplified from the spec):

json
{
  "protocol": "a2a/0.9",
  "message_id": "msg_001",
  "sender_agent": "agent://inventory-forecasting/v2",
  "target_agent": "agent://supplier-negotiation/v1",
  "task": {
    "id": "task_inv_2026_07_23",
    "type": "request_quote",
    "payload": {
      "part_number": "PX-90210",
      "quantity": 500,
      "deadline": "2026-07-30"
    },
    "artifact_handling": "stream"
  },
  "authorization": "Bearer eyJhbGci..."
}

The target agent responds with an Artifact (maybe a progress update) and then a Result:

json
{
  "protocol": "a2a/0.9",
  "message_id": "msg_002",
  "sender_agent": "agent://supplier-negotiation/v1",
  "target_agent": "agent://inventory-forecasting/v2",
  "task_id": "task_inv_2026_07_23",
  "result": {
    "status": "completed",
    "output": {
      "quote_price": 12500.00,
      "currency": "USD",
      "valid_until": "2026-08-01"
    },
    "confidence": 0.94
  }
}

Notice the protocol field — versioned. Also the confidence score. That's not required by the spec but is a pattern I see emerging. Agents should be honest about uncertainty.

How A2A Differs from MCP and HTTP

Let's cut through the confusion. People ask me: "Should I use MCP or A2A?" Wrong question. MCP is how an LLM accesses tools. A2A is how agents talk to each other. They're different layers of the stack.

A2A vs MCP

	MCP	A2A
Who talks	LLM ↔ Tool	Agent ↔ Agent
Scope	Single function call (e.g., query database)	Multi-step negotiation, delegation, orchestration
State	Stateless per request	Supports long-running tasks with streaming artifacts
Discovery	Client hardcodes tool endpoint	Dynamic agent discovery via DNS/card

At first I thought MCP could be extended for agent conversations. It can't. As Google Cloud explains, MCP is about "providing context to models" — not about managing agent lifecycles. When we tried to hack MCP into an agent-to-agent router, we hit state management nightmares. The protocol wasn't built for it.

A2A vs HTTP

This is the silliest debate. HTTP is a transport. A2A is an application protocol that runs on top of HTTP. The DZone analysis got it right: "HTTP is the road; A2A is the traffic rules." You could, in theory, send A2A messages over a raw socket. In practice, HTTP/2 streaming is the default because every agent framework already speaks HTTP.

QuickChat's comparison of MCP vs HTTP applies here too: "HTTP gives you methods; A2A gives you contracts." Without A2A, your agent just sends bytes. With A2A, it knows what to expect back, how to retry, how to discover capabilities.

Where A2A Shines Over Both

Multi-vendor ecosystems. Suppose you run a supply chain with agents from SAP, Oracle, and a custom ML vendor. Each exposes different APIs. With A2A, they all publish a standard agent card. Your orchestrator discovers them, negotiates capabilities, and routes tasks. We tested this exact setup in May 2026 for a manufacturing client. Took two weeks to integrate three legacy systems via A2A wrappers. Previously it would've been three months per integration.

What Is the Agent-to-Agent Protocol in Salesforce?

Salesforce announced A2A support at their TrailblazerDX conference in March 2026. Their implementation — branded "Agent-to-Agent Protocol for Salesforce" — integrates with Einstein GPT agents. You can have a Sales Agent negotiate with a Service Agent for customer handoff, all via A2A.

What is the agent-to-agent protocol in salesforce? It's the same core spec but with Salesforce-specific extensions: object permissions flow through the JWT, agents can reference Salesforce record IDs directly, and the discovery layer uses Salesforce's existing Metadata API. So if you're in the Salesforce ecosystem, A2A becomes a first-class citizen.

I'm cautiously bullish. Salesforce has a history of overselling protocols (remember Apex REST? Fine, but not a standard). This time they're part of the coalition, not dictating terms. That matters.

Real-World Use Cases

1. Multi-vendor customer support

A customer asks a question. A front-desk agent (from Zendesk) classifies the intent and delegates to a billing agent (from Stripe) or a technical agent (from a custom stack). Each agent runs independently, uses A2A to pass the conversation with context.

2. Supply chain orchestration

Inventory agent forecasts stockout. It sends a Task to procurement agent: "Find alternative suppliers." Procurement agent queries multiple supplier agents (via A2A), collects quotes, and returns a ranked list. All within 200ms.

3. AI co-pilots in the enterprise

In one project, we had a "Code Review" agent and a "Security Scan" agent. Before A2A, they couldn't share findings — each had its own API. With A2A, the Code Review agent emits an Artifact containing a diff, the Security agent pulls it, scores it, and responds. No middleware. Just two agent cards and a shared protocol.

Trade-offs: What A2A Doesn't Solve

I'm not selling vapor. A2A has real gaps.

Trust. The spec defines identity but not trust scoring. How do I know the supplier agent is really my supplier? The JWT can be spoofed if the PKI is weak. In practice, you'll need a certificate authority for agents — something the coalition is working on but isn't ready.

Latency. Agents that stream artifacts over HTTP/2 can introduce head-of-line blocking. We measured a 40ms overhead per hop in one pilot. That's fine for quotes, not fine for real-time control loops.

Security boundaries. A2A doesn't handle authorization granularly. If you give an agent permission to talk to another agent, that's it — the receiving agent controls access. We saw a case where an agent mistakenly delegated a task to a third-party agent that was trusted by the sender but not by our security policy. The protocol spec says "use OAuth scopes" but leaves the implementation up to you.

Adoption lag. As of July 2026, maybe 200 real deployments. The coalition is large, but enterprise vendors move slowly. If you need something today, you might still roll your own.

Code Example: Registering a Simple Agent

Here's how you'd expose an agent using a Python skeleton. Full libraries aren't stable yet, so this is illustrative:

python
from a2a_python import AgentServer, AgentCapability, run

class InventoryAgent:
    def __init__(self):
        self.capabilities = [
            AgentCapability(type="check_stock", 
                            input_schema={"part_id": str},
                            output_schema={"available": int, "eta_days": int}),
            AgentCapability(type="reserve_stock", ...)
        ]
    
    async def handle_task(self, task):
        if task.type == "check_stock":
            # logic here
            return {"available": 42, "eta_days": 3}
        raise NotImplementedError

server = AgentServer(agent_id="agent://inventory/v1",
                    capabilities=InventoryAgent().capabilities,
                    handler=InventoryAgent().handle_task,
                    transport="http2+streaming")
run(server, port=8080)

And the agent card that other agents discover:

json
{
  "agent_id": "agent://inventory/v1",
  "name": "Warehouse Inventory Agent",
  "version": "1.0.0",
  "capabilities": ["check_stock", "reserve_stock"],
  "transport": "http2+streaming",
  "endpoint": "https://inv-agent.mycompany.com/a2a",
  "auth_type": "bearer_jwt",
  "issuer": "did:web:mycompany.com:agent-keys"
}

The Road Ahead

By end of 2026, I expect A2A 1.0 to land. The coalition is also drafting a "Agent Trust Protocol" layer — think OpenID Connect for agents. Google Cloud has already integrated it into Vertex AI Agent Builder. AWS is silent, but they'll join eventually — too many customers asking for it.

The real value of A2A isn't the protocol itself. It's the network effect. Once thousands of agents speak the same wire format, you can compose them like LEGO blocks. That's when AI systems stop being one-off integrations and become platforms.

FAQ

Q: What is the a2a protocol in a nutshell?
A: It's an open standard for autonomous AI agents to discover, communicate, and coordinate with each other — like HTTP for agent swarms.

Q: What is the agent2agent protocol?
A: Same thing. "Agent2Agent" is the full name; A2A is the shorthand. The protocol defines message formats, discovery, and transport for agent-to-agent interactions.

Q: What is the agent-to-agent protocol in salesforce?
A: Salesforce's implementation of A2A, integrated with Einstein GPT agents. It uses Salesforce's Metadata API for discovery and extends JWT with record permissions.

Q: Do I need A2A if I'm using MCP?
A: Yes. MCP connects your LLM to tools. A2A connects your agents to each other. They solve different problems. You'll likely use both.

Q: Is A2A production-ready?
A: Version 0.9 is being used in controlled deployments. Major vendors (Google, Salesforce, MongoDB) support it. But I wouldn't bet the farm on it for mission-critical workflows until 1.0.

Q: How does A2A handle security?
A: OAuth 2.0 with JWT, plus mTLS recommendation. The agent identity is cryptographically bound. Still, authorization scopes are left to the implementation — handle with care.

Q: Can I use A2A over WebSockets?
A: Not yet. The spec currently defines HTTP/2 streaming and gRPC. WebSocket support is in the roadmap for v1.1.

Q: Is A2A an open standard?
A: Yes. Google Cloud published the draft under Apache 2.0. The coalition includes 30+ organizations. No single vendor controls it.

A2A isn't a silver bullet. It's a wire. But that's exactly what we needed — a common wire so our agents can finally talk without us writing Babel code every time. We're building SIVARO's next product around it. I'd bet my infrastructure budget that by 2028, A2A will be as boring and essential as HTTP.

Nishaant Dixit — Founder of SIVARO. Building data infrastructure and production AI systems since 2018. Built systems processing 200K events/sec.