SIVARO
A2A Agent Communication Standard 2026 Guide
You’re staring at a fleet of agents that don’t talk to each other. One handles support tickets. Another watches inventory. A third writes code. They all work for you, but they might as well be in different time zones. I’ve been there. In early 2025, we built SIVARO’s internal AI ops layer and hit a wall: every agent had its own API, its own authentication, its own idea of what a "request" looks like. It was chaos.
The Agent-to-Agent (A2A) communication standard fixes that. It’s not a framework. It’s a protocol — a common language for agents to discover each other, route tasks, and exchange data without human hand-holding. This guide is the practical playbook I wish I had in 2025. We’ll cover what A2A actually is, how to set up discovery and routing, and where the 2026 spec pushes harder on security and interoperability. Plus, real code you can steal.
By the end, you’ll know how to wire up an agent mesh that doesn't make you want to quit.
What the A2A Standard Actually Is (And What It Isn't)
Most people think A2A is another chat protocol. It’s not. It’s a specification for how autonomous software agents — think LLM-driven systems, not just API wrappers — announce themselves, negotiate capabilities, and pass work between each other.
The core insight from the Linux Foundation’s A2A project is that agents need three things:
- An Agent Card — a JSON description of who the agent is, what it does, and how to reach it.
- A Discovery mechanism — how agents find each other, either via a central registry or peer-to-peer.
- A Task-based communication model — agents don't just send messages; they create tasks, send artifacts, and track status.
That sounds obvious. But the devil is in the execution. In 2025, the spec was loose. Vendors (looking at you, big cloud providers) bolted on proprietary extensions. The 2026 update tightens this down to a baseline profile that every compliant agent must support. If your agent doesn't speak the core protocol, it gets ignored.
Here’s the part that shocks people: A2A isn’t tied to a single transport. HTTP/2 with JSON-RPC is the default, but the standard allows for gRPC and even raw WebSockets in high-latency environments. We tested this at SIVARO on a project for a logistics client in late 2025. The agents ran a mix of HTTP and gRPC internals, but because they all exposed the same A2A envelope, they interop'd without a hitch. The point isn’t the wire format; it’s the semantic contract.
The Discovery Problem: Finding the Right Agent
Discovery is the first thing you’ll implement, and it’s where most architectures go wrong. I’ve seen teams build a giant monolithic registry that becomes a single point of failure. Bad move.
The 2026 spec supports a hybrid model:
- Centralized directory for your stable, internal agents (like a "Finance Agent" or "HR Agent").
- Peer-to-peer mDNS or DNS-SD for ephemeral agents that spin up for specific tasks.
We run a hybrid at SIVARO. A small, replicated Redis-backed registry holds the core agent cards. Ephemeral agents register with TTLs, so they vanish automatically if they crash or get terminated. It sounds simple, but it solves a huge operational headache: no stale endpoints.
Here’s an example of an Agent Card from our production system:
json
{
"protocolVersion": "2026.1",
"agentId": "svro-orders-agent-01",
"name": "OrderRoutingAgent",
"description": "Routes inbound orders to warehouse systems",
"url": "https://agents.sivaro.io/orders",
"security": {
"authType": "mTLS",
"scopes": ["orders:write", "inventory:read"]
},
"capabilities": [
{
"name": "create_order",
"inputMimeTypes": ["application/json"]
},
{
"name": "track_shipment",
"inputMimeTypes": ["application/json"]
}
]
}
Notice the security block. That’s non-negotiable in 2026. If your agent card doesn't include authentication requirements, most directories will refuse to publish it. We learned that the hard way — our first internal deployment in January 2026 got rejected by our own gateway because we omitted the mTLS declaration.
Setting Up Routing Dynamically
Static routing (Agent A always talks to Agent B) is fine for two agents. It falls apart at scale. When we hit 40+ agents at SIVARO, we had to move to intent-based routing. The standard defines a RoutingRequest message that agents can broadcast.
Instead of hardcoding "send invoice to FinanceAgent", you send a discovery query:
python
import a2a
client = a2a.Client()
request = a2a.DiscoveryRequest(
query={
"capability": "calculate_tax",
"jurisdiction": "DE"
},
max_results=3
)
results = client.discover(request)
for agent in results:
print(f"Found: {agent.name} - {agent.url}")
# -> Found: GermanTaxAgent - https://agents.sivaro.io/de-tax
This works brilliantly for cold-start scenarios. But beware: broadcast discovery is slow if you have hundreds of agents. The workaround we use is cached discovery. Agents maintain a local TTL cache of frequently used peers. The 2026 spec explicitly recommends this to reduce network chatter.
The A2A Communication Model: Tasks Over Messages
Here’s the philosophical shift that defines the 2026 guide: agents share tasks, not just messages. A message says "here is data". A task says "here is a job, and here’s the status of it". This distinction is critical for long-running operations.
The A2A standard defines a state machine for tasks: submitted, working, completed, failed, input-required. We rely on input-required heavily. When an agent hits a decision point it can't resolve, it pings the requester for guidance. That prevents the zombie-agent scenario where a process hangs forever waiting for clarification.
A2A Agent Communication Example Code
Let me show you a real interaction. This is a customer support agent delegating a refund task to a finance agent:
python
from a2a import A2AClient, Task, Message
finance_agent = A2AClient("https://agents.sivaro.io/finance")
task = Task(
agent="FinanceAgent",
type="process_refund",
payload={
"customer_id": "cust_2345",
"order_id": "ord_8867",
"amount_usd": 149.99
}
)
response = finance_agent.submit_task(task)
# Poll for status
while response.status not in ["completed", "failed"]:
response = finance_agent.get_task(response.task_id)
time.sleep(2)
print(response.result)
# -> {"refund_id": "ref_8829", "status": "approved"}
Notice we didn't hardcode a webhook or a callback. The A2A spec supports both polling and push (via webhooks), but polling is the safest default for asynchronous cloud environments.
Security in 2026: Threat Modeling is Not Optional
The 2026 standard is a lot less "trusting" than 2025. And for good reason. If agents are executing actions autonomously, you need to control blast radius. The biggest mistake I see teams make is running agents with blanket admin credentials. Stop that now.
The A2A spec now mandates:
- Scoped OAuth2 tokens or mTLS for every request.
- Task-level authorization — an agent must verify access before mutating anything.
- Audit trails built into the protocol, not as a bolt-on.
We built a middleware layer that injects a trace ID into every A2A task. It costs microseconds but if a rogue agent goes sideways, we can trace exactly which agent triggered what. I won't write code here because it's boring middleware, but the point is: bake it in from day one.
The standard also addresses agent identity spoofing. In 2025, a well-known issue was agents lying about their agent cards to receive privileged tasks. The 2026 spec introduced a mandatory signature field in the Agent Card that must be signed by the organization's PKI. Unsigned cards get dropped at the directory level.
Practical Wiring: A Step-by-Step Setup Guide
Let's walk through deploying your first A2A-compliant agent pair. I’ll keep this to the minimum viable setup.
Step 1: Define Your Agent Card
Create the JSON file we showed above. Save it as agent-card.json. If you have multiple agents, create a folder for each.
Step 2: Publish to a Directory
We use an in-house directory built on etcd. But for testing, you can run a local A2A registry service. Here’s a snippet to register your agent:
bash
curl -X POST https://registry.local/register \
-H "Content-Type: application/json" \
-d @agent-card.json
Step 3: Subscribe to Intent-Based Topic
Discovery is reactive: you ask, you get answers. But real systems push events. The 2026 A2A spec includes a topic model. Agents subscribe to topics, and when a new task type is available, the directory pings subscribers. It's like mDNS for the enterprise.
python
agent.subscribe(topic="finance.refund.requests")
Step 4: Enable Tracing
Set up a simple log layer. Use the trace_id from the incoming task and pass it through all internal calls. Don't skip this.
When Not to Use A2A (Honest Take)
A2A isn't a silver bullet.
- If you have 2 agents that you control tightly, just call the API directly.
- If you need hard real-time latency (single-digit milliseconds), HTTP-based A2A adds too much overhead. Use a raw socket or gRPC-style streaming.
- If your agents are dumb scripts, not LLM- or ML-driven systems, the abstraction overhead is unjustified.
I’ve seen teams shoehorn A2A into a CRUD app and it feels like wearing a wetsuit to a business meeting. It technically works, but why?
A2A shines when you have heterogeneous agents built by different teams, possibly different vendors, and you need them to collaborate without constant code changes.
Interoperability: The Vendor Trap
The 2026 standard has matured significantly because Google’s A2A framework and Microsoft’s Agent Framework have aligned on JSON-RPC core payloads. That alignment is huge. In mid-2025, I was burning weeks writing translation layers between these two ecosystems. That's now gone.
But careful. Some vendors still push "extensions" that break portability. If a vendor tells you to use a proprietary header to "improve performance", run the other way. It’s a lock-in tactic.
The Future: Federation and the Public Internet
The next frontier is inter-organizational A2A. Imagine your supply chain agent talking to your partner’s inventory agent across VPNs or even public internet. The 2026 spec has a draft for federated discovery that uses signed DNS records to validate foreign agents.
We haven't implemented this in production yet. It scares me slightly. But the groundwork is there. For most enterprises, you’ll start with internal agent meshes. Master won't be wasted.
FAQ Section
Q: What's the difference between A2A and MCP (Model Context Protocol)?
MCP is about connecting an LLM to tools and data sources. A2A is about connecting agents to each other. Different layers. If MCP is the nervous system, A2A is the language between brains. They complement each other.
Q: Do agents need to be LLM-based to use this?
No, but they should be stateful and capable of handling complex tasks. The spec assumes agents can parse structured input and act on it autonomously to some degree.
Q: Best transport for A2A in 2026?
HTTP/2 with JSON-RPC is the safest default. gRPC is fine for internal high-throughput links, but public-facing agents should stick to HTTP for easier firewall traversal.
Q: How do I ensure my legacy system talks A2A?
Write a thin adapter. Expose a lightweight service that reads the A2A task protocol, calls your COBOL/salesforce/etc. system, and returns the result. This works well.
Q: Does A2A solve security? Could an agent act maliciously?
No protocol solves security. It provides the structure to enforce your policies. You still need to define fine-grained permissions and rotate credentials. Treat every agent like a third-party vendor.
Q: Which sectors adopting it fastest?
Finance and logistics. We’re seeing massive A2A deployments in fraud detection workflows where multiple specialist agents (transaction analyzer, user behavior agent, case management agent) must sync rapidly.
Q: What's the hardest part to implement?
Discovery and trust at scale. Handling intent-based queries well is trickier than you’d think. Bias towards simple query syntax.
Final Tips for 2026
Start small. Connect two agents. Add a registry. Watch the network traffic. You’ll be surprised what you learn by looking at the failure modes.
Don't try to build the "perfect" mesh from day one. The standard itself matured after public deployments exposed real bugs. Treat your implementation the same way.
Act on this now, because agent interoperability isn't a differentiator anymore. It's hygiene.
Nishaant Dixit — Founder of SIVARO. Building data infrastructure and production AI systems since 2018. Built systems processing 200K events/sec.