Sous-agents Claude : paralléliser vos tâches IA sans perdre le fil (guide 2026)

Publié le 29 avril 2026 par Valentin Charrier, expert n8n et IA chez Ocade Fusion.

Un sous-agent Claude est une instance IA isolée, lancée par un agent principal pour exécuter une mission précise dans son propre contexte. Au lieu de traiter séquentiellement cinq tâches dans une seule fenêtre de 200 000 tokens, l’agent principal délègue chaque tâche à un sous-agent dédié qui travaille en parallèle. Résultat mesuré sur des projets réels : un gain de 3 à 5 fois sur le temps d’exécution des tâches parallélisables, sans polluer le contexte principal (documentation officielle Anthropic).

Chez Ocade Fusion, la publication d’un article mobilise 5 audits indépendants - liens internes, conformité GEO, sécurité, résumé audio, vérification build - chacun délégué à un sous-agent dédié. Sur les 10 derniers articles publiés en avril 2026, le temps moyen de publication est passé de 18 minutes à 5 minutes grâce à cette parallélisation. Ce guide couvre la définition des sous-agents, les 3 types disponibles, le SDK programmatique, les patterns de coordination et un cas concret pas à pas. Prérequis : avoir installé et configuré Claude Code sur votre machine.

Qu’est-ce qu’un sous-agent Claude

Un sous-agent Claude est une instance Claude isolée qu’un agent principal peut créer à la demande pour lui confier une mission précise. L’analogie la plus directe : un collaborateur temporaire à qui vous donnez un brief clair, qui exécute la tâche dans son propre bureau, et vous rapporte le résultat une fois terminé. Le sous-agent dispose de son propre contexte (jusqu’à 200 000 tokens), de ses propres outils et de ses propres permissions. Il ne voit pas le contexte de l’agent parent, et l’agent parent ne voit pas le détail de son exécution - uniquement le résultat final synthétisé (documentation Anthropic sur les sous-agents).

La différence avec un prompt classique est structurelle. Dans un prompt classique, tout s’exécute dans le même fil de contexte : chaque instruction, chaque résultat intermédiaire, chaque erreur consomme des tokens du même budget de 200 000. Avec un sous-agent, le contexte est cloisonné. L’agent parent consomme seulement les tokens nécessaires pour formuler la tâche (environ 50-200 tokens) et recevoir le résultat (variable selon la tâche). Les outils disponibles pour le sous-agent sont définis explicitement lors du lancement : un sous-agent de lecture n’a pas accès à l’écriture de fichiers, un sous-agent d’audit n’a pas accès aux outils de déploiement. Ce cloisonnement réduit les risques d’effets de bord et améliore la fiabilité de chaque tâche déléguée. Pour approfondir les mécanismes de personnalisation, consultez le guide des skills Claude.

Les 3 types de sous-agents dans Claude Code

Claude Code distingue trois types de sous-agents natifs, chacun avec un niveau d’accès et un jeu d’outils différent. Le choix du type détermine ce que le sous-agent peut faire - et surtout ce qu’il ne peut pas faire. Cette restriction par défaut est un choix de sécurité : on accorde le minimum de permissions nécessaires pour la tâche (documentation Claude Code - subagent types).

Type	Outils disponibles	Cas d’usage	Temps moyen
Explore	Read, Glob, Grep, Bash (lecture seule)	Analyse de code, recherche de patterns, audit read-only	10-30 secondes
Plan	Read, Glob, Grep, Bash (lecture seule)	Architecture, design, planification sans écriture	20-60 secondes
General-purpose	Tous les outils (Read, Write, Edit, Bash, etc.)	Création et édition de fichiers, exécution de commandes	30 secondes - 5 minutes

Le sous-agent Explore est le plus rapide et le plus sûr. Il ne peut que lire : parcourir des fichiers, chercher des patterns avec grep, exécuter des commandes bash en lecture seule. C’est le choix par défaut pour tout audit, toute analyse de codebase, toute recherche d’information. En production chez Ocade Fusion, plus de 60 % des sous-agents lancés sont de type Explore.

Le sous-agent Plan partage les mêmes outils qu’Explore mais se distingue par son prompt système : il est optimisé pour produire des plans d’action structurés, des architectures, des listes de tâches. Il ne modifie rien mais prépare le terrain pour un sous-agent General-purpose ou pour l’agent principal.

Le sous-agent General-purpose dispose de tous les outils, y compris l’écriture de fichiers et l’exécution de commandes. Il est nécessaire quand la tâche implique de modifier du code, de créer des fichiers ou de lancer des builds. L’isolation par worktree (répertoire Git séparé) est recommandée pour éviter les conflits quand plusieurs sous-agents General-purpose tournent en parallèle. Au-delà de ces trois types natifs, les hooks Claude Code permettent de définir des types personnalisés avec des outils et des permissions sur mesure.

