Hierarchical teams

Aussi appelé : supervisor of supervisors, superviseurs à plusieurs niveaux, arbre d'agents, orchestration imbriquée, délégation récursive, hierarchical multi-agent system (HMAS), hierarchical agent teams (LangGraph), hierarchical task decomposition (Google ADK), sub-workflows (Microsoft Agent Framework), nested subagents (Claude Code)

Intention

Placer des managers au-dessus d'autres managers. Un agent de tête répartit l'objectif entre quelques chefs d'équipe, et chaque chef répartit sa part entre ses propres workers. Les briefs descendent, des rapports condensés remontent, et chaque agent ne voit que ses subordonnés directs, une courte liste d'outils et le contexte de son propre niveau.

Problème

Une entreprise veut un assistant qui rédige des analyses de marché. Une demande typique : « Rédigez une analyse de six pages du marché européen des pompes à chaleur résidentielles pour notre équipe stratégie. » Le travail demande de la recherche web, du scraping de pages, la consultation de données financières, une sandbox Python pour les graphiques, l'élaboration d'un plan, la rédaction, la vérification des faits, une relecture de conformité et la mise en forme. Disons 10 spécialistes avec environ 25 outils.

Un agent unique doté des 25 outils et d'un prompt géant choisit les mauvais outils et remplit son contexte de pages brutes avant même de commencer à écrire. AWS a constaté davantage de paramètres d'outils hallucinés et de mauvais choix d'outils dans sa référence à agent unique (Shu et al.). L'équipe passe donc à un superviseur qui aiguille entre les 10 spécialistes. Cela aide, mais de nouveaux problèmes apparaissent :

Un seul superviseur est relié à dix workers spécialisés ; son contexte se remplit de pages brutes et le rapport sort avec des étapes mal aiguillées et des contraintes perdues. Un seul superviseur choisit parmi 10 workers contexte plein de pages brutes Rapport étapes mal aiguillées règles de prompt mêlées contraintes perdues search scraping finance sql graphes plan brouillon vérifier juridique format 10 spécialistes et environ 25 outils, qui rendent tous compte dans la même conversation
Un superviseur à plat fonctionne avec trois workers. Avec dix, chaque décision d'aiguillage devient plus difficile et chaque résultat atterrit dans un seul contexte.

Solution

Regroupez les workers en équipes et donnez à chaque équipe son propre chef. Le manager de tête voit désormais trois éléments (équipe recherche, équipe rédaction, équipe relecture) au lieu de dix. Le chef de la recherche voit trois workers et uniquement le contexte de la recherche. Le manager de tête reçoit un rapport de recherche condensé au lieu de quarante pages, et chaque équipe peut être construite et testée séparément.

  1. La racine découpe l'objectif par équipe. Le manager racine lit la demande sur les pompes à chaleur, la découpe au grain le plus grossier qui reste utile (recherche, puis rédaction, puis relecture) et décide quelle équipe solliciter en premier.
  2. Elle écrit un brief, pas une transcription. Le brief de recherche énonce l'objectif, le contexte dont l'équipe a besoin, les contraintes (marché résidentiel européen uniquement, sources datées), le format du rapport et un budget. La racine ne transmet pas tout son historique. Le tutoriel de LangGraph ne passe à une équipe que le dernier message.
  3. Le chef répète le processus un niveau plus bas. Le chef de la recherche répartit son brief entre ses propres workers : le chercheur, le scraper et l'analyste de données. Il ne choisit que parmi ses subordonnés directs et ne peut pas s'adresser aux workers de l'équipe rédaction.
  4. Les workers font le travail. Chaque worker exécute sa propre boucle d'outils dans un contexte vierge et écrit sa sortie complète (pages scrapées, tableau de prix) dans un stockage d'artefacts partagé.
  5. Le chef vérifie et condense. Le chef de la recherche lit les résultats de ses workers, vérifie que chaque chiffre a une source et une date, et renvoie un seul rapport : un résumé, les principaux résultats, des ID d'artefacts, les points ouverts et un statut.
  6. La racine intègre et poursuit. La racine lit le rapport, envoie un brief à l'équipe rédaction avec les résultats et les ID d'artefacts, puis à l'équipe relecture avec le brouillon. Si un rapport indique « partial » ou « blocked », la racine envoie un brief de relance ou prévient l'utilisateur.
  7. La récursion s'arrête à une limite fixée dans le code. Un agent cesse de déléguer quand il décide de faire le travail lui-même, ou quand la limite de profondeur lui retire son outil de délégation. Ici, les workers n'ont aucun outil de délégation.

