As Precondições para Aumentar a Precisão de Múltiplos Agentes de LLM

O problema

Existe a intuição de que “rodar vários agentes torna o resultado mais preciso”. Só metade está certa.

O alvo exato não é o múltiplo agente em si, mas sim o múltiplo agente que vota sem independência. Rodar N agentes feitos com o mesmo modelo, os mesmos dados e o mesmo alinhamento e tirar a maioria — não fica mais preciso. Eles erram juntos.

• Medição real de ensemble de LLM em análise de sentimento: adicionar um modelo maior e mais preciso trouxe ganho mínimo. Porque a independência pressuposta pelo teorema de Condorcet estava quebrada (arXiv:2409.00094).
• Debate multiagente (MAD): mesmo colocando os agentes para debater, não se vence de forma estável a self-consistency de um único agente (ICML 2024, arXiv:2311.17371).
• Minha observação anedótica (amostra de 1, sem controle): na tarefa do ZenFlow, ao rodar o Grok Build com 8 agentes simultâneos, ele travou em 3 dos 10 endpoints e não passou no validate. É só uma anedota, então não vamos dar o mesmo peso que aos dois estudos acima.

A maioria não é mágica. O teorema do júri de Condorcet explicitou as precondições há 200 anos. E se essas precondições forem satisfeitas, os múltiplos agentes realmente funcionam. Este texto é sobre o que são essas precondições e como satisfazê-las.

As duas precondições de Condorcet

Em 1785, Condorcet fixou em fórmula as condições para que a regra da maioria convirja para a verdade.

1. A precisão de cada votante > 50%
2. Os erros entre os votantes são independentes

(Rigorosamente, há uma terceira, a premissa de uniformidade — de que todos têm a mesma precisão. Vamos deixá-la de lado para simplificar.)

A segunda é o cerne. Modelos alinhados com os mesmos dados de treino, a mesma arquitetura e o mesmo RLHF erram nos mesmos lugares. Ao votar, “a resposta errada compartilhada” se torna maioria.

Isso não é só intuição. Um estudo que analisou mais de 350 LLMs relata que, quando dois modelos erram ao mesmo tempo, eles convergem para exatamente a mesma resposta errada com 60% de probabilidade (ICML 2025, arXiv:2506.07962). No mesmo estudo observou-se um paradoxo ainda maior — quanto maior e mais preciso o modelo, maior a correlação dos erros. Isso valia mesmo com arquiteturas diferentes. (É uma única análise de grande escala, e a reprodução ampla ainda não veio. Mesmo assim, a direção é exatamente a que Condorcet previu.)

A matemática dos erros correlacionados

Se os erros são independentes, o ensemble corta as respostas erradas. Se são correlacionados, não há o que cortar.

• Quando independentes: P(ambos erram) = 0,1 × 0,1 = 0,01
• Quando totalmente correlacionados: P(ambos erram) ≈ 0,1 (se um erra, o outro também erra)

Essa intuição tem raiz em um teorema de 30 anos. A decomposição de ambiguity de Krogh e Vedelsby (NeurIPS 1994): erro do ensemble = erro médio dos membros − diversidade do ensemble. Quanto mais correlacionados os erros dos membros, mais o termo de diversidade converge para 0, e por mais modelos que se adicione, o ganho desaparece. A teoria unificada de 2023 no JMLR generalizou isso — a diversidade não é uma alavanca separada, mas uma dimensão escondida dentro da decomposição bias-variance (arXiv:2301.03962).

Resumindo:

• Condição em que o ensemble aumenta a precisão: quanto menor a correlação dos erros, maior o ganho (máximo na correlação negativa).
• Condição em que o ganho do ensemble converge para 0: correlação dos erros → 1 (mesmos dados, mesmo viés).

A forma da votação também importa. A maioria (majority), se há independência, eleva a precisão exatamente como Condorcet previu. Mas se você amarra tudo num consenso de “todos têm de aprovar” (unanimity, gate AND), a precisão desaba multiplicativamente — se a precisão do classificador é 0,977 e você amarra n deles em unanimidade, fica 0,977ⁿ. Se o gate for mal projetado, mais agentes produzem menos precisão.

