AI CodeOps

Schémas multi-agents : pipelines, revues parallèles et débat

Mis à jour le

Les façons courantes de répartir le travail logiciel entre agents IA (pipelines, revues parallèles, débat, orchestrateurs, boucles de vérification) et comment chaque schéma échoue.

Les schémas multi-agents sont les façons dont un travail logiciel est réparti entre plusieurs agents IA aux rôles différents. Les plus courants sont un pipeline de rôles dans l'ordre, des perspectives parallèles qui examinent le même travail sous différents angles avant d'être fusionnées, le débat, où des agents proposent et critiquent des alternatives, un orchestrateur qui distribue des sous-tâches, et les boucles de génération et de vérification. Chacun échange du coût et de la complexité contre de la concentration et une vérification indépendante. Le schéma compte moins que deux choses : si les agents de vérification voient des preuves réelles, et si leurs boucles sont bornées.

Cette page développe la section « Agent unique ou développement multi-agents » de Comment les agents IA s'intègrent-ils au cycle de vie logiciel ?.

Pourquoi répartir le travail entre plusieurs agents

Un agent unique compétent peut planifier, écrire et tester un changement à lui seul. Répartir le travail présente trois avantages principaux :

  • Concentration. Chaque agent reçoit un rôle étroit et uniquement le contexte dont il a besoin. Un relecteur chargé uniquement de chercher des problèmes de sécurité a tendance à les chercher plus attentivement qu'un agent généraliste à qui l'on demande de « vérifier aussi la sécurité ».
  • Indépendance. La sortie d'un agent est vérifiée par un autre qui ne l'a pas produite et n'a aucun intérêt à la défendre.
  • Traçabilité. Chaque étape produit sa propre trace, ce qui permet de voir plus facilement où un plan a dérapé.

Cela a aussi des coûts. Davantage d'appels au modèle coûtent davantage. Chaque passage de relais entre agents perd une partie du contexte. Et la coordination elle-même peut échouer : des agents peuvent mal interpréter la sortie des autres ou refaire le travail des autres.

Le pipeline

Les agents s'exécutent l'un après l'autre, chacun avec un rôle fixe : par exemple planifier, développer, relire, tester. Chaque étape lit la tâche et tout ce qu'ont écrit les étapes précédentes.

  • Bon pour : la plupart des travaux de fonctionnalités et des corrections de bugs, où les étapes sont bien comprises.
  • À surveiller : les erreurs qui se propagent. Un plan erroné produit une implémentation fidèle de la mauvaise chose. Une étape de revue qui ne lit que le plan, et non le code, ne peut pas repérer les erreurs d'implémentation.

Perspectives parallèles

Plusieurs agents examinent la même chose sous différents angles, comme l'exactitude, la sécurité et la couverture de tests, et une étape finale fusionne leurs constats en un seul résultat. Les agents peuvent réellement s'exécuter en même temps, ou l'un après l'autre ; ce qui définit le schéma, c'est que chacun examine le travail de façon indépendante.

  • Bon pour : la revue et l'inspection, où des spécialités différentes remarquent des problèmes différents.
  • À surveiller : les constats en double, et une étape de fusion qui écarte des préoccupations valables en résumant. Si les perspectives s'exécutent en séquence, les relecteurs suivants peuvent s'ancrer sur les précédents au lieu d'examiner le travail de façon indépendante.

Débat

Deux agents ou plus proposent des approches différentes du même problème, un critique les évalue, et une étape finale choisit l'une d'elles ou les combine.

  • Bon pour : les décisions de conception avec de vrais compromis, comme les choix d'architecture, les modèles de données ou les stratégies de migration, où voir les alternatives côte à côte est tout l'intérêt.
  • À surveiller : des propositions qui ne diffèrent qu'en surface. Des agents fondés sur le même modèle peuvent converger vers la même idée formulée autrement. Demandez explicitement des approches différentes, avec leurs compromis énoncés.

Orchestrateur et exécutants

Un agent coordinateur découpe une tâche volumineuse en sous-tâches, les attribue à des agents exécutants et combine les résultats. Contrairement à un pipeline, les étapes sont décidées au moment de l'exécution.

  • Bon pour : les tâches volumineuses et divisibles, comme des changements touchant de nombreux modules, ou des recherches sur de nombreuses sources.
  • À surveiller : un coût et une durée imprévisibles, puisque l'orchestrateur décide de la quantité de travail à créer, et des sous-tâches qui entrent en conflit une fois combinées. Ce schéma exige les limites les plus strictes sur le temps, les tokens et le nombre d'exécutants.

Générer et vérifier

Un agent produit quelque chose, un autre le vérifie, et la boucle se répète jusqu'à ce que la vérification réussisse : écrire le code, exécuter les tests, corriger, relancer.

  • Bon pour : les tâches dotées d'une vérification objective, comme faire passer des tests ou satisfaire un linter.
  • À surveiller : les boucles qui ne convergent jamais, et les vérificateurs qui peuvent être satisfaits de la mauvaise manière. Si la vérification est « les tests passent », la voie la moins coûteuse peut consister à affaiblir les tests. Limitez le nombre de tours, et considérez que toute modification des vérifications elles-mêmes doit être relue.

Comparaison des schémas