Qui décide du déroulement

Chaque manager décide, mais seulement parmi ses propres enfants. Le développeur fixe en général la forme de l'arbre, et le code impose les limites strictes.

Qui prend chaque décision dans une hiérarchie
DécisionPrise par
Forme de l'arbre : quelles équipes existent, qui rend compte à quiEn général le développeur (hiérarchie statique). Dans les variantes récursives, les agents créent des enfants à l'exécution (ReDel, Self-Organized Agents, sous-agents imbriqués de Claude Code).
Quel enfant agit ensuite, et avec quel briefLe parent à chaque niveau, qui choisit uniquement parmi ses propres enfants.
Quand une équipe a terminéLe chef d'équipe (FINISH dans LangGraph, finish_task dans ADK), dans les limites fixées par le code.
Profondeur maximale, enfants par nœud, budgetLe code ou la configuration (CLAUDE_CODE_MAX_SUBAGENT_SPAWN_DEPTH, limite de profondeur de ReDel, recursion_limit de LangGraph). Jamais le modèle seul.

La propriété qui fait fonctionner le pattern est le contexte cloisonné : un niveau voit son brief, son propre état de travail et les rapports de ses enfants, et rien d'autre, sauf si vous ajoutez volontairement un stockage partagé. Les sous-graphes LangGraph dotés de leur propre schéma, les sub-workflows de Microsoft Agent Framework et les sous-agents en mode tâche d'ADK appliquent tous une version de ce principe.

Un superviseur est un manager unique qui aiguille entre des membres fixes, et un orchestrateur est un chef unique qui invente un lot de sous-tâches. On obtient une hiérarchie quand certains de leurs workers sont eux-mêmes des superviseurs ou des orchestrateurs. Cette page réserve le terme « hiérarchique » à deux niveaux de délégation ou plus. Le « hierarchical process » de CrewAI et le « hierarchical collaboration model » de Bedrock désignent surtout un seul niveau de manager, c'est-à-dire le pattern Supervisor sur ce site.

Analogie

Une entreprise prépare une étude de marché pour son conseil d'administration. La PDG (le manager racine) demande leur part au responsable des études de marché, à la responsable de la communication et au responsable juridique (les chefs d'équipe). Chaque responsable confie le travail à sa propre équipe (les workers). La PDG reçoit une note de deux pages de chaque service, pas les carnets des analystes, et les analystes ne parlent jamais à la PDG.

L'analogie cède sur un point. Dans une entreprise, les gens partagent une mémoire, des couloirs et des discussions informelles : un responsable de service sait des choses que personne n'a écrites. Un agent ne sait que ce qui figure dans son brief. Cognition a rapporté que ses agents managers supposaient que leurs enfants partageaient un état qu'ils n'avaient pas, et que les enfants ne faisaient pas remonter leurs découvertes sans canal explicite prévu pour cela.

Structure

