Les conditions préalables à l'amélioration de la précision des LLM multi-agents

Les conditions préalables à l’amélioration de la précision des LLM multi-agents

Le problème

Il existe une intuition : « lancer plusieurs agents rend plus précis ». Elle n’est qu’à moitié vraie.

Ce qu’il faut viser précisément, ce n’est pas le multi-agent en soi, mais le multi-agent qui vote sans indépendance. Faire tourner N agents construits avec le même modèle, les mêmes données, le même alignement, puis voter à la majorité — cela ne rend pas plus précis. On se trompe ensemble.

Mesure empirique sur un ensemble de LLM en analyse de sentiment : ajouter un modèle plus grand et plus précis n’apportait qu’un gain négligeable. L’indépendance présupposée par le théorème de Condorcet était rompue (arXiv:2409.00094).
Débat multi-agents (MAD) : même en confrontant les agents, le débat ne bat pas de façon stable la self-consistency d’un agent unique (ICML 2024, arXiv:2311.17371).
Mon observation anecdotique (échantillon 1, sans contrôle) : sur la tâche ZenFlow, en lançant Grok Build en 8 agents simultanés, le système s’est bloqué sur 3 des 10 endpoints et n’a pas passé la validation. Ce n’est qu’une anecdote, ne lui accordons donc pas le même poids qu’aux deux études ci-dessus.

Le vote à la majorité n’est pas de la magie. Le théorème du jury de Condorcet a explicité ses conditions préalables il y a 200 ans. Et lorsque ces conditions sont remplies, le multi-agent fonctionne réellement. Ce texte porte sur ce que sont ces conditions et sur la manière de les remplir.

Les deux prémisses de Condorcet

En 1785, Condorcet a inscrit dans une formule les conditions sous lesquelles le vote à la majorité converge vers la vérité.

Précision de chaque votant > 50 %
Erreurs indépendantes entre les votants

(À la rigueur, il existe une troisième prémisse d’uniformité : tous ont la même précision. Je la mets de côté par souci de simplification.)

C’est la deuxième qui est centrale. Des modèles alignés avec les mêmes données d’entraînement, la même architecture, le même RLHF se trompent aux mêmes endroits. Si on les fait voter, c’est « la réponse fausse partagée » qui devient majoritaire.

Ce n’est pas qu’une intuition. Une étude analysant plus de 350 LLM rapporte que, lorsque deux modèles se trompent simultanément, ils convergent vers la même mauvaise réponse avec une probabilité de 60 % (ICML 2025, arXiv:2506.07962). La même étude a observé un paradoxe encore plus marqué : plus le modèle est grand et précis, plus la corrélation des erreurs était élevée. Cela restait vrai même pour des architectures différentes. (C’est une analyse unique à grande échelle, pas encore largement reproduite. La direction reste néanmoins exactement celle qu’annonçait Condorcet.)

Les mathématiques des erreurs corrélées

Si les erreurs sont indépendantes, l’ensemble rabote les mauvaises réponses. Si elles sont corrélées, il n’y a rien à raboter.

Cas indépendant : P(les deux se trompent) = 0,1 × 0,1 = 0,01
Cas parfaitement corrélé : P(les deux se trompent) ≈ 0,1 (si l’un se trompe, l’autre aussi)

Cette intuition s’enracine dans un théorème vieux de 30 ans. La décomposition d’ambiguïté de Krogh et Vedelsby (NeurIPS 1994) : erreur de l’ensemble = erreur moyenne des membres − diversité de l’ensemble. Plus les erreurs des membres sont corrélées, plus le terme de diversité converge vers 0, et plus le gain disparaît quel que soit le nombre de modèles ajoutés. La théorie unifiée du JMLR 2023 l’a généralisé : la diversité n’est pas un levier distinct, mais une dimension cachée à l’intérieur de la décomposition bias-variance (arXiv:2301.03962).

En résumé :

