Claude Code Sub-Agents : Déléguer des Tâches à l'IA

Mis à jour le 3 mars 2026

Un seul Claude Code, c'est bien. Plusieurs Claude Code qui travaillent en parallèle, chacun spécialisé dans une tâche, c'est mieux. Les sub-agents sont des instances spécialisées que Claude Code peut lancer pour déléguer du travail — exploration de code, planification, exécution de tâches complexes. C'est la délégation intelligente appliquée à l'IA.

Quand tu donnes une instruction complexe à Claude Code, il ne fait pas tout seul dans un seul fil d'exécution. Il peut découper le travail et lancer des sub-agents — des instances séparées, chacune avec son propre contexte, ses propres outils, et sa propre spécialisation. Chaque sub-agent traite sa partie du problème et renvoie le résultat à ta session principale. Toi, tu ne vois que le résultat final, propre et consolidé.

Si tu découvres Claude Code, commence par le guide complet avant de plonger dans les sub-agents. Cette fonctionnalité est puissante, mais elle prend tout son sens quand tu maîtrises déjà les bases.

C'est quoi un sub-agent

Un sub-agent est une instance séparée de Claude Code, lancée automatiquement pour traiter une sous-tâche. Il a son propre contexte, ses propres outils, et retourne un résultat sans polluer ta conversation principale. C'est la délégation IA.

Imagine que tu demandes à Claude Code de refactorer un module complet de ton application. Au lieu de tout faire dans ta session — ce qui saturerait la fenêtre de contexte (la quantité d'informations que l'IA peut garder en tête en même temps) — Claude Code lance des sous-agents. Un pour explorer les fichiers concernés. Un pour analyser les dépendances. Un pour effectuer les modifications. Chaque sous-agent travaille dans son propre espace isolé.

Le concept clé ici, c'est l'isolation du contexte. Chaque sub-agent a sa propre fenêtre de contexte, séparée de ta session principale. Ça veut dire que toute la recherche, l'analyse, les essais-erreurs que fait un sub-agent ne viennent pas encombrer ta conversation. Tu ne reçois que le résultat final, condensé et pertinent.

C'est exactement comme déléguer du travail à un collaborateur : tu lui donnes un brief, il bosse de son côté, et il te revient avec le livrable. Tu n'as pas besoin de suivre chaque étape intermédiaire.

Les 3 sub-agents built-in

Claude Code embarque trois types de sub-agents, chacun optimisé pour un rôle précis. Ils ne sont pas interchangeables — chacun a ses forces et ses limites.

Explore : le rapide en lecture seule

L'agent Explore utilise le modèle Haiku — le plus petit et le plus rapide de la gamme Claude. Son job : fouiller rapidement dans ton code pour trouver des informations. Il a accès à trois outils uniquement : Glob (recherche de fichiers par pattern), Grep (recherche de contenu dans les fichiers), et Read (lecture de fichiers).

C'est de la lecture seule. Explore ne peut rien modifier, rien écrire, rien exécuter. Et c'est voulu. Il est là pour répondre vite à des questions comme "où est définie cette fonction ?", "quels fichiers utilisent ce composant ?", "quelle est la structure de ce module ?". En quelques secondes, il scanne, trouve, et retourne la réponse.

Pourquoi Haiku plutôt qu'un modèle plus puissant ? Parce que la recherche de fichiers ne nécessite pas un raisonnement complexe. Un modèle petit et rapide fait le travail aussi bien qu'un gros modèle, en coûtant beaucoup moins de tokens et en allant beaucoup plus vite.

Plan : le stratège

L'agent Plan hérite du modèle de ta session principale (Opus ou Sonnet, selon ta configuration). Lui aussi est en lecture seule — il peut chercher et analyser, mais pas modifier. Sa spécialité : comprendre un problème dans sa globalité et produire un plan d'action structuré.

Quand tu actives le Plan Mode dans Claude Code, c'est cet agent qui prend le relais. Il analyse les fichiers concernés, identifie les dépendances, anticipe les impacts, et te propose une stratégie étape par étape avant toute modification. C'est le sub-agent qui réfléchit avant d'agir.

L'avantage d'utiliser un sub-agent pour la planification plutôt que de planifier dans ta session principale : toute l'analyse exploratoire (les dizaines de fichiers lus, les patterns identifiés, les possibilités évaluées) reste dans le contexte du sub-agent. Ta session principale ne reçoit que le plan final, clair et condensé.

General-purpose : le bras armé

L'agent General-purpose est le plus puissant. Il hérite du modèle principal et a accès à tous les outils : Read, Write, Edit, Bash, Glob, Grep. Il peut lire des fichiers, en créer, en modifier, exécuter des commandes dans le terminal. C'est le sub-agent qui fait le travail concret.