Até aqui é o diagnóstico. Agora a receita se bifurca em dois caminhos — reduzir a correlação dos erros (eixo 1) ou contorná-la (eixo 2).

Eixo 1 — Garantida a independência, os múltiplos agentes funcionam

Sejamos claros. Não é o múltiplo agente que está errado. É a votação sem independência que está. Se você satisfizer a segunda precondição de Condorcet — se tornar os erros dos agentes não correlacionados — a maioria eleva a precisão como prometido. Há dois caminhos para criar independência.

(a) Divida o problema — é o mais poderoso.

Não dê o mesmo problema aos agentes e os faça votar; dê a cada um um subproblema diferente. Se os insumos são diferentes, os erros se tornam estruturalmente independentes — mesmo com o mesmo modelo. Dois agentes lendo documentos diferentes não têm como errar no mesmo lugar. Porque estão olhando para lugares diferentes.

O fato de o sistema de pesquisa multiagente da Anthropic relatar uma melhora de 90,2% em relação ao agente único é exatamente esse princípio. O agente líder divide o problema, distribui aos subagentes paralelos, e combina os resultados que cada um explorou de forma independente. Não foi preciso verifier. A decomposição tornou a independência gratuita.

Mas há uma condição. Tem de ser um problema decomponível. Em tarefas em que os subtrabalhos dependem uns dos outros e exigem coordenação constante — como vários consertando ao mesmo tempo um único bloco de código —, os subagentes paralelos, ao contrário, colidem. O contexto se fragmenta e eles tomam decisões mutuamente contraditórias (Cognition, “Don’t Build Multi-Agents”). A independência da decomposição só é gratuita quando os subproblemas são de fato independentes.

(b) Heterogeneíze os modelos — funciona, mas tem teto.

Mesmo com o mesmo problema, fazer modelos diferentes resolverem (GPT, Claude, Gemini) reduz a correlação dos erros, pois os pesos são diferentes. O debate multiagente também só vence a baseline única quando se misturam modelos heterogêneos (arXiv:2502.08788) — não refuto isso. O cerne é que o que importa não é a precisão individual, mas a correlação. Há um resultado de teoria da informação segundo o qual, mesmo ao escolher os modelos para o ensemble, você deve escolher não o modelo mais forte, mas a combinação menos correlacionada — fracos, mas diversos, vencem o modelo único mais forte (arXiv:2602.08003). Só que essa alavanca tem teto baixo. Os corpora da internet se sobrepõem e, como vimos antes, quanto maior o modelo, mais ele volta a errar junto (arXiv:2506.07962). A diversidade reduz a correlação, mas não a leva a 0.

Em terceiro lugar, dentro do mesmo modelo, dispersar os caminhos de raciocínio com self-consistency também descorrelaciona os erros de superfície e gera ganho (GSM8K +17,9pp, arXiv:2203.11171). Mas esse ganho para diante do ponto em que o modelo erra sistematicamente — o mesmo viés gravado pelos mesmos dados. Por mais que você diversifique os caminhos, o modo como o modelo desconhece o que desconhece é único.

Conclusão do eixo 1: os múltiplos agentes funcionam quando se projeta a independência. E a independência mais segura não vem de buscar outro modelo, mas de dividir o problema em pedaços independentes.

Eixo 2 — O verifier contorna a independência

A terceira alavanca é de outra natureza. O eixo 1 salva a votação reduzindo a correlação dos erros. O verifier contorna a correlação — mesmo que todos os agentes errem juntos, um critério externo, independente do erro, barra a aprovação. Não é votação, é gate. Por isso funciona mesmo onde não se consegue garantir independência, desde que seja um domínio verificável.

