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 :
- Le routage devient plus difficile. Le superviseur choisit à chaque étape parmi 10 descriptions de workers, et des descriptions proches provoquent des erreurs d'aiguillage. Le tutoriel hierarchical teams de LangGraph donne exactement cette motivation : avec trop de workers, un seul superviseur devient moins efficace.
- Le contexte du superviseur se remplit. La sortie de chaque worker revient dans la même conversation. Après la phase de recherche, le superviseur traîne des dizaines de pages scrapées pendant qu'il essaie de coordonner la rédaction.
- Un seul prompt mélange toutes les préoccupations. Stratégie de recherche, règles de style rédactionnel et politique de conformité vivent toutes dans le prompt système du superviseur.
- Rien n'est réutilisable. Les spécialistes de la recherche n'existent que comme entrées d'un gros routeur, si bien que personne ne peut construire, tester ou réutiliser « la recherche » comme une unité.
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.
- 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.
- 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.
- 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.
- 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é.
- 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.
- 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.
- 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.
| Décision | Prise par |
|---|---|
| Forme de l'arbre : quelles équipes existent, qui rend compte à qui | En 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 brief | Le 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, budget | Le 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
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
Prompt généré
Le texte surligné vient du formulaire. Le texte [entre crochets] reste à compléter.
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
- Un superviseur unique atteint ses limites de façon mesurable. Il aiguille mal ou se dégrade parce qu'il a trop de subordonnés directs ou d'outils, et les workers se regroupent naturellement en équipes cohérentes.
- Le travail se divise en domaines ou en phases. Les détails de la recherche restent dans la recherche et seuls les résultats remontent : les échanges internes d'une équipe n'ont jamais besoin d'atteindre le sommet.
- Les équipes ont des responsables et des tests distincts. Des ingénieurs différents s'occupent de l'équipe recherche et de l'équipe conformité, et chaque équipe a besoin de ses propres évaluations.
- Les niveaux exigent des politiques différentes. Gamme de modèle, permissions, outils ou garde-fous diffèrent selon l'équipe. Dans Bedrock, par exemple, chaque agent a ses propres garde-fous et bases de connaissances.
- Le problème est récursif. Du code qui se décompose en fonctions (Self-Organized Agents) ou des questions qui se ramifient en sous-questions (ReDel sur FanOutQA).
À éviter quand
- Un agent ou un superviseur suffit déjà. L'étude de passage à l'échelle de Google (Kim et al.) a constaté que les gains de coordination diminuent ou s'inversent dès que la référence à agent unique dépasse environ 45 % de réussite. Restez sur un superviseur ou un orchestrateur.
- La tâche est séquentielle et fortement couplée. Dans la même étude, toutes les variantes multi-agents ont dégradé PlanCraft de 39 à 70 %, et la documentation des agent teams de Claude Code recommande une session unique pour un travail séquentiel ou sur un même fichier. Utilisez un agent ReAct unique ou Plan-and-Execute.
- La latence compte. Chaque niveau ajoute au moins un aller-retour de modèle. Dans l'article d'AWS, le seul domaine doté d'un niveau supplémentaire était environ trois fois plus lent que l'agent unique, même si les auteurs l'attribuent à la complexité de la tâche et à de gros échanges de code plutôt qu'à la profondeur.
- Les « niveaux » ne sont que des noms de rôles dans un ordre fixe. MetaGPT et ChatDev sont souvent qualifiés de hiérarchiques, mais tous deux exécutent un pipeline séquentiel de rôles. Utilisez Prompt Chaining.
- Vous ne pouvez pas vous permettre les tokens. Chaque manager est un modèle de plus qui lit des briefs et des rapports, et les coûts se multiplient avec les agents et les tours.
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
- 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.
- 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.
- 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
statusetopen_issuespermettent à un chef de répondre « blocked » au lieu d'inventer un résultat. - 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. - 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. - 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).
- 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.
- 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)
| Framework | Forme que prend ce pattern |
|---|---|
| LangGraph | Le 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-supervisor | Une é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 ADK | L'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 SDK | agent.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 Code | Par 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 Framework | Un 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.4 | SocietyOfMindAgent 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 Bedrock | Process.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-supervisora 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
- Supervisor : un manager unique qui aiguille entre des membres fixes. Les Hierarchical teams sont des superviseurs de superviseurs.
- Orchestrator–Workers : un seul niveau de décomposition à l'exécution. Une hiérarchie apparaît quand certains workers sont eux-mêmes des orchestrateurs.
- Routing : la racine joue souvent le rôle de routeur vers les équipes, et un contournement par routage évite la hiérarchie pour les demandes simples.
- Parallelization : la façon habituelle dont un chef exécute ses workers, et dont des équipes indépendantes tournent côte à côte à un même niveau.
- Evaluator–Optimizer : souvent placé en sous-arbre (l'équipe d'évaluation de TalkHier) ou comme contrôle qualité d'un chef avant qu'il ne rende compte.
- ReAct (tool-use loop) : ce que chaque worker, et souvent chaque chef, exécute à l'intérieur.
- Plan-and-Execute : un agent planifie et exécute dans un seul contexte ; une hiérarchie répartit le plan entre des agents aux contextes séparés.
- Prompt Chaining : un pipeline peut constituer une équipe au sein d'une hiérarchie. Les systèmes « entreprise » comme MetaGPT et ChatDev sont surtout des chaînes avec des noms de rôles.
- Swarm / Handoffs : des pairs se transfèrent le contrôle sans arbre fixe et sans retour à un parent.
- Group Chat : peut être enveloppé comme une seule équipe (
SocietyOfMindAgentd'AutoGen) ; les liens latéraux d'une hiérarchie hybride ressemblent à un group chat. - Blackboard : le stockage d'artefacts partagé entre les équipes est un blackboard léger.
- Council / Debate : peut se placer sous un chef comme une équipe-jury dont le verdict remonte.
- Human-in-the-Loop : les demandes de validation doivent remonter à travers les niveaux pour atteindre une personne.
Pour aller plus loin
Les sources ci-dessous sont en anglais.
- Hierarchical Agent Teams (LangGraph, notebook archivé) : l'implémentation statique de référence, avec des superviseurs d'équipe et le passage du seul dernier message entre les niveaux.
- How we built our multi-agent research system (Anthropic) : un système de production avec un chef et des sous-agents, son coût en tokens, et pourquoi les sorties vont dans un stockage externe.
- Subagents (documentation Claude Code) : les sous-agents imbriqués, le réglage de profondeur de lancement et la façon dont la limite de profondeur retire l'outil de délégation.
- ReDel (Zhu, Dugan, Callison-Burch, démo EMNLP 2024) : la délégation récursive, ses défaillances de surimplication et de sous-implication, et des outils de rejeu des arbres de délégation.
- TalkHier (Wang et al.) : des équipes imbriquées avec un protocole de messages structuré et une équipe d'évaluation, avec ablations.
- Towards a Science of Scaling Agent Systems (Kim et al.) : quand la coordination aide ou nuit, l'amplification des erreurs et le surcoût selon l'architecture.