# Agent2Agent (A2A)

Deprecated in 1.x, removed in 2.0

`Agent.to_a2a()` and the `pydantic-ai-slim[a2a]` extra are deprecated and will be removed in 2.0. The `fasta2a` package is now maintained at [datalayer/fasta2a](https://github.com/datalayer/fasta2a) and ships a Pydantic AI bridge since [v0.6.1](https://github.com/datalayer/fasta2a/releases/tag/v0.6.1). Install it with the `pydantic-ai` extra and use `agent_to_a2a` directly:

Terminal

```bash
pip/uv-add 'fasta2a[pydantic-ai]>=0.6.1'
```

```python
from fasta2a.pydantic_ai import agent_to_a2a

from pydantic_ai import Agent

agent = Agent('openai:gpt-5.2', instructions='Be fun!')
app = agent_to_a2a(agent)
```

The [Agent2Agent (A2A) Protocol](https://a2a-protocol.org/) is an open standard introduced by Google that enables communication and interoperability between AI agents, regardless of the framework or vendor they are built on.

At Pydantic, we built the [FastA2A](#fasta2a) library to make it easier to implement the A2A protocol in Python. It is now maintained at [datalayer/fasta2a](https://github.com/datalayer/fasta2a) and ships a Pydantic AI bridge since [v0.6.1](https://github.com/datalayer/fasta2a/releases/tag/v0.6.1) -- install it with the `pydantic-ai` extra and use `agent_to_a2a` to expose a Pydantic AI agent as an A2A server:

agent\_to\_a2a.py

```python
from fasta2a.pydantic_ai import agent_to_a2a

from pydantic_ai import Agent

agent = Agent('openai:gpt-5.2', instructions='Be fun!')
app = agent_to_a2a(agent)
```

_You can run the example with `uvicorn agent_to_a2a:app --host 0.0.0.0 --port 8000`_

This will expose the agent as an A2A server, and you can start sending requests to it.

See more about [exposing Pydantic AI agents as A2A servers](#pydantic-ai-agent-to-a2a-server).

## FastA2A

**FastA2A** is an agentic framework agnostic implementation of the A2A protocol in Python. The library is designed to be used with any agentic framework, and is **not exclusive to Pydantic AI**.

### Design

**FastA2A** is built on top of [Starlette](https://www.starlette.io), which means it's fully compatible with any ASGI server.

Given the nature of the A2A protocol, it's important to understand the design before using it, as a developer you'll need to provide some components:

-   [`Storage`](/docs/ai/api/fasta2a/#fasta2a.Storage): to save and load tasks, as well as store context for conversations
-   [`Broker`](/docs/ai/api/fasta2a/#fasta2a.Broker): to schedule tasks
-   [`Worker`](/docs/ai/api/fasta2a/#fasta2a.Worker): to execute tasks

Let's have a look at how those components fit together:

```mermaid
flowchart TB
    Server["HTTP Server"] <--> |Sends Requests/<br>Receives Results| TM

    subgraph CC[Core Components]
        direction RL
        TM["TaskManager<br>(coordinates)"] --> |Schedules Tasks| Broker
        TM <--> Storage
        Broker["Broker<br>(queues & schedules)"] <--> Storage["Storage<br>(persistence)"]
        Broker --> |Delegates Execution| Worker
    end

    Worker["Worker<br>(implementation)"]
```

FastA2A allows you to bring your own [`Storage`](/docs/ai/api/fasta2a/#fasta2a.Storage), [`Broker`](/docs/ai/api/fasta2a/#fasta2a.Broker) and [`Worker`](/docs/ai/api/fasta2a/#fasta2a.Worker).

#### Understanding Tasks and Context

In the A2A protocol:

-   **Task**: Represents one complete execution of an agent. When a client sends a message to the agent, a new task is created. The agent runs until completion (or failure), and this entire execution is considered one task. The final output is stored as a task artifact.
    
-   **Context**: Represents a conversation thread that can span multiple tasks. The A2A protocol uses a `context_id` to maintain conversation continuity:
    
    -   When a new message is sent without a `context_id`, the server generates a new one
    -   Subsequent messages can include the same `context_id` to continue the conversation
    -   All tasks sharing the same `context_id` have access to the complete message history

#### Storage Architecture

The [`Storage`](/docs/ai/api/fasta2a/#fasta2a.Storage) component serves two purposes:

1.  **Task Storage**: Stores tasks in A2A protocol format, including their status, artifacts, and message history
2.  **Context Storage**: Stores conversation context in a format optimized for the specific agent implementation

This design allows for agents to store rich internal state (e.g., tool calls, reasoning traces) as well as store task-specific A2A-formatted messages and artifacts.

For example, a Pydantic AI agent might store its complete internal message format (including tool calls and responses) in the context storage, while storing only the A2A-compliant messages in the task history.

### Installation

FastA2A is available on PyPI as [`fasta2a`](https://pypi.org/project/fasta2a/) so installation is as simple as:

-   [pip](#tab-panel-46)
-   [uv](#tab-panel-47)

Terminal

```bash
pip install fasta2a
```

Terminal

```bash
uv add fasta2a
```

The only dependencies are:

-   [starlette](https://www.starlette.io): to expose the A2A server as an [ASGI application](https://asgi.readthedocs.io/en/latest/)
-   [pydantic](https://pydantic.dev): to validate the request/response messages
-   [opentelemetry-api](https://opentelemetry-python.readthedocs.io/en/latest): to provide tracing capabilities

Install **FastA2A** with the Pydantic AI bridge included:

-   [pip](#tab-panel-48)
-   [uv](#tab-panel-49)

Terminal

```bash
pip install 'fasta2a[pydantic-ai]>=0.6.1'
```

Terminal

```bash
uv add 'fasta2a[pydantic-ai]>=0.6.1'
```

The `pydantic-ai-slim[a2a]` extra still works for back-compat in 1.x but is deprecated and removed in 2.0.

### Pydantic AI Agent to A2A Server

To expose a Pydantic AI agent as an A2A server, use `agent_to_a2a` from `fasta2a.pydantic_ai`:

agent\_to\_a2a.py

```python
from fasta2a.pydantic_ai import agent_to_a2a

from pydantic_ai import Agent

agent = Agent('openai:gpt-5.2', instructions='Be fun!')
app = agent_to_a2a(agent)
```

Since `app` is an ASGI application, it can be used with any ASGI server.

Terminal

```bash
uvicorn agent_to_a2a:app --host 0.0.0.0 --port 8000
```

`agent_to_a2a` is a convenience function that accepts the same arguments as the [`FastA2A`](/docs/ai/api/fasta2a/#fasta2a.FastA2A) constructor.

When using `agent_to_a2a()`, Pydantic AI automatically:

-   Stores the complete conversation history (including tool calls and responses) in the context storage
-   Ensures that subsequent messages with the same `context_id` have access to the full conversation history
-   Persists agent results as A2A artifacts:
    -   String results become `TextPart` artifacts and also appear in the message history
    -   Structured data (Pydantic models, dataclasses, tuples, etc.) become `DataPart` artifacts with the data wrapped as `{"result": <your_data>}`
    -   Artifacts include metadata with type information and JSON schema when available