Phase 16 - Lesson 05

Padrão Supervisor / Orquestrador-Trabalhador

Um agente líder planeja e delega; trabalhadores especializados executam em contextos paralelos e reportam de volta. Este é o padrão por trás do sistema de Pesquisa (Research) da Anthropic (Claude Opus 4 como líder, Sonnet 4 como subagentes), medido em +90.2% em relação a um único agente Opus 4 em avaliações de pesquisa internas. O post de engenharia da Anthropic relata que 80% da variância no BrowseComp é explicada apenas pelo uso de tokens — multiagentes vencem em grande parte porque cada subagente recebe uma nova janela de contexto. Esta lição constrói o padrão supervisor a partir das primitivas e cobre as lições de engenharia de 2026 de implantações em produção.

Tipo: Aprender + Construir Linguagens: Python (stdlib, threading) Pré-requisitos: Fase 16 · 04 (Modelo Primitivo) Tempo: ~75 minutos

O Problema

A pesquisa é a tarefa arquetípica na qual os sistemas de agente único falham. Você pergunta "o que mudou nos sistemas multiagentes entre 2023 e 2026?" Um único agente lê cinco artigos sequencialmente, preenche metade do seu contexto com o texto deles e depois precisa raciocinar sobre todos eles juntos. Ele se esquece do primeiro artigo quando chega ao quinto. Ele não consegue paralelizar.

O padrão supervisor corrige isso: um agente líder planeja a busca, delega cada subpergunta a um trabalhador e faz a síntese. Cada trabalhador recebe sua própria janela de 200k tokens para uma pergunta delimitada. O líder nunca vê os artigos originais — apenas os resumos dos trabalhadores.

O sistema de Pesquisa em produção da Anthropic relata +90.2% em avaliações de pesquisa internas versus um único Opus 4. O mesmo post observa que 80% da variância do BrowseComp é explicada apenas pelo uso de tokens. Um contexto limpo por subagente é o principal mecanismo.

Conceito

O padrão

                 ┌──────────────┐
                 │   Lead       │  plans, decomposes,
                 │  (Opus 4)    │  synthesizes
                 └──┬────┬───┬──┘
                    │    │   │
            ┌───────┘    │   └───────┐
            ▼            ▼           ▼
      ┌─────────┐  ┌─────────┐  ┌─────────┐
      │ Worker1 │  │ Worker2 │  │ Worker3 │
      │(Sonnet) │  │(Sonnet) │  │(Sonnet) │
      └─────────┘  └─────────┘  └─────────┘
         fresh       fresh        fresh
         context     context      context

O líder nunca lê os materiais brutos. Os trabalhadores nunca veem o trabalho uns dos outros até que o líder faça a síntese. Cada seta representa uma entrega (handoff) com um artefato delimitado.

Por que ele vence

Três mecanismos:

1. Contexto limpo por subagente. Um trabalhador explorando "FIPA-ACL heritage" não carrega os 40k tokens que o líder gastou no planejamento. Ele recebe uma janela de 200k para uma única pergunta.
2. Especialização via prompt. O prompt do líder é "decompor e sintetizar", não "pesquisar". O prompt de cada trabalhador é específico: "encontrar o que mudou em X". Prompts focados produzem saídas focadas.
3. Paralelismo. Os trabalhadores executam de forma concorrente. O tempo de execução total (tempo de relógio) é de aproximadamente max(worker_times) + plan + synthesis, não sum(worker_times).

Lições de engenharia (Anthropic 2025)

O post da Anthropic lista várias lições de produção que ainda são relevantes em 2026:

• Escalar o esforço de acordo com a complexidade da consulta. Consultas simples: um agente, 3-10 chamadas de ferramentas. Consultas complexas: mais de 10 agentes. O líder deve estimar isso, não o chamador.
• Amplo e depois estreito. Decompõe primeiro em subperguntas amplas e, em seguida, inicia mais trabalhadores por subpergunta se a resposta exigir profundidade.
• Implantações arco-íris (Rainbow deployments). Agentes são de longa duração e possuem estado. O modelo tradicional azul-verde (blue-green) não funciona. A Anthropic usa o modelo arco-íris: implantação gradual de novas versões enquanto as antigas são drenadas.
• O uso de tokens domina. Multiagente consome cerca de 15× mais tokens do que um agente único. Execute-o apenas quando o valor da tarefa justificar o custo.

A mudança do LangGraph

O LangGraph originalmente distribuía uma biblioteca langgraph-supervisor com um assistente de alto nível create_supervisor. Em 2025, a LangChain mudou a recomendação para implementar o padrão supervisor diretamente via chamada de ferramentas (tool-calling), porque as chamadas de ferramentas dão mais controle sobre o que o supervisor vê (engenharia de contexto). A biblioteca ainda funciona; a documentação agora recomenda a forma de chamada de ferramentas.

Modos de falha

