MODULO 1.5

πŸ“‘ Comunicacao entre Agentes

Como agentes trocam informacao, transferem controle e evitam conflitos β€” dos handoffs simples aos protocolos emergentes MCP, A2A e ACP.

6
Topicos
35
Minutos
Interm.
Nivel
Teoria
Tipo
1

πŸ“‘ Por que comunicacao importa

Um swarm sem comunicacao eficaz e apenas um grupo de agentes independentes trabalhando no escuro. Imagine uma equipe de cirurgia onde o anestesista nao fala com o cirurgiao, ou uma orquestra onde cada musico toca no seu proprio tempo. O resultado seria catastrofico. Em sistemas multiagentes, a comunicacao e o tecido conectivo que transforma agentes isolados em uma equipe coordenada capaz de resolver problemas complexos.

Sem mecanismos de comunicacao bem definidos, agentes caem em tres armadilhas classicas: duplicacao de trabalho (dois agentes fazendo a mesma coisa), conflitos de escrita (dois agentes editando o mesmo arquivo simultaneamente) e inconsistencia de estado (um agente tomando decisoes baseadas em informacoes desatualizadas). Cada uma dessas falhas pode comprometer todo o swarm, e a solucao passa por protocolos claros de coordenacao e sincronizacao.

πŸ’‘ Conceito Fundamental

A comunicacao entre agentes resolve tres problemas criticos de qualquer sistema distribuido:

  • β€’ Coordenacao: Quem faz o que, quando e em que ordem β€” evita duplicacao e garante cobertura completa da tarefa
  • β€’ Sincronizacao: Garantir que agentes que dependem do resultado de outros esperem antes de comecar β€” evita trabalho sobre dados incompletos
  • β€’ Evitar conflitos: Mecanismos que impedem dois agentes de modificar o mesmo recurso ao mesmo tempo β€” evita corrupcao de dados
  • β€’ Propagacao de contexto: Informacoes descobertas por um agente (ex: Explorer) precisam chegar a quem vai usa-las (ex: Coder)

πŸ“Š Impacto na pratica

  • Sem coordenacao: Agentes paralelos frequentemente geram conflitos de merge em 40-60% das execucoes, exigindo intervencao manual
  • Com coordenacao basica: Zonas seguras e handoffs reduzem conflitos para menos de 5%
  • Sincronizacao importa: Um agente de testes que roda antes do codigo estar pronto desperdiΓ§a tokens e gera falsos negativos
  • Contexto propagado: Quando o Explorer compartilha descobertas com o Coder, a taxa de acerto na primeira tentativa sobe de 35% para 72%
2

πŸ”„ Handoffs: passando o bastao

O handoff e o mecanismo mais simples e eficaz de comunicacao entre agentes. Funciona como uma corrida de revezamento: um agente completa sua etapa, empacota o resultado e transfere o controle para o proximo agente da cadeia. O agente que recebe o bastao herda todo o contexto necessario para continuar o trabalho β€” sem precisar "perguntar" o que aconteceu antes.

O framework OpenAI Swarm popularizou este padrao com sua funcao transfer_to_agent(). Quando um agente de triagem identifica que o usuario precisa de suporte tecnico, ele chama transfer_to_tech_support(), e o controle da conversa passa imediatamente para o agente especializado. As context variables β€” um dicionario compartilhado β€” permitem que o agente receptor acesse informacoes como nome do usuario, historico de compras ou codigo do erro, sem que nada se perca na transicao.

πŸ’‘ Anatomia de um Handoff

Cada handoff envolve tres componentes essenciais:

  • β€’ Transferencia de controle: O agente atual para de processar e o proximo agente assume β€” nao ha dois agentes ativos ao mesmo tempo no mesmo fluxo
  • β€’ Context variables: Dicionario de dados compartilhado entre todos os agentes β€” informacoes persistem ao longo de toda a cadeia de handoffs
  • β€’ Decisao inteligente: O agente decide para quem transferir com base no conteudo da conversa β€” nao e um roteamento fixo, e uma decisao contextual
  • β€’ Exemplo OpenAI Swarm: Agente Triage analisa pedido β†’ decide que e suporte β†’ chama transfer_to_support() β†’ agente Support assume com todo o contexto

πŸ“Š Handoffs na pratica

  • Pipeline sequencial: Explorer β†’ SME β†’ Architect β†’ Coder β€” cada transicao e um handoff com contexto acumulado
  • Atendimento ao cliente: Triage β†’ Vendas ou Triage β†’ Suporte β€” routing baseado na intencao do usuario
  • Vantagem principal: Zero race conditions β€” apenas um agente esta ativo por vez, eliminando conflitos de escrita
  • Limitacao: Handoffs sao sequenciais por natureza β€” para paralelismo, sao necessarios mecanismos adicionais
3

πŸ“‹ Estado compartilhado

Enquanto handoffs funcionam bem para pipelines sequenciais, swarms mais complexos precisam de um mecanismo mais robusto: o estado compartilhado. Em vez de passar informacoes diretamente de agente para agente, todos os agentes leem e escrevem em um repositorio central de estado β€” como um quadro branco compartilhado que toda a equipe pode consultar e atualizar a qualquer momento.

