Agent Teams : le multi-agent natif dans Claude Code

Jusqu'à présent, Claude Code fonctionnait comme un agent unique — puissant certes, mais limité à une seule fenêtre de contexte et un traitement séquentiel des tâches. Avec Agent Teams, Anthropic franchit un cap en permettant d'orchestrer plusieurs instances Claude Code qui collaborent, communiquent et se répartissent le travail automatiquement.

Concrètement, au lieu d'un seul agent qui gère tout, vous disposez d'une équipe d'agents spécialisés — chercheur, développeur frontend, développeur backend, testeur — qui travaillent en parallèle, partagent leurs découvertes et coordonnent leurs actions via un système de messagerie intégré.

Pourquoi Agent Teams change la donne

Le problème des sub-agents classiques

Avant Agent Teams, Claude Code proposait déjà les sub-agents (ou sous-agents). Un sub-agent est une tâche déléguée qui s'exécute dans la même session et ne peut que rapporter ses résultats à l'agent principal. C'est utile pour paralléliser des recherches simples, mais limité :

—Les sub-agents ne peuvent pas communiquer entre eux

—Ils dépendent de l'agent principal comme intermédiaire

—Leur contexte est perdu une fois la tâche terminée

—La coordination complexe est impossible

Ce qu'Agent Teams apporte de nouveau

Agent Teams supprime ces limitations. Chaque coéquipier (teammate) est une instance Claude Code autonome avec sa propre fenêtre de contexte. Les teammates peuvent :

—S'envoyer des messages directement entre eux

—Réclamer des tâches depuis une liste partagée

—Partager leurs découvertes en temps réel

—Travailler en vrai parallèle sur différentes parties du code

—Se coordonner sans passer par un intermédiaire

Comment activer Agent Teams

Agent Teams est une fonctionnalité expérimentale désactivée par défaut. Pour l'activer, ajoutez cette configuration dans votre fichier settings.json de Claude Code :

{
  "env": {
    "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1"
  }
}

Vous pouvez placer cette configuration dans :

—~/.claude/settings.json (global, pour tous vos projets)

—.claude/settings.json (au niveau du projet)

Prérequis techniques

—Claude Opus 4.6 — le modèle qui propulse Agent Teams

—Abonnement Pro (20$/mois) ou Max (100-200$/mois)

—tmux (optionnel mais recommandé) — pour visualiser chaque agent dans un panneau terminal séparé

Pour installer tmux sur macOS :

brew install tmux

Architecture d'une équipe d'agents

