Multi-agente é tentador mas frequentemente injustificado. Aqui você aprende padrões reais (orquestrador-trabalhador, debate, blackboard), o que MCP traz, e — crucialmente — quando UM agente bem-feito bate três meia-bocas.
🎯 Default ao single agent
Multi-agente é uma promoção condicional do single agent — só compensa quando há benefício REAL (especialização, debate, paralelismo).
- •Tarefa cabe em 1 agente bem-feito? Use 1.
- •Especialização exige tools/contexto distintos? Orquestrador + trabalhadores.
- •Crítica adversarial valida raciocínio? Debate.
- •Trabalho paralelo independente? Blackboard.
- •Sempre: handoff explícito + tracing global.
💡 Comece com 1 agente, prove que precisa de mais
Antes de multi-agente, esgote single agent com bons tools e prompts. Multi-agente é resposta a problema medido, não default.
🎼 Orquestrador + trabalhadores especializados
O padrão mais comum
Padrão mais comum e útil: um orquestrador coordena trabalhadores especializados, cada um com prompt e tools focados. O orquestrador planeja e delega; os trabalhadores executam. Especialização vem do contexto restrito por agente.
exemplo: agente de pesquisa científica
- ▸Orquestrador: recebe query, decide quais especialistas chamar.
- ▸Trabalhador-busca: tools de retrieval (BM25, vetor, web).
- ▸Trabalhador-código: tools de execução de código sandboxed.
- ▸Trabalhador-redação: sumariza resultados em prosa final.
- ▸Handoff: orquestrador passa SUMÁRIO (não histórico) entre trabalhadores.
📑 Resumo navegável
💬 Debate: dois agentes argumentam
Du et al. 2023
Multi-agent debate (Du et al. 2023): dois agentes resolvem a mesma tarefa, comparam respostas e debatem discordâncias até convergir. Em raciocínio adversarial (matemática difícil, problemas com armadilhas), debate consistente bate single agent. Custo: 2-3× tokens — só vale a pena quando qualidade > custo.
def debate(query, agentes=2, rodadas=3):
respostas = [a.responder(query) for a in agentes]
for r in range(rodadas):
if all(r == respostas[0] for r in respostas):
return respostas[0] # consenso
for i, a in enumerate(agentes):
outras = [r for j, r in enumerate(respostas) if j != i]
respostas[i] = a.refinar(query, propria=respostas[i], outras=outras)
return respostas[0] # ou voting📑 Resumo navegável
🗂️ Blackboard: estado compartilhado
Memória comum
Blackboard architecture: agentes leem e escrevem em estado compartilhado, comunicação assíncrona. Para workflows longos com sub-tarefas paralelas, blackboard escala melhor que conversation. Implementação simples: dict thread-safe ou Redis.
blackboard = {'tarefas_abertas': [...], 'resultados': {}}
def trabalhador(nome: str, board: dict):
while board['tarefas_abertas']:
t = board['tarefas_abertas'].pop()
if t.assigned_to == nome:
board['resultados'][t.id] = executar(t)📑 Resumo navegável
🔌 MCP: Model Context Protocol
Anthropic 2024
MCP (Model Context Protocol, Anthropic 2024) padroniza integração de tools/resources com LLMs. Inspirado em LSP (do mundo de IDE): um servidor MCP serve tools que qualquer cliente compatível pode consumir. Padrão emergente; ecosistema ainda em crescimento.
vantagens do MCP
- ▸Tool reutilizável entre projetos (servidor único, vários clientes).
- ▸Padrão para resources (não só tools — também contexto stático).
- ▸Transports: stdio (local), SSE (rede), WebSocket.
- ▸Reduz lock-in: trocar de modelo não significa reescrever tools.
📑 Resumo navegável
🤝 Handoff: passar contexto entre agentes
Resumir + delegar
Quando agente A passa controle para agente B, NÃO passe histórico inteiro — passe sumário do estado relevante. Histórico cresce; lost-in-the-middle entra em jogo; custo escala. Handoff explícito mantém contexto enxuto e atenção alta no que importa.
def handoff(de_agente, para_agente, contexto):
sumario = de_agente.sumarizar(
f'Em 3 bullets, qual o estado atual e o que falta?\n'
f'Histórico: {contexto.historico}'
)
return para_agente.continuar(sumario, contexto.tarefa_pendente)📑 Resumo navegável
🚫 Quando UM agente é melhor
A maioria dos casos
Multi-agente é tentador mas frequentemente injustificado. Tarefa cabe em 1 agente bem-feito? Use 1. Multi adiciona handoff loss, custo extra e complexidade de tracing. Default ao single agent; promova a multi só com benefício medido (especialização, debate, paralelismo real).
| Sinal | 1 agente | Multi |
|---|---|---|
| Tarefa cabe em 1 contexto coerente | ✓ | ✗ overhead |
| Especializações distintas (busca + código + redação) | ? | ✓ orquestrador-trabalhador |
| Raciocínio adversarial crítico | ? | ✓ debate (custo 2-3×) |
| Volume alto / latência baixa | ✓ | ✗ multiplica round-trips |
📑 Resumo navegável
📑 Resumo navegável dos tópicos
1 🎼 Orquestrador + trabalhadores especializados — O padrão mais comum
2 💬 Debate: dois agentes argumentam — Du et al. 2023
3 🗂️ Blackboard: estado compartilhado — Memória comum
4 🔌 MCP: Model Context Protocol — Anthropic 2024
5 🤝 Handoff: passar contexto entre agentes — Resumir + delegar
6 🚫 Quando UM agente é melhor — A maioria dos casos
✓ O que FAZER
- ✓Tracing global atravessa todos os agentes
- ✓Handoff com sumário explícito
- ✓Comparação de custo single vs multi no harness
- ✓MCP server para tools reusáveis
✗ O que NÃO fazer
- ✗Tracing isolado por agente
- ✗Passar histórico inteiro entre agentes
- ✗Adotar multi por inércia
- ✗Reimplementar tools em cada agente
🚫 Quando NÃO usar
- •Tarefa cabe em single agent: multi adiciona overhead sem ganho.
- •Latência crítica: cada agente é roundtrip; multi multiplica.
- •Sem tracing global: debug em multi-agente sem trace é desastre.
💻 Exemplo de código
# Padrão orquestrador + trabalhadores (esquemático)
def orquestrador(query: str) -> str:
plano = llm_planejar(query) # decompõe em sub-tarefas
resultados = []
for tarefa in plano:
if tarefa.tipo == "busca":
r = trabalhador_busca(tarefa.descricao)
elif tarefa.tipo == "código":
r = trabalhador_codigo(tarefa.descricao)
# ... outros especialistas
resultados.append({"tarefa": tarefa, "resultado": r.summary}) # handoff = sumário
return llm_consolidar(query, resultados)🏋️ Exercício hands-on
Compare single agent vs orquestrador+trabalhadores em uma tarefa multi-domínio. Tabela com custo, latência, qualidade. Justifique a escolha. Em projetos/post-launch/P3/.
📚 Bibliografia
- Du et al. (2023) — Improving Factuality and Reasoning via Multi-Agent Debate
- Anthropic (2024) — Model Context Protocol
- Park et al. (2023) — Generative Agents
- Hong et al. (2023) — MetaGPT
🎯 Resumo do Módulo
- ✓Default ao single agent — multi exige justificativa medida.
- ✓Orquestrador-trabalhador é o padrão mais útil.
- ✓Debate bate single em raciocínio adversarial (custo 2-3×).
- ✓MCP padroniza integração de tools/resources.
- ✓Handoff = sumário, não histórico inteiro.
Próximo Módulo:
T5 — Memória e Compressão