Урок 4: A2A — агент-к-агенту

Чему вы научитесь

После этого урока вы поймёте:

• Что такое A2A (Agent-to-Agent) протокол
• Разницу между MCP и A2A
• Как агенты общаются между собой
• Когда нужны мультиагентные системы

Содержание

Что такое A2A?

A2A (Agent-to-Agent) — это протокол от Google для коммуникации между несколькими AI-агентами. Это стандарт для построения систем, где несколько агентов работают вместе над одной задачей.

Аналогия: если MCP — это “интерфейс между агентом и инструментами”, то A2A — это “интерфейс между агентом и другим агентом”.

MCP vs A2A — главная разница

graph LR
    A["Agent"] -->|MCP| B["Tools<br/>Files, DB,<br/>GitHub, Slack"]
    
    C["Agent 1"] -->|A2A| D["Agent 2<br/>Task<br/>Result"]

Как работает A2A?

Компоненты A2A

┌────────────────────────────────────────────┐
│         Agent Card (Описание агента)      │
│  - Имя, описание                          │
│  - Какие задачи может решить              │
│  - Какой результат возвращает             │
└────────────────────────────────────────────┘
           ↓
┌────────────────────────────────────────────┐
│         Task (Задача от другого агента)   │
│  - Что нужно сделать                      │
│  - Параметры и контекст                   │
│  - Результаты других агентов              │
└────────────────────────────────────────────┘
           ↓
┌────────────────────────────────────────────┐
│  Artifact (То, что вернёт агент)          │
│  - Результат работы                       │
│  - Метаданные                             │
│  - Возможно, следующая задача             │
└────────────────────────────────────────────┘

Пример A2A workflow

sequenceDiagram
    participant User
    participant Agent1 as Researcher<br/>Agent
    participant Agent2 as Writer<br/>Agent
    participant Tools as External<br/>Tools

    User->>Agent1: Напиши отчёт про AI

    Agent1->>Tools: Найди информацию про AI
    Tools->>Agent1: Вот 10 статей

    Agent1->>Agent2: Я нашёл эту информацию,<br/>напиши отчёт

    Agent2->>Agent2: Пишу отчёт

    Agent2->>User: Вот готовый отчёт

    Note over Agent1,Agent2: A2A communication между агентами

Пример 1: Поиск информации + Написание отчёта

Агент 1 (Researcher):

Описание: я умею искать информацию в интернете
Инструменты: web_search, read_article
Результат: 5-10 ключевых фактов по теме

Агент 2 (Writer):

Описание: я умею писать структурированные отчёты
Инструменты: document_create, document_edit
Результат: готовый отчёт в Google Docs

Workflow:

1. User просит написать отчёт про “Machine Learning”
2. Agent1 (Researcher) ищет информацию
3. Agent1 отправляет найденную информацию Agent2 через A2A
4. Agent2 (Writer) пишет отчёт на основе информации
5. User получает готовый отчёт

Код с использованием A2A (концептуально):

# Определение агента 1 (Researcher)
researcher = Agent(
    name="Researcher",
    model="claude",
    tools=["web_search", "read_article"],
    role="Ищет и собирает информацию"
)

# Определение агента 2 (Writer)
writer = Agent(
    name="Writer",
    model="claude",
    tools=["document_create"],
    role="Пишет отчёты на основе информации"
)

# A2A интеграция
def run_report_workflow(topic):
    # Агент 1 ищет информацию
    research_result = researcher.execute(f"Найди 10 фактов про {topic}")
    
    # Агент 2 пишет отчёт
    report = writer.execute(
        task=f"Напиши отчёт про {topic}",
        context=research_result  # A2A: передаём результат другого агента
    )
    
    return report

# Использование
report = run_report_workflow("Machine Learning")

Пример 2: Code Review + Bug Fixing

Агент 1 (Code Reviewer):

• Анализирует код
• Находит проблемы
• Пишет рекомендации

Агент 2 (Bug Fixer):

• Получает рекомендации от Reviewer
• Исправляет код
• Возвращает улучшенный код

Workflow:

User код → Reviewer агент → "Нашел проблемы X, Y, Z"
                             ↓
                         Fixer агент → исправляет X, Y, Z
                             ↓
User → готовый код

Пример 3: Data Analysis + Visualization

Агент 1 (Data Analyst):

• Анализирует данные
• Находит тренды и паттерны
• Возвращает выводы

Агент 2 (Data Visualizer):

• Получает выводы от Analyst
• Создаёт графики и диаграммы
• Вставляет их в отчёт

Архитектура A2A

graph TB
    subgraph "Agent System"
        A1["Agent 1<br/>Skills: search,<br/>read"]
        A2["Agent 2<br/>Skills: write,<br/>format"]
        A3["Agent 3<br/>Skills: code,<br/>debug"]
    end
    
    subgraph "Communication"
        MSG["A2A Message<br/>Protocol"]
    end
    
    subgraph "External"
        WEB["Web Tools"]
        DB["Database"]
        GIT["GitHub"]
    end
    
    A1 -->|find info| MSG
    MSG -->|pass result| A2
    A2 -->|format output| MSG
    MSG -->|may need code| A3
    
    A1 -->|MCP| WEB
    A2 -->|MCP| DB
    A3 -->|MCP| GIT