Un manager racine envoie des briefs à trois chefs d'équipe et reçoit leurs rapports ; chaque chef délègue à deux ou trois workers, les workers écrivent leurs sorties complètes dans un stockage d'artefacts partagé, et un gouverneur impose les limites de profondeur, d'étapes et de budget. objectif réponse limites brief rapport Utilisateur Manager racine voit 3 fiches d'équipe Gouverneur profondeur, étapes, budget Chef recherche voit 3 workers Chef rédaction voit 3 workers Chef relecture voit 2 workers recherche web scraping fetch données sql plan docs brouillon docs graphes python vérifier search juridique règles Stockage d'artefacts partagé : les sorties complètes y restent, les rapports portent leurs ID 1 2 3 4 5 6
Entre la racine et ses chefs, les flèches pleines sont les briefs qui descendent et les flèches en pointillés les rapports qui remontent. La même paire brief et rapport existe entre chaque chef et ses workers ; elle y est dessinée comme une seule ligne pour garder la figure lisible.
  1. Manager racine. Porte l'objectif de l'utilisateur, la répartition entre les équipes, la synthèse finale et la décision d'arrêter. Il devrait détenir moins de détails bruts que tout autre agent, et c'est souvent le modèle le plus puissant : le système de recherche d'Anthropic fait diriger des sous-agents Sonnet par un chef Opus.
  2. Chef d'équipe. Transforme un brief d'équipe en briefs de workers, aiguille entre ses workers, vérifie leurs sorties et rédige un rapport d'équipe unique. Pour son parent, c'est un worker : il doit donc respecter le contrat de rapport du parent.
  3. Workers. Exécutent des boucles d'outils et renvoient des résultats. Ils n'ont pas d'outil de délégation et ne peuvent donc pas récurser.
  4. Contrat de brief et de rapport. Des messages typés pour tout ce qui franchit un niveau. Un brief porte l'objectif, le contexte, les contraintes, le format de rapport et le budget. Un rapport porte un statut, un court résumé, les principaux résultats, des ID d'artefacts et les points ouverts.
  5. Stockage d'artefacts partagé. Des fichiers, des lignes ou des ID de blobs qui contiennent les sorties complètes, pour que les rapports transportent des références plutôt que du contenu. Anthropic s'en sert pour éviter un « téléphone arabe » entre agents.
  6. Gouverneur. Du code qui impose la profondeur maximale, le nombre d'enfants par nœud, les étapes par chef, le budget total et les délais. Un traceur qui enregistre l'arbre d'appels avec les ID parents se trouve généralement à côté.

Générateur de prompt

Décrivez l'objectif global et une ligne par équipe. Le générateur écrit un contrat commun de brief et de rapport, un prompt système pour le manager racine et un prompt système par chef d'équipe. Utilisez-les comme prompts système des nœuds d'un super-graphe LangGraph, d'agents ADK reliés par AgentTool, d'agents OpenAI exposés avec as_tool(), ou de sous-agents Claude Code.

Équipes une ligne par chef d'équipe ; évitez que les périmètres se recoupent
Comment la racine sollicite les équipes

Prompt généré

Le texte surligné vient du formulaire. Le texte [entre crochets] reste à compléter.

Le contrat compte plus que la prose

La plupart des défaillances d'une hiérarchie se produisent aux frontières : un brief qui omet une décision, ou un résumé qui laisse tomber une réserve. Dans l'ablation de TalkHier, retirer la partie « background » de chaque message a davantage nui à la précision que retirer n'importe quel autre champ. Concentrez vos efforts sur ce que chaque brief doit transporter et ce que chaque rapport doit conserver, et testez chaque équipe seule avant de la brancher sous la racine.

Quand l'utiliser

À utiliser quand

À éviter quand

Quelle profondeur ?

Deux niveaux de délégation (racine, chefs, workers) couvrent presque tous les cas documentés en production, et beaucoup s'arrêtent à un. C'est un consensus de praticiens et un choix par défaut des frameworks, pas un résultat mesuré : aucune étude parmi les recherches menées pour cette page ne fait varier la profondeur à budget constant. Les valeurs par défaut des frameworks penchent vers la faible profondeur. Claude Code permet d'imbriquer des sous-agents jusqu'à trois couches sous la conversation principale, d'anciennes documentations de Codex fixaient agents.max_depth à 1 par défaut, les agents ADK en mode tâche doivent être des feuilles, et les agent teams de Claude Code interdisent les équipes imbriquées.

Un modèle grossier montre pourquoi. Si chaque étape de résumé conserve une fraction r des détails utiles à la décision, un fait trouvé dans une feuille arrive à la racine avec environ rd de ces détails après d niveaux : avec r = 0,8, deux niveaux en conservent environ 64 % et quatre environ 41 %. C'est une illustration tirée des notes de recherche, pas un résultat mesuré, mais elle explique pourquoi les sources préfèrent des arbres peu profonds dont les rapports portent des références d'artefacts.

