🛰️ Arquitetura multiagente em escala

Até aqui você delegou tarefas isoladas. Agora imagine um pedido grande de verdade: "levante tudo o que existe sobre o tema X, confirme o que é mesmo verdade e me entregue um relatório fechado". Um único subagente não dá conta — e pior, se ele parar cedo demais ou acreditar no primeiro resultado, você recebe uma resposta bonita e errada. A arquitetura em escala resolve isso com três estágios encadeados: uma frota que busca até secar (find), um tribunal que refuta cada achado (verify) e um sintetizador que junta só o que sobreviveu (synthesize). Grave esse pipeline — ele é o esqueleto do módulo inteiro.

↑ O esqueleto do harness: find em laço → verify adversarial por maioria → synthesize só dos sobreviventes.

Uma frota é um conjunto de subagentes do mesmo tipo trabalhando o mesmo problema ao mesmo tempo — não um, não dois, mas dez, quarenta, cem, cada um numa fatia. O maestro deixa de "delegar uma tarefa" e passa a comandar uma operação: dividir o espaço de busca, despachar a frota, recolher os pedaços e seguir para o próximo estágio. A unidade de raciocínio deixa de ser o subagente e vira o sistema inteiro.

O maior erro de uma busca em escala é parar cedo demais. Um subagente acha cinco coisas, acha que "deu", e devolve — mas existiam quinze. A correção é o loop-until-dry: rode a frota em rodadas, e só pare quando K rodadas seguidas voltarem vazias (nada de novo). "Seco" não é "uma rodada sem novidade"; é K rodadas sem novidade — um amortecedor contra parar no primeiro respiro.

Achar não é confirmar. Cada achado da frota entra num tribunal: você dispara N subagentes céticos, e a tarefa de cada um não é concordar — é tentar derrubar a afirmação ("ache uma evidência de que isto está errado"). Se a maioria conseguir refutar, o achado morre. Sobrevive só o que aguentou o ataque. É o oposto de pedir confirmação — pedir confirmação só reforça o viés.

Uma frota de subagentes idênticos comete os mesmos erros em coro — todos olham para o mesmo lugar e ignoram o mesmo ponto cego. A correção é dar a cada subagente uma lente diferente: o mesmo material, papéis distintos. Um caça contradições, outro caça o que está faltando, outro lê pela ótica de custo, outro pela de segurança. Diversidade de lente = diversidade de erro encontrado. É a mesma ideia das 5 personas da Trilha 1, agora como peça de arquitetura.

Loop-until-dry te diz quando a frota parou de achar. Mas "parou de achar" não é "achou tudo o que importa" — pode ter ficado um buraco inteiro inexplorado. Entra o completeness critic: um subagente cuja única missão é olhar o conjunto reunido e perguntar "o que ainda falta?". Ele não busca; ele aponta os buracos. Cada buraco que ele aponta vira uma nova rodada de busca direcionada — fechando o ciclo entre verificar e buscar de novo.

# Pergunta única do crítico: "o que ainda falta?"

COBERTO    ✓ definição do conceito
COBERTO    ✓ 3 casos de uso confirmados
COBERTO    ✓ limites conhecidos

LACUNA     ✗ nenhuma fonte sobre custo em produção
LACUNA     ✗ nada sobre o que muda fora do Claude Code
LACUNA     ✗ zero contra-exemplos (só casos de sucesso)

# → o harness abre 3 buscas direcionadas para
#   fechar exatamente estas lacunas e roda de novo.

Todo sistema em escala tem limites — de tokens, de tempo, de número de itens. O problema não é cortar; é cortar em silêncio. Se a frota achou 500 itens e o sistema só processa 50 sem avisar, você recebe um relatório que parece completo e não é — e nunca vai saber. A regra de ouro: nenhum corte silencioso. Cortou? Loga: o que foi cortado, quanto, e por qual critério. O usuário precisa ver a borda do mapa.

No fim, alguém tem que juntar tudo — mas juntar não é colar. O sintetizador recebe só os achados que sobreviveram ao tribunal, depois das lacunas fechadas, com o log de cortes em mãos, e produz uma narrativa coesa: dedup, agrupa por tema, resolve conflitos restantes, cita a origem de cada afirmação e declara o que ficou de fora. O relatório final é a única coisa que volta para você — limpo, como manda o modelo do subagente.