Claude Code lance un agent General-purpose quand une sous-tâche nécessite de produire ou modifier du code. Par exemple, si tu demandes de refactorer trois modules, Claude Code pourrait lancer trois agents General-purpose en parallèle, chacun travaillant sur un module. Le tout sans saturer ta session principale.

C'est aussi le type d'agent que tu utilises quand tu crées tes propres agents custom (on y revient plus bas).

Quand Claude Code lance un sub-agent

Tu n'as pas besoin de demander explicitement un sub-agent. Claude Code décide automatiquement quand la délégation est pertinente. Voici les scénarios typiques.

Exploration d'un codebase volumineux. Tu demandes "comment fonctionne le système d'authentification dans ce projet ?". Plutôt que de lire tous les fichiers dans ta session (et saturer ta fenêtre de contexte), Claude Code lance un agent Explore qui fouille, synthétise, et retourne un résumé.

Plan Mode activé. Quand tu actives le Plan Mode (via shift+tab en session interactive ou la commande dédiée), Claude Code délègue l'analyse au sub-agent Plan. Il te revient avec une stratégie structurée que tu peux valider avant l'implémentation.

Tâches parallélisables. Si ta demande peut être découpée en sous-tâches indépendantes — modifier plusieurs fichiers qui n'ont pas de dépendances entre eux, analyser plusieurs modules, tester plusieurs scénarios — Claude Code lance des sub-agents en parallèle. Un agent par sous-tâche, exécution simultanée, résultats consolidés.

L'outil Agent. En interne, Claude Code a un outil appelé "Agent" (aussi nommé "Task" selon le contexte). Quand il l'invoque, il crée un sub-agent avec un brief spécifique, des outils sélectionnés, et un objectif clair. C'est le mécanisme technique derrière toute la délégation.

Créer un agent custom

Les trois agents built-in couvrent les cas génériques. Mais tu peux créer tes propres agents, spécialisés pour tes besoins. Un agent qui fait de la revue de code avec tes conventions. Un agent qui génère de la documentation dans ton format. Un agent qui débugue tes workflows N8N.

La structure est simple. Tu crées un fichier Markdown dans le dossier .claude/agents/ de ton projet :

.claude/agents/mon-agent/mon-agent.md

Ce fichier contient deux parties : un frontmatter YAML (les métadonnées de l'agent) et un corps Markdown (les instructions). Voici un exemple minimal :

---
name: code-reviewer
description: Revue de code read-only avec focus sécurité
model: opus
tools:
  - Read
  - Glob
  - Grep
permissionMode: bypassPermissions
maxTurns: 10
---

Tu es un revieweur de code spécialisé sécurité.
Analyse les fichiers modifiés et signale :
- Failles de sécurité potentielles
- Variables sensibles exposées
- Injections possibles
Ne modifie aucun fichier. Lecture seule.

Les propriétés clés du frontmatter :

• name : le nom de l'agent (utilisé pour l'appeler)
• description : ce que fait l'agent (affiché dans la liste)
• model : le modèle à utiliser (opus, sonnet, haiku)
• tools : la liste des outils autorisés (Read, Write, Edit, Bash, Glob, Grep)
• permissionMode : comment gérer les permissions (bypassPermissions pour du read-only, default pour demander confirmation)
• maxTurns : nombre maximum d'itérations avant de s'arrêter

Pour le guide complet de création d'agents custom avec des exemples avancés :

Foreground vs Background

Un sub-agent peut s'exécuter de deux manières, et la distinction est importante pour comprendre comment ils s'intègrent dans ton workflow.

Mode Foreground (premier plan)

C'est le mode par défaut. Le sub-agent s'exécute de manière bloquante : ta session principale attend qu'il finisse avant de continuer. Si l'agent a besoin d'une confirmation (par exemple pour exécuter une commande Bash), il te pose la question directement. C'est le mode interactif, où tu gardes le contrôle total.

Utilise le foreground quand la tâche est critique, quand tu veux valider chaque étape, ou quand le résultat du sub-agent conditionne la suite du travail.

Mode Background (arrière-plan)

Le sub-agent tourne en arrière-plan pendant que ta session principale continue. Il pré-approuve les permissions automatiquement (pas de questions interactives) et travaille de manière autonome. Tu es notifié quand il a terminé.

Le mode background est puissant pour la parallélisation. Pendant qu'un agent en background explore un module, tu peux continuer à travailler sur autre chose dans ta session principale. Pour un agent custom, tu actives ce mode dans le frontmatter :

---
name: mon-agent-bg
background: true
---

