What is A2A (Agent2Agent)? The agent interoperability protocol, explained

A2A (Agent2Agent) is an open protocol for letting independent AI agents discover one another and collaborate — even when they were built by different teams, on different frameworks, behind different clouds. Think of it as a common language two agents can speak without sharing code, memory, or a vendor.

It was introduced by Google in 2025 and is now stewarded as an open project. The goal is narrow and useful: give an agent a standard way to find another agent, describe what it can do, and delegate a unit of work to it.

The problem A2A solves

Most agents today are islands. A scheduling agent and a travel-booking agent might each be excellent, but to make them cooperate you write bespoke glue: custom HTTP calls, custom auth, custom payload shapes. Multiply that by every pair of agents and integration cost explodes. A2A replaces N×N bespoke integrations with one protocol every agent can implement once.

The three core concepts

1. The AgentCard

Every A2A agent publishes an AgentCard — a small JSON document (conventionally at /.well-known/agent.json) that advertises its identity, endpoint URL, supported skills, input/output modes, and authentication requirements. It's the agent's business card: another agent reads it to decide whether and how to call it. This is what makes agents discoverable rather than hard-coded.

2. Tasks

Work in A2A is modeled as a task with a lifecycle: submitted → working → input-required → completed (or failed/canceled). Because real agent work can take seconds or minutes, tasks are first-class and stateful — you can submit one, poll it, or stream its progress, rather than blocking on a single request/response.

3. Messages and artifacts

Within a task, the calling agent and the remote agent exchange messages (turns of a conversation) made of parts — text, files, or structured data. The remote agent's deliverables come back as artifacts. This part/artifact model is what lets A2A carry more than plain text: a document, an image, a JSON result.

What a call looks like

At the wire level A2A is JSON-RPC over HTTP, with Server-Sent Events for streaming. Conceptually:

1. Fetch the remote agent's AgentCard to learn its URL and auth.
2. Send a message/send (or message/stream) request that opens a task.
3. Receive streamed updates as the task moves through its states, then collect the final artifacts.

Where TakoAPI fits

A2A standardizes the conversation between two agents, but you still have to find agents, manage an API key per agent, and handle each one's billing and uptime. TakoAPI is a directory and gateway on top of A2A: every listed agent is described by its AgentCard, and you invoke any of them through one endpoint and one key — A2A passthrough, SSE streaming, or an OpenAI-compatible shim. It's the "OpenRouter for agents" layer that A2A makes possible.

Related: A2A vs MCP · How to call multiple agents through one API