Mise en œuvre

  1. Prouvez que vous avez besoin d'un niveau. Commencez par un agent, puis un superviseur ou un orchestrateur. N'ajoutez un niveau que lorsque vous savez nommer la défaillance : erreurs d'aiguillage entre trop de workers, contexte du superviseur qui déborde, ou équipes qui doivent avoir des responsables et des tests séparés. Le guide ADK de Google dit clairement de ne pas construire un système de boucles imbriquées dès le premier jour.
  2. Dessinez l'arbre selon la cohésion. Regroupez les workers pour que la plupart des échanges restent à l'intérieur d'une équipe et que seuls des résumés franchissent les frontières entre équipes. Découpez par domaine ou par phase. Un découpage est mauvais quand deux équipes ont sans cesse besoin de l'état intermédiaire l'une de l'autre. Gardez des équipes petites : le guide des agent teams de Claude Code suggère de commencer avec 3 à 5 coéquipiers.
  3. Définissez le contrat à chaque frontière. Un brief typé qui descend (ID de tâche, objectif, contexte, contraintes, schéma de rapport, budget, profondeur) et un rapport typé qui remonte (statut, résumé, principaux résultats, ID d'artefacts, points ouverts, confiance, coût). Les champs status et open_issues permettent à un chef de répondre « blocked » au lieu d'inventer un résultat.
  4. Construisez de bas en haut et testez chaque équipe seule. Construisez chaque équipe comme une unité autonome (un sous-graphe compilé, un AgentTool, un sub-workflow) et évaluez-la sur des tâches de niveau équipe avant de la brancher sous la racine. L'astuce qui rend cela possible : une équipe a la même interface qu'un worker, donc l'arbre se construit par composition.
  5. Imposez les limites dans le code. Par équipe : une décision FINISH, un nombre maximal d'étapes par chef et un contrôle qualité avant le rapport. Globalement : profondeur maximale, nombre total maximal d'agents, plafond de coût et échéance. Retirez l'outil de délégation à la limite de profondeur et rejetez les briefs qui redélèguent telle quelle la tâche du parent.
  6. Condensez en remontant, gardez un accès au détail. Chaque chef renvoie un résumé et des références vers les artefacts complets, pour que la racine puisse ouvrir le détail quand le résumé ne suffit pas. AWS a rapporté que passer des références au lieu des charges utiles réduisait d'environ 30 % les tokens de sortie par échange (Shu et al., article d'un éditeur).
  7. Tracez sous forme d'arbre. Chaque span porte l'ID de tâche, l'ID parent, la profondeur, l'équipe, les tokens, les appels d'outils et la durée réelle. Placez des faits ou des réserves « aiguilles » dans les feuilles et vérifiez qu'ils survivent jusqu'à la réponse de la racine : cela mesure directement la perte façon téléphone arabe.
  8. Faites des ablations de niveaux. Comparez la hiérarchie à un agent unique, à un superviseur à plat sur tous les workers, et à la hiérarchie avec un niveau fusionné, à budget de tokens comparable. Anthropic attribue environ 80 % de la variance de performance de son évaluation de recherche à la consommation de tokens : un budget inégal fausse donc la comparaison.

Une version statique minimale, en pseudocode. Une équipe et un worker partagent la même interface, donc une équipe peut être membre d'une autre équipe :

def make_team(name, lead_prompt, members, llm, max_steps=20):
    def run(brief):
        history = [system(lead_prompt), user(render(brief))]
        for _ in range(max_steps):
            decision = llm.structured(history, next=[m.name for m in members] + ["FINISH"])
            if decision.next == "FINISH":
                return llm.structured(history + [user(REPORT_PROMPT)], schema=Report)
            report = lookup(members, decision.next).run(decision.child_brief)
            history.append(tool_result(decision.next, compact(report)))
        return Report(status="partial", summary="step limit reached")
    return Agent(name=name, run=run)

