Phase 16 - Lesson 12

A2A — O Protocolo Agent-to-Agent

O Google anunciou o A2A em abril de 2025; em abril de 2026, a especificação está em https://a2a-protocol.org/latest/specification/ e mais de 150 organizações a apoiam. O A2A é o complemento horizontal do MCP (Lição 13): onde o MCP é vertical (agente ↔ ferramentas), o A2A é ponto a ponto (agente ↔ agente). Ele define Agent Cards (descoberta), tarefas com artefatos (texto, dados estruturados, vídeo), ciclos de vida de tarefas opacos e autenticação. Os sistemas de produção combinam cada vez mais o MCP com o A2A. O Google Cloud integrou o suporte ao A2A no Vertex AI Agent Builder durante 2025-2026.

Tipo: Aprenda + Construa Linguagens: Python (stdlib, http.server, json) Pré-requisitos: Phase 16 · 04 (Primitive Model) Tempo: ~75 minutos

Problema

Seu agente precisa chamar outro agente em outro sistema. Como? Você pode expor um endpoint HTTP, definir um esquema JSON personalizado e esperar que o outro lado saiba se comunicar com ele. Cada par de agentes torna-se uma integração sob medida.

O A2A é o protocolo de comunicação universal para essa chamada. Descoberta padrão, modelo de tarefa padrão, transporte padrão, artefatos padrão. Como HTTP+REST, mas para agentes como cidadãos de primeira classe.

Conceito

Os quatro elementos

Agent Card. Um documento JSON em /.well-known/agent.json que descreve o agente: nome, habilidades, endpoints, modalidades suportadas, requisitos de autenticação. A descoberta acontece ao ler o card.

GET https://agent.example.com/.well-known/agent.json
→ {
    "name": "code-review-agent",
    "skills": ["review-python", "review-typescript"],
    "endpoints": {
      "tasks": "https://agent.example.com/tasks"
    },
    "auth": {"type": "bearer"},
    "modalities": ["text", "structured"]
  }

Task. A unidade de trabalho. Um objeto assíncrono e com estado (stateful) que possui um ciclo de vida: submitted → working → completed / failed / canceled. Um cliente envia uma tarefa, faz consultas periódicas (poll) ou se inscreve para receber atualizações.

Artifact. O tipo de resultado produzido por uma tarefa. Texto, JSON estruturado, imagem, vídeo, áudio. Os artefatos são tipados para que as diferentes modalidades sejam tratadas como primeira classe.

Opaque lifecycle. O A2A não prescreve como o agente remoto resolve a tarefa. O cliente vê transições de estado e artefatos; a implementação é livre para usar qualquer framework.

A divisão MCP/A2A

• MCP (Lição 13): agente ↔ ferramenta. O agente lê/escreve via JSON-RPC para um servidor de ferramentas. Sem estado (stateless) por padrão.
• A2A: agente ↔ agente. Protocolo de pares; ambos os lados são agentes com seu próprio raciocínio.

Sistemas multiagentes de produção utilizam ambos. Um par A2A chama ferramentas MCP em seu próprio lado. A divisão mantém as duas preocupações organizadas e separadas.

Fluxo de descoberta

Client                     Agent server
  ├──GET /.well-known/agent.json──>
  <──Agent Card JSON─────────────
  ├──POST /tasks {skill, input}──>
  <──201 task_id, state=submitted
  ├──GET /tasks/{id}──────────────>
  <──state=working, 42% done──────
  ├──GET /tasks/{id}──────────────>
  <──state=completed, artifacts──

Ou com streaming: assinatura SSE para /tasks/{id}/events para atualizações por push.

Autenticação

O A2A suporta três padrões comuns:

• Bearer token — OAuth2 ou opaco.
• mTLS — TLS mútuo; organizações provam identidade umas às outras.
• Signed requests — HMAC sobre o payload.

A autenticação é declarada no Agent Card; os clientes a descobrem e cumprem os requisitos.

Mais de 150 organizações em abril de 2026

A adoção corporativa impulsionou a escala do A2A. O ponto principal: o A2A tornou-se a forma como os sistemas de agentes corporativos cruzam fronteiras de confiança. O Google Cloud lançou o suporte ao A2A no Vertex AI Agent Builder; o Microsoft Agent Framework o suporta; a maioria dos frameworks mais importantes (LangGraph, CrewAI, AutoGen) oferece adaptadores A2A.

