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 :
- Un seul agent avec tous les outils. Avec deux domaines, cela fonctionne. Avec six, le prompt contient plus de 100 schémas d'outils et plusieurs documents de règles, et le modèle choisit les mauvais outils et confond les règles. LangChain l'a mesuré sur une version modifiée du jeu retail de τ-bench : le score de l'agent unique chutait nettement dès que deux domaines d'outils supplémentaires ou plus étaient ajoutés, et sa consommation de tokens augmentait à chaque domaine.
- Un routeur en un seul coup. Un routeur classe le message dans « commandes » et l'envoie à un spécialiste. Personne n'effectue ensuite le remboursement, ne vérifie le stock ni ne contrôle que chaque étape a réussi, car un routeur ne reprend jamais la main.
- Des handoffs entre pairs. Si l'agent commandes passe la main à l'agent remboursements, qui la passe à l'agent catalogue, chaque agent doit connaître tous les autres, aucun n'est responsable de la réponse finale, et les garde-fous doivent être recopiés dans chacun d'eux.
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.
- 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.
- Décider. Le superviseur voit sa liste (
orders_agent,refunds_agent,catalog_agent,faq_agent) et appelleorders_agent: « Trouve la dernière commande du client C-77 et indique si elle donne droit à un remboursement pour casse. » - 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}. - 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 ») etcatalog_agent(« Le successeur du modèle X200 est-il en stock ? À quel prix ? ») dans la même étape. - 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.
- 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
- Utilisateur. Ne parle qu'au superviseur, à chaque tour. Un seul tour de l'utilisateur peut contenir plusieurs étapes.
- 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.
- Délégation. La façon dont une décision devient une exécution de worker : un champ structuré
nextlu 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. - 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.
- 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é.
- 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.
Prompt généré
Le texte surligné vient du formulaire. Le texte [entre crochets] reste à compléter.
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
- Plusieurs domaines surchargeraient un agent unique. Trop d'outils ou des règles contradictoires font choisir les mauvais outils à un agent unique ; chaque worker ne voit que les siens.
- Les demandes exigent souvent plusieurs spécialistes à la suite. Le superviseur transmet identifiants et faits d'un worker au suivant, et vérifie chaque résultat avant de continuer.
- Vous voulez une seule voix face à l'utilisateur. Un seul endroit pour les garde-fous, le ton, la conformité et la réponse finale. C'est la raison qu'avance OpenAI pour préférer les agents as tools aux handoffs.
- Des équipes différentes sont responsables de spécialistes différents. Les workers peuvent être construits, testés et remplacés séparément, sans toucher aux autres.
- Vous avez besoin d'une piste d'audit centrale. Chaque décision de routage est une étape explicite que vous pouvez journaliser.
À éviter quand
- Un agent avec un jeu d'outils raisonnable suffit. Microsoft, OpenAI et LangChain recommandent tous de commencer par là. Utilisez une boucle ReAct.
- Chaque demande relève d'un seul domaine. Utilisez Routing, ou un superviseur doté d'un raccourci de routage.
- Le spécialiste doit garder la conversation une fois sollicité. Les dialogues longs et ciblés, comme le support technique, conviennent mieux à Swarm / Handoffs, sans couche de relais.
- Le travail consiste à répartir largement des sous-tâches inventées à l'exécution. Les recherches ou les audits qui se découpent puis se fusionnent conviennent à Orchestrator–Workers.
- Les étapes sont connues à l'avance. Utilisez Prompt Chaining ou du code ordinaire.
- Les contraintes de latence sont serrées, ou la tâche est une planification strictement séquentielle. AWS a vu la latence par tour doubler ou tripler environ, et une étude de Google Research a constaté que toutes les conceptions multi-agents perdaient de 39 à 70 % sur les tâches de planification séquentielle.
Mise en œuvre
- 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.
- 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.
- 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.
- 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 plusFINISH) et des arêtes fixes de chaque worker vers le superviseur. - 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. - 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.
- 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.
| Framework | Forme que prend ce pattern |
|---|---|
| LangChain / LangGraph | La 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 SDK | Agents 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é. |
| AWS | Strands 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 ADK | AgentTool(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 Framework | Orchestration Magentic (MagenticBuilder) : un manager choisit l'agent suivant à chaque tour à partir d'un registre de progression, avec max_round_count et max_stall_count. |
| CrewAI | Process.hierarchical avec un manager_llm ou un manager_agent qui attribue les tâches du développeur aux membres de l'équipage. |
| smolagents | managed_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
- Manager à liste de tâches. Le développeur définit les tâches, et le manager attribue chacune à un membre de l'équipage puis valide le résultat (CrewAI).
- Superviseur asynchrone. Les appels de workers lancent des tâches en arrière-plan, et le superviseur continue de parler à l'utilisateur pendant ce temps (LangChain subagents, mode asynchrone).
- Superviseur appris. La politique de routage est entraînée par apprentissage par renforcement au lieu d'être écrite dans un prompt (Dang et al., « puppeteer »). Les résultats ne sont rapportés qu'au niveau du résumé de l'article et n'ont pas été vérifiés pour cette page.
- Plusieurs niveaux. Les workers sont eux-mêmes des superviseurs ; voir Hierarchical teams.
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_countchez 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
statussur 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
- Routing : un classifieur en un seul coup qui ne reprend jamais la main. Un superviseur est un routeur qui s'exécute à chaque étape, garde la conversation et vérifie les résultats. Le raccourci de routage d'AWS combine les deux.
- Orchestrator–Workers : même forme en étoile et souvent le même code agents as tools, mais l'orchestrateur invente un lot de sous-tâches et les fusionne, alors que le superviseur oriente chaque étape suivante vers une liste fixe. Beaucoup de sources emploient les deux termes l'un pour l'autre.
- ReAct (tool-use loop) : un superviseur à appels d'outils est un agent ReAct dont les outils sont des agents, et chaque worker est en général lui aussi un agent ReAct.
- Plan-and-Execute : se combine bien. Un superviseur peut tenir un plan (les registres de Magentic), et un worker peut planifier et exécuter en interne, comme le font les agents par cas d'usage de Fastweb.
- Evaluator–Optimizer : un superviseur peut envoyer un brouillon à un worker relecteur puis le récupérer, ce qui donne une boucle auteur–vérificateur pilotée par le superviseur.
- Hierarchical teams : des superviseurs dont les workers sont des superviseurs. L'étape suivante quand une liste devient trop longue.
- Swarm / Handoffs : l'agent actif passe directement la main à un pair, qui garde le contrôle et répond lui-même à l'utilisateur. Pas de centre, pas de relais.
- Group Chat : un sélecteur choisit le prochain intervenant dans une transcription partagée. Microsoft décrit Magentic comme l'architecture de group chat avec un manager plus fort.
- Blackboard : les workers se coordonnent par un espace de stockage partagé plutôt que par le superviseur. Les clés d'état partagées d'un graphe superviseur en sont une forme légère.
- Council / Debate : plusieurs agents répondent à la même question ; un superviseur donne à chaque worker une tâche différente.
- Human-in-the-Loop : validation avant les actions sensibles des workers, et escalade quand le superviseur atteint ses limites.
Pour aller plus loin
Les sources ci-dessous sont en anglais.
- Benchmarking multi-agent architectures (LangChain, 2025) : supervisor face à swarm et à un agent unique sur τ-bench avec des domaines distracteurs, l'explication du téléphone arabe et les corrections. Les scores ne figurent que dans des graphiques, et les tâches à plusieurs étapes n'ont pas été testées.
- Towards Effective GenAI Multi-Agent Collaboration (Shu et al., AWS) : la conception du superviseur derrière le multi-agent de Bedrock, avec des chiffres sur la réussite de l'objectif, la latence, le passage par référence et le routage. Recherche d'un éditeur, sur 90 scénarios.
- Subagents (documentation LangChain) : le superviseur actuel à base d'outils, les entrées isolées ou dupliquées, et un outil par agent ou un outil d'aiguillage unique.
- Multi-agent orchestration (OpenAI Agents SDK) : agents as tools ou handoffs, et quand choisir l'un ou l'autre.
- AI agent orchestration patterns (Microsoft Azure Architecture Center) : pourquoi un agent unique est souvent le bon choix par défaut, et des conseils de fiabilité pour les conceptions multi-agents.
- Why Do Multi-Agent LLM Systems Fail? (Cemri et al.) : la taxonomie de défaillances MAST, dont la répétition d'étapes et les défaillances d'arrêt.