Esse diagnóstico não é só meu. “Consensus is Not Verification” (arXiv:2603.06612) cravou primeiro a mesma conclusão — a agregação baseada em consenso não traz ganho consistente sobre uma amostra única e amplifica equívocos compartilhados, e o scaling em tempo de inferência funciona em domínios verificáveis (matemática), mas falha em domínios não verificáveis. Não é que o consenso funcione na matemática por ser um sinal de verdade, mas porque o verifier filtra os candidatos. Aceito esse diagnóstico e dou um passo além — para a receita. A fonte mais forte de independência é a decomposição, independência e verificação não competem, mas se complementam, e o ponto em que o verifier determinístico se aparta do juiz LLM são três (abaixo).

Mas a indústria entrega até essa verificação ao LLM — LLM-as-Judge.

Comecemos com justiça. O juiz LLM muitas vezes funciona bem. No MT-Bench, o juiz GPT-4 concordou com a preferência humana em mais de 80%, no mesmo nível da concordância entre humanos (arXiv:2306.05685). Para avaliação de preferências vagas, o juiz LLM é útil. O problema é onde ele quebra.

O juiz quebra quando compartilha as mesmas armadilhas do gerador. O LLM julgador avalia outputs que lhe são familiares (de baixa perplexity) acima do que os humanos avaliariam (self-preference bias, NeurIPS 2024 WS, arXiv:2410.21819). Se o julgador compartilha a mesma distribuição do gerador, aprova a alucinação produzida pelo mesmo modelo “porque é familiar”. A concordância de 80% não consola, porque os 20% que erram se concentram justamente onde o gerador também erra — não é a precisão média, é a correlação dos erros o problema. O julgamento também oscila diante de variáveis irrelevantes, como a posição em que o candidato é apresentado, e não a resposta correta (position bias, arXiv:2406.07791).

Uma evidência auxiliar. O julgamento por LLM oscila até na camada de hardware. Mesmo com o mesmo insumo e T=0 greedy decoding, o resultado varia conforme a configuração da GPU, por causa da não associatividade de ponto flutuante e do batching dinâmico — em BF16, a precisão variou até 9pp (arXiv:2506.09501). Isso é um problema de reprodutibilidade, não de validade, então não o tomo como argumento central. Apenas que é desconfortável colocar na cadeira de juiz final algo que não garante nem a mesma resposta para a mesma pergunta.

Por isso há uma direção oposta. Gerador fraco + verifier forte. Mesmo um modelo fraco se aproxima do modelo forte quando recebe o mesmo verifier, e os erros do modelo fraco são até mais fáceis de detectar (arXiv:2509.17995). Pode-se também combinar vários verificadores fracos com pesos para formar um verificador forte (Weaver, arXiv:2506.18203), ou refinar o output do LLM com o feedback de um formal verifier para garantir consistência (AlphaVerus, arXiv:2412.06176). Isso não é uma afirmação marginal — modelos de raciocínio e agentes de codificação que aprendem com recompensas verificáveis são hoje a área que mais rápido avança, e Jason Wei resumiu isso na verifier’s law: o quanto a IA se fortalece é proporcional à verificabilidade da tarefa.

Aqui é preciso ser honesto. O verifier não é um oráculo mágico. Os testes podem ter lacunas, a especificação pode estar errada. E, de forma mais aguda — se o verifier for escrito por um LLM, a crítica que acabei de fazer ao LLM-as-Judge ressuscita intacta. Se gerador e verificador são o mesmo modelo, um teste errado no mesmo lugar aprova um código errado no mesmo lugar. A correlação dos erros apenas muda de lugar para a camada de verificação; não desaparece.

Então, como impedir a ressurreição. Elevando a confiabilidade do verifier fora do gerador. Três coisas andam juntas.