• O líder alucina o plano. Se o líder gerar subperguntas que não decompõem a questão real, os trabalhadores farão pesquisas precisas no alvo errado.
• Os trabalhadores exploram além do limite. Sem limites explícitos de escopo, os trabalhadores desviam-se de sua subpergunta atribuída e poluem a etapa de síntese.
• Conflitos de síntese. Dois trabalhadores retornam fatos contraditórios. O líder deve pedir novamente (adicionar uma rodada) ou registrar o desentendimento explicitamente. Escolher silenciosamente um dos lados é a pior falha: o usuário nunca fica sabendo que houve discordância.

Quando o padrão supervisor é a escolha errada

• Tarefas sequenciais. Se o passo 2 precisa literalmente da saída do passo 1, o paralelismo não traz vantagens. Use um pipeline (CrewAI Sequential, grafo linear do LangGraph).
• Consultas simples. Um agente único lida com elas de forma mais rápida e barata. Use a verificação de "escala de esforço" do líder antes de iniciar os trabalhadores.
• Determinismo estrito. O supervisor usa delegação selecionada por LLM. Grafos estáticos são melhores quando a auditoria/reprodução são mais importantes do que a adaptabilidade.

Construa

O arquivo code/main.py implementa um supervisor de três trabalhadores paralelos usando threading. O líder decompõe uma consulta em subperguntas, os trabalhadores executam simultaneamente em cada subpergunta e o líder realiza a síntese. Sem LLMs reais — os trabalhadores são programados por script para simular busca e resumo.

Estrutura chave:

• Lead.plan(query) divide uma consulta em 3 subperguntas.
• Worker.run(sub_q) retorna um resumo simulado (poderia ser qualquer agente de uso de ferramentas em produção).
• Lead.run(query) inicia os trabalhadores em threads, faz a junção (join) e realiza a síntese.

Execute:

python3 code/main.py

A saída mostra o plano, os rastros paralelos dos trabalhadores com carimbos de data/hora de início/fim e a síntese final. Você pode ver os ganhos de tempo de execução real (wall-clock): três trabalhadores de 0.3 segundos são executados em aproximadamente 0.35 segundos, não 0.9.

Use

O outputs/skill-supervisor-designer.md recebe uma consulta do usuário e produz um design de padrão supervisor: prompt do sistema líder, funções dos trabalhadores, regras de decomposição de subperguntas e o modelo de síntese. Use isto antes de construir um novo sistema de agentes de estilo de pesquisa.

Colocando em Produção

Lista de verificação antes de implantar um padrão supervisor:

• Emparelhamento de modelos. Líder em um modelo de nível de raciocínio (classe Opus, classe o3). Trabalhadores em um modelo mais rápido e barato (Sonnet, o4-mini).
• Timeout do trabalhador. Qualquer trabalhador que exceder 2× o tempo de execução mediano é encerrado; o líder pode reiniciá-lo com um escopo mais estreito ou prosseguir sem ele.
• Limite de tokens por trabalhador. Um limite estrito (por exemplo, 10× a entrada de síntese esperada) evita que um trabalhador descontrolado estoure o orçamento.
• Observability. Rastreie o plano do líder, as chamadas de ferramentas de cada trabalhador e a síntese. Esta é a base para qualquer depuração posterior.
• Implantação Rainbow. Agentes com estado e de longa duração precisam de transição gradual de versão, não de substituição imediata (hot swap).

Exercícios

1. Execute code/main.py e, em seguida, modifique o líder para iniciar 5 trabalhadores em vez de 3. Observe o efeito no tempo de execução real. Com qual quantidade de trabalhadores o overhead de criação excede a economia paralela nesta demonstração?
2. Implemente um timeout do trabalhador: encerre qualquer trabalhador que execute por mais de 0.5 segundos e faça com que o líder sintetize os resultados restantes. Qual observabilidade você precisa para saber que um trabalhador foi interrompido?
3. Adicione uma etapa de detecção de conflitos à síntese do líder: se dois trabalhadores retornarem respostas contraditórias, o líder registrará a divergência em vez de escolher uma. Como você detecta contradições sem chamar um LLM?
4. Leia o post de engenharia do sistema de Pesquisa da Anthropic. Liste três práticas que esta demonstração simples precisaria adotar para rodar em produção.
5. Compare o create_supervisor do LangGraph (legado) com a nova recomendação de chamada de ferramentas (tool-calling). Qual deles oferece melhor controle sobre o que o supervisor vê? Por que a Anthropic passa explicitamente apenas as subrespostas e não o contexto bruto do trabalhador para a síntese?

Termos-Chave

Leituras Adicionais

• Anthropic engineering — How we built our multi-agent research system — a referência de produção para o padrão supervisor
• LangGraph workflows and agents — o supervisor de chamada de ferramentas agora é o formato recomendado
• LangGraph supervisor reference — o utilitário legado, ainda usado na produção de 2026
• OpenAI cookbook — Orchestrating Agents: Routines and Handoffs — variante de supervisor baseada em entrega (handoff)