Na pratica, o estado compartilhado frequentemente vive no sistema de arquivos. O opencode-swarm usa um diretorio .swarm/ que funciona como uma maquina de estados persistente. Dentro dele, arquivos como plan.md registram o plano de execucao, evidence.md guarda descobertas dos agentes exploradores, e state.json rastreia em que etapa cada tarefa esta. Quando o Coder precisa saber o que o Architect decidiu, ele simplesmente le o plano. Quando o Reviewer termina, ele atualiza o estado da tarefa para "reviewed".

πŸ’‘ Componentes do Estado Compartilhado

Um sistema de estado bem projetado tem estas camadas:

  • β€’ State machine: Fluxo formal de estados (PLANNING β†’ CODING β†’ REVIEWING β†’ TESTING β†’ DONE) que governa transicoes permitidas
  • β€’ Diretorio .swarm/: Armazenamento persistente em disco β€” plan.md, evidence.md, decisions.md, state.json β€” sobrevive a reinicializacoes
  • β€’ Plan.md como contrato: O plano escrito e a "fonte de verdade" β€” todos os agentes se referem a ele para saber o que fazer e o que ja foi feito
  • β€’ Versionamento implicito: Como tudo esta em arquivos, o git pode rastrear cada mudanca de estado β€” auditoria gratuita

πŸ“Š Estado compartilhado vs context variables

  • Context variables (Swarm): Dicionario em memoria, simples, perde-se ao encerrar β€” ideal para swarms de sessao unica
  • Estado em arquivo (.swarm/): Persistente em disco, auditavel, sobrevive a falhas β€” ideal para swarms de longa duracao
  • Estado em banco de dados: Escalavel, consultas complexas, compartilhavel entre maquinas β€” ideal para swarms enterprise
  • Melhor pratica: Comece com arquivos (simples e transparente), migre para banco so quando a complexidade exigir
4

πŸ”’ Zonas seguras: evitar interferencia

Quando multiplos agentes trabalham em paralelo, o risco de conflitos de escrita e real e perigoso. Imagine dois agentes editando o mesmo arquivo ao mesmo tempo: o Agente A adiciona uma funcao na linha 50, enquanto o Agente B refatora a linha 48. Quando ambos tentam salvar, um dos trabalhos e sobrescrito. Esse problema classico de sistemas distribuidos β€” conhecido como race condition β€” exige solucoes arquiteturais especificas.

O oh-my-openagent resolve isso com o conceito de zonas seguras (safe zones). Cada agente recebe uma area exclusiva de trabalho β€” arquivos ou diretorios especificos onde apenas ele pode escrever. Adicionalmente, o sistema usa um mecanismo engenhoso de hash unico por linha: cada linha editada recebe um identificador que permite detectar e resolver conflitos automaticamente quando dois agentes tocam regioes proximas do mesmo arquivo.

πŸ’‘ Estrategias de Isolamento

Tres abordagens para evitar interferencia entre agentes paralelos:

  • β€’ File locking: Um agente "trava" o arquivo antes de editar e "destrava" ao terminar β€” outros agentes esperam na fila. Simples mas pode criar gargalos
  • β€’ Zonas exclusivas: Cada agente so pode escrever em arquivos/diretorios pre-definidos. Agente de frontend edita /src/components, agente de backend edita /src/api β€” sem sobreposicao
  • β€’ Hash unico por linha: Cada linha modificada recebe um hash identificador. Se dois agentes tocam a mesma regiao, o sistema detecta o conflito e aplica resolucao automatica
  • β€’ Branches isolados: Cada agente trabalha em um branch git separado, e o merge e feito pelo orquestrador ao final β€” maximo isolamento

πŸ“Š Resultados do hash checking

  • Sem hash checking: Taxa de sucesso de apenas 6% em tarefas paralelas complexas β€” conflitos constantes corrompem o resultado
  • Com hash checking: Taxa de sucesso sobe para 68.3% β€” o sistema detecta e resolve conflitos automaticamente
  • Zonas exclusivas: Eliminam 100% dos conflitos de escrita, mas limitam a flexibilidade β€” melhor para projetos com fronteiras claras entre modulos
  • Abordagem hibrida: Zonas exclusivas para a maioria + hash checking para areas compartilhadas = melhor relacao seguranca/flexibilidade
5

πŸ“¨ Protocolos emergentes: MCP, A2A, ACP

Ate recentemente, cada framework de agentes inventava sua propria forma de comunicacao β€” criando silos incompativeis. Em 2025-2026, tres protocolos emergentes comecaram a padronizar como agentes se comunicam, acessam ferramentas e interoperam entre plataformas diferentes. Juntos, eles formam a infraestrutura de comunicacao da era agentica, e entende-los e fundamental para construir swarms que nao fiquem presos a um unico ecossistema.

Os tres protocolos resolvem problemas complementares: o MCP (Model Context Protocol) da Anthropic padroniza como agentes acessam ferramentas e dados externos. O A2A (Agent-to-Agent) do Google padroniza como agentes de diferentes plataformas se comunicam diretamente. E o ACP (Agent Communication Protocol) da IBM padroniza dialogos estruturados entre agentes com contratos formais. Nenhum deles substitui os outros β€” eles se complementam em camadas diferentes do stack de comunicacao.

