Gouvernance

Orchestrer plusieurs agents IA avec gouvernance

· fondateur d'ETCSEC · mis à jour le 11 novembre 2026 · 10 min
La réponse courte

Les équipes qui appliquent déjà un périmètre de fichiers et une revue avant fusion voient encore des conflits, car l'échec commence plus tôt : un brief non découpé, pas les agents en parallèle eux-mêmes. La chaîne qui empêche vraiment les conflits va du brief aux tickets, des tickets aux agents avec périmètre réservé, puis à la revue et à l'intégration qui rejoue les contrôles du projet, quel que soit le client MCP utilisé.

L'échec commence avant que le premier agent ne s'exécute

Un CTO qui dit que faire tourner des agents en parallèle crée des conflits, des doublons et des livraisons non relues a généralement déjà résolu la moitié du problème : un worktree et une branche dédiés par agent, un périmètre de fichiers réservé par ticket, et une revue avant fusion, les cinq pratiques qu'un guide connexe de ce blog couvre déjà, illustrées là-bas avec Claude Code mais sans s'y limiter. Ce qui brise la chaîne avant même que tout cela s'applique se situe plus en amont : un brief qui n'est jamais devenu un ensemble de tickets distincts et délimités au départ, et une étape de revue et d'intégration qui doit tenir quel que soit le client ayant exécuté quel agent.

Rien de ce qui suit ne répète les pratiques de worktree, de périmètre ou de revue avant fusion déjà documentées ; cela couvre les deux parties de la chaîne qui se situent de part et d'autre, transformer un brief en tickets avant que le travail en parallèle ne commence, et coordonner la revue et l'intégration une fois que plusieurs livraisons arrivent en même temps, construit autour de l'architecture neutre vis-à-vis de l'hôte propre au Model Context Protocol plutôt qu'autour d'un client spécifique.

Traiter les cinq pratiques et cette chaîne comme une seule et même chose est l'erreur qui amène une équipe à adopter le périmètre de fichiers et la revue, à voir quand même des conflits, et à conclure que les pratiques ne fonctionnent pas ; les pratiques résolvent ce qui se passe une fois que les tickets existent, et une équipe qui passe directement à des agents en parallèle depuis un brief non découpé reste exposée au mode d'échec que ces cinq pratiques n'ont jamais été conçues pour intercepter.

L'architecture de MCP est neutre vis-à-vis de l'hôte, ce qui explique pourquoi la chaîne fonctionne avec tout client

La vue d'ensemble de l'architecture propre au protocole, version 2026-07-28, décrit MCP comme un modèle client-serveur où un hôte MCP, « une application IA comme Claude Code ou Claude Desktop », crée un client MCP pour chaque serveur auquel il se connecte, chaque client détenant une connexion dédiée à son serveur. La documentation donne un second hôte, différent, comme son propre exemple : quand Visual Studio Code se connecte au serveur MCP Sentry puis à un serveur de système de fichiers local, le runtime de Visual Studio Code instancie un objet client distinct pour chacun.

Cette conception explique pourquoi une chaîne de gouvernance construite sur des tickets, un périmètre et une revue n'a pas besoin d'être réécrite pour chaque client : l'hôte change, Claude Code, Claude Desktop, VS Code, ou toute autre application mettant en œuvre le protocole, mais le modèle de connexion client-serveur, et les outils, ressources et prompts qu'un serveur expose, restent les mêmes en dessous. Un ticket qui nomme un périmètre de fichiers et un critère d'acceptation contraint l'agent quel que soit l'hôte qui l'exécute ce jour-là.

La même vue d'ensemble précise deux mécanismes de transport sous ce modèle client-serveur, un transport stdio pour un serveur local parlant à un seul client sur la même machine, et un transport Streamable HTTP pour un serveur distant servant plusieurs clients à la fois, chacun transportant le même format de message JSON-RPC quel que soit le transport ou l'hôte de l'autre côté.

Du brief aux tickets : ce qui doit être décidé avant que le travail en parallèle ne commence

Un brief, écrit pour une personne, regroupe généralement plusieurs changements qui touchent différentes parties d'une base de code ou d'un jeu de données sous une seule description. Le découper en tickets qu'un ensemble d'agents peut exécuter en parallèle signifie décider, avant qu'aucun agent ne démarre, quelles parties de ce brief peuvent être traitées sans toucher les mêmes fichiers, lesquelles dépendent d'un autre ticket terminé en premier, et lequel devrait au contraire rester un ticket unique absorbant un changement trop imbriqué pour être découpé en sécurité.

