Protocolos de agentes AI: MCP, A2A, ACP e AG-UI

Resposta rápida

MCP, A2A, ACP e AG-UI não substituem um ao outro diretamente. Eles resolvem fronteiras diferentes em um sistema de agentes.

Protocolo	Problema principal	Fronteira típica
MCP	Como uma app AI conecta ferramentas, dados, prompts e contexto	Host/agente para servidor de ferramentas ou recursos
A2A	Como um agente delega trabalho a outro	Tarefas agente a agente
ACP	Como expor agentes como serviços interoperáveis	Interoperabilidade entre serviços de agentes
AG-UI	Como um agente transmite estado e ações para UI	Backend de agente para frontend

Em produção, a pergunta não é "qual vence?", mas "qual fronteira estamos padronizando?".

Por que importam

Sistemas iniciais de agentes costumam codificar chamadas de ferramentas, eventos de UI e delegação dentro de uma app. Funciona para protótipos, mas fica frágil com várias ferramentas, equipes, fornecedores e interfaces.

Protocolos separam responsabilidades:

Ferramentas e dados podem ser expostos sem reescrever o agente.
Agentes delegam sem revelar implementação interna.
Frontends exibem progresso, tools e estado intermediário de forma consistente.
Segurança analisa permissões e auditoria em fronteiras claras.

A chave é escolher o protocolo para a fronteira certa.

MCP: ferramentas e contexto

MCP, Model Context Protocol, conecta apps AI a ferramentas e contexto externos. Um host pode descobrir e chamar ferramentas, ler recursos e usar templates de prompt.

Use MCP quando:

Uma app AI precisa consultar banco, filesystem, API, repositório ou sistema interno.
Ferramentas devem ser reutilizadas por vários clientes.
Recursos e prompts precisam ser expostos de forma padrão.
Schemas e permissões de tools devem ser explícitos.

MCP é forte na fronteira "agente chama ferramenta". Não é protocolo completo de orquestração multiagente e não define UI.

AI app / agent host
  -> MCP client
  -> MCP server
  -> database, file system, API, internal tool

Boas práticas:

Ferramentas pequenas e bem descritas.
Evitar escrita ampla.
Logar chamadas e argumentos.
Tratar saída como dado não confiável.
Versionar schemas.

A2A: colaboração agente a agente

A2A, Agent-to-Agent, foca colaboração. Um agente pode anunciar capacidades e aceitar tarefas de outro agente ou orquestrador.

Use A2A quando:

Vários agentes especializados precisam colaborar.
Um planner delega trabalho.
Agentes pertencem a equipes ou serviços diferentes.
Tarefas longas precisam de status, artefatos e progresso.

A2A é forte na fronteira "agente delega a agente". Não substitui MCP; um agente A2A pode usar MCP internamente.

Orchestrator agent
  -> A2A task request
  -> Specialist agent
  -> status updates and artifacts

Boas práticas:

Definir o que cada agente pode fazer.
Validar respostas.
Usar timeouts e budgets.
Registrar ownership e histórico de handoff.
Evitar loops de delegação.

ACP: serviços de agentes interoperáveis

ACP costuma ser discutido como Agent Communication Protocol e busca tornar agentes descobríveis e interoperáveis como serviços. Implementações variam, mas o objetivo é expor capacidades de forma previsível.

Use abordagens estilo ACP quando:

Agentes devem se comportar como serviços de rede.
Descoberta de capacidades importa.
Runtimes ou fornecedores diferentes precisam interoperar.
Uma fronteira de serviço é melhor que uma chamada de biblioteca.

ACP se sobrepõe conceitualmente a A2A. Avalie a implementação concreta: formato, autenticação, ciclo de vida, streaming, SDK e governança.

AG-UI: agente para interface

AG-UI foca a fronteira frontend. Ele padroniza como um backend de agente transmite mensagens, chamadas de ferramentas, mudanças de estado, progresso e eventos relevantes para a UI.

Use AG-UI quando:

Você constrói uma UI de copilot ou assistente.
O frontend precisa mostrar tools, passos intermediários ou progresso.
Usuários precisam aprovar ações na UI.
Estado do agente deve sincronizar com React, Vue ou outros frameworks.

AG-UI é forte na fronteira "backend de agente fala com UI". Não define workflow interno nem hospedagem de ferramentas.

Agent backend
  -> event stream
  -> frontend UI
  -> user approval / input
  -> backend resumes

Boas práticas:

Manter tipos de evento estáveis.
Separar estado visível de segredos internos.
Lidar com reconexões e streams parciais.
Tornar aprovações explícitas e auditáveis.
Nunca deixar eventos frontend pularem permissões do servidor.

Como se combinam

Os protocolos costumam ser complementares:

User interface
  <-> AG-UI events
Agent application / orchestrator
  <-> A2A or ACP for agent collaboration
Specialist agent
  <-> MCP for tools, resources, and prompts
Business systems

Um sistema de suporte pode usar AG-UI para progresso e confirmação, A2A para delegar a um agente financeiro e MCP para ferramentas de pedidos, pagamentos e tickets.

Comparação

Dimensão	MCP	A2A	ACP	AG-UI
Fronteira	Agente para tools/contexto	Agente para agente	Serviço de agente	Agente para UI
Objeto	Tool, resource, prompt	Task, message, artifact	Capability, agent, message	Event, state, action
Melhor para	Integração de ferramentas	Delegação	Interoperabilidade	Frontends interativos
Substitui lógica da app?	Não	Não	Não	Não
Combinável?	Sim	Sim	Sim	Sim
Risco	Tools poderosas demais	Delegação sem limite	Implementações divergentes	Vazamento de estado/segurança

Guia de decisão

Escolha MCP se o problema principal é conectar ferramentas ou dados.

Escolha A2A se um agente precisa delegar tarefas a outro.

Escolha ACP se agentes devem ser expostos como serviços com descoberta de capacidades.

Escolha AG-UI se você constrói uma UI interativa com progresso, aprovações e estado intermediário.

Erros comuns

Tratar protocolos como frameworks

Protocolos definem fronteiras de comunicação. Não substituem orquestração, avaliação, segurança, deploy nem produto.

Usar multiagente para tool calls simples

Se o agente só consulta banco ou API, MCP pode bastar. Não adicione delegação sem necessidade.

Expor demais

Um servidor de tools deve expor operações estreitas. "Executar SQL arbitrário" ou "executar shell" exige controle forte.

Confiar sem validar

Comunicação entre agentes ainda precisa de validação. Artefatos retornados são dados que devem ser checados.

Transformar eventos de UI em permissões

Aprovação no frontend é sinal de interação, não controle completo de segurança. O backend deve aplicar permissões.

Checklist de produção

Área	Perguntas
Autenticação	Quem pode chamar o endpoint?
Autorização	Quais tools, agents, tasks ou ações UI são permitidas?
Auditoria	Dá para reconstruir quem pediu o quê?
Timeouts	O que acontece se tool ou agente trava?
Budgets	Chamadas de modelo, tools e profundidade têm limites?
Validação	Inputs e outputs têm schema?
Observabilidade	Traces conectam UI, agente, tool e task?
Versionamento	Dá para mudar schemas sem quebrar clientes?

Resumo

MCP, A2A, ACP e AG-UI são protocolos de fronteira. MCP padroniza ferramentas e contexto, A2A colaboração entre agentes, ACP serviços interoperáveis e AG-UI eventos de frontend. Um sistema maduro pode usar vários, mas cada um deve entrar apenas onde cria uma fronteira mais clara e segura.