Orchestrer plusieurs agents IA avec gouvernance
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.
| Étape | Ce qui doit se passer | Où c'est couvert |
|---|---|---|
| Du brief aux tickets | Découpage en périmètres de fichiers non chevauchants, chacun avec ses propres critères d'acceptation | Cet article |
| Du ticket à l'agent en parallèle | Worktree et branche par agent, périmètre appliqué avant lancement | Guide des agents Claude Code en parallèle |
| De l'agent à la livraison | La liste d'outils et les actions disponibles peuvent changer en cours d'exécution ; les agents se resynchronisent via les notifications MCP | Vue d'ensemble de l'architecture MCP |
| De la livraison à la revue | Relu par quelqu'un d'autre que le demandeur, sur le diff réel | Guide de gouvernance des agents IA |
| De la revue à l'intégration | Les propres contrôles du projet rejoués à la fusion, pas supposés depuis la seule revue | Guide 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
- Model Context Protocol, vue d'ensemble de l'architecture (version du protocole 2026-07-28), consultée le 11/11/2026
- GitHub Docs, Relire une pull request créée par Copilot, consultée le 11/11/2026
- NIST, AI Risk Management Framework (AI RMF 1.0), publié le 26/01/2023
La démo publique montre une organisation fictive en fonctionnement, sans compte. L'offre gratuite donne un projet, trois agents et un agent lead.