πŸ’‘ Os Tres Protocolos

Cada protocolo atua em uma camada diferente da comunicacao agentica:

  • β€’ MCP (Anthropic) β€” Agente ↔ Ferramentas: Padroniza como agentes descobrem e usam ferramentas externas (APIs, bancos de dados, sistemas de arquivos). Pense como "USB-C para agentes" β€” conecte qualquer ferramenta a qualquer agente
  • β€’ A2A (Google) β€” Agente ↔ Agente: Padroniza comunicacao direta entre agentes de plataformas diferentes. Um agente CrewAI pode delegar para um agente LangGraph sem adaptadores customizados. Agora sob governanca da Linux Foundation
  • β€’ ACP (IBM) β€” Dialogo estruturado: Define contratos formais para conversas entre agentes β€” schemas de entrada/saida, capacidades declaradas, negociacao de tarefas. Foco em ambientes enterprise com compliance

πŸ“Š Adocao e maturidade

  • MCP: Mais maduro β€” ja integrado nativamente em Claude Code, OpenCode, Cursor e dezenas de IDEs. Ecossistema de servidores MCP crescendo rapidamente
  • A2A: Em adocao acelerada β€” Google, Salesforce, SAP e outros grandes players ja implementam. Transferido para a Linux Foundation para governanca neutra
  • ACP: Mais recente β€” foco enterprise com IBM liderando. Forte em cenarios regulados (financas, saude) que exigem contratos formais
  • Tendencia: A industria caminha para usar os tres juntos β€” MCP para ferramentas, A2A para interoperabilidade, ACP para compliance
6

πŸ“Š Feedback e auto-correcao

A comunicacao nao e apenas "para frente" β€” a capacidade de um swarm dar feedback para tras e se autocorrigir e o que separa sistemas amadores de sistemas de producao. Em um pipeline rigido, se o Coder produz codigo com bug, o Tester detecta a falha mas nao tem como pedir uma correcao β€” o resultado ruim simplesmente e entregue. Em um swarm com feedback loop, o Tester envia o resultado de volta ao Coder com instrucoes especificas de correcao, e o ciclo se repete ate atingir o padrao de qualidade.

O padrao maker-checker e a implementacao mais comum: um agente "faz" (maker) e outro "verifica" (checker). Se a verificacao falha, o resultado volta ao maker com feedback detalhado. Este loop pode ter limites configurados (maximo de 3 tentativas, por exemplo) para evitar loops infinitos. No opencode-swarm, os quality gates automatizam este processo com 6 verificacoes sequenciais β€” se qualquer gate falha, o agente responsavel recebe feedback especifico e tenta novamente.

πŸ’‘ Mecanismos de Auto-correcao

Tres niveis de feedback em swarms, do mais simples ao mais sofisticado:

  • β€’ Feedback loop basico: Resultado do Checker volta ao Maker com erro descrito β†’ Maker corrige β†’ Checker verifica novamente. Maximo N tentativas
  • β€’ Maker-Checker com modelos diferentes: O Maker usa Claude, o Checker usa GPT (ou vice-versa) β€” modelos diferentes capturam erros que o mesmo modelo ignoraria (anti-blindspot)
  • β€’ Quality gates automatizados: Verificacoes programaticas (nao-LLM) como linting, testes unitarios, analise SAST β€” feedback objetivo e determinΓ­stico
  • β€’ Escalacao ao orquestrador: Se o loop maker-checker esgota tentativas, o orquestrador e notificado e pode tomar decisoes mais amplas (trocar agente, mudar estrategia)

πŸ“Š Impacto do feedback

  • Sem feedback: Primeira versao do codigo aceita como final β€” taxa de bugs em producao alta, correcoes manuais constantes
  • Com 1 ciclo de feedback: Agente revisor identifica problemas e o coder corrige β€” reducao de 60% em bugs
  • Com quality gates: 6 verificacoes automaticas garantem qualidade minima antes de aceitar β€” bugs residuais caem para menos de 5%
  • Limite pratico: Mais de 3 ciclos de feedback geralmente indica que o prompt ou a tarefa precisa ser reformulada, nao que mais tentativas resolverao

πŸ“š Resumo do Modulo

βœ“
Comunicacao e essencial - Coordenacao, sincronizacao e prevencao de conflitos sao os tres pilares
βœ“
Handoffs - Transferencia de controle com context variables β€” simples, eficaz, zero race conditions
βœ“
Estado compartilhado - Diretorio .swarm/, plan.md e state machine para persistencia e coordenacao
βœ“
Zonas seguras - File locking, zonas exclusivas e hash unico por linha evitam conflitos
βœ“
Protocolos MCP/A2A/ACP - Tres padroes complementares para ferramentas, interoperabilidade e compliance
βœ“
Feedback e auto-correcao - Loops maker-checker e quality gates garantem qualidade iterativa

Proximo Modulo:

1.6 - Modelos e Custos: estrategia inteligente