Текущий статус A2A (на март 2026)

История и текущее состояние:

• Апрель 2025: Google публично анонсировала A2A с поддержкой 50+ партнёров (Atlassian, Box, Langchain, Salesforce и др.)
• Июнь 2025: Google передала A2A в Linux Foundation (Agentic AI Foundation)
• V0.2 спецификации: поддержка stateless-взаимодействий и стандартизированная аутентификация
• Native поддержка в Google Agent Development Kit (ADK)
• 150+ организаций в экосистеме

Реальное положение дел:

• К сентябрю 2025 года большинство AI-агентной экосистемы консолидировалось вокруг MCP
• A2A не умер, но активная разработка замедлилась
• Google Cloud поддерживает A2A для enterprise, но сам добавляет MCP-совместимость
• На практике MCP стал доминирующим стандартом для agent-to-tool коммуникации

Что развивается:

• Интеграция с облачными платформами Google
• Совместимость с MCP (два стандарта сближаются)

Что не готово:

• Встроенная поддержка в основных IDE
• Большое количество готовых мультиагентных приложений

Когда нужны мультиагентные системы?

Нужны A2A, если:

1. Разные роли в одном проекте

   • Один агент проверяет код (Code Reviewer)
   • Другой исправляет ошибки (Bug Fixer)
   • Третий пишет тесты (Test Writer)

2. Разделение по специализации

   • Агент 1: поиск информации
   • Агент 2: анализ
   • Агент 3: создание документов

3. Масштабирование и параллелизм

   • Несколько агентов одновременно работают
   • Каждый на своей части задачи
   • Быстрее, чем один агент всё делает

4. Enterprise workflows

   • Утверждение документов (multiple agents)
   • Сложные бизнес-процессы
   • Compliance checks

НЕ нужны A2A, если:

• Одна простая задача (один агент справится)
• Нет разных ролей
• Всё можно сделать через MCP инструменты

Сравнение подходов

Пример: Написать и проверить статью

Подход 1: Один агент (без A2A)

Agent: "Напиши статью про AI и проверь её"
Результат: одна статья с самопроверкой (часто хуже)

Подход 2: A2A (несколько агентов)

Agent Writer: "Напиши статью"
     ↓
Agent Reviewer: "Проверь статью Writer"
     ↓
Agent Editor: "Отредактируй на основе отзывов"
     ↓
Результат: лучшее качество, более объективная проверка

Разница между системными инструкциями и A2A

Системные инструкции (одного агента):

Ты: исследователь AI
Когда тебя просят: найди информацию, напиши отчёт
Используешь: web_search, document_create

A2A (несколько агентов):

Agent 1 (Researcher): ищет информацию
Agent 2 (Writer): пишет на основе информации из Agent 1
Agent 3 (Editor): редактирует результат Agent 2
Каждый агент специализирован на одном!

Преимущество A2A:

• Каждый агент лучше в своём деле
• Легче добавлять новые агенты
• Лучшее распределение работы
• Проще отлаживать (каждый агент отдельно)

Попробуйте сами

Пока A2A не так распространён, но вы можете подготовиться:

1. Подумайте о вашем проекте

   • Какие разные роли нужны?
   • Какие разные умения нужны агентам?

2. Спланируйте мультиагентную систему

   • Агент 1: …
   • Агент 2: …
   • Агент 3: …

3. Начните с простого

   • Создайте два Claude Code окна
   • В первом: агент-исследователь
   • Во втором: агент-писатель
   • Вручную передавайте результаты между ними

4. Пример вручную:

   Claude Code 1:
   "Найди 5 фактов про WebAssembly"
   
   (скопировал результат)
   
   Claude Code 2:
   "На основе этих фактов напиши статью:
   [вставляю результат из окна 1]"

Ключевые выводы

• A2A — это протокол для общения между агентами (vs MCP для общения агента с инструментами)
• MCP = агент ↔ инструменты; A2A = агент ↔ агент
• Когда нужны мультиагентные системы: разные роли, разные умения, масштабирование, enterprise workflows
• Текущий статус (март 2026): A2A существует, управляется Linux Foundation, но экосистема консолидировалась вокруг MCP. A2A больше жив в Google Cloud/enterprise, а не в IDE-инструментах
• На практике: большинство IDE-агентов и фреймворков используют MCP, а не A2A
• Преимущества: лучше качество (специализация), легче масштабировать, удобнее отлаживать
• Не спешите: сначала овладейте MCP, потом при необходимости изучайте A2A

Что дальше?

После этого модуля вы знаете:

• Что такое MCP и как его настраивать (Урок 1-2)
• Какие MCP-серверы доступны (Урок 3)
• Как строить мультиагентные системы с A2A (Урок 4)

Следующие шаги:

1. Установите 2-3 MCP-сервера в Claude Code
2. Поэкспериментируйте с ними
3. Создайте свой простой MCP-сервер на Python
4. Если нужна мультиагентная система — начните учить A2A

Рекомендуемые ресурсы:

• MCP Documentation: https://modelcontextprotocol.io/
• MCP Registry (официальный): https://registry.modelcontextprotocol.io/
• Google A2A Spec (Linux Foundation): https://github.com/a2aproject/A2A