Condition où l’ensemble augmente la précision : plus la corrélation des erreurs est faible, plus le gain est grand (maximal en corrélation négative).
Condition où le gain de l’ensemble converge vers 0 : corrélation des erreurs → 1 (mêmes données, même biais).

La forme du vote compte aussi. Le vote à la majorité (majority) élève la précision conformément à Condorcet si l’indépendance tient. Mais si on l’attache à un consensus « tous doivent valider » (unanimité, porte AND), la précision s’effondre multiplicativement : si la précision d’un classifieur est de 0,977 et qu’on lie n d’entre eux à l’unanimité, on obtient 0,977ⁿ. Mal concevoir la porte, c’est faire produire une précision plus basse par davantage d’agents.

Voilà pour le diagnostic. Le remède se divise désormais en deux branches : réduire la corrélation des erreurs (axe 1) ou la contourner (axe 2).

Axe 1 — Si l’on assure l’indépendance, le multi-agent fonctionne

Soyons clairs. Ce n’est pas le multi-agent qui est faux. C’est le vote sans indépendance qui l’est. Si l’on satisfait la deuxième prémisse de Condorcet — si l’on rend les erreurs des agents non corrélées — le vote à la majorité élève la précision comme promis. Il y a deux chemins pour créer de l’indépendance.

(a) Découper le problème — le plus puissant.

Ne donnez pas le même problème aux agents pour les faire voter ; donnez-leur des sous-problèmes différents. Si les entrées diffèrent, les erreurs deviennent structurellement indépendantes — même avec le même modèle. Deux agents qui lisent des documents différents ne peuvent pas se tromper au même endroit. Puisqu’ils regardent des endroits différents.

C’est exactement ce principe qui explique que le système de recherche multi-agents d’Anthropic ait rapporté une amélioration de 90,2 % par rapport à un agent unique. Un agent leader découpe le problème et le distribue à des sous-agents parallèles, et l’on combine les résultats que chacun a explorés indépendamment. Aucun verifier n’a été nécessaire. Car la décomposition a rendu l’indépendance gratuite.

Mais il y a une condition. Le problème doit être décomposable. Pour des tâches où les sous-tâches dépendent les unes des autres et exigent une coordination incessante — comme corriger à plusieurs et en même temps un même bloc de code — les sous-agents parallèles entrent au contraire en conflit. Le contexte se fragmente et ils prennent des décisions contradictoires (Cognition, « Don’t Build Multi-Agents »). L’indépendance de la décomposition n’est gratuite que lorsque les sous-problèmes sont réellement indépendants.

(b) Hétérogénéiser les modèles — ça marche, mais il y a un plafond.

Même pour un même problème, faire résoudre par des modèles différents (GPT, Claude, Gemini) abaisse la corrélation des erreurs, car les poids diffèrent. Le débat multi-agents ne bat enfin la baseline unique que lorsqu’on y mêle des modèles hétérogènes (arXiv:2502.08788) — et je ne le réfute pas. L’essentiel, c’est qu’il s’agit non pas de la précision individuelle, mais de la corrélation. Un résultat de théorie de l’information montre que, même au moment de choisir les modèles à mettre dans l’ensemble, il faut choisir non pas le modèle le plus fort, mais la combinaison la moins corrélée — faibles mais divers, ils battent le modèle unique le plus puissant (arXiv:2602.08003). Seulement, ce levier a un plafond bas. Les corpus d’Internet se recouvrent, et comme on l’a vu, plus les modèles sont grands, plus ils se trompent à nouveau ensemble (arXiv:2506.07962). La diversité réduit la corrélation mais ne la ramène pas à 0.

Troisièmement, au sein d’un même modèle, la self-consistency, qui disperse les chemins de raisonnement, décorrèle aussi les erreurs de surface et produit un gain (GSM8K +17,9 pp, arXiv:2203.11171). Mais ce gain s’arrête face aux points où le modèle se trompe systématiquement — le même biais gravé par les mêmes données. On a beau diversifier les chemins, le modèle n’a qu’une seule façon d’ignorer ce qu’il ignore.

