> ## Documentation Index
> Fetch the complete documentation index at: https://docs.corti.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# A2A protocol

> Learn about the Agent-to-Agent protocol in the Agentic Framework: v1.0 only, the two protocol bindings, and how A2A relates to MCP.

The **Agent-to-Agent (A2A)** protocol is an open standard that enables secure, framework-agnostic communication between autonomous AI agents. Instead of building bespoke integrations whenever you want agents to collaborate, A2A gives Corti and other systems a common language agents can use to discover, talk to, and delegate work to one another.

For the full technical specification, see the official A2A project docs at [a2a-protocol.org](https://a2a-protocol.org/latest/).

## Why Corti uses A2A

We chose A2A because it:

* **Standardizes agent communication**: Agents can talk to each other without siloed, point-to-point integrations. That makes composite workflows easier to build and maintain.
* **Supports real workflows**: A2A includes discovery, task negotiation, and streaming updates, so agents can coordinate long-running or multi-step jobs.
* **Preserves security and opacity**: Agents exchange structured messages without sharing internal memory or tools. That protects intellectual property and keeps interactions predictable.
* **Leverages open tooling**: There are open source SDKs in multiple languages and example implementations you can reuse.

## A2A v1.0 in Corti

The Agentic Framework supports **A2A v1.0 only**. The previous v0.3 protocol version is no longer supported. All requests and responses follow the v1.0 specification.

### A2A-Version header

The server returns an `A2A-Version: 1.0` header on every A2A response, indicating the protocol version used to handle the request. Client SDKs may also send this header on requests.

## Protocol bindings

A2A v1.0 defines two protocol bindings. Corti supports both, and they share the same base URL:

```
/v2/agentic/agents/{agentId}/a2a
```

### JSON-RPC binding

The JSON-RPC binding sends a JSON-RPC 2.0 envelope to the base URL. The `method` field determines the operation:

| JSON-RPC method        | Description                                    |
| ---------------------- | ---------------------------------------------- |
| `SendMessage`          | Send a message (blocking or non-blocking)      |
| `SendStreamingMessage` | Send a message and stream the response via SSE |
| `GetTask`              | Get a task by ID                               |
| `ListTasks`            | List tasks for the agent                       |
| `CancelTask`           | Cancel a task                                  |
| `SubscribeToTask`      | Subscribe to task events via SSE               |

```json theme={null}
{
  "jsonrpc": "2.0",
  "id": "msg-001",
  "method": "SendMessage",
  "params": {
    "message": {
      "role": "ROLE_USER",
      "parts": [{ "text": "What is the ICD-10 code for asthma?" }]
    }
  }
}
```

### HTTP+JSON binding

The HTTP+JSON binding uses path-suffixed endpoints. Each JSON-RPC method maps to a specific HTTP endpoint:

| JSON-RPC method        | HTTP endpoint                        |
| ---------------------- | ------------------------------------ |
| `SendMessage`          | `POST /a2a/message:send`             |
| `SendStreamingMessage` | `POST /a2a/message:stream`           |
| `ListTasks`            | `GET /a2a/tasks`                     |
| `GetTask`              | `GET /a2a/tasks/{taskId}`            |
| `CancelTask`           | `POST /a2a/tasks/{taskId}:cancel`    |
| `SubscribeToTask`      | `POST /a2a/tasks/{taskId}:subscribe` |

<Info>The HTTP+JSON binding is simpler for most use cases. Use the JSON-RPC binding if your client or tooling expects a JSON-RPC envelope.</Info>

### REST query parameters

The HTTP+JSON binding supports query parameters on certain endpoints:

| Parameter       | Endpoints                                           | Description                                           |
| --------------- | --------------------------------------------------- | ----------------------------------------------------- |
| `historyLength` | `GET /a2a/tasks/{taskId}`, `POST /a2a/message:send` | Cap the number of history messages returned per task  |
| `pageSize`      | `GET /a2a/tasks`                                    | Page size for list responses                          |
| `pageToken`     | `GET /a2a/tasks`                                    | Opaque cursor from a prior response's `nextPageToken` |
| `contextId`     | `GET /a2a/tasks`                                    | Filter tasks by context                               |

## Agent discovery

A2A enables agent discovery through [agent cards](/agentic/agent-cards). Every agent exposes its card at the `.well-known/agent-card.json` location, describing its capabilities, skills, and supported protocol bindings. You can retrieve a card to inspect an agent before integrating. The agent card endpoint requires the same authentication (bearer token and tenant header) as all other v2 endpoints.

## Relationship to MCP

MCP (Model Context Protocol) and A2A serve different purposes in the Agentic Framework:

* **A2A** is the conversational surface: how clients talk to agents, send messages, receive tasks, and stream responses
* **MCP** is a connector type: how agents call external tool servers to retrieve data or perform actions

In v2, MCP servers are attached as [connectors](/agentic/connectors) (type `mcp`) to an agent. The agent runtime calls the MCP server when it needs data or actions from that tool. A2A is the protocol the client uses to talk to the agent itself.

<Info>The v1 MCP protocol and authentication pages are preserved in the [v1 archived documentation](/agentic/v1/mcp-protocol). In v2, MCP concepts are covered by the [connectors](/agentic/connectors) and [connector auth](/agentic/guides/connector-auth) pages.</Info>

## Open source SDKs and tooling

For links to Corti's official SDK and the official A2A project SDKs (Python, JavaScript/TypeScript, Java, Go, and .NET), see [SDKs and integrations](/agentic/sdks-integrations).

## Next steps

* Learn about [agent cards](/agentic/agent-cards) for A2A discovery
* Read about [connectors](/agentic/connectors) and how MCP fits as a connector type
* Follow the [quickstart](/agentic/quickstart) to send your first A2A message