research = make_team("research", RESEARCH_LEAD, [search, scrape, data], llm)
writing  = make_team("writing",  WRITING_LEAD,  [outline, draft, charts], llm)
review   = make_team("review",   REVIEW_LEAD,   [verify, legal], llm)
root     = make_team("root",     ROOT_PROMPT,   [research, writing, review], strong_llm)
Prise en charge par les frameworks (vérifiez la documentation actuelle avant usage)
FrameworkForme que prend ce pattern
LangGraphLe tutoriel « Hierarchical Agent Teams » : chaque équipe est un StateGraph compilé avec son propre nœud superviseur ; le graphe de tête ne transmet que le dernier message vers le bas et ne reçoit en retour que le dernier message de l'équipe. Les sous-graphes s'imbriquent à n'importe quel niveau, chacun ne voyant que ses propres clés d'état.
langgraph-supervisorUne équipe superviseur compilée peut être membre d'un create_supervisor de niveau supérieur ; output_mode règle la part de l'historique de l'équipe qui atteint le parent. Son README recommande désormais de construire les superviseurs directement avec des outils, et le paquet aurait été archivé en septembre 2026.
Google ADKL'arbre vient de sub_agents, ou d'AgentTool, qui transforme l'exécution complète d'un sous-agent en un seul appel de fonction. Dans ADK 2.x, les agents en mode tâche doivent être des feuilles.
OpenAI Agents SDKagent.as_tool() s'imbrique naturellement. L'agent imbriqué n'hérite pas de la conversation du parent, et il n'existe pas de limite de profondeur intégrée.
Claude CodePar défaut, les sous-agents peuvent lancer des sous-agents jusqu'à trois couches sous la conversation principale (CLAUDE_CODE_MAX_SUBAGENT_SPAWN_DEPTH ; 1 désactive l'imbrication). Les agent teams (expérimentales) n'autorisent pas les équipes imbriquées.
Microsoft Agent FrameworkUn workflow s'imbrique dans un workflow (WorkflowExecutor en Python, AsAIAgent() en C#) à n'importe quelle profondeur, avec un état isolé par niveau, et les demandes d'intervention humaine remontent à travers les niveaux.
AutoGen 0.4SocietyOfMindAgent enveloppe une équipe interne comme un seul agent et renvoie un résumé, rédigé par le modèle, de la discussion interne.
CrewAI, AWS BedrockProcess.hierarchical et le superviseur de Bedrock offrent un seul niveau de manager. Les structures CrewAI plus profondes se construisent en orchestrant des crews depuis un Flow ; un agent Bedrock peut être à la fois collaborateur et superviseur, avec au plus 10 collaborateurs par superviseur.

Mise en garde. Ces API évoluent vite. Les règles d'imbrication de Claude Code ont changé (d'anciennes documentations disaient que les sous-agents ne pouvaient pas lancer de sous-agents), la valeur par défaut de 1 pour max_depth dans Codex provient d'anciennes documentations et d'un miroir tiers, ADK 2.x est en transition et sa règle du parent unique n'est confirmée que par un extrait de recherche et des retours de la communauté, AutoGen serait passé en mode maintenance au profit de Microsoft Agent Framework (source presse, non vérifiée), et Bedrock Agents est désormais « Agents Classic », en mode maintenance.

Variantes

Équipes statiques de superviseurs

Le développeur fixe l'arbre : un superviseur racine au-dessus de superviseurs d'équipe, eux-mêmes au-dessus de workers, chacun aiguillant tour par tour. C'est la forme du tutoriel LangGraph et le choix par défaut quand les équipes sont connues à l'avance.

Arbre d'agents-outils

Chaque agent inférieur est un outil de celui du dessus : le parent garde le contrôle et reçoit un résultat d'outil. ADK documente un exemple à trois niveaux (rédacteur de rapport, assistant de recherche, recherche web et résumeur). Choisissez-le quand vous voulez que le parent garde la main sur chaque appel.

Délégation récursive dynamique