Le team lead (chef d'équipe)

Quand vous demandez à Claude Code de créer une équipe, votre session principale devient le team lead. Son rôle est de :

1.Créer l'équipe avec TeamCreate

2.Définir les tâches et les dépendances

3.Spawner les teammates — chacun avec un rôle spécialisé

4.Assigner le travail aux agents disponibles

5.Coordonner la progression et synthétiser les résultats

6.Terminer l'équipe proprement une fois le travail accompli

Les teammates (coéquipiers)

Chaque teammate est une instance Claude Code indépendante avec :

—Sa propre fenêtre de contexte (pas de partage de tokens)

—Un accès complet au système de fichiers du projet

—La capacité d'envoyer et recevoir des messages

—L'accès à la liste de tâches partagée

Le système de tâches partagé

Les tâches sont stockées sous forme de fichiers JSON sur le disque. Chaque tâche passe par trois états :

—pending — en attente d'attribution

—in_progress — en cours de traitement par un agent

—completed — terminée

Un mécanisme de verrouillage de fichier (file locking) empêche deux agents de réclamer la même tâche simultanément, évitant les conflits de concurrence.

Tutoriel pratique : créer votre première équipe

Voici comment lancer une équipe d'agents pour développer une fonctionnalité full-stack.

Étape 1 : Décrire la tâche en langage naturel

Lancez Claude Code et décrivez ce que vous voulez :

Crée une équipe de 3 agents pour développer une page de profil utilisateur.
- Un agent pour le frontend (composant React)
- Un agent pour le backend (API route Next.js)
- Un agent pour les tests (Jest + Playwright)

Claude Code va automatiquement :

1.Créer l'équipe et la liste de tâches

2.Spawner les trois agents spécialisés

3.Leur assigner les tâches appropriées

4.Coordonner le travail entre eux

Étape 2 : Observer le travail en cours

Si vous avez tmux installé, chaque agent apparaît dans son propre panneau terminal. Vous pouvez observer en temps réel :

—Le frontend agent qui crée les composants React

—Le backend agent qui développe les routes API

—Le test agent qui écrit les tests en attendant que les deux autres terminent

Étape 3 : Intervenir si nécessaire

Le team lead vous envoie des mises à jour régulières. Vous pouvez :

—Répondre pour ajuster la direction

—Demander plus de détails sur une décision

—Valider les choix architecturaux importants

Cas d'usage les plus efficaces

1. Recherche et analyse en parallèle

Plusieurs agents analysent simultanément différents aspects d'un problème, puis partagent et confrontent leurs résultats. Idéal pour auditer une codebase ou investiguer un bug complexe avec plusieurs hypothèses.

2. Développement full-stack coordonné

Un agent par couche — frontend, backend, base de données, tests. Chaque agent est spécialisé et n'a pas besoin de charger la totalité du projet dans son contexte.

3. Debugging avec hypothèses concurrentes

Plusieurs agents testent des hypothèses différentes en parallèle. Le premier à trouver la cause racine la partage avec l'équipe. Cette approche est jusqu'à 3x plus rapide qu'un débogage séquentiel.

4. Refactoring à grande échelle

Un agent planifie les changements, un autre les implémente fichier par fichier, un troisième vérifie que les tests passent après chaque modification. La coordination réduit considérablement les régressions.

Le rôle crucial du CLAUDE.md

Votre fichier CLAUDE.md devient le cerveau partagé de tous les agents. Chaque teammate le lit au démarrage de sa session. Voici ce qu'il doit contenir :

—L'architecture du projet : structure des dossiers, patterns utilisés

—Les conventions de code : style, nommage, formatage

—Les patterns à suivre : composants, API, gestion d'état

—Les dépendances critiques : librairies, versions

—Les fichiers à ne jamais toucher : configs de production, secrets

Un bon CLAUDE.md est encore plus important en mode Agent Teams qu'en mode solo. Pour approfondir ce sujet, consultez notre [guide des meilleures pratiques](/blog/meilleures-pratiques-claude-code).

Communication entre agents

Messages directs

Les agents communiquent via un système de messagerie intégré. Par exemple, le frontend agent peut demander au backend agent de créer un endpoint spécifique :

"J'ai besoin d'un endpoint GET /api/profile/:id
qui retourne { name, email, avatar, bio }."

Le backend agent reçoit le message, implémente l'endpoint, et confirme quand c'est prêt.

Broadcast pour les annonces critiques

Pour les situations urgentes qui concernent toute l'équipe — par exemple un bug bloquant dans un module partagé — un agent peut diffuser un message à tous les teammates simultanément.

Les broadcasts sont coûteux (un message envoyé à chaque agent) et ne doivent être utilisés que pour les situations véritablement critiques.

Cycle de vie d'un teammate

Chaque agent passe par un cycle régulier :

1.Recevoir une tâche ou un message

2.Travailler de manière autonome

3.Communiquer ses résultats ou ses besoins

4.Passer en idle en attendant la suite

5.Se réveiller quand un nouveau message arrive

Ce cycle idle/actif est normal et attendu. Un agent idle n'est pas bloqué — il attend simplement du travail.

Gestion des coûts

Agent Teams consomme significativement plus de tokens qu'une session solo, puisque chaque agent a sa propre fenêtre de contexte. Quelques conseils pour optimiser :

—Limitez le nombre d'agents — 2 à 4 est souvent le point optimal

—Définissez des tâches précises — moins d'exploration inutile

—Utilisez les dépendances entre tâches — évitez le travail en double

—Surveillez la progression — coupez les agents bloqués rapidement

En moyenne, une session Agent Teams coûte 2 à 4 fois plus qu'une session solo, mais elle peut accomplir le travail 3 à 5 fois plus vite grâce au parallélisme réel.

Agent Teams vs Sub-agents : comment choisir

Critère	Sub-agents	Agent Teams
Communication	Retour au parent uniquement	Entre tous les agents
Contexte	Partagé avec le parent	Indépendant par agent
Complexité	Tâches simples et parallèles	Collaboration complexe
Coût	Modéré	Élevé
Durée de vie	Éphémère (une tâche)	Persiste toute la session
Cas idéal	Recherche parallèle	Développement multi-couche

Règle simple : si vous avez besoin d'exécution ciblée, utilisez les sub-agents. Si vous avez besoin de collaboration, utilisez Agent Teams.

Pour comprendre les sub-agents en profondeur, consultez notre article sur l'[automatisation du développement avec Claude Code](/blog/automatiser-dev-claude-code).

Bonnes pratiques pour Agent Teams

Structurez les tâches avec des dépendances

Ne lancez pas tous les agents en même temps sur des tâches qui se chevauchent. Définissez clairement les dépendances : le test agent doit attendre que le code soit écrit avant de lancer les tests.

Utilisez des agents spécialisés

Plutôt que 3 agents génériques, créez des agents avec des rôles clairs. Un agent frontend-dev avec un prompt orienté React sera plus efficace qu'un agent générique.

Gérez les conflits de fichiers

Deux agents modifiant le même fichier simultanément créeront des conflits. Répartissez le travail pour que chaque agent ait sa propre zone de code.

Investissez dans votre CLAUDE.md

C'est l'investissement le plus rentable. Un CLAUDE.md détaillé évite aux agents de perdre du temps à redécouvrir l'architecture du projet.

Limitations actuelles

Agent Teams est en phase expérimentale. Gardez en tête ces limitations :

—Stabilité variable — des comportements inattendus peuvent survenir dans les orchestrations complexes

—Coût élevé — chaque agent consomme son propre budget de tokens

—Pas de persistance — les équipes ne survivent pas à la fermeture de la session principale

—Conflits de fichiers possibles — si deux agents modifient le même fichier

—Courbe d'apprentissage — formuler les bonnes instructions pour une équipe demande de la pratique

Par où commencer

Si vous découvrez Claude Code, commencez d'abord par maîtriser les bases avec notre [guide pour débutants](/blog/claude-code-pour-debutants). Familiarisez-vous ensuite avec les sub-agents simples avant de passer aux Agent Teams.

Pour les développeurs expérimentés, Agent Teams représente la prochaine étape de l'ingénierie assistée par IA. C'est la différence entre avoir un assistant et avoir une équipe entière à votre disposition.

Activez la fonctionnalité, expérimentez avec une petite équipe de 2 agents, et progressez vers des configurations plus complexes au fur et à mesure que vous maîtrisez les patterns de coordination.

Le futur du développement est multi-agent. Agent Teams est votre porte d'entrée.

---

*Agent Teams est une fonctionnalité expérimentale de Claude Code nécessitant Opus 4.6. Activez-la via CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS dans settings.json. Les coûts et performances peuvent varier selon la complexité des tâches.*

Claude Code Agent Teams : Coordonner Plusieurs Agents IA en Parallèle