🛰️ Arquitectura multiagente a escala

Hasta aquí delegaste tareas aisladas. Ahora imagina un pedido realmente grande: "recopila todo lo que existe sobre el tema X, confirma qué es realmente cierto y entrégame un informe completo". Un solo subagente no es suficiente, y peor aún, si detenerse demasiado pronto o creer en el primer resultado, recibes una respuesta convincente pero incorrecta. La arquitectura a escala lo resuelve con tres etapas encadenadas: una flota que busca hasta agotar las opciones (find), un tribunal que refuta cada hallazgo (verify) y uno sintetizador que reúne solo lo que sobrevivió (synthesize). Graba este pipeline — es el esqueleto de todo el módulo.

↑ El esqueleto del harness: find en bucle → verify adversarial por mayoría → synthesize solo de los sobrevivientes.

Una flota es un conjunto de subagentes del mismo tipo que trabajan en el mismo problema al mismo tiempo: no uno, no dos, sino diez, cuarenta, cien, cada uno en una parte. El maestro deja de «delegar una tarea» y pasa a ejecutar una operación: dividir el espacio de búsqueda, despachar la flota, recopilar las partes y pasar a la siguiente etapa. La unidad de razonamiento deja de ser el subagente y pasa a ser el sistema entero.

El mayor error de una búsqueda a gran escala es detenerse demasiado pronto. Un subagente encuentra cinco cosas, cree que «ya está» y las devuelve, pero en realidad había quince. La solución es el loop-until-dry: ejecuta la flota en rondas, y solo detente cuando K rondas seguidas no devuelvan resultados (nada nuevo). «Seco» no es «una ronda sin novedades»; es K rondas sin novedades — un amortiguador contra detenerse en el primer respiro.

Encontrar no es confirmar. Cada hallazgo de la flota se incluye en un tribunal: tú activas N subagentes escépticos, y la tarea de cada uno no es estar de acuerdo: es intentar derribar la afirmación ("encuentra una evidencia de que esto está mal"). Si la mayoría poder refutar, el hallazgo muere. Solo sobrevive lo que resistió el ataque. Es lo contrario de pedir confirmación: pedir confirmación solo refuerza el sesgo.

Una flota de subagentes idénticos cometen los mismos errores en coro: todos miran el mismo lugar e ignoran el mismo punto ciego. La solución es darle a cada subagente una lente diferente: el mismo material, distintos roles. Uno busca contradicciones, otro busca lo que falta, otro lo analiza desde la perspectiva del costo y otro desde la seguridad. Diversidad de perspectivas = diversidad de errores encontrados. Es la misma idea de las 5 personas de la Ruta 1, ahora como pieza de arquitectura.

Loop-until-dry te dice cuándo la flota dejó de encontrar. Pero "dejó de encontrar" no significa "encontró todo lo importante"; puede haber quedado una brecha entera sin explorar. Entra el completeness critic: un subagente cuya única misión es revisar el conjunto reunido y preguntar "¿qué falta todavía?". No busca; señala las brechas. Cada brecha que señala se convierte en una nueva ronda de búsqueda dirigida, cerrando el ciclo entre verificar y volver a buscar.

# 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 a escala tiene límites — de tokens, de tiempo, de número de elementos. El problema no es limitar; es cortar en silencio. Si la flota encontró 500 elementos y el sistema solo procesa 50 sin avisar, recibes un informe que parece completo y no es — y nunca lo vas a saber. La regla de oro: ningún recorte silencioso. ¿Recortaste algo? Regístralo: qué se recortó, cuánto y con qué criterio. El usuario necesita ver el límite del mapa.

Al final, alguien tiene que juntarlo todo — pero reunir no es pegar. El sintetizador recibe solo los hallazgos que sobrevivieron al tribunal, después de cerrar las brechas, con el registro de recortes a mano, y produce una narrativa coherente: deduplica, agrupa por tema, resuelve los conflictos restantes, cita el origen de cada afirmación y declara lo que quedó fuera. El informe final es lo único que vuelve a ti: limpio, como indica el modelo de 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

Uno harness es el código (o la skill) que orquesta la flota: el «almirante» hecho programa. No necesitas escribirlo ahora en ningún lenguaje específico; lo que importa es reconocer la forma. Abajo, el esqueleto en pseudocódigo: los siete temas de este módulo aparecen como pasos de una función. Léelo como una receta, no como código listo para usar.

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

Tres prompts para imponer la doctrina de este módulo a una flota, incluso sin escribir un harness. Fíjate en el patrón: pide agotamiento, pide refutación y prohíbe el 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.

Así es como aparece la operación en la terminal: el harness está en la ronda 3 del find, con una flota de buscadores y escépticos en paralelo. Observa el contador de rondas vacías (1/2 — aún no se ha secado), los escépticos derribando hallazgos y, en la base, la línea de log del corte — visible, nunca silenciosa.

↑ Recreación ilustrativa del terminal (no es una captura de pantalla real). La flota consume contexto en sus ventanas; la tuya casi no se mueve, y el recorte de 214→50 está a la vista en el registro.