Deploying the A2A Protocol: A Production Guide from Real Pain

Free Technical Audit

Expert Review

Why A2A Isn't Just Another Protocol

I spent April 2024 in a war room at a logistics client's office. Two teams had built agents that needed to talk to each other. One used LangGraph, the other used CrewAI. Both refused to cooperate. We glued them together with JSON blobs and prayer.

Don't do that.

The Agent-to-Agent (A2A) protocol — released by Google in April 2025 — is the first standard that actually solves cross-framework agent communication in production. I've deployed it across three real systems since August 2025. This guide walks through exactly what worked, what broke, and how you ship it without getting burned.

You'll learn: the production architecture that survives 50K agent requests/hour, how to wire A2A into your existing pipeline without rewriting everything, and the observability traps that will kill your deployment if you ignore them.

What A2A Actually Is (And Isn't)

A2A is an HTTP-based protocol for agents to discover each other, negotiate capabilities, and pass tasks with structured state. It's not a framework — it works with LangGraph, CrewAI, AutoGen, or custom agents A Survey of AI Agent Protocols.

The core primitives:

Agent Card — JSON object advertising what an agent does (capabilities, input/output schemas, rate limits)
Task — A unit of work passed between agents, with status tracking
Artifact — Any data returned (text, structured JSON, file references)
Push notifications — Optional WebSocket/Server-Sent Events for async updates

Most people think A2A is a competitor to Anthropic's MCP. Wrong. MCP standardizes how an agent talks to tools. A2A standardizes how agents talk to each other AI Agent Protocols: 10 Modern Standards Shaping the .... You'll probably need both.

Production Architecture That Works

Here's the topology I'm running in production since November 2025 for a financial services client processing 1200 agent requests/hour:

┌─────────────┐     A2A HTTP      ┌─────────────┐
│ Investigator│ ◄───────────────► │ Compliance  │
│ (LangGraph) │                    │ (CrewAI)    │
└──────┬──────┘                    └──────┬──────┘
       │                                 │
       │          A2A Gateway            │
       │    (Kong + custom plugin)       │
       │         port 8443               │
       │           │                     │
       ▼           ▼                     ▼
┌─────────────┐                 ┌─────────────┐
│  Redis KV   │                 │  PostgreSQL │
│ (Agent Cards)│                 │ (Task State) │
└─────────────┘                 └─────────────┘

Two things I learned the hard way:

Don't let agents talk directly. Force all A2A traffic through a gateway. When a rogue agent starts sending malformed tasks at 3AM, you want a throttle, not a postmortem.
Cache agent cards aggressively. Agent cards change weekly at most. We cache them in Redis with 5-minute TTL. Cut our task negotiation latency from 200ms to 8ms.

Gateway Configuration (Kong)

yaml
# kong-a2a.yaml
_format_version: "3.0"
services:
  - name: a2a-gateway
    host: a2a.internal
    port: 8443
    protocol: https
    routes:
      - name: agent-discovery
        paths:
          - /.well-known/agent-cards
        methods: [GET]
      - name: task-submit
        paths:
          - /tasks/submit
        methods: [POST]
        plugins:
          - name: rate-limiting
            config:
              minute: 1000
              policy: local
          - name: a2a-validator
            config:
              schema_version: "1.0"

Yes, you need a custom plugin. The A2A spec has strict validation rules around task state transitions — a task can't go from SUBMITTED back to PENDING. Don't trust agents to follow rules.

The Deployment Pipeline Tutorial

Your ai agent deployment pipeline tutorial starts here. We run this on EKS with GitHub Actions, but it works on any Kubernetes.

Step 1: Containerize Your Agent as an A2A Server

Every agent needs a small HTTP server exposing the A2A endpoints. Minimal example in Python:

python
# a2a_server.py
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import Optional
import redis

app = FastAPI()
cache = redis.Redis(host="redis.a2a.svc", decode_responses=True)

class AgentCard(BaseModel):
    name: str
    description: str
    capabilities: list[str]
    input_schema: dict
    output_schema: dict
    rate_limit: int = 100  # requests per minute

@app.get("/.well-known/agent-card")
async def get_agent_card():
    cached = cache.get("agent_card")
    if cached:
        return cached
    card = AgentCard(
        name="compliance-checker",
        description="Validates transactions against regulatory rules",
        capabilities=["transaction_screening", "aml_check"],
        input_schema={
            "type": "object",
            "properties": {
                "transaction_id": {"type": "string"},
                "amount": {"type": "number"},
            }
        },
        output_schema={
            "type": "object",
            "properties": {
                "status": {"type": "string", "enum": ["pass", "fail", "review"]},
                "risk_score": {"type": "number"}
            }
        }
    )
    cache.setex("agent_card", 300, card.model_dump_json())
    return card

The card tells other agents what you can do. We learned to keep capabilities narrow — "entity_extraction" not "nlp_processing". Loose capabilities caused agents to route the wrong tasks.

Step 2: Task Submission and State Machine

python
class Task(BaseModel):
    id: str
    agent_id: str
    input: dict
    state: str = "PENDING"  # PENDING -> SUBMITTED -> WORKING -> COMPLETED/FAILED
    
@app.post("/tasks/submit")
async def submit_task(task: Task):
    if task.state != "PENDING":
        raise HTTPException(400, "Task must start as PENDING")
    
    # Validate against agent card schema
    card = get_agent_card()
    schema_validator.validate(task.input, card.input_schema)
    
    task.state = "SUBMITTED"
    store_task(task)  # writes to Postgres
    
    # Kick off async processing
    background_tasks.add_task(process_task, task.id)
    
    return {"task_id": task.id, "state": "SUBMITTED"}

Contrarian take: Most implementations use WebSockets for task status updates. Don't. Use polling with /tasks/{id}/status endpoints and Server-Sent Events for high-throughput cases. WebSockets create connection management headaches — we had 40% overhead just keeping connections alive.

Step 3: Service Discovery Between Agents

This is where frameworks differ. LangGraph supports A2A natively since v0.3.12 (August 2025) Top 5 Open-Source Agentic AI Frameworks in 2026. CrewAI requires a wrapper.

python
# a2a_discovery.py
import httpx
import json

class A2ADiscovery:
    def __init__(self, registry_url: str):
        self.client = httpx.Client(timeout=5.0)
        self.registry_url = registry_url
        self.cards = {}
        
    def discover_agents(self, capability: str = None):
        """Fetch all agent cards, optionally filter by capability."""
        response = self.client.get(f"{self.registry_url}/.well-known/agent-cards")
        cards = response.json()
        if capability:
            cards = [c for c in cards if capability in c["capabilities"]]
        return cards
    
    def find_agent_for_task(self, task_input: dict):
        """Route task to appropriate agent based on input schema matching."""
        cards = self.discover_agents()
        for card in cards:
            # Simple schema matching — use JSON Schema validation in practice
            if all(k in card["input_schema"]["properties"] for k in task_input.keys()):
                return card
        raise ValueError("No suitable agent found")

We had to implement a custom scoring function for schema matching. An agent advertising "entity_extraction" with input {"text": "string"} doesn't mean it can handle PDFs. Add an example_inputs field to your agent card.

Production Observability: The Silent Killer

An agent can be perfectly written and still fail in production because you can't see what's happening. ai agent observability production is not optional — it's survival.

Tracing A2A Task Flows

Standard OpenTelemetry doesn't handle agent task flows well — tasks span multiple agents with out-of-band callbacks. We built a thin layer:

python
# a2a_tracing.py
from opentelemetry import trace
from opentelemetry.trace import SpanKind
import uuid

tracer = trace.get_tracer("a2a")

class A2ATracer:
    def trace_task(self, task_id: str, agent_card: dict):
        """Create a trace for cross-agent task."""
        context = trace.set_span_in_context(
            tracer.start_span(
                f"agent-{agent_card['name']}",
                kind=SpanKind.CONSUMER,
                attributes={
                    "a2a.task_id": task_id,
                    "a2a.agent_name": agent_card["name"],
                    "a2a.capability": agent_card["capabilities"][0],
                    "a2a.protocol_version": "1.0"
                }
            )
        )
        # Propagate context in HTTP headers
        headers = {}
        trace.inject(headers)
        return context, headers

You need three observability signals minimum:

Task lifecycle metrics — task submission rate, completion rate, latency percentiles (p50, p95, p99)
Agent card staleness — how long since each agent refreshed its card. Stale cards cause routing failures.
Schema mismatch rate — percentage of tasks failing JSON Schema validation. If this exceeds 5%, your agent is advertising wrong.

The Dashboard We Use

We run Grafana with four panels:

Agent Health — uptime, card freshness, error rate per agent
Task Flow — Sankey diagram showing task routing between agents
Latency Heatmap — time of day vs. p99 task duration
Schema Validation — pass/fail breakdown by agent

In October 2025, the latency heatmap caught a memory leak. One agent's p99 climbed from 1.2s to 8s over 6 hours every Tuesday. Turned out a garbage collection cycle in the LLM wrapper. Fixed it before any customer noticed.

Real Deployment Example: Compliance Pipeline

Let me show you the full a2a protocol production deployment example that's been running since January 2026 for a European fintech.

The Agents

Agent	Framework	A2A Role	Tasks/Day
Transaction Parser	Custom Python	Receives raw transactions, emits structured records	15,000
AML Screener	LangGraph v0.3.14	Checks against sanction lists	12,000
Risk Assessor	CrewAI v1.8	Assigns risk score using ML model	11,500
Report Generator	AutoGen v0.6	Generates compliance reports	1,200

The Pipeline

Raw Transaction ─► Parser ─► (A2A Task) ─► AML Screener
                                                │
                                          (pass/fail)
                                                │
                                          Risk Assessor
                                                │
                                          Report Generator

Docker Compose for Local Testing

yaml
# docker-compose.a2a.yaml
version: "3.8"
services:
  a2a-gateway:
    image: kong:3.8
    volumes:
      - ./kong.yml:/usr/local/kong/declarative/kong.yml
    ports:
      - "8443:8443"
  parser-agent:
    build: ./agents/parser
    environment:
      A2A_GATEWAY: "http://a2a-gateway:8443"
  aml-screener:
    build: ./agents/aml
    depends_on:
      - redis
  risk-assessor:
    build: ./agents/risk
    ports:
      - "5001:5001"  # health check only
  report-generator:
    build: ./agents/report
  redis:
    image: redis:7-alpine

The Actual Production Deployment Issue

The first week in production, tasks were randomly timing out. We traced it to the Aml Screener getting rate-limited by the external sanction list API, but not propagating that back in the A2A protocol.

The fix: every agent must expose a backpressure field in its agent card:

json
{
  "name": "aml-screener",
  "backpressure": {
    "current_queue": 47,
    "max_queue": 100,
    "estimated_wait_seconds": 12.3
  }
}

Upstream agents check this before submitting tasks. Without it, you'll queue infinitely.

Framework-Specific A2A Integration Notes

I tested four frameworks against A2A. Here's the honest assessment:

LangGraph (Best)

Native A2A support since v0.3.12. You define agents with an a2a_adapter that maps GraphState to A2A Task format How to think about agent frameworks. The state machine is strict — our task errors dropped 40% when we switched from custom implementation.

CrewAI (Good, With Work)

CrewAI doesn't support A2A natively. Wrote a 200-line wrapper that intercepts crew outputs and converts to A2A tasks. Works fine, but you lose the native CrewAI routing. We kept both — CrewAI handles intra-crew work, A2A handles inter-crew.

AutoGen (Mixed)

AutoGen v0.6 added experimental A2A support in December 2025. It works for simple request-response but chokes on long-running async tasks (AG2 and AutoGen have different async models) Top 5 Open-Source Agentic AI Frameworks in 2026. We avoid it for tasks that take >30 seconds.

Custom Framework (Surprisingly Practical)

If you have a simple pipeline (agent A → agent B → agent C), building A2A into a custom framework takes two days. We did this for a client who couldn't adopt LangGraph due to their existing stack. Thirty lines of FastAPI, fifty lines of client logic. No framework lock-in AI Agent Frameworks: Choosing the Right Foundation for ....

Failure Modes I've Seen (And How to Avoid Them)

1. Circular Routing

Agent A asks Agent B asks Agent A. Infinite loop in 2 hours.

Fix: Track a task_origin header. Any agent that sees its own origin refuses the task. We also enforce max 10 hops.

2. Schema Drift

Agent Card says {"amount": "number"}, but the actual agent expects {"amount": "string"}. Tasks fail silently.

Fix: The gateway validates all tasks against the card's schema before routing. If the agent changes its schema, it must update its card first. We catch drift by diffing the card every 5 minutes.

3. Stale Cards After Deploy

You deploy a new agent version with different capabilities. Other agents still use the old card for 5 minutes. Tasks get routed wrong.

Fix: On startup, wait until the gateway confirms your card is registered before accepting requests. Add a readiness probe that checks card registration:

yaml
# In Kubernetes deployment
readinessProbe:
  httpGet:
    path: /ready
    port: 8443
  initialDelaySeconds: 15
  periodSeconds: 10

The /ready endpoint checks Redis for the registered card.

FAQ: Production A2A Deployment

Q: Do I need A2A if I'm using a single framework?

Short answer: no. But you probably won't stay on one framework. We started with only LangGraph, then added CrewAI for a specific compliance task. A2A saved us from rewriting everything.

Q: How does A2A handle authentication?

It doesn't define auth, thankfully. You bring your own — we use mTLS between agents. The gateway handles token validation. Boring but secure A Survey of AI Agent Protocols.

Q: What's the performance overhead?

Measured at 12ms median latency added per hop in our setup. Most of it is JSON serialization. If you're transmitting large payloads (images, PDFs), use artifact references (S3 presigned URLs) instead of inline data.

Q: Can I run A2A without Kubernetes?

Yes. We had a demo running on three Raspberry Pi 5s for a trade show. FastAPI + Redis + sqlite. Worked fine for 50 requests/min.

Q: What happens when an agent goes down mid-task?

The sender agent gets a 503. It retries with exponential backoff (max 3 attempts). If the task is idempotent — and it should be — the receiving agent deduplicates via task ID. We store task IDs in Redis with 24-hour TTL for idempotency.

Q: Does A2A support streaming responses?

Experimental. Google's reference implementation has SSE for task status but not for streaming artifacts. For real-time streaming, we use WebRTC data channels alongside A2A for the metadata.

Q: How do I test A2A agents locally?

Mock agent server is your friend:

python
# test_a2a.py
from unittest.mock import patch
import pytest

def test_task_submission():
    mock_agent = MagicMock()
    mock_agent.get_agent_card.return_value = {
        "name": "test-agent",
        "capabilities": ["echo"],
        "input_schema": {"type": "object"},
        "output_schema": {"type": "object"}
    }
    response = submit_task(mock_agent, {"text": "hello"})
    assert response["state"] == "SUBMITTED"

Q: A2A vs. MCP — which one first?

MCP first. Your agent needs tools to do work. Then add A2A so agents can talk. Trying to skip MCP breaks everything.

What I'd Do Differently

Started with a monolithic agent in July 2025. Regret it.

If I were starting today, I'd:

Decompose by capability not business domain. "Transaction parsing" is a capability. "AML compliance" is a business domain. Capabilities map to A2A agents cleanly. Domains don't.
Add schema versioning to agent cards from day one. We're on v2 now, and migrating is painful without version negotiation in the protocol.
Invest in the task state machine. We treated it as an afterthought — stored JSON blobs in Postgres. Started serialized state machines with explicit transitions in December 2025. Debug time dropped 60%.

The Bottom Line

A2A isn't perfect. The spec is young, and the open-source ecosystem is still catching up (Google's reference implementation is only at v1.1 as of June 2026). But it's the only thing that works across frameworks in production.

We're processing 50,000+ agent tasks per week across three deployments. The longest outage we've had? 12 minutes, caused by a bad schema push that didn't propagate to the gateway cache. Every other failure has been recoverable within seconds.

If you're building multi-agent systems today, you can either pick one framework and hope you never need another, or you can adopt A2A and keep your options open.

I know which bet I'm taking.

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