• Revisão humana. Os critérios de verificação (especificação, testes, propriedades) são revisados uma vez por uma pessoa e fixados. Mesmo que o LLM escreva o rascunho, os critérios de aprovação são definidos por uma pessoa que está fora da distribuição do gerador. O custo é uma única vez, e um critério fixado uma vez é reutilizado infinitamente — esse é o ponto que o distingue decisivamente do LLM-as-Judge, que rejulga a cada geração.
• Redução à matemática e à lógica. Sempre que possível, mova a verificação para uma forma mecanicamente decidível — type check, invariante (invariant), prova formal, propriedade matemática. Aqui não há lugar para o “julgamento” do LLM. O verdadeiro/falso é decidido por regra, não por opinião do modelo.
• Testes repetidos. Como os erros do verifier são reproduzíveis, eles melhoram de forma acumulada. Ao ampliar a cobertura com testes de regressão e property-based testing, o buraco que o verifier deixou passar uma vez fica fixado num teste e nunca mais vaza no mesmo lugar. O juiz LLM oscila mesmo com o mesmo insumo, o que torna esse acúmulo impossível.

Esses três tornam o verifier um critério independente do viés do gerador. A forma de cortar a correlação dos erros também na camada de verificação é cravar o verifier fora do modelo — na pessoa, na matemática, na suíte de testes.

Então onde está a diferença do verifier determinístico. Não é a ausência de erro. São três. Primeiro, o critério de verificação está fora dos pesos do gerador — escrito por uma pessoa ou feito por outro procedimento, é possível erguer um critério independente do viés do gerador (o juiz LLM é estruturalmente incapaz disso). Segundo, os erros do verifier não se revelam como alucinações confiantes, mas como falhas detectáveis e reproduzíveis — como dá o mesmo julgamento ao mesmo insumo, são depurados e melhorados de forma acumulada. Terceiro, a confiança migra para uma superfície pequena e auditável (especificação, testes), que, revisada uma vez por uma pessoa, é reutilizada infinitamente. Não é que o verifier garanta a precisão, mas a qualidade do verifier torna-se o teto da precisão — não o tamanho do gerador.

A intuição central

A fórmula de precisão dos múltiplos agentes:

precisão = f(precisão individual, independência de erros, mecanismo de verificação)

A indústria investe só no primeiro (modelos maiores). O segundo (independência) não é projetado, e o terceiro (verificação) é entregue ao LLM. E a estratégia de investir só no primeiro esbarra num paradoxo — como a correlação dos erros aumenta à medida que o modelo cresce, quanto mais agentes mais espertos você reúne, mais harmoniosamente eles erram juntos.

O segundo e o terceiro são as verdadeiras alavancas. E os dois não competem. A independência (eixo 1) salva a votação, e o verifier (eixo 2) corta onde a votação não alcança. Ter os dois é o mais forte.

• Sistema de pesquisa da Anthropic: a decomposição do eixo 1 levada ao extremo — dividir o problema em exploração paralela independente. Melhora de 90,2% sem verifier.
• SciencePedia (China, 2026): vários solvers independentes resolvem cada um o seu (eixo 1), e só se preserva o que tem consenso entre os modelos (cross-model consensus, arXiv:2510.26854). Mas, como o filtro final é “consenso de modelos”, o eixo 2 foi capturado só pela metade — consenso não é verificação determinística. Por isso só é confiável quando limitado a domínios verificáveis, como matemática e lógica.
• Por que 8 agentes do mesmo modelo falham: ausência dos dois eixos. Independência zero, loop de verificação zero. Os 8 travam juntos no mesmo lugar.
• Por que o yongol funciona até com Haiku: implementação direta do eixo 2. Mesmo com baixa precisão do modelo, o verifier determinístico filtra a cada etapa — enquanto a qualidade do verifier sustentar.

Uma analogia com a democracia

Assim como a democracia, se for a maioria de eleitores que viram a mesma notícia, vira oclocracia, a maioria de LLMs treinados com os mesmos dados é o consenso da alucinação. O número de cabeças não cria a verdade. Cabeças independentes a criam. E onde o número de cabeças não alcança, um critério fora das cabeças a cria.

A conexão com a evolução