Source d’indépendance	Principe de fonctionnement	Limite
Décomposition du problème (entrées différentes)	Si les entrées diffèrent, les erreurs sont structurellement indépendantes	Seulement les problèmes décomposables. Contre-productif pour les tâches dépendantes nécessitant coordination
Modèles hétérogènes (GPT+Claude+Gemini)	Si les poids diffèrent, corrélation↓	Recouvrement des corpus + plus le modèle est grand, plus la corrélation↑
Diversification des chemins de raisonnement (self-consistency)	Échantillonnage de chemins dans un même modèle puis vote majoritaire	S’arrête face aux erreurs systématiques

Conclusion de l’axe 1 : le multi-agent fonctionne si l’on conçoit l’indépendance. Et l’indépendance la plus sûre ne vient pas de se procurer un autre modèle, mais de découper le problème en morceaux indépendants.

Axe 2 — Le verifier contourne l’indépendance

Le troisième levier est d’une nature différente. L’axe 1 sauve le vote en réduisant la corrélation des erreurs. Le verifier contourne la corrélation : même si les agents se trompent tous ensemble, un critère externe sans rapport avec leurs erreurs bloque la validation. Ce n’est pas un vote mais une porte. C’est pourquoi il fonctionne même là où l’on ne peut assurer l’indépendance, pourvu seulement qu’il s’agisse d’un domaine vérifiable.

Ce diagnostic n’est pas le mien seul. « Consensus is Not Verification » (arXiv:2603.06612) a cloué la même conclusion en premier : l’agrégation fondée sur le consensus n’apporte pas de gain cohérent par rapport à un échantillon unique et amplifie les malentendus partagés, et la mise à l’échelle au moment de l’inférence fonctionne dans les domaines vérifiables (mathématiques) mais échoue dans les domaines non vérifiables. Si cela marche en mathématiques, ce n’est pas parce que le consensus serait un signal de vérité, mais parce que le verifier filtre les candidats. J’accepte ce diagnostic et je fais un pas de plus — vers le remède. La source la plus puissante d’indépendance est la décomposition ; indépendance et vérification ne sont pas en concurrence mais complémentaires ; et le point où le verifier déterministe se sépare du juge LLM tient en trois (voir plus bas).

Or l’industrie confie même cette vérification au LLM — le LLM-as-Judge.

Commençons avec équité. Le juge LLM fonctionne souvent bien. Sur MT-Bench, le juge GPT-4 s’accordait à plus de 80 % avec les préférences humaines, soit le même niveau que l’accord entre humains (arXiv:2306.05685). Pour une évaluation de préférence vague, le juge LLM est utilisable. Le problème, c’est de savoir où il se brise.

Le juge se brise lorsqu’il partage les mêmes pièges que le générateur. Un LLM juge évalue plus haut que les humains les sorties qui lui sont familières (à faible perplexity) — self-preference bias (NeurIPS 2024 WS, arXiv:2410.21819). Si le juge partage la même distribution que le générateur, il laisse passer les hallucinations produites par le même modèle « parce qu’elles lui sont familières ». Si le taux d’accord de 80 % ne console pas, c’est que les 20 % d’erreurs se concentrent justement là où le générateur se trompe aussi — le problème n’est pas la précision moyenne mais la corrélation des erreurs. Le jugement vacille aussi sous des variables sans rapport avec la bonne réponse, comme la position où le candidat est présenté (position bias, arXiv:2406.07791).

Un argument auxiliaire. Le jugement LLM vacille jusque dans la couche matérielle. Même avec la même entrée et un greedy decoding à T=0, le résultat varie selon la configuration GPU à cause de la non-associativité en virgule flottante et du batching dynamique — en BF16, la précision a varié jusqu’à 9 pp (arXiv:2506.09501). C’est un problème de reproductibilité, pas de validité, je n’en fais donc pas un argument principal. Disons seulement qu’il est gênant d’asseoir sur le siège du juge final quelque chose qui ne garantit même pas la même réponse à la même question.

