Aller au contenu
EN 4 QUESTIONSTrouver mon modèle
Agents et automatisation · guide nerd · 25 min de lecture

Faire travailler plusieurs agents ensemble, sans casse

Plusieurs agents vont plus vite et se relisent mieux qu'un seul, à condition de ne pas se marcher dessus. Voici les trois montages possibles, leur réglage pas à pas et les règles qui évitent les dégâts.

Illustration du thème Agents et automatisation

Un agent qui vient d’écrire du code est mal placé pour le juger : il relit ce qu’il voulait faire plutôt que ce qu’il a fait. Un second agent, qui n’a rien écrit, voit ce que le premier ne voit plus. Plusieurs agents permettent aussi d’avancer sur plusieurs fronts à la fois. Le risque change de nature : deux agents qui modifient le même fichier, un relecteur qui se prend pour un chef, une facture qui grimpe.

Comment ça marche

Deux agents travaillent chacun dans sa copie du dépôt, sur sa branche ; un troisième relit sans coder. Un fichier de notes partagé garde la trace de qui fait quoi.

Trois montages existent, du plus léger au plus lourd :

  • Les sous-agents. Dans une même session, l’agent principal confie une tâche à un assistant spécialisé. Celui-ci travaille dans son propre contexte, avec ses propres outils, et ne rapporte qu’un résumé. Les journaux, résultats de recherche et fichiers lus restent hors de la conversation principale. Claude Code, Codex, Gemini CLI et Hermes savent le faire.
  • Les sessions parallèles. Vous lancez vous-même plusieurs sessions, chacune dans sa propre copie de travail du dépôt (un worktree Git) sur sa branche. Elles ne peuvent pas écraser les fichiers les unes des autres.
  • Les équipes d’agents. Dans Claude Code, une session chef lance des coéquipiers, chacun étant une session complète. Ils partagent une liste de tâches, se répartissent le travail et s’écrivent directement. La fonction est expérimentale et coupée par défaut.
Montage Communication Coût en jetons
Sous-agents Ils rendent un résultat à l’agent principal Plus faible : seul le résumé revient
Sessions parallèles Par vous, ou par un fichier de notes partagé Une session par agent
Équipe d’agents Les coéquipiers s’écrivent entre eux Plus élevé : chaque coéquipier est une instance complète

À quoi ça sert

  • Une relecture sous plusieurs angles : un agent sur la sécurité, un sur les performances, un sur les tests, puis une synthèse.
  • Un bogue dont on ignore la cause : chaque agent défend une hypothèse et cherche à réfuter celles des autres. La documentation de Claude Code décrit ce montage, qui évite de s’arrêter sur la première explication plausible.
  • Des modules indépendants : l’interface, le serveur et les tests, chacun confié à un agent qui ne touche qu’à ses fichiers.
  • Un relecteur permanent : une session qui ne code pas, relit le travail des autres et vérifie que la machine tient debout.

Pas à pas : un sous-agent relecteur

Dans Claude Code, un sous-agent est un fichier Markdown avec un en-tête, rangé dans .claude/agents/ (projet) ou ~/.claude/agents/ (tous vos projets).

  1. Créez .claude/agents/relecteur.md :
---
name: relecteur
description: Relit les changements en cours et signale bogues et risques. À utiliser après chaque modification importante.
tools: Read, Grep, Glob
model: sonnet
---

Tu relis le code sans jamais le modifier. Pour chaque problème, donne le fichier,
la ligne, la raison et la gravité. Si tu n'es pas sûr, dis-le.
  1. Le champ tools est une liste blanche : avec Read, Grep, Glob, le relecteur lit et cherche, mais ne peut ni écrire ni lancer de commande. Le corps du fichier devient ses consignes.
  2. Ouvrez une session et demandez « fais relire mes changements par le relecteur ». Claude délègue aussi seul quand la description correspond.
  3. Pour qu’un sous-agent travaille dans sa propre copie du dépôt, ajoutez isolation: worktree à son en-tête. Claude Code supprime la copie à la fin si elle n’a pas changé.

Pas à pas : des sessions parallèles

  1. Créez une copie de travail par agent, chacune sur sa branche :