A mesma intuição se lê também nos algoritmos de aprendizado. Na backpropagation, as direções do gradient são correlacionadas; na evolução, as mutações se dispersam de forma independente. Há relato de que algoritmos genéticos que não usam gradient algum exploram um espaço de soluções diferente dos baseados em gradient no aprendizado por reforço profundo (Deep Neuroevolution, arXiv:1712.06567). A busca independente alcança onde a busca correlacionada não chega — o princípio visto no ensemble tem o mesmo formato na otimização. Mas “é melhor por causa da independência” ainda é interpretação a posteriori — deixo como hipótese, não como prova.

Conclusão

O múltiplo agente não é “muitos, logo preciso”. O alvo do ataque não é o múltiplo agente, mas a votação sem independência. Reunir N do mesmo modelo e tirar a maioria é criar um coral que erra junto.

A receita é dupla, e as duas são reais. Primeiro, projete a independência — se dividir o problema em pedaços independentes (o mais seguro), os múltiplos agentes funcionam até com o mesmo modelo. Segundo, se for um domínio verificável, erga um verifier fora do LLM — eleva o teto da precisão independentemente da independência.

Fixemos o escopo com honestidade. O eixo do verifier (eixo 2) é a resposta apenas em domínios verificáveis — código, matemática, especificações formais, onde se pode cortar a resposta correta por um critério externo. Em áreas sem esse critério — geração aberta, resumo, aconselhamento, criação, julgamento estratégico —, o eixo 1, ou seja, o projeto de independência, é a única alavanca que resta. A alavanca travada não é o tamanho do modelo — é a independência dos erros e, onde possível, o verifier externo.

(Aviso de conflito de interesse: eu construo o yongol, uma ferramenta que tem o verifier determinístico como keystone. Por isso minha cabeça pende para o eixo do verifier. Leiam a argumentação acima levando em conta esse viés — se a espinha estiver errada, a ferramenta também está.)

Referências

Condorcet e teoria de ensemble

• Teorema do júri de Condorcet (1785) — as duas precondições da convergência da maioria: precisão individual >50%, independência dos erros
• Krogh & Vedelsby, Neural Network Ensembles, Cross Validation, and Active Learning (NeurIPS 1994) — decomposição de ambiguity
• Wood et al., A Unified Theory of Diversity in Ensemble Learning (JMLR 2023, arXiv:2301.03962) — decomposição bias-variance-diversity

Correlação de erros de LLM / limites do consenso

• Kim et al., Correlated Errors in Large Language Models (ICML 2025, arXiv:2506.07962) — quando dois modelos erram ao mesmo tempo, 60% de resposta errada idêntica; quanto maior o modelo, correlação↑
• Lefort et al., Examining Independence in Ensemble Sentiment Analysis … Condorcet Jury Theorem (arXiv:2409.00094) — a premissa de independência de Condorcet quebra nos LLMs
• Denisov-Blanch et al., Consensus is Not Verification: Why Crowd Wisdom Strategies Fail for LLM Truthfulness (2026, arXiv:2603.06612) — a agregação por consenso amplifica equívocos compartilhados; o scaling em tempo de inferência só funciona em domínios verificáveis (mesmo diagnóstico deste texto — diferenciado na receita, no corpo)

Múltiplos agentes: independência e decomposição

• Cemri et al., Why Do Multi-Agent LLM Systems Fail? (UC Berkeley, 2025, arXiv:2503.13657) — análise de 1.600+ traces de execução em 7 frameworks. Classifica 14 modos de falha em 3 categorias: design do sistema, falha de alinhamento entre agentes, verificação (task verification)
• Smit et al., Should we be going MAD? (ICML 2024, arXiv:2311.17371) — o debate não vence de forma estável uma baseline simples
• Zhang et al., Stop Overvaluing Multi-Agent Debate (arXiv:2502.08788) — a heterogeneidade é o antídoto (funciona quando a independência é recuperada)
• Du et al., Improving Factuality and Reasoning through Multiagent Debate (ICML 2024, arXiv:2305.14325) — afirmação positiva original do MAD
• Wang et al., Self-Consistency Improves Chain of Thought Reasoning (ICLR 2023, arXiv:2203.11171) — o ganho da diversificação de caminhos
• Turkmen et al., Don’t Always Pick the Highest-Performing Model: An Information Theoretic View of LLM Ensemble Selection (2026, arXiv:2602.08003) — o critério de seleção do ensemble não é o desempenho individual, mas correlação↓ (maximização da informação mútua). Fracos, mas diversos, vencem