# Síntese: <pergunta original>

## Conclusões (sobreviveram ao tribunal)
- <afirmação A>  [fonte: f1, f7 · 4/4 céticos mantiveram]
- <afirmação B>  [fonte: f3 · 3/4 mantiveram]

## Conflitos resolvidos
- A vs. C → C caiu (refutado por evidência em f9)

## O que ficou de fora (sem cap silencioso)
- 500 achados → 38 processados (top por relevância)
- lacuna ainda aberta: custo em produção (0 fontes)

## Confiança
- alta nos itens 4/4; média nos 3/4; baixa onde há 1 fonte

Um harness é o código (ou a skill) que orquestra a frota — o "almirante" feito programa. Você não precisa escrever isto em nenhuma linguagem específica agora; o que importa é reconhecer a forma. Abaixo, o esqueleto em pseudocódigo: os sete tópicos deste módulo aparecem como passos de uma função. Leia como uma receita, não como código pronto.

função pesquisar_em_escala(pergunta, K=2, max_rodadas=8, N_ceticos=4):
    achados        = conjunto()      # dedup automático
    rodadas_vazias = 0
    log_cortes     = []

    # ── 1+2 · FIND em loop-until-dry ──────────────────────
    enquanto rodadas_vazias < K e rodada < max_rodadas:
        fatias = particionar(pergunta, achados)        # tópico 1: frota
        novos  = frota_paralela(BUSCADOR, fatias)      # cada um, uma lente (tópico 4)
        ineditos = novos - achados
        se ineditos vazio: rodadas_vazias += 1
        senão:           rodadas_vazias = 0; achados |= ineditos

    # ── 3 · VERIFY adversarial (mata por maioria) ─────────
    para cada a em achados:
        votos = frota_paralela(CETICO, repetir(a, N_ceticos))  # "ache o erro"
        se maioria(votos) == "refuta": achados.remove(a)

    # ── 5 · COMPLETENESS critic → realimenta o find ───────
    lacunas = subagente(CRITICO_COMPLETUDE, achados)    # "o que falta?"
    se lacunas: retornar pesquisar_em_escala(focar(pergunta, lacunas), K, ...)

    # ── 6 · SEM CAP SILENCIOSO ────────────────────────────
    se tamanho(achados) > TETO:
        log_cortes.append(f"processados {{TETO}} de {{tamanho(achados)}} (top relevância)")
        achados = top(achados, TETO)

    # ── 7 · SYNTHESIZE (única saída p/ o maestro) ─────────
    retornar subagente(SINTETIZADOR, achados, log_cortes)  # relatório citado

Três prompts para impor a doutrina deste módulo a uma frota — mesmo sem escrever um harness. Repare no padrão: peça exaustão, peça refutação e proíba o corte silencioso.

Dispare uma frota de subagentes para levantar TUDO sobre
<tema>. Rode em rodadas e só pare quando 2 rodadas
seguidas não trouxerem nada novo. No fim, diga quantas
rodadas rodou e por que considerou a busca esgotada.

Para cada achado, abra 4 subagentes céticos cuja missão
é TENTAR REFUTÁ-LO com evidência (não confirmar). Se a
maioria refutar, descarte o achado. Me entregue só os
que sobreviveram, com a contagem de votos de cada um.

Antes de fechar, rode um crítico que liste o que ainda
falta e abra buscas para as lacunas. Depois sintetize um
relatório citado. Se você cortar QUALQUER coisa por
limite, registre o que cortou, quanto e por qual critério.

É assim que a operação aparece no terminal: o harness está na rodada 3 do find, com uma frota de buscadores e céticos em paralelo. Note o contador de rodadas vazias (1/2 — ainda não secou), os céticos derrubando achados e, na base, a linha de log do corte — visível, nunca silenciosa.

↑ Recriação ilustrativa do terminal (não é screenshot real). A frota queima contexto nas janelas dela; a sua mal se move — e o corte de 214→50 está no log, à vista.