Supervisor

Aussi appelé : manager agent, supervisor–worker, supervisor–collaborator (AWS Bedrock), agents as tools ou manager pattern (OpenAI), subagents (LangChain), Crew manager (CrewAI), Magentic manager (Microsoft)

Intention

Un agent LLM central est maître de la conversation et, étape après étape, choisit quel spécialiste d'une liste fixe agit ensuite, ou décide de répondre ou de s'arrêter. Chaque worker (exécutant) fait sa part, et le contrôle revient toujours au superviseur, qui décide à nouveau.

Problème

Vous construisez l'assistant de support d'une boutique d'électronique en ligne. Il couvre les commandes et les livraisons, les remboursements, le catalogue produits et les règles de la boutique. Chaque domaine a ses propres outils d'API, souvent 10 à 20, ses propres règles, et parfois sa propre équipe responsable. Un client écrit : « Ma dernière commande est arrivée cassée. Remboursez-la sur ma carte et dites-moi si le modèle plus récent est en stock. »

Ce message demande les outils de commande, puis ceux de remboursement, puis le catalogue, avec le numéro de commande transmis d'une étape à l'autre. Les conceptions évidentes échouent toutes :

Une demande client qui touche trois domaines va soit à un agent unique qui détient tous les outils et choisit les mauvais, soit à un routeur en un seul coup qui ne traite que la première partie. Demande client colis, remboursement, stock Option A Un agent à tout faire 100+ outils, 6 jeux de règles Mauvais outil choisi règles confondues Option B Routeur, un seul coup n'envoie qu'aux commandes Remboursement, stock jamais traités
Les deux premières options : l'agent unique se noie dans les outils ; un routeur ne sait ni enchaîner plusieurs spécialistes ni vérifier leurs résultats.

Solution