Les agents décident à l'exécution s'ils lancent des enfants, si bien que la forme de l'arbre varie selon la tâche (ReDel, sous-agents imbriqués de Claude Code). Cela convient aux problèmes ouverts mais exige des limites strictes de profondeur, de ramification et de budget. Avec GPT-4o, ReDel a obtenu 0,494 contre 0,394 pour un agent unique sur FanOutQA, mais son analyse d'erreurs a aussi relevé de la surimplication et de la sous-implication, décrites dans les modes de défaillance.

Décomposition récursive du code

Dans Self-Organized Agents, un agent « Mother » écrit un squelette de fonction et lance un agent par sous-fonction non implémentée ; à la profondeur maximale, l'agent lancé est un « Child » qui implémente. Les auteurs annoncent 71,4 en Pass@1 sur HumanEval avec GPT-3.5 à la profondeur 2, contre 66,5 pour Reflexion, mais la comparaison est biaisée (1 contre 6 tests unitaires par problème).

Imbrication hétérogène

Une équipe n'est pas un agent mais un autre pattern enveloppé pour en avoir l'air : un pipeline, une répartition en parallèle, une boucle évaluateur–optimiseur ou une discussion de groupe. Une forme courante : un superviseur à la racine, des orchestrator–workers dans la recherche et une boucle d'affinage dans la rédaction.

Affinage hiérarchique

Un sous-arbre est une équipe d'évaluation dont le chef agrège plusieurs évaluateurs à métrique unique et renvoie un seul verdict. Dans l'ablation de TalkHier sur trois matières de MMLU, retirer le superviseur d'évaluation a fait passer la précision de 87,21 % à 81,86 %, et retirer toute l'équipe d'évaluation, à 76,15 %.

Hiérarchie avec liens latéraux

L'arbre reste, mais certains pairs s'envoient aussi directement des messages, comme dans les agent teams de Claude Code. L'information circule plus vite, à un prix élevé : l'étude de passage à l'échelle de Google a mesuré 515 % de surcoût et 6,2 fois plus de tours qu'un agent unique pour son architecture « hybrid ».

Racine avec contournement par routage

La racine envoie les demandes simples directement à un collaborateur et ne mobilise la hiérarchie complète que pour les demandes complexes, comme dans le mode « supervisor with routing » de Bedrock. Cela réduit la latence pour les cas faciles.

Avantages et inconvénients

Avantages

  • Chaque agent a un contexte plus petit et ciblé ; la racine ne voit que des résumés.
  • Chaque décision d'aiguillage a moins d'options (trois équipes au lieu de dix workers).
  • Les équipes sont des unités que l'on peut construire, tester, confier et réutiliser séparément.
  • Chaque niveau peut avoir sa propre gamme de modèle, ses outils, ses permissions et ses garde-fous.
  • Un chef qui vérifie son équipe arrête les erreurs avant qu'elles n'atteignent le sommet : l'étude de Google a mesuré une amplification des erreurs de 4,4 fois avec un coordinateur, contre 17,2 fois sans.

Inconvénients

  • Chaque niveau ajoute au moins un aller-retour de modèle par saut ; le parallélisme n'aide qu'à l'intérieur d'un niveau.
  • Chaque manager est un modèle de plus qui lit des briefs et des rapports, et le nombre de tours croît plus vite que le nombre d'agents.
  • Chaque étape de résumé peut perdre ou déformer des détails (le téléphone arabe).
  • Un chef qui ne vérifie pas fait remonter les erreurs de ses workers avec une autorité supplémentaire.
  • Les défaillances se cachent dans les sous-arbres : il faut des traces en arbre pour déboguer.

Modes de défaillance

Perte façon téléphone arabe

La racine agit sur le résumé d'un résumé. Une réserve trouvée dans une feuille (« les données ne couvrent que 2023 ») disparaît en remontant.

Parade : les rapports portent des références d'artefacts et des points ouverts, la racine peut ouvrir les artefacts bruts, et les schémas de rapport sont contraints. Transmettez mot pour mot le message d'un worker quand c'est possible (langgraph-supervisor a un outil de transmission de message pour cela).