SchémaIdéal pourRisque principalCoût relatif
PipelineTravaux courants de fonctionnalités et de correctionsErreurs initiales propagées à chaque étapeModéré
Perspectives parallèlesRevue et inspectionDoublons ; constats perdus lors de la fusionModéré à élevé
DébatDécisions de conception avec compromisDes alternatives qui ne sont pas vraiment différentesModéré
Orchestrateur–exécutantsTâches volumineuses et divisiblesTravail non borné ; résultats de sous-tâches contradictoiresÉlevé et variable
Générer et vérifierTâches dotées d'une vérification objectiveBoucles qui ne convergent pas ; contournement de la vérificationVariable ; exige des limites

Comment les systèmes multi-agents échouent

Les modes de défaillance sont pour la plupart les mêmes d'un schéma à l'autre.

  • Erreurs corrélées. Des agents qui partagent un modèle et des instructions similaires partagent leurs angles morts. Trois relecteurs qui manquent le même bug ne sont pas trois fois plus sûrs qu'un seul.
  • Vérifier des résumés au lieu de preuves. Un relecteur qui lit la description du changement rédigée par l'agent qui l'a écrit, plutôt que le diff, vérifie une affirmation. Transmettez de vrais artefacts entre agents : diffs, sortie des tests, messages d'erreur.
  • Perte de contexte aux passages de relais. Chaque agent ne voit que ce qu'on lui donne. Des contraintes mentionnées tôt dans la tâche peuvent avoir disparu à la quatrième étape.
  • Accord pris pour exactitude. Que plusieurs agents parviennent à la même conclusion ne prouve pas qu'elle est juste, surtout s'ils lisent la sortie les uns des autres.
  • Multiplication des coûts. Chaque agent relit le contexte. Un workflow comptant de nombreuses étapes peut coûter bien des fois plus qu'une exécution à agent unique.

Les mesures d'atténuation sont elles aussi les mêmes : des instructions différentes pour des rôles différents, des preuves réelles pour chaque étape de vérification, des limites sur les tours, le temps et les dépenses, et une personne qui approuve le résultat.

Choisir un schéma

Commencez par l'organisation la plus simple qui inclut une vérification indépendante : un pipeline court dont les dernières étapes relisent le changement réel et exécutent de vrais tests. Ajoutez des perspectives parallèles lorsque la qualité de la revue compte plus que le coût, le débat lorsque la difficulté réside dans la décision plutôt que dans le code, et l'orchestration uniquement pour les tâches qui ne tiennent vraiment pas dans le contexte d'un seul agent. Ajoutez un agent lorsqu'il vérifie quelque chose que les autres ne vérifient pas.

Comment AI CodeOps s'y prend

Les sessions AI CodeOps exécutent l'un des 16 workflows intégrés, chacun étant une liste fixe d'étapes exécutées par des agents nommés. Le workflow par défaut, Plan, Build, Review & Test, est un pipeline. Parallel Review comporte des revues d'exactitude, de sécurité et de couverture de tests suivies d'une étape de fusion. Swarm Inspection confie les volets relecteur, sécurité et testeur à des étapes distinctes et les fusionne. Architecture Debate fait proposer des approches par deux architectes, les fait relire par un critique et se termine par une synthèse finale.

Dans chaque workflow, les étapes s'exécutent l'une après l'autre, et chacune voit ce qu'ont écrit les étapes précédentes. Les étiquettes parallel, debate et swarm décrivent la façon dont le travail est réparti, pas le moment où il s'exécute. Rien n'est décidé par vote. Le changement est écrit sur une copie neuve du dépôt après l'étape qui l'implémente, et vos tests s'exécutent dans un bac à sable. Les étapes suivantes, comme Review et Test, s'exécutent ensuite et lisent le changement écrit et le résultat des tests. Une passe des constats distincte relit ensuite le diff réel. Puis une personne approuve. Vous ne pouvez pas encore définir vos propres workflows.

Consultez Workflows pour chaque workflow intégré et ses étapes, et Revues multi-agents pour la façon dont les étapes de revue et la passe des constats s'articulent.

Questions fréquentes

Les systèmes multi-agents écrivent-ils un meilleur code qu'un agent unique ?

Pas automatiquement. Répartir le travail aide lorsque chaque agent reçoit une tâche ciblée et que la sortie d'un agent est réellement vérifiée par un autre. Cela ajoute aussi du coût et des passages de relais, si bien qu'un agent unique peut être le meilleur choix pour des tâches petites et bien définies.

Les agents d'un workflow doivent-ils s'exécuter en parallèle ?

Seulement lorsque leur travail est indépendant. L'exécution en séquence est plus lente mais permet à chaque étape de lire tout ce qui la précède, et c'est souvent ce qui rend utile une revue ou une décision finale.

Chaque agent doit-il utiliser le même modèle ?

Pas nécessairement. Des agents sur le même modèle avec des prompts similaires peuvent partager les mêmes angles morts. Des instructions différentes aident, et un modèle différent pour les étapes de revue peut apporter davantage d'indépendance.

Comment empêcher les agents de s'accorder sur la même erreur ?

Donnez aux agents de vérification des preuves réelles, comme le diff effectif et la sortie des tests, plutôt que les résumés des autres agents, demandez-leur de chercher des problèmes plutôt que de confirmer, et gardez une personne pour approuver le résultat.