Onde o A2A vence

• Chamadas entre organizações. Um agente na empresa A chama um agente na empresa B. Sem o A2A, cada par seria um contrato sob medida.
• Frameworks heterogêneos. Um agente LangGraph chama um agente CrewAI que chama um agente Python personalizado. O A2A normaliza a comunicação.
• Artefatos tipados. Resultados em vídeo, JSON estruturado, áudio — todos tratados como primeira classe.
• Tarefas de longa duração. Ciclo de vida opaco + polling torna tarefas que duram horas algo simples de gerenciar.

Onde o A2A enfrenta dificuldades

• Microchamadas sensíveis à latência. O ciclo de vida do A2A é assíncrono. Comunicação agente a agente abaixo de milissegundos não é adequada; utilize RPC direta.
• Agentes fortemente acoplados no mesmo processo. Se ambos os agentes rodam no mesmo processo Python, a viagem de ida e volta HTTP do A2A é desnecessária.
• Equipes pequenas. O custo de especificação é real; agentes estritamente internos podem não precisar dessa formalidade.

A2A vs ACP, ANP, NLIP

Várias especificações relacionadas surgiram em 2024-2026:

• ACP (IBM/Linux Foundation) — predecessor do A2A, escopo mais restrito.
• ANP (Agent Network Protocol) — focado em descoberta de pares descentralizada.
• NLIP (Ecma Natural Language Interaction Protocol, padronizado em dezembro de 2025) — tipo de conteúdo em linguagem natural.

O A2A é o protocolo de pares mais adotado em abril de 2026. Consulte arXiv:2505.02279 (Liu et al., "A Survey of Agent Interoperability Protocols") para fins de comparação.

Construa

code/main.py implementa um cliente e servidor A2A mínimos usando http.server e JSON. O servidor:

• expõe /.well-known/agent.json,
• aceita POST /tasks,
• gerencia o estado da tarefa,
• retorna artefatos em GET /tasks/{id}.

O cliente:

• busca o Agent Card,
• envia uma tarefa,
• faz polling até a conclusão,
• lê o artefato.

Execute:

python3 code/main.py

O script inicia o servidor em uma thread de segundo plano e, em seguida, executa o cliente contra ele. Você verá o fluxo completo: descoberta, envio, polling, artefato.

Use

outputs/skill-a2a-integrator.md projeta uma integração A2A: conteúdo do Agent Card, esquemas de tarefas, escolha de autenticação, streaming versus polling.

Coloque em Produção

Lista de verificação:

• Fixe a versão da especificação. O A2A ainda está evoluindo; o Agent Card deve declarar a versão do protocolo.
• Criação de tarefas idempotente. Envios duplicados (tentativas de rede) devem produzir apenas uma tarefa.
• Esquemas de artefatos. Declare quais formatos o agente retorna; os consumidores devem validá-los.
• Limites de taxa + autenticação. O A2A é voltado para o público externo; aplique a segurança web padrão.
• Dead-letter para tarefas com falha. Inspecione padrões ao longo do tempo para tipos de falhas recorrentes.

Exercícios

1. Execute code/main.py. Confirme se o cliente descobre o servidor e recebe o artefato correto.
2. Adicione uma segunda habilidade ao servidor (por exemplo, "summarize"). Atualize o Agent Card. Escreva um cliente que escolhe a habilidade com base no tipo de tarefa.
3. Implemente um endpoint de streaming SSE: /tasks/{id}/events que emite mudanças de estado. O que o cliente precisa fazer de diferente?
4. Leia a especificação do A2A (https://a2a-protocol.org/latest/specification/). Identifique três coisas que a especificação exige, mas que esta demonstração não implementa.
5. Compare o A2A (descoberta por Agent Card) ao MCP (listagem de recursos do lado do servidor via listTools). Qual é a compensação (tradeoff) entre agentes autodescritivos e sondagem de recursos?

Termos-Chave

Leituras Adicionais

• A2A specification — a especificação canônica
• Google Developers Blog — A2A announcement — post de lançamento de abril de 2025
• A2A GitHub repo — referência para implementações e SDKs
• Liu et al. — A Survey of Agent Interoperability Protocols — comparação entre MCP, ACP, A2A, ANP