D’où une direction inverse. Générateur faible + verifier fort. Un modèle faible, doté du même verifier, s’approche d’un modèle fort, et les erreurs du modèle faible sont au contraire plus faciles à détecter (arXiv:2509.17995). On peut aussi combiner par pondération plusieurs verifiers faibles pour en faire un fort (Weaver, arXiv:2506.18203), ou raffiner la sortie d’un LLM par le retour d’un formal verifier pour garantir la cohérence (AlphaVerus, arXiv:2412.06176). Ce n’est pas une thèse marginale : les modèles de raisonnement et les agents de codage entraînés par récompenses vérifiables sont le domaine qui progresse aujourd’hui le plus vite, et Jason Wei l’a formalisé en verifier’s law : le degré de renforcement de l’IA est proportionnel à la vérifiabilité de la tâche.

Ici, il faut être honnête. Le verifier n’est pas un oracle magique. Des tests peuvent manquer, une spécification peut être fausse. Plus tranchant encore : si le verifier est écrit par un LLM, la critique que je viens d’adresser au LLM-as-Judge ressuscite telle quelle. Si le générateur et le verifier sont le même modèle, un test faux au même endroit laisse passer un code faux au même endroit. La corrélation des erreurs ne disparaît pas, elle ne fait que se déplacer vers la couche de vérification.

Alors, comment empêcher cette résurrection ? En élevant la fiabilité du verifier en dehors du générateur. Trois choses vont de pair.

Revue humaine. Le critère de vérification (spécification, tests, propriétés) est examiné une fois par une personne, puis figé. Même si un LLM en rédige le brouillon, le critère de validation est arrêté par une personne située hors de la distribution du générateur. Le coût n’est payé qu’une fois, et un critère une fois figé se réutilise à l’infini — point décisif de différence avec le LLM-as-Judge qui rejuge à chaque génération.
Réduction aux mathématiques et à la logique. Autant que possible, on déplace la vérification vers une forme mécaniquement décidable — type checking, invariants, preuves formelles, propriétés mathématiques. Ici, le « jugement » du LLM n’a aucune place. Le vrai/faux est tranché par une règle, non par l’opinion d’un modèle.
Tests répétés. Comme les erreurs du verifier sont reproductibles, elles s’améliorent cumulativement. En élargissant la couverture par tests de régression et property-based testing, le trou que le verifier a manqué une fois est figé en test et ne fuit plus jamais au même endroit. Le juge LLM, vacillant à entrée identique, rend cette accumulation impossible.

Ces trois éléments font du verifier un critère indépendant du biais du générateur. La façon de couper la corrélation des erreurs même dans la couche de vérification, c’est de clouer le verifier non pas à l’intérieur du modèle mais à l’extérieur — l’humain, les mathématiques, la suite de tests.

Alors, où se situe la différence du verifier déterministe ? Ce n’est pas l’absence d’erreur. C’est en trois points. Premièrement, le critère de vérification se trouve hors des poids du générateur — qu’il soit écrit par un humain ou produit par une autre procédure, on peut dresser un critère indépendant du biais du générateur (ce qui est structurellement impossible pour un juge LLM). Deuxièmement, l’erreur du verifier ne se révèle pas comme une hallucination assurée mais comme un échec détectable et reproductible — comme il donne le même verdict à entrée identique, il se débugue et s’améliore cumulativement. Troisièmement, la confiance se déplace vers une surface petite et auditable (spécification, tests) : une fois revue par un humain, elle se réutilise à l’infini. Le verifier ne garantit pas la précision ; c’est la qualité du verifier qui devient la borne supérieure de la précision — et non la taille du générateur.

L’intuition centrale

La formule de précision du multi-agent :

précision = f(précision individuelle, indépendance des erreurs, mécanisme de vérification)

