🛰️ Multiagent architecture at scale

So far, you've delegated isolated tasks. Now imagine a truly large request: "gather everything available about topic X, confirm what's actually true, and give me a complete report". A single subagent can't handle it — and worse, if it stop too early or believe the first result, you get a polished but wrong answer. Scaled architecture addresses this with three linked stages: a fleet that searches until it runs dry (find), a a court that refutes each finding (verify) is one synthesizer that brings together only what survived (synthesize). Remember this pipeline — it's the backbone of the entire module.

↑ The harness skeleton: find in a loop → verify adversarial by majority → synthesize only the survivors.

A fleet is a group of subagents of the same type working on the same problem at the same time—not one, not two, but ten, forty, a hundred, each on a slice. The conductor stops "delegating a task" and starts run an operation: split up the search space, dispatch the fleet, gather the pieces, and move on to the next stage. The unit of reasoning stops being the subagent and becomes the entire system.

The biggest mistake in a large-scale search is stop too early. A subagent finds five things, thinks "that's enough," and returns — but there were fifteen. The fix is the loop-until-dry: run the fleet in rounds, and only stop when K consecutive rounds come back empty (nothing new). “Dry” doesn’t mean “a round without news”; it means K rounds nothing new—a buffer against stopping at the first breath.

Finding is not confirmation. Each finding from the fleet goes into a court: you launch N skeptical subagents, and each one’s task no is to agree—it’s try to take down the claim ("find evidence that this is wrong"). If the majority be able to refute, the finding dies. Only what withstands the attack survives. It’s the opposite of asking for confirmation—asking for confirmation only reinforces the bias.

A fleet of subagents identical make the same mistakes in unison—everyone looks in the same place and misses the same blind spot. The fix is to give each subagent a different lens: the same material, different roles. One looks for contradictions, another looks for what’s missing, another reads from a cost perspective, and another from a security perspective. Diversity of perspective = diversity of errors found. It’s the same idea as the 5 personas from Track 1, now as an architecture component.

Loop-until-dry tells you when the fleet stopped finding. But "stopped finding things" doesn't mean "found everything that matters" — an entire gap may have remained unexplored. Enter the completeness critic: a subagent whose only mission is to look at the assembled whole and ask "what's still missing?". It doesn’t search; it points out the gaps. Every gap it points out becomes a new round of targeted searching — closing the loop between checking and searching again.

# 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.

Every system at scale has limits — on tokens, time, and number of items. The problem isn’t setting limits; it’s cut silently. If the fleet finds 500 items and the system processes only 50 without warning you, you get a report that seems complete and isn't — and you'll never know. The golden rule: no silent cuts. Cut? Log it: what was cut, how much, and by what criterion. The user needs to see the edge of the map.

In the end, someone has to put everything together — but combining isn't pasting together. The synthesizer receives only the findings that survived to the tribunal, after the gaps are closed, with the cut log in hand, and produces a coherent narrative: deduplicates, groups by topic, resolves remaining conflicts, cites the source of each claim, and states what was left out. The final report is the only thing that comes back to you—clean, as the subagent model requires.

# 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

One harness is the code (or skill) that orchestrates the fleet—the “admiral” implemented as a program. You don’t need to write this in any specific language right now; what matters is recognize the form. Below is the pseudocode skeleton: the seven topics in this module appear as steps in a function. Read it like a recipe, not as ready-to-run code.

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

Three prompts to enforce this module's doctrine across a fleet—even without writing a harness. Notice the pattern: ask exhaustion, ask for refutation and prohibit the silent cut.

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.

This is how the operation appears in the terminal: the harness is in the find round 3, with a fleet of searchers and skeptics in parallel. Notice the empty-round counter (1/2 — it still hasn't dried), skeptics knocking down findings, and at the base, the cutoff log line — visible, never silent.

↑ Illustrative recreation of the terminal (not a real screenshot). The fleet burns through context in its own windows; yours barely moves — and the 214→50 cut is visible in the log.