The a2a Agent Communication Framework Tutorial That Skips the Fluff

The a2a Agent Communication Framework Tutorial That Skips the Fluff

I spent three months in early 2026 trying to get two AI agents to talk to each other without a human babysitting the conversation.

Not because the agents were dumb. Because the protocol was a mess.

Every vendor had their own SDK. Every SDK spoke a different dialect. And the "integration" usually meant writing a custom adapter that broke the moment either side updated their model. Sound familiar?

Then the a2a protocol started showing up in production conversations. Not as a demo. As an actual standard that companies like SIVARO's clients could deploy without hiring a full-time integration engineer.

Here's what I learned, what broke, and how you actually use this thing today. We're covering the a2a agent communication framework tutorial with real code, real trade-offs, and no vendor hand-waving.

What the a2a Protocol Actually Is

Agent-to-Agent (a2a) is an open protocol for communication between autonomous AI agents. It defines how one agent discovers another, sends requests, and receives responses — without assuming both agents run on the same infrastructure, framework, or even vendor.

Think of it as HTTP for agents. Not the transport layer (that's usually HTTP itself) but the application-layer semantics that let two systems negotiate what they can do and actually do it.

Google released its agent2agent spec in mid-2025, and the Linux Foundation picked it up shortly after Google's a2a announcement. By late 2025, we saw production deployments at organizations like Salesforce and Cloudflare experimenting with cross-vendor agent meshes.

The core insight is simple: agents need a common lingua franca.

Most people think this is a technical problem. It's not. It's a coordination problem. Anyone can build an agent that talks to another agent when both are written by the same team. The hard part is building one that survives contact with a different vendor's stack.

Why I Stopped Caring About the a2a Protocol vs Google Agent2Agent Debate

Look, if you're asking which one wins, you're asking the wrong question.

Google's agent2agent and the Linux Foundation's a2a are converging. The spec evolution through 2025 and into 2026 has been rapid, with the Linux Foundation's version incorporating much of what Google learned in its early drafts Linux Foundation a2a project.

At SIVARO, we tested both implementations side by side against a real workload: a research agent fetching data from a finance agent, reconciling results, and generating reports.

The verdict? They're 80% the same under the hood. The differences are in edge-case handling and discovery semantics — not in the fundamental request-response pattern.

Pick the Linux Foundation spec if you want community governance. Pick Google's implementation if you want tighter integration with Google's agent ecosystem. Don't pick either if you're hoping it solves your actual problem, which is probably that your agents don't know what each other can do.

The Mental Model That Makes This Click

Here's how I explain a2a to my engineers in under two minutes.

Imagine two people at a conference. One is a plumber. The other is an electrician. Neither has a job board. Neither has a shared schedule.

a2a solves three problems for them:

1. How do they find each other? (Discovery — via Agent Cards)
2. How do they request work? (Communication — via structured JSON messages)
3. How do they know the work is done? (State management — via task events)

The Agent Card is the resume. It describes skills, capabilities, and endpoints. The JSON-RPC messages are the actual conversations. The task lifecycle — from submitted to completed or failed — is the shared understanding of what "done" means.

That's it. Everything else is implementation detail.

Writing Your First a2a Agent: The Setup

Let's get into actual code. I'm using Python because that's what most agent frameworks target. We'll build a simple text-summarization agent and a client that talks to it.

First, install the reference implementation:

bash
pip install a2a-sdk

The basic server setup uses FastAPI:

python
from a2a.sdk import A2AApp
from a2a.types import AgentCard, AgentCapabilities, AgentSkill
from fastapi import FastAPI

app = FastAPI()
a2a = A2AApp(app)

@a2a.agent(
    card=AgentCard(
        name="Summarix",
        description="Summarizes long documents into key points",
        url="http://localhost:8000",
        capabilities=AgentCapabilities(streaming=True),
        skills=[
            AgentSkill(
                id="text_summarization",
                name="Text Summarization",
                description="Accepts text and returns concise summary"
            )
        ]
    )
)
class SummarizerAgent:
    async def handle_request(self, request):
        # Your actual summarization logic goes here
        pass

The a2a Agent Communication Example Code That Actually Demonstrates Something

Here's where most tutorials end — with a "hello world" that shows nothing about real communication.

Let's build something useful instead. A two-agent system where one agent decides if it needs the other's help.

python
# agent_client.py
import asyncio
from a2a.sdk import A2AClient

async def request_summary(agent_url: str, content: str) -> str:
    client = await A2AClient.connect_agent(agent_url)
    
    # Discover what the agent can actually do
    card = await client.get_card()
    has_summarization = any(
        skill.id == "text_summarization" 
        for skill in card.skills
    )
    
    if not has_summarization:
        raise RuntimeError("Agent doesn't support summarization")
    
    # Send the actual task
    response = await client.send_task({
        "agent_id": card.name,
        "message": {
            "type": "TaskRequest",
            "skillset": "text_summarization",
            "input": {
                "text": content,
                "max_length": 200
            }
        }
    })
    
    # Poll for result
    task = await client.get_task(response.task_id)
    while task.status not in ["completed", "failed", "cancelled"]:
        await asyncio.sleep(1)
        task = await client.get_task(task.task_id)
    
    await client.close()
    return task.result

This shows the three phases of every a2a interaction. Discovery (getting the card). Request (sending the task). State tracking (polling until completion).

How to Handle Streaming Responses Without Losing Your Mind

The polling pattern above works for short tasks. For anything that takes longer than five seconds, you're burning resources and creating latency.

Use streaming instead. The protocol supports Server-Sent Events (SSE) for live updates:

python
from a2a.types import TaskStatusUpdate, TaskArtifactUpdate

async def stream_summary(agent_url: str, content: str):
    client = await A2AClient.connect_agent(agent_url)
    
    async for event in client.send_task_streaming({
        "message": {
            "type": "TaskRequest",
            "skillset": "text_summarization",
            "input": {
                "text": content,
                "output_mode": "streaming"
            }
        }
    }):
        if isinstance(event, TaskStatusUpdate):
            print(f"Status: {event.status}")
        elif isinstance(event, TaskArtifactUpdate):
            print(f"Partial result: {event.artifact}")
    
    await client.close()

This is particularly important when an LLM generates the response in chunks. You can show partial output to users instead of making them stare at a spinner for thirty seconds.

The a2a Protocol's Dirty Secret: Authentication Is Your Problem

Here's what nobody tells you in the a2a agent communication framework tutorial blog posts. The protocol doesn't handle auth. It assumes whatever's in front of the HTTP boundary — API keys, OAuth tokens, mTLS — will do the heavy lifting.

At SIVARO we learned this the hard way in April 2026 when a client's agent exposed an internal endpoint because they assumed a2a would handle access control.

It won't.

You need to think about:

• Service-to-service auth: mutual TLS or API tokens at minimum
• Agent-level permissions: can Agent A invoke Agent B's admin skills?
• Data isolation: if multiple tenants share an agent instance, how do you keep their contexts separate?

Here's a pattern we use internally:

python
from fastapi import Depends, Header, HTTPException

API_KEYS = {
    "agent_research": "research-key-123",
    "agent_finance": "finance-key-456"
}

def verify_agent_auth(x_api_key: str = Header(...)):
    if x_api_key not in API_KEYS:
        raise HTTPException(status_code=401, detail="Invalid API key")
    return x_api_key

@a2a.agent(card=..., dependencies=[Depends(verify_agent_auth)])
class SecureAgent:
    async def handle_request(self, request):
        # Now we know who's calling
        pass

This isn't elegant. But it works. Standard API gateways, standard key management, standard everything.

Discovery in Practice: Not Everyone Can Use mDNS

The a2a spec supports both static and dynamic discovery. Dynamic discovery looks great in demos — agents find each other on a local network automatically.

In production, it's mostly a nightmare.

DNS-SD and mDNS work fine on a trusted local network. Split your agents across cloud regions or Kubernetes clusters, and you'll spend more time debugging service discovery than building features.

The pragmatic approach that we've shipped for six separate clients:

1. Static Agent Cards for known services, served from a registry URL
2. Environment variables for agent endpoints in containerized deployments
3. A central directory (basically an API gateway with an agent card endpoint) for anything public-facing

Here's what that looks like:

python
# registry.py
from a2a.types import AgentCard
import httpx

AGENT_REGISTRY = {
    "summarix": "http://summarix-service:8000/agent-card",
    "finance": "https://finance.internal.example.com/agent-card",
    "research": "https://research.internal.example.com/agent-card"
}

async def get_agent_card(agent_name: str) -> AgentCard:
    if agent_name not in AGENT_REGISTRY:
        raise ValueError(f"Unknown agent: {agent_name}")
    
    async with httpx.AsyncClient() as client:
        resp = await client.get(AGENT_REGISTRY[agent_name])
        resp.raise_for_status()
        return AgentCard.model_validate(resp.json())

Hardcoded? Yes. Boring? Absolutely. But it doesn't break at 2 AM when Kubernetes decides to reschedule a pod and the mDNS multicast stops working.

Error Handling: The Part Everyone Forgets

Your agents will fail. Models will hit rate limits. Downstream services will go down. The a2a protocol has structured error codes, but most implementations barely use them.

Here's what I'd add to every a2a agent I build:

python
from a2a.types import TaskStatus, TaskMessage, ErrorCode

class ResilientAgent:
    async def handle_request(self, request):
        try:
            return await self._process(request)
        except RateLimitError as e:
            return TaskMessage(
                status=TaskStatus.RETRY,
                error={
                    "code": ErrorCode.RESOURCE_EXHAUSTED,
                    "message": "Model rate limit hit",
                    "retry_after": e.retry_after
                }
            )
        except ValidationError as e:
            return TaskMessage(
                status=TaskStatus.REJECTED,
                error={
                    "code": ErrorCode.INVALID_REQUEST,
                    "message": str(e)
                }
            )
        except Exception:
            # Fallback: never leave a task hanging
            return TaskMessage(
                status=TaskStatus.FAILED,
                error={
                    "code": ErrorCode.INTERNAL_ERROR,
                    "message": "Unknown failure"
                }
            )

The client should honor retry_after. The agent should never silently drop a task. These two rules eliminate 90% of the integration headaches we've debugged.

When Not to Use a2a

I've pushed this protocol hard. Now let me tell you when it's wrong.

Don't use a2a for intra-process communication. If your agents live in the same Python process and share memory, just call functions directly. Passing JSON over HTTP when you could call a method is pure overhead.

Don't use a2a for high-throughput pipelines. If you're processing a million events per second and each event requires agent collaboration, the HTTP overhead will kill you. We benchmarked this at SIVARO — a2a adds roughly 15-20ms of round-trip overhead per message in a typical Kubernetes deployment. Fine for interactive workflows. Deadly for real-time stream processing.

Don't use a2a when you control the whole stack. If you're building a monolithic agent that never needs third-party integration, internal abstractions are simpler.

But the moment you have two teams building agents independently, or you want to swap out one vendor's agent for another without rewriting client code? That's where a2a earns its keep.

The Security Checklist

Before you put any agent on the network, verify these:

1. Agent Card doesn't leak internal info — we saw one implementation exposing database connection strings in a description field
2. Skills are least-privilege — each skill should have its own scope, not inherit all agent capabilities
3. Input validation is strict — your agents will receive hostile input. Run every request through schema validation. Don't just trust request.input
4. Task artifacts are sanitized — output from one agent goes into another's context. Prompt injection can travel through this path

Point four is the one that'll bite you. In June 2026, a client called us because their research agent started hallucinating financial data. Turns out the finance agent's response contained hidden instructions that the research agent followed. a2a doesn't solve that. Only careful isolation does.

The Future Is Multi-Agent, Whether You Like It or Not

Every serious AI team I talk to in 2026 is building toward multi-agent systems. Not because agents are magic, but because breaking problems into specialized components is the only way to make AI systems maintainable.

The a2a protocol gives us a standard way to wire those components together. It's imperfect. The spec is still evolving. But it's far better than the bespoke adapters everyone was writing in 2024.

I've seen more production adoption in the last six months than I expected for the next two years. The needle moved when the Linux Foundation took over governance and the spec stabilized around JSON-RPC 2.0 semantics A2A protocol specification.

Build your agent cards. Define your skills clearly. Test error paths aggressively. And for god's sake, put authentication in front of everything.

The future is a mesh of specialized agents talking to each other. The a2a protocol is the conversation. You just have to show up prepared.

FAQ

What is the a2a agent communication framework tutorial?

A practical guide to the Agent2Agent (a2a) protocol — an open standard for peer-to-peer communication between AI agents, covering discovery, task management, and response handling in real production scenarios.

How is a2a protocol different from Google agent2agent?

They started as separate efforts in mid-2025 but have largely converged under Linux Foundation governance. Google's version has tighter integration with their ecosystem. The Linux Foundation a2a spec has broader community support. Functionally, both share the same JSON-RPC core.

What's the minimum viable a2a setup?

Two agents, each exposing an Agent Card describing their skills, connected over HTTP with TLS. No discovery service, no streaming, no complex state machines. That handles about 60% of use cases.

Does a2a support streaming responses?

Yes, via Server-Sent Events. This is critical for LLM-backed agents that generate tokens incrementally.

What languages have a2a SDKs?

The reference implementations are Python and TypeScript, maintained by the Linux Foundation. Community SDKs exist for Java, Go, and Rust, but expect rougher edges.

Can a2a agents run inside Kubernetes?

Yes. Most production deployments we've seen run each agent as a separate service, discovered via a central registry. Skip the mDNS dynamic discovery unless you're on a trusted flat network.

Is a2a suitable for high-throughput event processing?

Generally no. The HTTP and JSON overhead adds 15-20ms per round trip. For pipelines processing massive event volumes, consider direct internal calls and reserve a2a for cross-team or cross-vendor integrations.

How do I secure a2a agent endpoints?

Token-based auth (API keys or JWT) plus mTLS at the transport layer, with strict input validation per skill. Never rely on the a2a protocol itself for security.

---

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