Chaque ticket résultant a toujours besoin des deux choses qu'un modèle de gouvernance basé sur les tickets exige déjà : un périmètre de fichiers réservé avant le lancement de l'agent, afin que deux tickets en cours ne puissent pas revendiquer les mêmes fichiers, et des critères d'acceptation écrits à l'avance, afin que l'agent ait une cible vérifiable et que le relecteur dispose d'un test objectif plutôt que du propre résumé de l'agent sur ce qu'il a fait. Mal faire ce découpage ici, des périmètres qui se chevauchent, ou des critères d'acceptation copiés mot pour mot du brief d'origine sans être rendus spécifiques à chaque ticket, est ce qui produit le travail en double et les conflits de fusion qu'un CTO constate en aval, même quand toutes les autres pratiques de la chaîne sont correctement suivies.

Un brief qui regroupe une migration de base de données avec un changement d'interface sans rapport est le cas le plus clair à découper avant d'assigner des agents, puisque les deux touchent des fichiers disjoints et portent un risque indépendant ; un brief qui change la signature d'une fonction et tous les fichiers qui l'appellent est le cas le plus clair à conserver comme ticket unique, puisque le découper reviendrait à donner à deux agents un périmètre qui se chevauche sur le même changement.

La chaîne, étape par étape

Le tableau ci-dessous nomme le contrôle à chaque étape de la chaîne, du brief à l'intégration, et où ce contrôle apparaît déjà plus en détail ailleurs sur ce blog plutôt que de le répéter ici.

ÉtapeCe qui doit se passerOù c'est couvert
Du brief aux ticketsDécoupage en périmètres de fichiers non chevauchants, chacun avec ses propres critères d'acceptationCet article
Du ticket à l'agent en parallèleWorktree et branche par agent, périmètre appliqué avant lancementGuide des agents Claude Code en parallèle
De l'agent à la livraisonLa liste d'outils et les actions disponibles peuvent changer en cours d'exécution ; les agents se resynchronisent via les notifications MCPVue d'ensemble de l'architecture MCP
De la livraison à la revueRelu par quelqu'un d'autre que le demandeur, sur le diff réelGuide de gouvernance des agents IA
De la revue à l'intégrationLes propres contrôles du projet rejoués à la fusion, pas supposés depuis la seule revueGuide de gouvernance des agents IA

Faire tourner des agents en parallèle sans perdre le fil

Une fois que plusieurs agents s'exécutent contre leurs propres périmètres réservés, le problème de coordination passe des conflits de fichiers au maintien de la synchronisation sur ce que chaque agent a réellement le droit de faire. Le système de notification propre à MCP existe précisément pour cela : un serveur peut indiquer aux clients connectés quand ses outils disponibles changent, par exemple quand un outil est ajouté, modifié ou temporairement désactivé, et un client abonné à cette notification rafraîchit sa liste d'outils plutôt que de continuer à travailler à partir d'une liste périmée.

Pour une équipe faisant tourner plusieurs agents contre les mêmes serveurs MCP, cela signifie qu'un changement de périmètre ou de permission effectué en cours d'exécution, un outil nouvellement bloqué par un administrateur, un serveur mis hors ligne pour maintenance, se propage à chaque agent connecté via le protocole lui-même, au lieu de dépendre du redémarrage de chaque agent pour prendre en compte le changement.

Il s'agit d'un mécanisme opt-in, pas de quelque chose qu'un client obtient automatiquement : la documentation propre au protocole précise que les notifications de changement ne sont envoyées qu'aux clients qui s'y sont abonnés, et que le polling garde un rôle puisque la livraison est au mieux (« best-effort ») plutôt que garantie, en particulier lors d'une reconnexion.

La revue doit avoir lieu une fois, par quelqu'un qui n'a pas fait le travail

Faire tourner cinq tickets en parallèle ne signifie pas inventer cinq normes de revue différentes ; cela signifie appliquer la même règle, la personne qui a demandé le travail n'est pas celle qui l'approuve, à chaque livraison qui arrive, qu'elles arrivent une par une ou toutes le même après-midi. La propre documentation de GitHub sur son agent de codage Copilot énonce la même contrainte pour un flux de travail comparable : une approbation de la personne qui a assigné le travail ne compte pas parmi les revues requises d'un dépôt.

