Agent-to-Agent (A2A) Protocol: JSON for Agent Interoperability

The interoperability problem

In 2026, building anything ambitious with AI means coordinating multiple agents — a researcher, a planner, a writer — often built with different frameworks by different teams. Without a shared standard, they cannot talk to each other. A2A (Agent-to-Agent) is the open protocol that fixes this: a common, JSON-based language for agents to discover each other, delegate tasks, and exchange results.

If MCP connects an agent to its *tools*, A2A connects agents to *each other*. They are complementary layers of the agentic stack.

Agent Cards: discovery via JSON

An agent advertises what it can do with an Agent Card — a JSON document (typically served at a well-known URL) describing its identity and skills:

{
  "name": "Research Agent",
  "description": "Finds and summarizes information from the web.",
  "url": "https://research.example.com/a2a",
  "version": "1.0.0",
  "capabilities": { "streaming": true },
  "skills": [
    {
      "id": "web_research",
      "name": "Web Research",
      "description": "Search the web and return a sourced summary.",
      "inputModes": ["text"],
      "outputModes": ["text"]
    }
  ]
}

Another agent reads this card to decide whether — and how — to delegate work, the same way you read an API's docs before calling it.

Tasks and messages

Work in A2A is organized around tasks. A client agent sends a message to start a task; the remote agent works on it and returns results, optionally streaming updates. Messages are JSON with typed parts (text, files, structured data):

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "message/send",
  "params": {
    "message": {
      "role": "user",
      "parts": [{ "kind": "text", "text": "Summarize the latest on JSON Schema 2020-12." }]
    }
  }
}

The task moves through states — submitted, working, completed, failed — and the result comes back as structured JSON the calling agent can use directly.

A2A and MCP together

These protocols solve different problems and stack cleanly:

A research agent might use MCP to call a search tool and a database, then expose itself over A2A so a planner agent can delegate research to it. Each agent keeps its own tools private; only the agent-to-agent contract is shared.

Why JSON is the foundation

Both protocols are built on JSON for the same reasons it won everywhere else: it is language-agnostic, human-readable for debugging, and supported by every stack. An agent written in Python can coordinate with one written in TypeScript because they exchange plain JSON messages — no shared runtime required. You can inspect an A2A exchange by reading the raw JSON, which makes multi-agent systems debuggable instead of opaque.

Designing agents for A2A

• Write a clear Agent Card. Skills with good descriptions are how other agents decide to use you — treat it like an API spec.
• Return structured results, not prose, so the calling agent can act on them.
• Handle long-running tasks with streaming status updates rather than one blocking response.
• Validate incoming messages against the expected shape; never trust another agent's payload blindly.