Você montou um agente de IA que consulta seu banco de dados, acessa o CRM e responde no WhatsApp. Tudo via MCP. Funciona. Mas quando o cliente pede algo que exige pesquisa externa, o agente trava. Você precisaria de um segundo agente especializado. Só que esse segundo agente não consegue falar com o primeiro sem código de cola customizado. Esse é o problema que o Google quis resolver. Em fevereiro de 2026, a solução virou padrão com o lançamento do A2A v1.0.
Por Que o MCP Sozinho Não Basta Para Agentes em Produção?
O MCP (Model Context Protocol) foi lançado pela Anthropic no final de 2024 e rapidamente se tornou o padrão para conectar agentes a ferramentas externas: bancos de dados, APIs, arquivos, CRMs. Em 2026, mais de 200 servidores MCP estão disponíveis no ecossistema.
Mas o MCP resolve só metade da equação. A especificação foi desenhada para o eixo agente ↔ ferramenta. O eixo agente ↔ agente ficou de fora propositalmente. O próprio time que criou o MCP foi explícito: o protocolo não é uma solução de orquestração entre agentes.
O resultado: cada framework inventou o próprio padrão de orquestração. AutoGen fala uma linguagem. LangGraph fala outra. CrewAI tem a própria. Você cola o sistema inteiro com código proprietário que ninguém mais consegue manter. Segundo levantamento da Linux Foundation, 62% das empresas ainda estão em fase de experimentação com agentes. O principal motivo reportado: complexidade de orquestração entre frameworks heterogêneos.
O Que o Google Fez Diferente com o A2A?
Em abril de 2025, o Google anunciou o A2A (Agent-to-Agent), um protocolo aberto para padronizar a comunicação entre agentes de IA de fabricantes diferentes. Em junho de 2025, doou o projeto para a Linux Foundation para garantir governança vendor-neutral. Em fevereiro de 2026, o A2A v1.0 foi lançado: a versão que saiu do modo experimento e entrou em produção.
Hoje, o protocolo tem mais de 150 organizações participantes, 22.000 stars no GitHub e deployments em produção no Azure AI Foundry (Microsoft) e Amazon Bedrock AgentCore (AWS). Não é hype. É infraestrutura.
Dado-chave: A2A v1.0 está em produção no Azure AI Foundry e Amazon Bedrock AgentCore. 150+ organizações adotaram o protocolo em menos de 12 meses após o lançamento inicial.
Como Funciona o A2A na Prática?
O A2A opera com quatro primitivas principais. Entender cada uma é suficiente para começar a implementar:
1. Agent Card
É um documento JSON publicado em /.well-known/agent.json que descreve o que o agente sabe fazer: nome, habilidades, URL de endpoint, formatos aceitos. Na v1.0, o Agent Card ganhou assinatura criptográfica (JWS) para verificação de identidade. Um agente orquestrador descobre outros agentes via Agent Card, sem configuração manual.
{
"name": "agente-qualificacao",
"description": "Qualifica leads via WhatsApp",
"url": "https://meu-agente.exemplo.com/a2a",
"version": "1.0",
"skills": [
{
"id": "qualificar-lead",
"name": "Qualificação de Lead",
"description": "Coleta BANT e retorna score de qualificação",
"inputModes": ["text"],
"outputModes": ["text", "json"]
}
]
}2. Task
É a unidade de trabalho. Um agente orquestrador cria uma Task e delega para um agente especialista. A Task tem estados definidos: submitted, working, completed, failed. O orquestrador não precisa saber como o especialista resolve. Só precisa do resultado.
3. Artifact
É o resultado entregue pelo agente especialista. Pode ser texto, JSON estruturado, arquivo ou streaming parcial. Múltiplos artifacts podem ser retornados em uma única Task.
4. Streaming via SSE
Para tarefas longas, o A2A usa Server-Sent Events para enviar resultados parciais em tempo real. O orquestrador não precisa ficar em polling. Recebe os updates conforme chegam.
A2A vs MCP: São Concorrentes?
Não. São complementares e resolvem problemas diferentes. A confusão é comum porque ambos aparecem no mesmo contexto de "infraestrutura para agentes de IA".
| Dimensão | MCP | A2A |
|---|---|---|
| Conecta | Agente ↔ Ferramentas | Agente ↔ Agente |
| Mantido por | Anthropic + comunidade | Linux Foundation |
| Status em 2026 | Adoção massiva (200+ servidores) | v1.0, produção enterprise |
| Transport | stdio, HTTP/SSE | HTTP + SSE + JSON-RPC 2.0 |
| Identidade | Não resolve | Signed Agent Cards (JWS) |
| Ideal para | RAG, APIs, databases, tools | Orquestração multi-agente |
| Concorrentes? | Não. Use os dois juntos. | |
O stack completo de um agente moderno usa MCP para acessar ferramentas e dados, e A2A para se comunicar com outros agentes. Um agente orquestrador recebe uma tarefa complexa, usa A2A para delegar subtarefas para especialistas, e cada especialista usa MCP para acessar os dados que precisa.
Como Implementar A2A com Python (SDK Oficial)
O A2A tem SDK oficial para Python e JavaScript. A instalação é direta:
pip install a2a-sdkUm servidor A2A mínimo em Python:
from a2a.server import A2AServer
from a2a.types import AgentCard, AgentSkill, Task, Artifact
skill = AgentSkill(
id="qualificar-lead",
name="Qualificação de Lead",
description="Coleta BANT e retorna score",
input_modes=["text"],
output_modes=["json"]
)
agent_card = AgentCard(
name="agente-qualificacao",
description="Qualifica leads via WhatsApp com BANT",
url="https://meu-agente.exemplo.com/a2a",
version="1.0",
skills=[skill]
)
server = A2AServer(agent_card=agent_card)
@server.task_handler("qualificar-lead")
async def qualificar(task: Task) -> Artifact:
mensagem = task.message.content
# lógica de qualificação aqui
return Artifact(
content={"bant_score": 85, "proximo_passo": "agendar_demo"},
mime_type="application/json"
)
if __name__ == "__main__":
server.run(host="0.0.0.0", port=8080)E um cliente que delega tarefas para esse agente:
from a2a.client import A2AClient
client = A2AClient("https://meu-agente.exemplo.com/a2a")
# Descobre o Agent Card automaticamente
card = await client.get_agent_card()
# Cria e envia uma task
task = await client.send_task(
skill_id="qualificar-lead",
message="Cliente interessado em automação de atendimento, budget de R$2K/mês"
)
# Aguarda o resultado
result = await task.wait()
print(result.artifact.content)
# {"bant_score": 85, "proximo_passo": "agendar_demo"}Qual É o Caso de Uso Real Para Esse Protocolo?
Imagine um sistema de atendimento com 3 agentes especializados:
- Agente Triagem: recebe a mensagem inicial no WhatsApp, classifica a intenção e delega via A2A.
- Agente Qualificação: coleta BANT, consulta o CRM via MCP e retorna o score.
- Agente Agendamento: acessa o calendário via MCP, propõe horários e confirma com o cliente.
Cada agente expõe um Agent Card. O orquestrador descobre os especialistas, delega tarefas e monta a resposta final para o cliente. Se você trocar o Agente Agendamento por outro fornecedor, o protocolo continua funcionando. Sem refatorar o orquestrador. Sem quebrar o fluxo inteiro.
Essa é a diferença entre um sistema colado com gambiarras e uma arquitetura que sobrevive à escala.
Na Verboo, a plataforma já opera com arquitetura de assistentes especializados. Mais de 390 empresas usam agentes com separação clara de responsabilidades: Instrução, Base de Conhecimento, Gatilhos e Tarefas agendadas, cada um com seu escopo. Com A2A, essa arquitetura passa a ser interoperável com qualquer ferramenta do ecossistema.
O stack moderno de IA não é um único agente fazendo tudo. É um time de agentes especializados, cada um com sua responsabilidade, se comunicando por protocolos abertos. MCP cuida da integração com ferramentas. A2A cuida da orquestração entre agentes. Juntos, resolvem o que nenhum dos dois resolve sozinho.
A Verboo já opera nesse modelo. Conheça a plataforma e veja como agentes especializados resolvem atendimento, qualificação e agendamento sem código de cola.
