A2A Protocol: Cross-Organization Agent Collaboration in 2026

TL;DR — A2A is the cross-org "agents talking to agents" protocol. Originally Google, donated to Linux Foundation, 150+ orgs in production by April 2026. JSON-RPC over HTTP, capability manifests, complementary to MCP. If you ship agent-facing APIs in 2026, you publish an A2A manifest.

The pattern

Each agent publishes a manifest describing the tasks it can handle (input schema, output schema, auth, SLA). A client agent fetches the manifest, sends a JSON-RPC 2.0 task request, receives a result or a stream of progress events.

A2A is the agent-to-agent layer. MCP is the agent-to-tool layer. They compose: an A2A request can trigger MCP tool calls inside the receiving agent.

flowchart LR
  ORG1[Org A's agent] -->|fetch manifest| MAN[Manifest URL]
  MAN --> ORG1
  ORG1 -->|JSON-RPC task| ORG2[Org B's agent]
  ORG2 -->|stream progress| ORG1
  ORG2 -->|MCP call| TOOL[(Org B's internal tool)]
  ORG2 --> ORG1
  ORG1 --> USER[End user]

When to use it

• Cross-vendor agent collaboration — your CRM agent talks to Salesforce's billing agent.
• Multi-tenant marketplaces — agents discover and call each other.
• Federated workflows where one party shouldn't (or can't) expose internals as raw APIs.

Skip when: it's all your own agents under one roof — internal RPC is simpler.

CallSphere implementation

CallSphere publishes an A2A manifest at /.well-known/agent.json. Three tasks exposed:

1. schedule_callback(phone, time_window) — invoked by partner CRM agents to schedule a CallSphere AI callback.
2. fetch_call_summary(call_id) — invoked by partner BI agents to pull summaries.
3. escalate_to_human(call_id, reason) — invoked by partner triage agents to escalate.

Explore a live demo and compare current plans to find the right fit for your business.

Build steps with code

# Server side — publish manifest
@app.get("/.well-known/agent.json")
def manifest():
    return {
        "name": "CallSphere Voice Agent",
        "tasks": [
            {"name": "schedule_callback", "input_schema": {...}, "output_schema": {...}},
            {"name": "fetch_call_summary", "input_schema": {...}, "output_schema": {...}},
        ],
        "auth": {"type": "bearer"},
        "endpoint": "https://callsphere.ai/a2a"
    }

# Client side — call a partner agent
import httpx
res = httpx.post(partner_endpoint, json={
    "jsonrpc": "2.0", "id": 1, "method": "schedule_callback",
    "params": {"phone": "+1...", "time_window": "tomorrow 9-12"}
}, headers={"Authorization": f"Bearer {token}"})

Pitfalls

• Auth as an afterthought — A2A includes auth slots; use OAuth or signed JWTs. Bearer tokens leak.
• No rate limits — partner agents can DOS you. Per-tenant quotas, please.
• Manifest drift — schema changes break partners silently. Version the manifest.
• Cross-org PII — A2A doesn't enforce data minimization. You must.

FAQ

Q: A2A or MCP? Both. A2A is agent ↔ agent; MCP is agent ↔ tool. They compose.

Q: Which orgs support A2A? By April 2026: Google, Microsoft, AWS, Salesforce, SAP, ServiceNow, Workday, IBM, plus 150+ others.

Q: Streaming? Yes — A2A supports server-sent events for long-running tasks.

Q: Discovery? A2A registries are emerging (Linux Foundation hosts a public one). Most orgs publish manifests at well-known URLs.

Q: Identity / agent attestation? Spec includes Verifiable Credentials slots; production usage still maturing.

Sources

• Google Developers Blog — A2A announcement
• IBM — What Is A2A
• A2A Protocol official docs
• OneReach — MCP vs A2A 2026
• Atlan — Google A2A Protocol explained

A2A Protocol: Cross-Organization Agent Collaboration in 2026: production view

A2A Protocol: Cross-Organization Agent Collaboration in 2026 forces a tension most teams underestimate: agent handoff state. A single LLM call is easy. A booking agent that hands a confirmed slot to a billing agent that hands a follow-up to an escalation agent — that's where context loss, hallucinated IDs, and double-bookings live. Solving it well means treating the conversation as a stateful workflow, not a chat.

Shipping the agent to production

Production AI agents live or die on three loops: evals, retries, and handoff state. CallSphere runs 37 agents across 6 verticals, each with its own eval suite — synthetic call transcripts replayed nightly with assertion checks on extracted entities (date, time, party size, insurance, address). Without that loop, prompt regressions ship silently and you only find out when bookings drop.

Structured tools beat free-form text every time. Our 90+ function tools all enforce JSON schemas validated server-side; if the model hallucinates an integer where a string is required, we retry with a corrective system message before falling back to a deterministic path. For long-running flows, we treat agent handoffs as a state machine — booking → confirmation → SMS — so context survives turn boundaries.

The Realtime API vs. async decision usually comes down to "is the user holding the phone right now?" If yes, Realtime; if no (callback queue, after-hours voicemail), async wins on cost-per-conversation, which we track per agent in 115+ database tables spanning all 6 verticals.

FAQ

What's the right way to scope the proof-of-concept? Real Estate runs as a 6-container pod (frontend, gateway, ai-worker, voice-server, NATS event bus, Redis) backed by Postgres realestate_voice with row-level security so multi-tenant data never crosses tenants. For a topic like "A2A Protocol: Cross-Organization Agent Collaboration in 2026", that means you're not starting from scratch — you're configuring an agent template that's already been hardened across thousands of conversations.

How do you handle compliance and data isolation? Day one is integration mapping (scheduler, CRM, messaging) and prompt tuning against your top 20 real call transcripts. Day two through five is shadow-mode running, where the agent transcribes and recommends but a human still answers, so you can compare side-by-side. Go-live is the moment your eval pass-rate clears your internal bar.

When does it make sense to switch from a managed model to a self-hosted one? The honest answer: it scales until your tool catalog gets stale. The agent is only as good as the integrations it can actually call, so the operational discipline is keeping schemas, webhooks, and fallback paths green. The platform handles the rest — observability, retries, multi-region routing — without your team owning the GPU layer.

Talk to us

Explore a live demo and compare current plans to find the right fit for your business.