Protocolos de AI Agents - Guia para Iniciantes

🧠 Primeiro: O que é um AI Agent?

Antes de falar de protocolos, precisamos alinhar três conceitos que os iniciantes frequentemente confundem:

⚠️ Chatbot vs LLM vs Agent - qual é a diferença?

🔑 A definição formal

"

Um AI Agent é basicamente: LLM + Memória + Ferramentas + Capacidade de decidir ações.

Quebrando cada parte:

• LLM → o "cérebro" que entende e raciocina (ex: GPT-4, Claude, Gemini)
• Memória → contexto da conversa, histórico, informações persistidas
• Ferramentas → capacidade de chamar APIs, ler arquivos, acessar bancos de dados
• Decidir ações → o agente escolhe o que fazer a seguir com base no objetivo - não só responde, ele age

LLM sozinho:     Pergunta → [Modelo] → Resposta
                 (passivo, só gera texto)

AI Agent:        Objetivo → [Modelo] → Decide ação → Executa ferramenta
                                ↑______________|
                            (loop até concluir o objetivo)

O loop de decisão é o que transforma um LLM em um agente. Ele continua agindo até completar a tarefa - não apenas responde uma vez e para.

Analogia simples 💡

"

Pense num gerente de projetos inteligente. Ele recebe uma tarefa ("organize uma viagem para São Paulo"), divide em subtarefas, delega para especialistas (um cuida de passagem, outro de hotel, outro do clima) e consolida o resultado final. Um chatbot seria apenas o formulário de contato na recepção.

🔌 O Problema: Como eles se comunicam?

Imagine que você tem vários assistentes inteligentes criados por empresas diferentes:

• Um feito pela Google
• Um feito pela Anthropic
• Um feito pela IBM

Como eles conversam entre si? Como um agente "fala" com uma ferramenta externa?

Sem um padrão, cada um fala uma língua diferente - seria um caos.

É exatamente por isso que surgiram os Protocolos de AI Agents - regras e padrões de comunicação, assim como o HTTP padronizou a comunicação na internet.

"

💡 Analogia: Assim como todos os sites usam HTTP para se comunicar com navegadores, os agentes usam esses protocolos para se comunicar entre si e com ferramentas.

📋 Os 7 Protocolos - Um por Um

1. 🔌 MCP - Model Context Protocol (Anthropic)

O que é: Um protocolo que conecta um LLM (modelo de linguagem) a ferramentas externas de forma segura e padronizada.

Analogia: É como um cabo USB-C universal - não importa qual dispositivo, você usa o mesmo cabo para carregar, transferir dados e conectar periféricos.

Como funciona na prática:

Usuário → MCP Client → LLM (cérebro) → MCP Server → Ferramentas externas
                                                      (Slack, banco de dados, APIs)

Exemplo prático:

"

Você pergunta ao agente: "Quais foram as vendas de hoje?"

1. O MCP Client recebe sua pergunta
2. O LLM entende o que precisa buscar
3. O MCP Server acessa o banco de dados ou uma API de vendas
4. O resultado volta para você

Casos de uso:

• Agente que lê e escreve no Slack
• Agente que consulta bancos de dados em tempo real
• Agente que pesquisa na web

2. 🤝 A2A - Agent to Agent Protocol (Google)

O que é: Um protocolo que permite que agentes conversem entre si, independentemente de qual empresa os criou ou qual framework usaram.

Analogia: É como o sistema diplomático internacional - países (agentes) de culturas diferentes conseguem negociar usando regras comuns.

Como funciona na prática:

Agente A (Deepseek + Google ADK)
         ↕  [A2A Protocol]
Agente B (Mistral + LangChain)

O protocolo cuida de:

• Descoberta: "Ei, quais agentes existem e o que cada um sabe fazer?"
• Delegação: "Você consegue resolver essa subtarefa?"
• Streaming: Resultados chegando em tempo real enquanto a tarefa é executada

Exemplo prático:

"

Um agente de atendimento ao cliente recebe: "Quero cancelar meu pedido e pedir reembolso"

1. Ele descobre que existe um Agente de Cancelamento e um Agente Financeiro
2. Via A2A, delega o cancelamento para o primeiro
3. E o reembolso para o segundo
4. Consolida e responde ao cliente