git worktree add ../projet-tests -b agent-tests
git worktree add ../projet-doc -b agent-doc
git worktree list
Terminal : deux commandes git worktree add créent les copies demo-projet-tests et demo-projet-doc, puis git worktree list affiche les trois dossiers avec leurs branches main, agent-doc et agent-tests.
Sortie réelle, relevée le 17 novembre 2026 sur le mini-PC de QUELLE IA dans un dépôt d'essai : une copie de travail par agent, chacune sur sa branche.
  1. Ouvrez un terminal par copie et lancez l’agent dedans. Avec Claude Code, claude --worktree tests fait les deux d’un coup : la copie est créée dans .claude/worktrees/tests/, sur une branche worktree-tests.
  2. Une copie neuve ne contient pas les fichiers ignorés par Git, comme .env. Pour Claude Code, listez-les dans un fichier .worktreeinclude à la racine, avec la syntaxe de .gitignore, et ils seront recopiés.
  3. Installez les dépendances dans chaque copie : c’est un projet complet.
  4. Lancez chaque session dans tmux (tmux new -s tests). Une session ouverte dans une simple connexion SSH meurt avec la connexion.
  5. Quand une branche est prête, fusionnez-la comme le travail d’un collègue, après relecture.

Pas à pas : une équipe d’agents dans Claude Code

  1. Activez la fonction dans settings.json :
{
  "env": {
    "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1"
  }
}
  1. Décrivez l’équipe en langage courant, avec des rôles indépendants :
Lance trois coéquipiers pour relire la demande de fusion 142 :
un sur la sécurité, un sur les performances, un sur la couverture de tests.
Chacun rend ses constats, puis fais la synthèse.
  1. Les coéquipiers apparaissent sous la zone de saisie. Les flèches choisissent un coéquipier, Entrée ouvre sa session pour lui écrire. Pour un panneau par coéquipier, réglez "teammateMode": "auto" et lancez Claude Code dans tmux ou iTerm2.
  2. Les demandes d’autorisation des coéquipiers remontent dans la session chef : approuvez-les là.
  3. Pour arrêter un coéquipier, demandez au chef de lui dire de s’arrêter, en le nommant.

Anthropic conseille de commencer avec trois à cinq coéquipiers et de débuter par des tâches de recherche ou de relecture, car elles se coordonnent plus facilement qu’une écriture de code en parallèle. Les coéquipiers ne reviennent pas après une reprise de session (/resume), et un coéquipier ne peut pas lancer sa propre équipe.

Les garde-fous

  1. Un périmètre par agent. Deux agents qui modifient le même fichier s’écrasent. Découpez le travail par fichiers ou par dossiers, et dites-le dans la consigne de chacun.
  2. Le relecteur ne code pas. Son intérêt vient de ce qu’il n’a rien écrit. S’il corrige lui-même, il perd ce recul et sort de son périmètre.
  3. Le droit de refus. Un agent présenté comme superviseur se trompe aussi. Dites à chaque session qu’elle peut refuser une correction proposée par une autre, mesures à l’appui, et qu’un agent qui s’est trompé retire sa position sans en faire un plat.
  4. Mesurer avant d’affirmer. Un agent fabrique vite une explication plausible à partir de trois mesures. Demandez l’expérience qui fait varier une seule chose à la fois.
  5. Un message d’agent n’est pas votre accord. Claude Code prévient chaque agent qu’un message vient d’une autre session. Un coéquipier ne peut pas approuver une action à votre place, et une action refusée à l’un ne s’obtient pas en la confiant à un autre.
  6. Annoncer ses effets de bord. Un agent qui touche hors de son périmètre, redémarre un service ou lance des appels payants le dit aux autres avant qu’ils ne le découvrent.
  7. Une trace écrite. Notes de progression et historique Git servent de mémoire commune. L’équipe d’Anthropic qui a fait construire une application sur de nombreuses sessions s’appuyait sur un fichier de progression et des enregistrements Git fréquents pour reprendre le travail d’une session à l’autre.
  8. Compter les jetons. La consommation croît avec le nombre d’agents actifs. Pour une tâche de routine, une seule session coûte moins cher.

Le brief d’un relecteur

Une session de relecture lancée sans consigne se contente de commenter. Ce brief, à adapter, cadre son rôle :

Tu relis le travail des autres sessions de la machine. Tu ne modifies aucun de leurs fichiers.
Avant d'affirmer une cause, montre la mesure qui l'isole ; sinon, présente-la comme une hypothèse.
Juge sur les commandes exécutées et l'état réel des fichiers, jamais sur la description qu'une session donne de son travail.
Si tu dois toucher à un fichier hors de ton périmètre, préviens la session concernée d'abord.
Si une action t'est refusée, arrête-toi et préviens-moi : tu ne la fais jamais faire par une autre session.

Chaque ligne de ce brief répond à une erreur réelle : une cause annoncée sur trois mesures non contrôlées, une action signalée qui n’avait jamais eu lieu, un fichier corrigé dans le périmètre d’un autre.

Pour aller plus loin

Sur mini lab AI, un guide du même auteur reprend ce sujet pour monter son atelier d'IA à la maison.

Tous les guides →

Sources

  1. code.claude.com, lue le
  2. code.claude.com, lue le
  3. code.claude.com, lue le
  4. anthropic.com, lue le