Contexte manquant en descendant

Un enfant refait un travail ou contredit une décision prise plus haut, parce que le brief l'a omise. Cognition a vu des agents managers supposer que leurs enfants partageaient un état qu'ils n'avaient pas.

Parade : chaque brief a un champ background avec les décisions et contraintes dont l'enfant a besoin. Dites à chaque agent que ses enfants ne voient pas sa conversation.

Surdélégation et explosion de la récursion

Trop d'enfants pour une tâche simple (les premiers agents d'Anthropic lançaient 50 sous-agents pour des requêtes simples), ou de longues chaînes où chaque agent redélègue (la sous-implication de ReDel, dans 44,8 % des exécutions WebArena avec GPT-4o).

Parade : des règles d'effort dans le prompt (« ne déléguez que si la tâche comporte au moins deux parties qui demandent un vrai travail avec des outils »), des limites strictes de profondeur, de ramification et de budget dans le code, aucun outil de délégation à la limite, et un contrôle qui rejette la redélégation telle quelle de la tâche du parent. Indiquez à chaque agent quels outils ont ses enfants, pour qu'il ne délègue pas un travail qu'ils ne peuvent pas faire.

Surimplication

Un chef fait le travail lui-même, remplit son contexte et oublie la tâche : 22,7 % des exécutions FanOutQA et 41,1 % des exécutions TravelPlanner avec GPT-4o dans ReDel. Des managers CrewAI et des chefs d'agent teams Claude commenceraient à implémenter au lieu d'attendre.

Parade : donnez aux chefs peu ou pas d'outils de travail, demandez-leur d'attendre leurs workers, et surveillez la taille du graphe de délégation.

Mauvais aiguillage entre équipes

Une demande part vers la mauvaise équipe parce que les descriptions d'équipes se recoupent.

Parade : des fiches d'équipe distinctes et sans recoupement (AWS donne le même conseil pour les collaborateurs), des évaluations de routage à chaque niveau, et une option « aucune équipe ne convient » qui renvoie à l'appelant.

Arrêt trop précoce, ou jamais

Un chef déclare le travail terminé trop tôt, ou répète des étapes sans remarquer qu'il a fini. L'étude MAST sur des traces multi-agents en échec range l'arrêt prématuré, la répétition d'étapes et la méconnaissance des conditions d'arrêt parmi ses modes de défaillance.

Parade : une limite d'étapes par chef, des critères de fin explicites dans le brief, et des contrôles des rapports d'équipe au niveau de la racine.

Erreurs non vérifiées qui gagnent en autorité

L'erreur d'un worker passe par un chef qui la valide sans regarder, et la racine s'y fie parce qu'elle vient de « l'équipe ».

Parade : les chefs vérifient avant de rendre compte, les rapports portent un statut et un niveau de confiance, et la racine contrôle des artefacts par sondage.

Défaillance silencieuse d'un sous-arbre

Une erreur au sein d'une équipe se transforme en rapport vide ou partiel que le parent prend pour un succès.

Parade : un champ de statut typé, des événements d'erreur étiquetés avec l'ID de l'équipe (Microsoft Agent Framework le fait pour les sub-workflows), et une règle qui impose d'échouer bruyamment vers le haut.

Conflits entre équipes et agents orphelins

Deux équipes écrivent le même fichier ou font des choix incompatibles ; un petit-enfant en arrière-plan continue de tourner après la fin de son parent.

Parade : un seul propriétaire par artefact, des enfants suivis par ID parent, des délais, et la collecte ou l'arrêt des enfants quand leur parent se termine.

Instructions injectées relayées vers le haut

Une page web lue par un worker contient des instructions, et le chef les fait remonter comme des « résultats ».

Parade : traitez la sortie des enfants comme des données, analysez les rapports avant que le parent ne les lise (Claude Code analyse la sortie des sous-agents), et ne laissez jamais un message relayé accorder des permissions.

Liens avec les autres patterns

Pour aller plus loin

Les sources ci-dessous sont en anglais.