L’industrie n’investit que dans le premier facteur (modèle plus grand). Elle ne conçoit pas le deuxième (indépendance) et confie le troisième (vérification) au LLM. Et la stratégie qui n’investit que dans le premier se heurte à un paradoxe : plus le modèle grossit, plus la corrélation des erreurs s’élève ; ainsi, plus on rassemble d’agents plus intelligents, plus ils se trompent ensemble, et en bons termes.

Les deuxième et troisième sont les vrais leviers. Et les deux ne sont pas en concurrence. L’indépendance (axe 1) sauve le vote, le verifier (axe 2) coupe là où le vote ne porte pas. Avoir les deux, c’est le plus fort.

Système de recherche d’Anthropic : la décomposition de l’axe 1 poussée à l’extrême — découper le problème en exploration parallèle indépendante. Amélioration de 90,2 % sans verifier.
SciencePedia (Chine, 2026) : plusieurs solvers indépendants résolvent chacun de leur côté (axe 1), et l’on ne conserve que ce qui fait consensus entre modèles (cross-model consensus, arXiv:2510.26854). Mais comme le filtre final est un « consensus de modèles », il n’a saisi que la moitié de l’axe 2 — le consensus n’est pas une vérification déterministe. C’est pourquoi on ne peut s’y fier que dans un domaine vérifiable comme les mathématiques ou la logique.
Pourquoi 8 agents du même modèle échouent : absence des deux axes. Indépendance zéro, boucle de vérification zéro. Les 8 se bloquent au même endroit, ensemble.
Pourquoi yongol fonctionne même avec Haiku : implémentation directe de l’axe 2. Même si la précision du modèle est basse, un verifier déterministe filtre à chaque étape — tant que la qualité du verifier soutient l’ensemble.

L’analogie démocratique

De même que la démocratie devient ochlocratie si elle se réduit au vote majoritaire d’électeurs ayant vu les mêmes nouvelles, le vote majoritaire de LLM entraînés sur les mêmes données est un consensus d’hallucinations. Le nombre de têtes ne fait pas la vérité. C’est un nombre de têtes indépendantes qui la fait. Et là où le nombre de têtes ne porte pas, c’est un critère hors du nombre de têtes qui la fait.

Le lien avec l’évolution

La même intuition se lit aussi dans les algorithmes d’apprentissage. En rétropropagation, les directions du gradient sont corrélées ; dans l’évolution, les mutations se dispersent indépendamment. Il est rapporté qu’un algorithme génétique n’utilisant aucun gradient explore un espace de solutions différent de celui des méthodes fondées sur le gradient en apprentissage par renforcement profond (Deep Neuroevolution, arXiv:1712.06567). L’exploration indépendante atteint là où l’exploration corrélée ne peut aller — le principe vu dans les ensembles prend la même forme en optimisation. Cependant « c’est meilleur à cause de l’indépendance » reste pour l’instant une interprétation a posteriori — je le laisse comme hypothèse, non comme preuve.

Conclusion

Le multi-agent, ce n’est pas « plus nombreux, plus précis ». La cible n’est pas le multi-agent mais le vote sans indépendance. Rassembler N exemplaires du même modèle pour voter à la majorité, c’est élever une chorale qui se trompe à l’unisson.

Il y a deux remèdes, et les deux sont réels. Premièrement, concevez l’indépendance — si l’on découpe le problème en morceaux indépendants (le plus sûr), le multi-agent fonctionne même avec le même modèle. Deuxièmement, s’il s’agit d’un domaine vérifiable, dressez un verifier en dehors du LLM — il relève la borne supérieure de la précision, indépendamment de l’indépendance.

Clouons honnêtement la portée. L’axe du verifier (axe 2) n’est une réponse que dans les domaines vérifiables — code, mathématiques, spécifications formelles, là où l’on peut trancher la bonne réponse par un critère externe. Dans les domaines dépourvus d’un tel critère — génération ouverte, résumé, conseil, création, jugement stratégique — l’axe 1, soit la conception de l’indépendance, est le seul levier qui reste. Le levier verrouillé, ce n’est pas la taille du modèle, mais l’indépendance des erreurs et, là où c’est possible, un verifier externe.

