Conteúdo
Depois de ter assimilado o conceito de "coordenar várias IAs" em O que é um sistema multi-agente?, a próxima pergunta é como construir um de verdade. Este artigo percorre um processo prático de 5 passos para iniciantes, usando o padrão de fato de 2026: o padrão supervisor.
Antes de qualquer conversa sobre framework, eis o princípio mais importante: "construa primeiro com um único agente e só adicione mais — de forma mínima — quando bater num limite." Partir para multi desde o início costuma ser sobre-engenharia. O código é mostrado como pseudocódigo independente de framework, então ele se aplica quer você use MCP ou qualquer SDK.
Construa pequeno, meça e depois acrescente
— O padrão supervisor, a partir de uma configuração mínima
* Os passos e dados deste artigo são citados de materiais públicos, guias de profissionais e relatórios de pesquisa (referência: junho de 2026). O código é pseudocódigo conceitual; consulte a documentação oficial de cada framework para a API real.
1. Antes de construir: você realmente precisa de multi?
O primeiro filtro não é técnico — é uma decisão de julgamento. Multi-agente é poderoso, mas ~80% dos casos de uso ficam bem com um único agente. Se nenhum dos pontos a seguir se aplica, construa primeiro com um único agente.
3 sinais de que você deve ir para multi
- Separação de especialidades: o conhecimento não cabe em um único prompt (os domínios abrangem pesquisa, jurídico, código etc.)
- Paralelismo: fazer várias tarefas ao mesmo tempo é claramente mais rápido
- Separação de decisão: a qualidade melhora quando você separa "executor" e "verificador"
Por outro lado, usar multi para um processo simples e linear — como vimos da última vez — infla o custo de 3-10x e, na verdade, reduz a precisão em tarefas sequenciais (uma pesquisa do Google relata −39-70% em relação a um único agente). Parta da premissa de que "mais agentes não significa mais inteligente".
2. A forma básica: supervisor (o padrão de 2026)
Se você não tem certeza de qual padrão construir, vá de padrão supervisor, ponto final. Subagentes do Claude Code, LangGraph Supervisor, handoffs do OpenAI Agents SDK — as principais implementações convergiram todas para essa forma. As razões são claras.
Suporte mais amplo de frameworks
Suporte nativo nos principais frameworks. Muitas implementações de referência.
Modo de falha conhecido
A principal falha é a "delegação excessiva", limitada por um teto de iterações.
Fácil de auditar
"Quem fez o quê" fica claro, o que facilita a depuração.
A mecânica é simples. O supervisor recebe a tarefa global, divide-a em subtarefas, delega-as a workers especialistas e agrega os resultados. O supervisor não precisa saber como um worker faz seu trabalho — apenas qual worker chamar e em que formato de saída. A expertise vive nos workers.
3. Construa em 5 passos
Monte uma configuração mínima de supervisor em cinco passos. A regra prática: comece com 2-3 workers e só acrescente mais à medida que a medição justificar.
PASSO 1. Decomponha a tarefa
Escreva o "objetivo final" e os "papéis de especialista" necessários. Exemplo: para um relatório de pesquisa de mercado, "1) coletar informações → 2) analisar → 3) redigir → 4) checar fatos". Decomponha com clareza desde o início — vagueza aqui derruba o conjunto todo.
PASSO 2. Defina os workers (até 3-5)
Dê a cada worker um papel, as ferramentas de que ele precisa e um formato de saída. Não seja ganancioso no começo — no máximo 3-5. Cada worker é independente e mantém apenas suas próprias ferramentas (busca, execução de código etc.).
PASSO 3. Projete o supervisor
No prompt do supervisor, liste explicitamente os nomes dos workers que ele pode chamar (um limite rígido). O truque: gaste mais tempo no supervisor do que em qualquer worker individual. Isso determina a qualidade geral.
PASSO 4. Decida o handoff e o compartilhamento de contexto
Defina o que é passado entre os workers e em que formato. Passar o contexto completo para todos infla os tokens, então passe apenas a informação necessária. O protocolo padrão para coordenação entre agentes é o A2A.
PASSO 5. Meça e opere com limites
Instrumente cada handoff antes de adicionar agentes (observabilidade não é opcional). Defina limites de iterações, tokens e custo. Configure evals e guardrails ao mesmo tempo.
4. Exemplo mínimo de código (pseudocódigo)
A essência do padrão supervisor é surpreendentemente curta. Eis um pseudocódigo independente de framework mostrando o loop em que o supervisor escolhe um worker e o executa (consulte a documentação oficial de cada SDK para a API real).
# Define os workers: um papel + ferramentas dedicadas
workers = {
"researcher": Agent(tools=[web_search]),
"writer": Agent(tools=[]),
"factcheck": Agent(tools=[web_search]),
}
# Supervisor: limite rígido nos nomes dos workers que pode chamar
supervisor = Agent(
instructions="Decompose the goal and pick one worker to call next. "
"Return 'DONE' when finished.",
allowed_workers=["researcher", "writer", "factcheck"],
)
# Loop de execução (um teto de iterações evita a delegação excessiva)
state = {"goal": "Write an AI market report", "history": []}
for step in range(MAX_STEPS): # <- um limite é essencial
next_worker = supervisor.decide(state)
if next_worker == "DONE":
break
result = workers[next_worker].run(state)
state["history"].append({next_worker: result}) # compartilha só o contexto necessário
log_handoff(next_worker, result) # <- instrumenta cada handoffTrês lições: 1) cada worker é um papel + ferramentas dedicadas, 2) o conjunto que o supervisor pode chamar é limitado, 3) o loop sempre tem um teto de iterações. Acrescente medição, guardrails e evals sobre esse esqueleto e você se aproxima da qualidade de produção. Os subagentes do Claude Agent SDK e do Claude Code seguem a mesma ideia.
5. Armadilhas comuns e soluções
Os pontos em que as pessoas tropeçam no desenvolvimento multi-agente são bastante previsíveis. Antecipe-se a eles.
| Armadilha | Solução |
|---|---|
| Delegação excessiva (o supervisor entra em loop infinito) | Teto de iterações + limitar os workers que podem ser chamados |
| Inchaço de tokens (custo 3-10x) | Pare de compartilhar o contexto completo; passe só o necessário + cache |
| Comportamento instável e não determinístico | Mantenha poucos workers (3-5) + fixe os formatos de saída |
| Queda de precisão em tarefas sequenciais (−39-70%) | Volte a um único agente para trabalho linear |
| Não dá para saber onde falhou | Instrumente cada handoff antes de escalar (observabilidade) |
A lição compartilhada: "os prompts, o design das ferramentas e o harness de eval decidem o sucesso mais do que o framework." Acima de uma arquitetura chamativa, a disciplina de construir pequeno, medir e adicionar apenas quando compensa é o que sai mais rápido no fim.
Resumo
Construir um sistema multi-agente não é assustador se você começar com o padrão supervisor a partir de uma configuração mínima. Vamos recapitular.
Pontos-chave
- 🚦 Único primeiro. Adicione agentes só depois que aparecerem sinais de especialização / paralelismo / separação de decisão.
- 🧠 A forma básica é o supervisor (padrão de 2026). Gaste o máximo de tempo no design do supervisor.
- 🔢 5 passos: decompor → definir workers (3-5) → projetar supervisor → handoff → medir.
- ⚠️ Armadilhas: delegação excessiva, inchaço de tokens, instabilidade. Resolva com limites, compartilhamento só do necessário e medição.
- 📏 Disciplina: prompts, ferramentas e evals decidem o sucesso mais do que o framework.
"Construa pequeno, meça e depois acrescente." Mantenha essa disciplina e um sistema multi-agente se torna um parceiro poderoso para trabalhos complexos. Para o conceito, veja O que é um sistema multi-agente?; para construir um único, Como construir um agente de IA.
FAQ
Q. Qual padrão devo construir primeiro?
A. O padrão supervisor, sem dúvida. Os principais frameworks o suportam, seu modo de falha é conhecido e as implementações de referência são as mais abundantes. Explore outros padrões quando estiver confortável.
Q. Com quantos workers devo começar?
A. Comece com 2-3 e mantenha no máximo 3-5. Quanto mais você adiciona, mais instável fica e mais os tokens disparam. A norma é acrescentar mais apenas quando a medição comprova a necessidade.
Q. É preciso usar um framework?
A. Não é obrigatório. Como mostra o pseudocódigo, um loop mais prompts já constroem uma configuração mínima. Mas se você precisa de persistência de estado, observabilidade e recuperação em produção, um framework de apoio é um atalho.
Q. Como evito explosões de custo?
A. Três coisas ajudam: 1) limitar a contagem de iterações, 2) compartilhar apenas o contexto necessário em vez do todo e 3) usar cache de prompt. Ir para multi pode custar 3-10x um único agente, então limites são essenciais desde o primeiro dia.