Sous-agents programmatiques avec l’Agent SDK Python

L’Agent SDK Python d’Anthropic (claude_agent_sdk) permet de définir et d’orchestrer des sous-agents par le code, en dehors de Claude Code interactif. C’est l’approche recommandée pour intégrer des sous-agents dans des pipelines CI/CD, des workflows n8n ou des applications backend. Le SDK est disponible depuis février 2026 et supporte les modèles Claude Opus 4.6, Opus 4.7 et Sonnet 4 (documentation Agent SDK Anthropic).

La brique de base est AgentDefinition. Chaque définition spécifie un nom, une description (utilisée par l’orchestrateur pour choisir le bon agent), un prompt système, les outils autorisés, le modèle et le nombre maximum de tours.

from claude_agent_sdk import AgentDefinition, AgentOrchestrator

# Définir un sous-agent de revue de code
code_reviewer = AgentDefinition(
    name="code-reviewer",
    description="Analyse le code modifié et signale les bugs, failles de sécurité et problèmes de maintenabilité",
    prompt="Tu es un expert en revue de code. Analyse les fichiers modifiés et produis un rapport structuré.",
    model="claude-opus-4-7-20260416",
    tools=["Read", "Glob", "Grep", "Bash"],
    max_turns=15,
    disallowed_tools=["Write", "Edit"]
)

# Définir un sous-agent de rédaction de tests
test_writer = AgentDefinition(
    name="test-writer",
    description="Génère des tests unitaires et d'intégration pour le code modifié",
    prompt="Tu es un expert en testing. Écris des tests couvrant les cas limites et les chemins critiques.",
    model="claude-opus-4-7-20260416",
    tools=["Read", "Write", "Edit", "Glob", "Grep", "Bash"],
    max_turns=25
)

# Orchestrer les deux en parallèle
orchestrator = AgentOrchestrator(
    agents=[code_reviewer, test_writer],
    allowed_tools=["Task"],  # Autorise le spawning de sous-agents
    strategy="parallel"
)

results = orchestrator.run(
    task="Analyse et teste les modifications du dernier commit"
)

Les paramètres clés à maîtriser sont max_turns (nombre maximum d’itérations avant arrêt forcé - 15 à 25 pour la majorité des tâches), disallowed_tools (restriction explicite d’outils) et allowed_tools=["Task"] qui autorise un sous-agent à lui-même spawner d’autres sous-agents (récursivité contrôlée). Pour les agents IA en production avec n8n, ce SDK s’intègre directement dans un nœud Code ou un sous-workflow Python.

Parallèle, séquentiel ou Agent Teams : comment choisir

Trois patterns d’orchestration couvrent la quasi-totalité des cas d’usage. Le choix dépend de deux facteurs : les tâches sont-elles indépendantes, et les sous-agents doivent-ils communiquer entre eux ? Le tableau suivant résume les critères de sélection, validés sur des projets Ocade Fusion en avril 2026 (guide officiel Agent Teams - Anthropic).

Pattern	Quand l’utiliser	Gain temps	Complexité	Communication
Parallèle	Tâches indépendantes, fichiers distincts	3-5x	Faible	Aucune (résultat final uniquement)
Séquentiel	Dépendances entre tâches, même fichier	1,5-2x (via spécialisation)	Faible	Résultat passe au suivant
Agent Teams	Coordination continue, projet multi-domaines	Variable (2-4x)	Élevée	Directe entre agents

Voici un arbre de décision en texte structuré pour choisir rapidement.

1. Une seule tâche ? - Pas besoin de sous-agent. Restez dans la session principale.
2. Plusieurs tâches indépendantes, fichiers distincts ? - Pattern parallèle. Gain maximal (3-5x), complexité minimale.
3. Plusieurs tâches, mais elles modifient les mêmes fichiers ? - Pattern séquentiel. Chaque sous-agent attend le résultat du précédent avant de commencer.
4. Les sous-agents doivent échanger des informations en cours d’exécution ? - Agent Teams (disponible depuis Claude Code v2.1.32+). Les agents communiquent directement entre eux via un bus de messages, sans repasser par le parent.
5. Plus de 5 sous-agents sur un même projet ? - Agent Teams avec un orchestrateur dédié. Le pattern parallèle simple ne scale pas bien au-delà de 5 agents concurrents (surcharge de coordination).

En pratique, le pattern parallèle couvre 70 % des besoins, le séquentiel 20 %, et les Agent Teams 10 % (projets complexes multi-domaines). Pour automatiser ces patterns dans le cloud, les routines Claude Code permettent de scripter l’orchestration et de la déclencher sans intervention humaine.

Comment utiliser les sous-agents : procédure pas à pas

Prérequis