Ce qui change sous charge parallèle, ce n'est pas la norme, c'est le volume qu'un relecteur doit absorber à la fois, ce qui est la raison pour laquelle le même guide de pratiques plafonne déjà les sessions simultanées à ce que la revue peut effectivement suivre, plutôt que de traiter la capacité de revue comme illimitée simplement parce que les agents eux-mêmes peuvent s'exécuter en parallèle.

Un plafond sur les sessions simultanées, déjà recommandé ailleurs sur ce blog à trois à cinq, est la forme pratique que cela prend : ce n'est pas une limite sur le nombre d'agents qu'un outil peut faire tourner, c'est une limite adaptée au nombre de livraisons pour lesquelles un relecteur, ou une rotation de relecture, peut effectivement lire le diff avant d'approuver.

L'intégration rejoue les contrôles, elle ne fait pas confiance à la seule revue

Un diff qui a passé la revue fusionne quand même dans un historique partagé dont dépend chaque autre ticket en cours, ce qui explique pourquoi le modèle de gouvernance que ce blog a déjà documenté rejoue les propres contrôles du projet au moment de l'intégration, plutôt que de s'appuyer uniquement sur la revue qui l'a précédée. Sous un travail en parallèle, cette étape compte davantage, pas moins : deux tickets relus et approuvés peuvent quand même entrer en conflit l'un avec l'autre d'une manière qu'aucun des deux relecteurs n'a vue isolément, et l'intégration est le moment où ce conflit apparaît réellement.

Traiter l'intégration comme un second contrôle indépendant plutôt que comme une formalité après la revue est ce qui empêche un conflit de fusion de devenir un incident de production découvert après coup plutôt qu'une fusion bloquée interceptée avant.

Rien de tout cela n'exige un outil différent pour le travail en parallèle par rapport au travail séquentiel ; la même étape de rejeu à l'intégration s'applique à un ticket unique fusionné seul, elle a simplement plus d'occasions de détecter quelque chose quand plusieurs tickets arrivent en même temps.

Construire la chaîne au sein d'une équipe

Les pratiques de worktree, de branche et de périmètre de fichiers qui font fonctionner l'étape des agents en parallèle de cette chaîne, plafond inclus, sont couvertes intégralement sur atipol.ai/agentic-ai-blog/parallel-claude-code-agents. La manière dont le coût de faire tourner plusieurs agents en parallèle est suivi par ticket plutôt que par mois est couverte sur atipol.ai/agentic-ai-blog/ai-agent-costs, et la visite guidée montrant un ticket passer du brief au travail en parallèle à la revue puis à l'intégration de bout en bout se trouve sur atipol.ai/tour.

Questions fréquentes

Une chaîne d'orchestration multi-agents gouvernée fonctionne-t-elle avec des clients IA autres que Claude Code ?

Oui. L'architecture propre au Model Context Protocol est neutre vis-à-vis de l'hôte : sa documentation décrit Claude Code, Claude Desktop et Visual Studio Code comme des exemples d'hôtes qui créent chacun leur propre client MCP par serveur, avec le même modèle de connexion client-serveur en dessous. Une chaîne construite sur des tickets, un périmètre de fichiers et une revue contraint l'agent quel que soit l'hôte qui l'exécute.

Que faut-il décider avant de découper un brief en tickets pour des agents en parallèle ?

Quelles parties du brief touchent des fichiers différents et peuvent s'exécuter sans chevauchement, lesquelles dépendent d'un autre ticket terminé en premier, et lesquelles sont trop imbriquées pour être découpées en sécurité et devraient rester un ticket unique. Chaque ticket résultant a toujours besoin de son propre périmètre de fichiers réservé et de critères d'acceptation écrits avant le lancement de l'agent.

Pourquoi rejouer les contrôles à l'intégration si une livraison a déjà été relue ?

Parce qu'une revue couvre un diff isolément, alors que l'intégration est le moment où ce diff rencontre chaque autre changement fusionné depuis le début de la revue. Deux tickets relus et approuvés séparément peuvent quand même entrer en conflit l'un avec l'autre d'une manière qu'aucun des deux relecteurs n'a vue, ce qui explique pourquoi rejouer les propres contrôles du projet au moment de la fusion détecte ce que la revue seule ne peut pas.

Sources

Essayez sur un vrai projet

La démo publique montre une organisation fictive en fonctionnement, sans compte. L'offre gratuite donne un projet, trois agents et un agent lead.