(Déclaration de conflit d’intérêts : je construis yongol, un outil dont le verifier déterministe est la clé de voûte. Mon cœur penche donc vers l’axe du verifier. Lisez l’argumentation ci-dessus en tenant compte de ce biais — si la colonne vertébrale est fausse, l’outil l’est aussi.)

Références

Condorcet et théorie des ensembles

Théorème du jury de Condorcet (1785) — les deux prémisses de la convergence majoritaire : précision individuelle >50 %, indépendance des erreurs
Krogh & Vedelsby, Neural Network Ensembles, Cross Validation, and Active Learning (NeurIPS 1994) — décomposition d’ambiguïté
Wood et al., A Unified Theory of Diversity in Ensemble Learning (JMLR 2023, arXiv:2301.03962) — décomposition bias-variance-diversity

Corrélation des erreurs des LLM / limites du consensus

Kim et al., Correlated Errors in Large Language Models (ICML 2025, arXiv:2506.07962) — 60 % de même mauvaise réponse en cas d’erreur simultanée, corrélation↑ pour les grands modèles
Lefort et al., Examining Independence in Ensemble Sentiment Analysis … Condorcet Jury Theorem (arXiv:2409.00094) — l’hypothèse d’indépendance de Condorcet rompue sur les LLM
Denisov-Blanch et al., Consensus is Not Verification: Why Crowd Wisdom Strategies Fail for LLM Truthfulness (2026, arXiv:2603.06612) — l’agrégation par consensus amplifie les malentendus partagés, la mise à l’échelle à l’inférence ne fonctionne que dans les domaines vérifiables (diagnostic identique à ce texte — différencié dans le corps par le remède)

Multi-agents : indépendance et décomposition

Cemri et al., Why Do Multi-Agent LLM Systems Fail? (UC Berkeley, 2025, arXiv:2503.13657) — analyse de 1 600+ traces d’exécution sur 7 frameworks. 14 modes d’échec classés en 3 catégories : conception du système, échec d’alignement entre agents, vérification (task verification)
Smit et al., Should we be going MAD? (ICML 2024, arXiv:2311.17371) — le débat ne bat pas de façon stable une baseline simple
Zhang et al., Stop Overvaluing Multi-Agent Debate (arXiv:2502.08788) — l’hétérogénéité est l’antidote (fonctionne si l’indépendance est restaurée)
Du et al., Improving Factuality and Reasoning through Multiagent Debate (ICML 2024, arXiv:2305.14325) — thèse positive originelle du MAD
Wang et al., Self-Consistency Improves Chain of Thought Reasoning (ICLR 2023, arXiv:2203.11171) — le gain de la diversification des chemins
Turkmen et al., Don’t Always Pick the Highest-Performing Model: An Information Theoretic View of LLM Ensemble Selection (2026, arXiv:2602.08003) — le critère de sélection d’ensemble n’est pas la performance individuelle mais corrélation↓ (maximisation de l’information mutuelle). Faibles mais divers, ils gagnent

Fiabilité du LLM-as-Judge

Zheng et al., Judging LLM-as-a-Judge with MT-Bench and Chatbot Arena (NeurIPS 2023, arXiv:2306.05685) — le juge GPT-4 s’accorde à 80 %+ avec l’humain (preuve positive)
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) — la sortie vacille même à T=0

Générateur faible + verifier fort

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)

Cas de génération vérifiable

SciencePedia (DP Technology / DeepModeling, 2026) — Inverse Knowledge Search over Verifiable Reasoning (arXiv:2510.26854). Solvers indépendants + filtre cross-model consensus

Évolution vs gradient

Such et al., Deep Neuroevolution (arXiv:1712.06567) — le GA explore un espace de solutions différent du gradient

Mesure de première main (l’auteur lui-même)

ZenFlow / Grok Build : 8 agents concurrents, 3 endpoints sur 10 inachevés (validation non passée)
ZenFlow / yongol : Haiku va au bout, Sonnet 131 min, Opus 76 min