• Claude Code v2.1 ou supérieur (vérifier avec claude --version)
• Abonnement Max (les sous-agents consomment des tokens supplémentaires, le plan Pro peut atteindre sa limite rapidement)
• Temps estimé : 5 minutes pour un premier test
• Résultat attendu : un sous-agent exécute une tâche isolée et retourne un résultat synthétique à l’agent principal

Étapes

1. Ouvrir un terminal avec Claude Code. Lancez claude dans votre répertoire de projet. L’agent principal démarre avec un contexte vide de 200 000 tokens.
2. Décrire la tâche au modèle principal. Formulez votre demande. Claude analyse la complexité et détermine si un sous-agent est nécessaire. Par exemple : “Analyse tous les fichiers TypeScript du dossier src/ pour trouver les imports inutilisés, puis génère les tests manquants pour le module auth.” Claude identifie deux tâches indépendantes et décide de les paralléliser.
3. Observer Claude choisir le sous-agent approprié (ou forcer le choix). Par défaut, Claude sélectionne automatiquement le type de sous-agent (Explore, Plan ou General-purpose). Pour forcer un type spécifique, utilisez une instruction explicite : “Lance un agent Explore sur le dossier src/ pour lister les imports inutilisés” ou “Utilise un sous-agent General-purpose pour écrire les tests dans tests/auth/”.
4. Suivre l’exécution. Le terminal affiche un indicateur de progression pour chaque sous-agent actif. Le format est : [subagent:explore] Analysing src/*.ts... (12/47 files). Les sous-agents parallèles apparaissent simultanément. Le temps moyen par sous-agent Explore est de 10-30 secondes, par General-purpose de 30 secondes à 5 minutes.
5. Récupérer le résultat synthétisé. Quand un sous-agent termine, il retourne un résumé au contexte principal. L’agent principal agrège les résultats de tous les sous-agents et vous présente une réponse unifiée. Le contexte principal ne contient que les résumés, pas le détail de chaque fichier analysé - c’est le mécanisme clé qui préserve vos 200 000 tokens.

Dépannage

• Sous-agent qui timeout : le sous-agent dépasse le nombre maximum de tours (par défaut 15-25 selon le type). Solution : augmenter maxTurns dans la configuration, ou découper la tâche en sous-tâches plus petites. Une tâche qui nécessite plus de 30 tours est probablement trop large.
• Conflit de fichiers entre sous-agents parallèles : deux sous-agents General-purpose tentent de modifier le même fichier. Solution : activer l’isolation par worktree (--worktree) pour que chaque sous-agent travaille dans une copie Git séparée, puis merger les résultats automatiquement.
• Contexte trop gros pour la tâche déléguée : un sous-agent reçoit un prompt de 50 000 tokens. Solution : déléguer les recherches lourdes (grep sur toute la codebase) à des sous-agents Explore préalables, puis ne transmettre que les résultats synthétiques au sous-agent suivant.

Pour une installation complète de Claude Code et la configuration initiale, consultez le guide d’installation pas à pas.

Cas concret : publier un article avec 5 sous-agents en parallèle

Voici un cas d’usage réel pratiqué chez Ocade Fusion depuis mars 2026. Chaque article publié sur ocadefusion.fr passe par 5 audits indépendants avant mise en ligne. Avant l’adoption des sous-agents, ces 5 vérifications s’exécutaient séquentiellement dans une seule session Claude Code, consommant la majeure partie des 200 000 tokens de contexte et prenant en moyenne 18 minutes par article.

Les 5 sous-agents lancés en parallèle sont les suivants :

1. Audit des liens internes (sous-agent Explore) - parcourt le HTML de l’article, extrait tous les liens <a href="/blog/...">, confronte chaque slug à la liste des articles publiés sur WordPress, signale les 404 potentiels. Temps moyen : 15 secondes.
2. Audit GEO (sous-agent Explore) - vérifie la structure en chunks de 150-200 mots, la présence de données chiffrées par section, le respect du pattern “Lost in the Middle” (informations clés dans les 200 premiers et derniers mots), et les signaux E-E-A-T (auteur identifié, sources citées, date de publication). Temps moyen : 20 secondes.
3. Audit de sécurité (sous-agent Explore) - recherche les secrets exposés (clés API, tokens), vérifie la sanitisation HTML et les attributs rel="noopener noreferrer" sur les liens externes. Temps moyen : 10 secondes.
4. Génération du résumé audio (sous-agent General-purpose) - appelle l’API ElevenLabs pour synthétiser un résumé vocal de 2 minutes, puis upload le fichier MP3 sur le bucket Supabase. Temps moyen : 45 secondes.
5. Vérification du build Next.js (sous-agent General-purpose) - lance npm run build en isolé, vérifie que l’article ne casse pas le rendu statique ISR, détecte les erreurs TypeScript ou les imports manquants. Temps moyen : 60 secondes.

Sans sous-agents, ces 5 tâches polluaient le contexte principal (chaque audit générait 5 000-15 000 tokens de données intermédiaires) et se faisaient séquentiellement : 15-20 minutes par article. Avec les sous-agents parallèles, chaque audit tourne dans sa propre fenêtre de contexte isolée. Le contexte principal ne reçoit que le résumé de chaque audit (environ 200 tokens chacun, soit 1 000 tokens au total contre 50 000+ auparavant). Sur les 10 derniers articles publiés en avril 2026, le temps moyen de publication est passé de 18 minutes à 5 minutes - divisé par 3,6. Le gain n’est pas linéaire (5 sous-agents ne donnent pas 5x) car le sous-agent le plus lent (build Next.js, 60 secondes) définit le temps total. Pour d’autres exemples concrets d’optimisation avec Claude, consultez les nouveautés d’Opus 4.7 pour praticiens n8n.

Limites, coûts et bonnes pratiques

Les sous-agents ne sont pas gratuits. Chaque sous-agent consomme ses propres tokens dans un contexte isolé. Cinq sous-agents parallèles génèrent 5 contextes séparés, soit potentiellement 5 fois la consommation token d’un seul agent pour une tâche équivalente. Sur Claude Opus 4.7 (5 $ par million de tokens en entrée, 25 $ en sortie), un pipeline de 5 sous-agents Explore consommant chacun 10 000 tokens coûte environ 0,25 $ en entrée - un ordre de grandeur raisonnable pour un usage professionnel, mais à surveiller sur des volumes importants (grille tarifaire Anthropic).

La latence de spawning ajoute 2 à 5 secondes par sous-agent au démarrage. Ce délai est constant : que le sous-agent traite 10 ou 10 000 tokens, le coût initial est le même. Pour des tâches très courtes (moins de 5 secondes d’exécution), le overhead de spawning annule le gain de la parallélisation. Règle pratique : ne paralléliser que les tâches qui prennent individuellement plus de 15 secondes.

Les sous-agents n’ont pas de mémoire partagée. Un sous-agent A ne peut pas lire ce que le sous-agent B a écrit, sauf si l’agent principal transmet explicitement l’information. La communication directe entre sous-agents n’existe que dans le mode Agent Teams (v2.1.32+). Sans Agent Teams, toute coordination passe par l’agent parent, ce qui ajoute de la latence.

Six bonnes pratiques validées en production :

• Utiliser Explore par défaut. N’accorder les droits d’écriture (General-purpose) que si la tâche l’exige. Sur nos projets, 60 % des sous-agents sont en lecture seule.
• Fournir un prompt précis et complet. Le sous-agent n’a pas le contexte parent. Chaque information nécessaire doit être dans le prompt de la tâche, pas implicite.
• Préférer 3 sous-agents ciblés plutôt que 10 micro-agents. Au-delà de 5 sous-agents parallèles, le coût de coordination (spawning, agrégation des résultats) dépasse souvent le gain de parallélisation.
• Toujours vérifier le résultat retourné. Un sous-agent peut halluciner, exactement comme un agent principal. Les résultats critiques (modification de code, données financières) doivent être validés par un second sous-agent ou par l’agent parent.
• Activer l’isolation worktree quand plusieurs sous-agents General-purpose modifient du code en parallèle. Sans worktree, les conflits Git sont fréquents et silencieux.
• Monitorer la consommation token. L’agrégation des coûts de 5 sous-agents parallèles peut surprendre. Utiliser le dashboard Anthropic pour suivre la consommation par session.

Pour automatiser la prospection commerciale en combinant sous-agents Claude et workflows n8n, consultez le guide pratique dédié.

Ce qu’il faut retenir

Un sous-agent Claude est une instance IA isolée avec son propre contexte et ses propres outils, lancée par un agent principal pour exécuter une mission précise. Trois types existent dans Claude Code : Explore (lecture seule, le plus rapide), Plan (architecture sans écriture) et General-purpose (accès complet). Le gain mesuré atteint 3 à 5 fois sur le temps d’exécution des tâches parallélisables - chez Ocade Fusion, le temps de publication d’un article est passé de 18 à 5 minutes grâce à 5 sous-agents parallèles. L’Agent SDK Python permet de définir des sous-agents par le code pour les intégrer dans des pipelines automatisés. La règle d’or : prompt précis + isolation des fichiers + vérification systématique du résultat. Chaque sous-agent consomme ses propres tokens (5x la consommation pour 5 agents), donc préférer 3 sous-agents ciblés plutôt que 10 micro-agents. Pour aller plus loin dans la personnalisation de Claude Code, explorez les hooks Claude Code qui permettent d’intercepter et d’adapter le comportement des sous-agents.