3. ⚡ SLIM - Secure Low-Latency Interactive Messaging (Cisco)

O que é: Um protocolo focado em comunicação em tempo real, com baixa latência e alta segurança, usando gRPC.

Analogia: Se o A2A é como e-mail (assíncrono), o SLIM é como uma chamada de vídeo ao vivo - instantâneo, streaming contínuo.

Conceitos-chave para iniciantes:

Exemplo prático:

"

Sistema de monitoramento financeiro em tempo real:

• Agente de mercado publica: "Ação XPTO caiu 5%"
• Agente de risco recebe instantaneamente e dispara alerta
• Agente de portfólio recebe e reavalia posições
• tudo em milissegundos

4. 📡 ACP - Agent Communication Protocol (IBM)

O que é: Um protocolo RESTful (baseado em APIs como as que você já conhece) para comunicação entre agentes de forma assíncrona e rastreável.

Analogia: É como um sistema de tickets de suporte - você abre um chamado (tarefa), ele é processado de forma organizada, e você pode acompanhar o status.

Por que isso importa?

• Assíncrono: O agente não precisa esperar a resposta na hora
• Observável: Você consegue ver o que está acontecendo (logs, rastreamento)
• Escalável: Funciona bem mesmo com muitos agentes ao mesmo tempo

Como funciona:

ACP Client → [Envia tarefa] → AI Agent 1
                                  ↓
                           ACP Protocol
                     (Discovery + Estrutura de mensagem)
                                  ↓
                             AI Agent 2
                         (LangChain + Brave Search)

Exemplo prático:

"

Pipeline de análise de documentos:

1. Cliente envia 1000 contratos para análise
2. ACP distribui para vários agentes em paralelo
3. Cada um processa de forma independente
4. Resultados são coletados e consolidados

5. 🗣️ Agora - Oxford University

O que é: Uma proposta acadêmica inovadora da Universidade de Oxford que converte linguagem natural em protocolos de comunicação dinamicamente. Em vez de protocolos fixos, eles são gerados em tempo real conforme a necessidade. Vale notar que o Agora ainda é mais experimental do que padrão industrial consolidado - mas representa uma direção promissora para o futuro dos sistemas multi-agente.

Analogia: Imagine um intérprete universal que, ao ouvir sua conversa, cria automaticamente as regras de comunicação necessárias para cada situação.

O que torna o Agora especial:

"Quero viajar para Lisboa na próxima semana"
                    ↓
              [NLP - Entende a intenção]
                    ↓
         [Gera protocolos dinamicamente]
          ↙         ↓          ↘
  Flight Protocol  Booking    Weather
  → Agente de Voos  Protocol   Protocol
                  → Hotel    → Clima

Exemplo prático:

"

Usuário: "Organize uma conferência para 50 pessoas em março"

O Agora gera automaticamente protocolos para:

• Agente de locais
• Agente de catering
• Agente de audiovisual
• Agente de transporte

Sem precisar programar esses protocolos manualmente!

6. 🌐 ANP - Agent Network Protocol (TeamANP)

O que é: Um protocolo descentralizado baseado em padrões W3C (os mesmos da web), onde agentes têm identidades próprias e se descobrem e negociam autonomamente.

Analogia: Assim como a blockchain é descentralizada - sem um servidor central controlando as transações - o ANP também distribui o controle: cada agente tem sua própria identidade e se conecta diretamente aos outros, sem depender de um intermediário.

Conceitos importantes:

Como funciona:

Usuário → Agente de Viagem
              ↕ [ANP Protocols]
         Hotel Agent ←→ Weather Agent
              ↕              ↕
         Booking Agent ←→ (negociam entre si)

Exemplo prático:

"

Um agente de compras precisa de um agente de logística. Em vez de consultar um catálogo central, ele descobre outros agentes pela rede, verifica a identidade deles e negocia diretamente.

7. 🖥️ AG-UI - Agent-User Interaction Protocol (CopilotKit)

O que é: O protocolo que conecta agentes de IA à interface do usuário (o que você vê na tela). É a camada de "frontend" do mundo agentico.

Analogia: Se MCP conecta agente com ferramentas, e A2A conecta agentes entre si, o AG-UI conecta agentes com humanos - é a "janela" pela qual você interage.

A stack completa fica assim:

[Você, no navegador]
        ↕  AG-UI Protocol
[Interface React/Vue]
        ↕
[Google ADK + Modelos + Ferramentas]
        ↕  A2A
[Remote Agents]

Exemplo prático:

"

Um chatbot de suporte no seu banco:

• Você digita uma mensagem (AG-UI captura)
• O agente processa e chama outros agentes (A2A)
• A resposta volta e é exibida em tempo real na tela (AG-UI renderiza)
• Você vê indicadores de "digitando...", cards interativos, botões de ação

🗺️ Visão Geral: Qual protocolo usar quando?

┌─────────────────────────────────────────────────────┐
│                    USUÁRIO                          │
└──────────────────────┬──────────────────────────────┘
                       │ AG-UI
┌──────────────────────▼──────────────────────────────┐
│              AGENTE PRINCIPAL                       │
│                                                     │
│  MCP → conecta com ferramentas (APIs, DBs, Slack)  │
│  A2A → fala com outros agentes                     │
│  ACP → delega tarefas assíncronas                  │
│  SLIM → comunicação em tempo real                  │
└──────────────────────────────────────────────────────┘
                       │ A2A / ACP / SLIM
┌──────────────────────▼──────────────────────────────┐
│         AGENTES ESPECIALIZADOS                      │
│  (Agente de clima, de pagamento, de busca, etc.)    │
└──────────────────────────────────────────────────────┘

Tabela resumo:

🛠️ Por onde começar na prática?

Se você está iniciando, siga esta ordem:

Passo 1: Entenda o MCP

É um dos protocolos com maior tração atual no ecossistema Anthropic. Comece instalando o Claude Desktop e conectando uma ferramenta simples.

# Exemplo conceitual de um servidor MCP simples
from mcp import MCPServer

server = MCPServer()

@server.tool("buscar_clima")
def buscar_clima(cidade: str) -> str:
    # Aqui você chamaria uma API de clima
    return f"Clima em {cidade}: 25°C, ensolarado"

Passo 2: Experimente o LangChain com Agentes

LangChain já implementa conceitos de MCP e A2A de forma acessível.

from langchain.agents import create_react_agent
from langchain.tools import Tool

# Ferramenta simples
def calcular(expressao: str) -> str:
    return str(eval(expressao))

tools = [Tool(name="Calculadora", func=calcular, description="Calcula expressões matemáticas")]

# O agente decide quando e como usar a ferramenta
agent = create_react_agent(llm=seu_modelo, tools=tools)
agent.invoke({"input": "Quanto é 15% de 2500?"})

Passo 3: Explore o CrewAI para múltiplos agentes

CrewAI implementa comunicação A2A de forma intuitiva.

from crewai import Agent, Task, Crew

# Dois agentes especializados
pesquisador = Agent(role="Pesquisador", goal="Encontrar informações precisas")
escritor = Agent(role="Escritor", goal="Transformar pesquisa em texto claro")

# Eles colaboram automaticamente
crew = Crew(agents=[pesquisador, escritor], tasks=[...])
resultado = crew.kickoff()

💡 Conceitos que você precisa conhecer

Antes de se aprofundar, certifique-se de entender estes termos:

🎯 Resumo Final

Os protocolos de AI Agents resolvem o maior problema dos sistemas multi-agente: a comunicação.

Pense assim:

"

🔌 MCP = Como o agente usa ferramentas

🤝 A2A = Como agentes falam entre si

⚡ SLIM = Como falam muito rápido

📡 ACP = Como delegam tarefas de forma organizada

🗣️ Agora = Como criam regras de comunicação dinamicamente

🌐 ANP = Como se encontram sem um servidor central

🖥️ AG-UI = Como chegam até você, na interface

O futuro é um ecossistema onde agentes de diferentes empresas, com diferentes habilidades, colaboram de forma fluida - como uma equipe humana bem coordenada.

E esses protocolos são a linguagem que permite isso.

Guia criado para iniciantes em AI Agents - baseado no artigo de Rakesh Gohel sobre os 7 principais protocolos de comunicação para agentes de IA.

🏗️ Indo Além - Para Quem Quer Construir em Produção

"

⚠️ Esta seção é para devs que já entenderam o básico e querem pensar como engenheiros de sistema. Se você está começando, pode pular por agora e voltar quando sentir necessidade.