Confiabilidade do LLM-as-Judge

• Zheng et al., Judging LLM-as-a-Judge with MT-Bench and Chatbot Arena (NeurIPS 2023, arXiv:2306.05685) — o juiz GPT-4 concorda 80%+ com humanos (evidência positiva)
• Wataoka et al., Self-Preference Bias in LLM-as-a-Judge (NeurIPS 2024 WS, arXiv:2410.21819)
• Shi et al., Judging the Judges: Position Bias in LLM-as-a-Judge (arXiv:2406.07791)
• Numerical Sources of Nondeterminism in LLM Inference (arXiv:2506.09501) — output oscila mesmo em T=0

Gerador fraco + verifier forte

• Saad-Falcon et al., Shrinking the Generation-Verification Gap with Weak Verifiers (Weaver, arXiv:2506.18203)
• Aggarwal et al., AlphaVerus: Formally Verified Code Generation (arXiv:2412.06176)
• Variation in Verification: Understanding Verification Dynamics in LLMs (arXiv:2509.17995)

Casos de geração verificável

• SciencePedia (DP Technology / DeepModeling, 2026) — Inverse Knowledge Search over Verifiable Reasoning (arXiv:2510.26854). Solvers independentes + filtro de cross-model consensus

Evolução vs gradient

• Such et al., Deep Neuroevolution (arXiv:1712.06567) — o GA explora um espaço de soluções diferente do gradient

Medição primária (do próprio autor)

• ZenFlow / Grok Build: 8 agentes concorrentes, 3 de 10 endpoints incompletos (validate não passou)
• ZenFlow / yongol: Haiku concluiu, Sonnet 131 min, Opus 76 min

Para ler junto

• Don’t Build Multi-Agents — Cognition (criadora do Devin), 2025. Texto de campo notável que afirma categoricamente que é melhor não construir múltiplos agentes. Quando o contexto se fragmenta, os agentes colidem entre si — a armadilha das tarefas que não se decompõem. (Junto com a sequência Multi-Agents: What’s Actually Working, 2026.)
• How we built our multi-agent research system — Anthropic, 2025. Ler em par com o texto acima. Mostra, com 90,2% de melhora, a condição em que o múltiplo agente funciona — quando os subtrabalhos são paralelizados de forma independente (a decomposição do eixo 1).
• Asymmetry of verification and verifier’s law — Jason Wei, 2025. “O quanto a IA se fortalece é proporcional à verificabilidade da tarefa.” A espinha teórica do eixo 2 (gerador fraco + verifier forte).
• Hallucinations in code are the least dangerous form of LLM mistakes — Simon Willison, 2025. O código denuncia a alucinação no instante em que é executado. O caso mais intuitivo de por que a verificação determinística é a alavanca decisiva.
• Using LLM-as-a-Judge For Evaluation — Hamel Husain, 2024. Por que não se deve confiar cegamente no juiz LLM e o procedimento prático de escalar com automação só depois de alinhá-lo com humanos.
• Defeating Nondeterminism in LLM Inference — Thinking Machines Lab, 2025. A verdadeira causa de o LLM oscilar mesmo em temperature=0. A base de infraestrutura para colocar o verifier fora do modelo.
• The Wisdom of Crowds — a sabedoria das multidões evapora quando diversidade e independência ruem. Uma introdução acessível que explica a premissa de independência de Condorcet em contexto não-IA.

• Imagem de capa: gerada por IA (Google Gemini)