Placez un agent entre l'utilisateur et une petite équipe de spécialistes. Le superviseur détient la liste des workers et les règles, mais aucun outil métier. À chaque étape, il lit la conversation et les résultats obtenus jusque-là, et prend exactement une décision : appeler un worker avec une instruction, répondre à l'utilisateur, ou terminer. Le worker exécute sa propre boucle d'outils et renvoie son résultat, puis le superviseur décide à nouveau.

  1. Recevoir. Le message du client va au superviseur, et à lui seul. Ce point d'entrée unique est aussi l'endroit où se placent les garde-fous sur les entrées.
  2. Décider. Le superviseur voit sa liste (orders_agent, refunds_agent, catalog_agent, faq_agent) et appelle orders_agent : « Trouve la dernière commande du client C-77 et indique si elle donne droit à un remboursement pour casse. »
  3. Travailler. L'agent commandes exécute sa propre boucle ReAct avec les outils de commande et renvoie {status: done, order_id: 8812, model: X200, eligible: true}.
  4. Revenir et décider à nouveau. Le contrôle revient au superviseur. Le remboursement et la vérification du stock ne dépendent pas l'un de l'autre : il appelle donc refunds_agent (« Rembourse intégralement la commande 8812 sur le moyen de paiement d'origine, motif : arrivée endommagée ») et catalog_agent (« Le successeur du modèle X200 est-il en stock ? À quel prix ? ») dans la même étape.
  5. Vérifier. Les deux résultats reviennent : remboursement R-551 émis, sous 3 à 5 jours ; modèle X300 en stock à 249 $. Le superviseur vérifie que chaque partie de la demande est couverte.
  6. Répondre. Il rédige une réponse unique au client, ou transmet tel quel le texte prêt à l'emploi d'un worker. Au message suivant, la boucle repart du superviseur, qui détient toujours toute la conversation.

Ce tour a pris trois appels au superviseur et trois exécutions de workers. Un agent unique utiliserait peut-être moins d'appels, mais avec tous les outils de tous les domaines dans son contexte.

Le développeur décide de la liste des workers, des outils et du prompt de chacun, de ce qu'un worker voit et de ce qu'il renvoie, et des limites strictes. Le LLM superviseur décide, à chaque étape, quel worker agit ensuite, avec quelle instruction, et quand le tour est terminé. Chaque worker décide comment faire son propre travail.

Le voisin le plus proche est Orchestrator–Workers, et les deux termes sont souvent employés l'un pour l'autre. Sur ce site, un orchestrateur invente un lot de sous-tâches à l'exécution et fusionne les résultats ; un superviseur oriente chaque étape suivante vers un spécialiste nommé d'une liste fixe et reprend la main après chaque worker. Cette distinction est une convention de ces notes, pas un standard du secteur. Dans Swarm / Handoffs, il n'y a pas de centre : l'agent actif passe le contrôle à un pair, qui garde alors l'utilisateur.

Analogie

Le médecin responsable d'un service hospitalier. Le patient parle à ce médecin, qui l'envoie en radiologie, lit le cliché, demande ensuite un bilan sanguin au laboratoire, puis décide du traitement et l'explique au patient. Les spécialistes ne parlent jamais directement au patient et ne se le renvoient jamais entre eux. Chaque résultat revient au médecin responsable, qui décide de l'étape suivante.

L'analogie s'arrête là où commence la reformulation. Un bon médecin lit le compte rendu du radiologue en entier ; un superviseur LLM a tendance à résumer les résultats des workers avec ses propres mots et peut perdre ou modifier des détails en route, ce qui est la principale faiblesse du pattern.

Structure

L'utilisateur ne parle qu'au superviseur. Le superviseur appelle l'un des trois workers, chaque worker renvoie son résultat au superviseur, et des limites strictes bornent la boucle. demande réponse Utilisateur Superviseur appel / réponse / fin décide à chaque étape Règles et limites étapes max, budget Agent commandes son prompt, ses outils Agent remboursements son prompt, ses outils Agent catalogue son prompt, ses outils Les workers ne se parlent jamais entre eux et ne parlent jamais à l'utilisateur. 1 2 3 4 5 6
Les traits pleins en couleur sont des délégations (une étape chacune) ; les traits pointillés sont des résultats et des réponses. Chaque résultat de worker revient au superviseur, jamais à un autre worker.
  1. Utilisateur. Ne parle qu'au superviseur, à chaque tour. Un seul tour de l'utilisateur peut contenir plusieurs étapes.
  2. Superviseur. Un LLM dans une boucle, avec la liste des workers et les règles dans son prompt système. Il rédige l'instruction de chaque worker, vérifie chaque résultat, interroge l'utilisateur quand il manque quelque chose, et décide quand le tour est terminé. En général, il ne détient aucun outil métier.
  3. Délégation. La façon dont une décision devient une exécution de worker : un champ structuré next lu par une arête du graphe, un outil de handoff, ou (le plus courant aujourd'hui) un outil ordinaire dont le corps exécute le worker. Le développeur contrôle ce que reçoit le worker : l'instruction seule, ou une partie ou la totalité de l'historique.
  4. Workers. Une liste fixe et nommée. Chacun a une description sur laquelle le superviseur s'appuie pour l'orienter, son propre prompt et ses propres outils, et en général sa propre boucle ReAct.
  5. Retour du résultat. Le contrôle revient au superviseur quoi qu'il arrive. Un adaptateur de résultat décide de ce que voit le superviseur : le dernier message, un objet structuré, la transcription complète, ou une référence vers un artefact stocké.
  6. Règles et limites. Nombre maximal d'étapes par tour, budget de tokens ou de coût, délais d'expiration, blocage des appels en double, et garde-fous sur les entrées et sur les actions sensibles des workers.

Générateur de prompt

Décrivez votre équipe et ses workers. Vous obtenez un prompt système pour l'agent superviseur, plus un bloc facultatif à ajouter au prompt de chaque worker pour que les résultats reviennent sous une forme que le superviseur peut vérifier. Il s'utilise avec tout framework où les workers sont exposés comme des outils (LangChain create_agent, OpenAI as_tool(), Strands, ADK AgentTool) ou dans une boucle écrite à la main.

Workers une ligne par spécialiste ; le nom sert de nom d'outil
Ce que voient les workers
Réponse finale

Prompt généré

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

Les descriptions des workers sont l'API de routage

Le superviseur choisit les workers uniquement d'après leurs noms et leurs descriptions. LangChain et Google insistent tous deux sur ce point, et AWS demande de réduire au minimum les responsabilités qui se chevauchent. Dites ce que chaque worker ne sait pas faire aussi clairement que ce qu'il sait faire, et testez le routage sur de vrais messages avant de régler quoi que ce soit d'autre.

Quand l'utiliser

À utiliser quand

À éviter quand

Mise en œuvre

  1. Prouvez que vous en avez besoin. Commencez par un agent avec des outils. Passez à un superviseur quand vous constatez une surcharge d'outils, des confusions de règles entre domaines, des équipes responsables distinctes, ou des frontières de sécurité qui imposent des agents séparés.
  2. Rédigez une fiche par worker. Nom, une ou deux phrases sur ce qu'il sait et ne sait pas faire, ses outils, son contrat d'entrée et son contrat de sortie. Gardez une liste courte : Bedrock limite un superviseur à 10 collaborateurs, et LangChain conseille de lister les agents dans le prompt seulement en dessous d'une dizaine environ ; au-delà, utilisez un outil de découverte ou des sous-superviseurs.
  3. Rédigez le prompt du superviseur. La liste des workers, la méthode de travail (un appel à la fois sauf s'ils sont indépendants, des instructions autonomes, la vérification de chaque résultat, jamais deux fois le même appel), quand répondre directement, quand transmettre tel quel, et la limite d'étapes avec ce qu'il faut dire quand elle est atteinte. Le générateur ci-dessus produit ce prompt.
  4. Choisissez le mécanisme de délégation. La plupart des frameworks proposent désormais par défaut les agents as tools : chaque worker est un outil, le superviseur est une boucle ordinaire d'appels d'outils, « répondre » est un message sans appel d'outil, et le résultat de l'outil sert de retour. L'ancien style en graphe utilise un champ structuré next (les noms des workers plus FINISH) et des arêtes fixes de chaque worker vers le superviseur.
  5. Décidez de ce que voient les workers et de ce qui revient. C'est la décision la plus importante. Une entrée isolée (l'instruction seule) garde les workers concentrés et peu coûteux, mais exige des instructions complètes. Ne renvoyer que le dernier message garde le contexte du superviseur réduit. Demandez aux workers un résultat structuré avec un champ status (done, partial, failed, needs_user_input), les identifiants trouvés, et éventuellement un texte prêt pour le client.
  6. Ajoutez une logique d'arrêt. Nombre maximal d'étapes par tour de l'utilisateur, nombre maximal de pas par worker, budget de tokens, délai d'expiration, et blocage des appels identiques répétés. Quand une limite est atteinte, faites dire au superviseur ce qui est fait et ce qui ne l'est pas, et faites-le escalader vers un humain plutôt que boucler.
  7. Tracez et évaluez par couches. Un span par décision du superviseur, avec un span imbriqué par exécution de worker. Testez les workers sur leurs propres jeux de données, puis le routage (worker attendu pour un état donné), puis les trajectoires, puis la réussite de l'objectif de bout en bout avec des utilisateurs simulés.
Prise en charge par les frameworks (vérifiez la documentation à jour avant usage)
FrameworkForme que prend ce pattern
LangChain / LangGraphLa recommandation actuelle est le pattern subagents : des workers create_agent enveloppés dans des fonctions @tool, appelés par un superviseur create_agent doté d'un checkpointer. L'ancienne bibliothèque langgraph-supervisor (create_supervisor) propose output_mode, add_handoff_messages et un outil de transmission de message.
OpenAI Agents SDKAgents as tools (le « manager pattern ») avec agent.as_tool(...). L'agent imbriqué ne voit pas la conversation parente, sauf si vous passez la même session. Les handoffs sont le mécanisme opposé.
AWSStrands Agents : des agents passés comme outils, avec un contexte vierge à chaque appel par défaut. Bedrock Agents : mode de collaboration SUPERVISOR ou SUPERVISOR_ROUTER, 10 collaborateurs au plus.
Google ADKAgentTool(agent=...) laisse le contrôle au parent et renvoie le résultat. transfer_to_agent cède au contraire le contrôle, ce qui se rapproche du routage ou des handoffs.
Microsoft Agent FrameworkOrchestration Magentic (MagenticBuilder) : un manager choisit l'agent suivant à chaque tour à partir d'un registre de progression, avec max_round_count et max_stall_count.
CrewAIProcess.hierarchical avec un manager_llm ou un manager_agent qui attribue les tâches du développeur aux membres de l'équipage.
smolagentsmanaged_agents=[...] sur un agent manager ; chaque agent géré doit avoir un name et une description.

Mise en garde. Ces API évoluent vite. Le dépôt langgraph-supervisor a été archivé le 2026-09-20 et son guide de migration indique qu'il n'est plus activement maintenu. AWS présente Bedrock Agents comme « Agents Classic », fermé aux nouvelles inscriptions et en mode maintenance, et oriente les nouveaux projets vers Strands et AgentCore. Les problèmes du manager CrewAI ne sont connus que par des signalements sur le forum de la communauté.

Variantes

Superviseur en nœud routeur

Le superviseur renvoie un champ structuré next, limité aux noms des workers plus FINISH, et des arêtes du graphe ramènent chaque worker vers lui. Les workers partagent en général tout l'historique des messages. C'est la forme du tutoriel LangGraph d'origine.

Superviseur à appels d'outils (agents as tools)

Les workers sont des outils et le résultat de l'outil sert de retour. Les workers reçoivent par défaut un contexte isolé, et les appels parallèles viennent sans effort. Un outil d'aiguillage unique task(agent_name, description) peut remplacer un outil par worker quand la liste est longue ou change souvent.

Superviseur avec transmission directe

Le superviseur, ou le runtime, envoie la réponse d'un worker à l'utilisateur mot pour mot au lieu de la réécrire. On évite ainsi le relais avec perte et on économise des tokens. L'outil forward_message de LangChain, la délégation à retour direct de Strands et le mode SUPERVISOR_ROUTER de Bedrock fonctionnent ainsi.

Raccourci de routage

Un classifieur peu coûteux envoie les demandes simples directement à un worker et se replie sur la supervision complète quand il a un doute ou que la demande est complexe. Dans l'étude d'AWS, un classifieur Claude 3 Haiku atteignait une précision de 0,90 à 0,92 et ajoutait environ 630 à 750 ms par tour.

Superviseur à envoi parallèle

Le superviseur peut appeler plusieurs workers en une seule étape, comme pour le remboursement et la vérification de stock plus haut. Plus il le fait, plus il se rapproche d'Orchestrator–Workers.

Manager à registre

Le superviseur tient un plan explicite et un registre de progression à chaque tour (la demande est-elle satisfaite, tourne-t-on en rond, progresse-t-on ?) et refait son plan quand il stagne. C'est la conception de Magentic-One chez Microsoft.

Autres variantes

Avantages et inconvénients

Avantages

  • Passe à l'échelle avec le nombre de domaines. Dans le test τ-bench de LangChain, le score et la consommation de tokens du superviseur restaient à peu près stables à mesure que des domaines distracteurs étaient ajoutés, alors que l'agent unique décrochait.
  • Meilleur taux de réussite sur les tâches multi-domaines riches en outils. L'étude d'AWS (recherche d'un éditeur, 90 scénarios) indiquait une réussite de l'objectif de 0,90 pour une équipe supervisée, contre 0,53 à 0,80 pour un agent unique.
  • Un seul point d'entrée pour les garde-fous, les validations, le ton et la journalisation.
  • Les workers restent petits et testables isolément, et des équipes différentes peuvent en être responsables.
  • La vérification centrale filtre les erreurs des workers : Google Research a mesuré une amplification d'erreur de 4,4x pour les conceptions centralisées, contre 17,2x pour des agents indépendants.
  • Un superviseur puissant peut piloter des workers moins chers : AWS a atteint 0,80 à 0,87 avec des spécialistes Haiku 3.5 sous un superviseur Sonnet.

Inconvénients

  • Un appel de LLM supplémentaire par étape. La documentation de LangChain décrit une demande sur un seul domaine qui coûte 4 appels avec des sous-agents contre 3 avec des handoffs (un exemple illustratif, pas un benchmark).
  • Plus de latence. AWS a mesuré de 24 à 169 secondes par tour, contre 9 à 53 secondes pour un agent unique.
  • Le relais perd des détails. Dans le benchmark de LangChain, swarm obtenait un score légèrement meilleur que supervisor dans toutes les configurations, surtout parce que le superviseur reformulait les réponses des workers.
  • Point de défaillance unique : une mauvaise décision de routage au début ou une instruction trop maigre contamine les étapes suivantes.
  • Des workers sans état refont le travail sur les demandes répétées, sauf si vous persistez leur état.

Modes de défaillance

Téléphone arabe (relais avec perte)

Le superviseur reformule les réponses des workers et perd des détails, modifie des nombres, ou régénère mal les sorties volumineuses. C'était la principale cause de l'écart du superviseur dans le benchmark de LangChain.

Parade : transmettre mot pour mot les réponses prêtes pour le client, renvoyer des résultats structurés avec identifiants, et passer les gros artefacts par référence. Les corrections de LangChain (retirer les messages de handoff du contexte des workers, ajouter un outil de transmission) ont apporté à leur superviseur une amélioration de « près de 50 % » par rapport à leur première version. Le passage de charges par référence chez AWS a fait monter la réussite de l'objectif sur des tâches de code de 0,73 à 0,90.

Le worker manque de contexte

Un worker isolé reçoit « rembourse la commande » sans le numéro de commande ni les contraintes, et échoue ou devine.

Parade : une règle de prompt exigeant que chaque instruction se suffise à elle-même, des schémas d'entrée typés sur les outils des workers, ou la transmission de clés d'état choisies.

Mauvais routage

Des descriptions vagues ou qui se recoupent envoient les demandes au mauvais spécialiste. Cela se voit à un taux élevé de résultats de workers en échec ou du type « ce n'est pas mon rôle ».

Parade : des fiches de workers précises et sans recoupement, une sortie de routage contrainte par une énumération, et des évaluations de routage qui suivent les confusions entre paires de workers.

Ping-pong et boucles

Le superviseur rappelle sans cesse le même worker, ou alterne entre deux. La taxonomie de défaillances MAST attribue à la répétition d'étapes 15,7 % des défaillances multi-agents observées.

Parade : un plafond d'étapes, le blocage des appels identiques répétés, des compteurs de stagnation avec replanification (max_stall_count chez Magentic), et l'escalade vers un humain.

Ne termine jamais, ou termine trop tôt

Il continue alors que le travail est fini, ou déclare avoir fini alors qu'il manque des parties. MAST attribue 12,4 % des défaillances à la méconnaissance des conditions d'arrêt et 6,2 % à un arrêt prématuré.

Parade : une liste de contrôle de fin explicite dans le prompt, un champ status sur chaque résultat de worker, et une étape de vérification finale.

Le superviseur fait le travail lui-même, ou pose trop de questions

Il répond avec ses propres connaissances au lieu de déléguer, ou continue de poser à l'utilisateur des questions auxquelles un worker pourrait répondre. AWS a observé le second cas.

Parade : aucun outil métier sur le superviseur, une règle interdisant de demander ce qu'un worker peut trouver, et un suivi des taux de délégation et de demandes de précision.

Contexte du superviseur qui enfle

Les transcriptions complètes des workers et les messages de routage s'accumulent dans la fenêtre de contexte du superviseur au fil d'une longue session : le coût augmente et l'attention se dégrade.

Parade : ne renvoyer que le dernier message ou un résultat structuré, retirer les messages de routage, et élaguer ou résumer l'historique du superviseur.

Injection de prompt via les workers

Un contenu non fiable récupéré par un worker parvient au superviseur sous forme de « résultat » et oriente sa décision suivante.

Parade : traiter la sortie des workers comme des données, donner à chaque worker le moins d'outils possible, et exiger une validation pour les actions sensibles.

Conflit entre appels parallèles

Deux workers appelés dans la même étape agissent sur la même ressource.

Parade : n'autoriser les appels parallèles que pour des workers en lecture seule ou indépendants, et garder les écritures en série.

Liens avec les autres patterns

Pour aller plus loin

Les sources ci-dessous sont en anglais.