Attention : un agent en background a les permissions pré-approuvées. Assure-toi de restreindre ses outils (via la propriété tools) pour éviter les modifications non désirées. Un agent background avec accès à Bash et Write sans restrictions, c'est risqué.

La mémoire persistante des agents

Par défaut, un sub-agent oublie tout quand il a terminé sa tâche. Son contexte est détruit. Mais pour les agents custom, tu peux activer la mémoire persistante — l'agent retient des informations d'une session à l'autre.

Trois modes de mémoire sont disponibles :

• memory: user — la mémoire est stockée dans ~/.claude/agent-memory/nom-agent/. Elle est liée à toi, pas au projet. L'agent se souvient de tes préférences quel que soit le projet sur lequel tu travailles.
• memory: project — la mémoire est stockée dans .claude/agent-memory/nom-agent/ à la racine du projet. Elle est partagée entre tous les utilisateurs du projet. Idéal pour les conventions d'équipe.
• memory: local — la mémoire est stockée dans .claude/agent-memory-local/nom-agent/. Elle est locale à ta machine et ajoutée au .gitignore automatiquement. Tes notes personnelles sur le projet, invisibles pour les autres.

Concrètement, la mémoire est un fichier MEMORY.md dans le dossier correspondant. Les 200 premières lignes de ce fichier sont automatiquement chargées au démarrage de l'agent. L'agent peut y écrire de nouvelles informations au fil de ses sessions — les patterns qu'il a identifiés, les décisions qu'il a prises, les préférences qu'il a apprises.

C'est particulièrement utile pour un agent de revue de code : il retient les patterns de ton projet, les exceptions à tes règles, les faux positifs qu'il a déjà signalés. Au fil du temps, ses revues deviennent de plus en plus pertinentes. C'est le même principe que le CLAUDE.md, mais spécifique à chaque agent.

Sub-agents vs Team Agents

Les deux concepts sont souvent confondus. Ils sont pourtant fondamentalement différents.

Un sub-agent est une instance unique, lancée par Claude Code pour traiter une sous-tâche précise. Il travaille dans l'ombre, retourne son résultat, et disparaît. C'est de la délégation ponctuelle. Un manager qui envoie un email à un collègue pour lui demander une info.

Un team agent fait partie d'une équipe coordonnée. Il y a un leader qui distribue les tâches, des agents spécialisés qui les exécutent, un système de messagerie pour communiquer entre agents, et une task list partagée pour suivre l'avancement. C'est un workflow collaboratif complet, comme une réunion de projet avec plusieurs intervenants.

Les team agents utilisent claude --team et impliquent plusieurs sessions Claude Code complètes qui collaborent. Les sub-agents sont des instances légères, lancées et détruites au sein d'une seule session. En termes de coût, un sub-agent consomme quelques centaines à quelques milliers de tokens. Un team avec 3-4 agents peut consommer 10 à 50 fois plus.

Quand utiliser quoi ? Sub-agents pour les tâches qui se décomposent en 2-3 sous-tâches rapides. Team agents pour les projets complexes qui nécessitent plusieurs spécialités différentes travaillant sur des livrables interdépendants.

Pour comprendre les team agents en détail :

Bonnes pratiques

Les sub-agents sont un outil puissant. Voici comment en tirer le maximum sans exploser ta consommation de tokens.

Laisse Claude Code décider. Dans la plupart des cas, tu n'as pas besoin de demander explicitement un sub-agent. Claude Code sait quand la délégation est pertinente. Formule ta demande normalement — si un sub-agent est utile, il sera lancé automatiquement.

Restreins les outils de tes agents custom. Un agent avec accès à tous les outils est un agent qui peut tout casser. Définis précisément ce dont il a besoin. Un agent de revue n'a besoin que de Read, Glob et Grep. Un agent de documentation a besoin de Read et Write, mais pas de Bash.

Utilise la mémoire pour les agents récurrents. Si tu utilises régulièrement un agent custom (revue de code, documentation, tests), active la mémoire persistante. Au fil du temps, il deviendra plus précis et plus aligné avec tes attentes.

Surveille le coût. Chaque sub-agent consomme des tokens. Utilise /cost pour suivre la consommation de ta session. Les agents Explore (Haiku) coûtent très peu. Les agents General-purpose (Opus) coûtent beaucoup plus. Adapte ta stratégie en fonction.

Pour aller plus loin, la construction d'interfaces connectées à des agents est détaillée dans le guide pour construire une interface IA sans coder. Et si tu veux comprendre comment les sub-agents s'intègrent dans un workflow entrepreneurial complet, consulte le guide Claude Code pour entrepreneurs.

Meydeey — Architecte IA & Automatisation

+110 entrepreneurs formés au Vibe Coding et à l'automatisation IA avec N8N. Fondateur du Labo IA.