Os três blocos abaixo são o que separa "entendo o que são agentes" de "sei construir agentes em produção".

🔐 Bloco 1 - Governança e Segurança

Em um sistema com múltiplos agentes se comunicando, surgem perguntas críticas que os protocolos precisam responder.

Autenticação: Quem garante que o agente B que está respondendo é realmente quem diz ser? Sem autenticação, um agente malicioso pode se passar por um agente legítimo e injetar respostas falsas na cadeia.

Controle de permissões: Um agente de atendimento ao cliente não deveria ter acesso ao banco de dados financeiro. Cada agente precisa de um escopo de permissões bem definido - princípio do menor privilégio, assim como em qualquer sistema seguro.

Rate limiting e tool abuse: Cada chamada a uma ferramenta tem custo (financeiro e de latência). Um agente em loop pode chamar uma API milhares de vezes em segundos. Sem rate limiting, isso gera custo explosivo ou derruba o sistema downstream.

Como cada protocolo aborda segurança:

"

💡 Na prática: Antes de colocar qualquer sistema multi-agente em produção, defina: quem pode chamar quem, com quais permissões e com qual limite de chamadas. Isso não é opcional.

⚡ Bloco 2 - Latência e Custo

Este é o trade-off mais ignorado por quem está aprendendo - e o mais sentido em produção.

Cada camada adiciona latência:

Usuário → Agente Principal → [A2A] → Agente B → [MCP] → Ferramenta externa
         ~50ms              ~100ms            ~200ms (API externa)
                     Total: ~350ms+ por ciclo de decisão

Se o agente precisar de 5 ciclos para concluir uma tarefa, são ~1.75 segundos só de overhead de protocolo - antes de qualquer processamento do LLM.

Cada chamada ao LLM tem custo de tokens:

Síncrono vs Assíncrono - impacto no UX:

• Síncrono (SLIM, A2A streaming): Usuário vê a resposta chegando em tempo real. Melhor UX, mas mais complexo de implementar e depurar.
• Assíncrono (ACP): Tarefa é enviada, resultado chega depois. Melhor para processamentos longos, mas exige polling ou webhooks para notificar o usuário.

"

💡 Na prática: Meça latência end-to-end antes de escolher o protocolo. Para UX conversacional, priorize streaming. Para processamento em lote, priorize assíncrono. Para tarefas críticas de custo, limite o número máximo de ciclos do agente.

🔄 Bloco 3 - Estado e Consistência

Em sistemas com um único agente, o estado é simples. Com múltiplos agentes concorrentes, surgem os problemas clássicos de sistemas distribuídos.

Quem é a fonte da verdade?

Se o Agente A e o Agente B leem o mesmo registro, modificam e tentam escrever ao mesmo tempo - qual versão prevalece? Sem uma estratégia de estado, você tem race conditions - os mesmos problemas de banco de dados distribuído, agora no nível de agentes.

Padrões para gerenciar estado:

Padrão 1 - Estado Centralizado
  Todos os agentes leem/escrevem em um store central (Redis, banco de dados)
  ✅ Simples de entender
  ❌ Gargalo e ponto único de falha

Padrão 2 - Agente Orquestrador
  Um agente "mestre" gerencia o estado e delega para os outros
  ✅ Controle claro, fácil de auditar
  ❌ O orquestrador vira gargalo em alta escala

Padrão 3 - Event Sourcing
  Agentes publicam eventos; o estado é reconstruído a partir do histórico
  ✅ Auditável, resiliente, escalável
  ❌ Complexidade maior de implementação

Coordenação de agentes concorrentes:

Quando dois agentes trabalham na mesma tarefa em paralelo, você precisa decidir: como dividir o trabalho sem duplicação? Como reunir os resultados parciais (fan-out / fan-in)? O que acontece se um agente falha no meio da execução?

"

💡 Na prática: Para sistemas simples, comece com um orquestrador central. Só migre para event sourcing quando a escala exigir - a complexidade não vale antes disso. E sempre defina o comportamento de falha de cada agente antes de ir para produção.

📊 Para qual público este guia se aplica?

O objetivo principal deste documento é o iniciante. Os blocos avançados existem para mostrar o caminho - não para ensinar tudo de uma vez.