Comment faire fonctionner plusieurs agents IA en même temps

Faire fonctionner un seul agent IA à la fois est le mode par défaut. Mais rien ne vous empêche d'en lancer deux, trois ou cinq en parallèle, chacun travaillant sur une partie différente de votre projet. Voici comment faire, à quoi faire attention et dans quels cas cela a du sens.

Pourquoi exécuter plusieurs agents ?

La raison la plus simple : le temps. Si vous avez trois tâches indépendantes et que chacune prend 5 minutes de travail agentique, les exécuter l'une après l'autre prend 15 minutes. Les exécuter en parallèle en prend 5.

Mais le gain de temps n'est pas le seul avantage :

• Spécialisation — Différents agents peuvent traiter différents types de travail. Utilisez Claude Code pour les refontes complexes, Codex pour le prototypage rapide et un script shell pour les tâches mécaniques.
• Boucles de revue — Un agent écrit le code, un autre le relit. Retour immédiat sans attendre.
• Séparation du contexte — Chaque agent obtient un contexte propre et concentré sur sa tâche, au lieu d'un contexte saturé qui essaie de tout gérer.

Méthode 1 : plusieurs fenêtres de terminal

L'approche la plus simple. Ouvrez plusieurs terminaux et lancez un agent dans chacun.

Terminal 1 :

cd ~/project
claude  # Démarrer Claude Code pour la refonte de l'auth

Terminal 2 :

cd ~/project
claude  # Démarrer Claude Code pour les tests API

Terminal 3 :

cd ~/project
codex   # Démarrer Codex pour la documentation

Cela fonctionne, mais avec un inconvénient majeur : vous ne pouvez voir qu'un terminal à la fois (ou alors vous devez découper l'écran en minuscules panneaux). Quand l'Agent 1 termine, vous ne le saurez pas à moins de basculer vers ce terminal et vérifier.

Méthode 2 : panneaux tmux divisés

tmux permet de répartir plusieurs sessions terminal dans une seule fenêtre :

tmux new-session -s agents
# Ctrl+b % pour diviser verticalement
# Ctrl+b " pour diviser horizontalement

C'est mieux que des fenêtres séparées : vous pouvez voir plusieurs agents à la fois. Mais les panneaux tmux forment une grille fixe. Avec 3 agents ou plus, chaque panneau devient trop petit pour être lisible confortablement. Et il n'y a aucun indicateur visuel de l'état de l'agent (travail, attente, terminé).

Méthode 3 : espace de travail sur canevas

L'approche la plus efficace pour 2 agents ou plus est un espace de travail visuel sur canevas. Placez chaque agent dans un tile distinct sur un canevas infini. Disposez-les spatialement selon leur rôle dans votre workflow.

Avantages par rapport aux fenêtres de terminal et à tmux :

• Redimensionnement libre — Donnez plus d'espace à l'agent sur lequel vous vous concentrez actuellement.
• Indicateurs d'état des agents — Voyez d'un coup d'œil quels agents travaillent, attendent ou ont terminé.
• Connexions de routage — Transmettez automatiquement la sortie d'un agent à un autre.
• Persistance — Votre disposition est sauvegardée. Fermez et rouvrez, tout est à sa place.

MadoHub est conçu pour cela : il vous donne un canevas infini où vous exécutez des agents de terminal dans des tiles déplaçables et redimensionnables, avec détection d'état en temps réel.

Ce à quoi faire attention

Conflits de fichiers

Deux agents qui modifient le même fichier en même temps créeront des conflits. Avant de lancer des agents en parallèle, assurez-vous qu'ils travaillent sur des fichiers ou modules différents.

Bonne répartition parallèle :

• L'Agent A travaille sur src/auth/ pendant que l'Agent B travaille sur src/api/

Mauvaise répartition parallèle :

• L'Agent A et l'Agent B modifient tous deux src/config/database.ts

Utilisation des ressources

Chaque session d'agent IA consomme de la RAM (pour le terminal et le processus de l'agent) et des crédits API. Lancer 5 instances de Claude Code en même temps signifie 5 fois l'utilisation API. Surveillez votre consommation si vous êtes sur un forfait mesuré.

Pollution du contexte

Si plusieurs agents travaillent dans le même dépôt git, les changements non commités d'un agent peuvent perturber un autre agent qui lit les mêmes fichiers. Solutions :

• Branches git — Chaque agent travaille sur une branche séparée.
• Répertoires indépendants — Si les tâches sont vraiment indépendantes, utilisez des copies séparées du projet.
• Dépendances séquentielles — L'Agent B ne démarre qu'après que l'Agent A a commit ses changements.

Quand utiliser plusieurs agents

La règle générale : si vous pouvez diviser proprement le travail en morceaux indépendants avec des frontières nettes, plusieurs agents iront plus vite. Si le travail est fortement interconnecté, un seul agent avec un contexte complet est préférable.

Automatiser la passation

Le principal point de friction avec plusieurs agents, c'est la passation. Copier manuellement la sortie de l'Agent A, la reformater en prompt et la coller dans l'Agent B est fastidieux et source d'erreurs.

Le routage automatisé élimine cette friction. Quand l'Agent A termine, le système :

1. Détecte la complétion (via des motifs de sortie ou la détection d'inactivité).
2. Extrait la sortie pertinente.
3. La transforme en prompt adapté à l'Agent B.
4. La livre.

L'étape de transformation est essentielle. La sortie brute du terminal est bruyante — codes ANSI, barres de progression, journaux verbeux. Un bon système de routage extrait le contenu sémantique et le reformule comme une instruction exploitable.

Pour commencer

1. Choisissez deux tâches indépendantes dans votre projet actuel.
2. Ouvrez deux terminaux côte à côte.
3. Lancez un agent dans chacun.
4. Remarquez comment cela change votre attention : vous passez du focus profond sur une tâche au balayage de deux tâches.
5. Quand l'un termine, essayez d'envoyer manuellement ses résultats clés à l'autre.

Une fois que vous aurez fait cela manuellement et ressenti le bénéfice, vous comprendrez pourquoi le routage automatisé et les espaces de travail visuels existent. Ils rendent la version manuelle sans effort.