Orchestrator–Workers

Aussi appelé : agent principal et sous-agents, délégation dynamique, manager pattern ou agents-as-tools (OpenAI), subagents pattern (LangChain), centralized multi-agent system (Google Research)

Intention

Un modèle principal lit la demande, détermine les sous-tâches nécessaires et confie chacune à un worker (un exécutant) qui démarre avec un contexte vierge. Les workers renvoient des résultats courts et structurés, et le modèle principal les fusionne ou planifie un nouveau tour. Le découpage est décidé par le modèle à l'exécution, et non écrit par le développeur dans le code.

Problème

Une équipe plateforme veut un assistant interne qui réponde aux questions sur l'outillage. Un développeur demande : « Compare Vitest, Jest et le runner intégré node:test pour notre monorepo TypeScript (environ 1 200 fichiers de test, sous Jest aujourd'hui). Couvre la vitesse en CI, l'écosystème et l'effort de migration, et recommandes-en un. »

Un agent unique, avec la recherche web et un accès en lecture au dépôt, essaie de tout faire dans une seule conversation. Cela marche sur les petites questions et casse sur celle-ci :

Un agent unique lit les pages des trois runners de test dans une seule fenêtre de contexte, les premières pages se retrouvent enfouies, et le rapport arrive lentement, avec une profondeur inégale. Demande comparer 3 runners de test, en choisir un Un seul agent lit tout, l'un après l'autre fenêtre de contexte pages Vitest (enfouies) pages Jest pages node:test config du dépôt guides de migration Rapport lent : page après page premières sources perdues profondeur inégale un prompt pour tout
Un agent, un contexte, un seul fil de travail : plus il lit, moins il retient ce qu'il a lu en premier.

Solution

Séparez le système entre un agent principal (l'orchestrateur) et des workers. L'orchestrateur planifie, rédige les briefs et combine les résultats ; il fait lui-même peu de lecture. Chaque worker reçoit un brief, un contexte vide, un petit jeu d'outils et un budget, et renvoie un résultat condensé plutôt que sa transcription.

  1. Planifier. L'orchestrateur classe la demande comme une comparaison et retient quatre sous-tâches : vitesse en CI et fonctionnalités de Vitest, de Jest, de node:test, et un inventaire des API propres à Jest utilisées dans le monorepo (mocks, matchers personnalisés, configuration).
  2. Rédiger les briefs. Pour chaque sous-tâche, il écrit un brief autonome : l'objectif, pourquoi il compte, ce que couvrent les autres workers (pour que le worker Vitest laisse Jest de côté), les sources à privilégier, un budget d'appels d'outils, le moment où s'arrêter et le format du résultat.
  3. Répartir. Le code runtime lance les workers en parallèle, sous une limite de concurrence. Trois utilisent la recherche web ; le quatrième a un accès en lecture seule au dépôt.
  4. Travailler et rendre compte. Chaque worker exécute sa propre boucle d'outils. Il peut lire des dizaines de milliers de tokens, mais il renvoie un court résultat JSON avec ses constats, ses sources, les contradictions et les questions ouvertes. Les tableaux de benchmark bruts vont dans un stockage de fichiers, et seule une référence revient.
  5. Synthétiser ou reboucler. L'orchestrateur fusionne les résultats et remarque une lacune : personne n'a trouvé de benchmark CI pour un dépôt de cette taille. Il lance un worker de plus pour exécuter node:test et Vitest sur une copie d'un package, puis rédige lui-même le rapport.

Qui décide du déroulement

Le modèle principal décide s'il faut déléguer, combien de workers lancer, ce que fait chacun et quand l'exécution est terminée. Le développeur décide quels types de workers existent et de quels outils ils disposent. Le code runtime impose les limites strictes : nombre total de workers, concurrence, tours, timeouts et budget de tokens. Chaque worker décide comment mener sa propre sous-tâche.

C'est la différence avec Parallelization, où le développeur fixe le découpage dans le code. Ici, la liste des sous-tâches est produite par un modèle à chaque demande. Le pattern diffère aussi d'un Supervisor, qui choisit un spécialiste par étape dans une liste fixe et reprend la main après chacun ; un orchestrateur planifie en général un lot de nouvelles sous-tâches d'un coup. Beaucoup de sources emploient les deux termes indifféremment : cette distinction est une convention de ce site.

Analogie

Une rédactrice en chef reçoit un gros sujet : la fermeture d'une usine, avec de nombreux angles. Elle joue le rôle de l'orchestrateur. Elle décide qu'un journaliste couvre l'entreprise, un autre le syndicat, un troisième l'économie locale, et dit à chacun ce que font les autres pour que deux personnes n'appellent pas la même source. Les journalistes rendent des papiers courts avec leurs notes en pièce jointe, et c'est elle qui écrit l'article publié.

L'analogie s'arrête au brief. Un journaliste humain peut aller demander à sa rédactrice ce qu'elle voulait dire, et il connaît l'histoire du journal. Un worker ne sait que ce qui est écrit dans son brief : tout ce qui n'y figure pas lui est tout simplement inconnu.

Structure

La tâche arrive à l'orchestrateur, qui rédige des briefs pour trois workers aux contextes séparés ; les workers renvoient des résultats condensés et déposent les sorties volumineuses dans un stockage d'artefacts ; l'orchestrateur fait la synthèse, puis répond ou planifie un nouveau tour, le tout dans des limites imposées par le code runtime. lacunes et budget restant : nouveau tour sorties volumineuses lu à la demande Tâche Orchestrateur plan + briefs Worker Vitest son contexte + outils Worker Jest son contexte + outils Worker dépôt lecture seule Orchestrateur synthétise Réponse Stock d'artefacts Code runtime : plafond de workers, concurrence max., timeouts, budgets de tours et de tokens 1 2 3 4 5 6 7 8
Les flèches pleines portent les briefs et la réponse finale, les flèches en pointillés portent les résultats. Les deux boîtes « Orchestrateur » sont le même agent à deux moments. Les workers ne se parlent pas entre eux.
  1. Orchestrateur, en planification. Lit la tâche, la classe, décide du nombre de workers et enregistre le plan hors de son propre contexte quand les exécutions sont longues. C'est en général le modèle le plus puissant du système.
  2. Brief. La seule chose qu'un worker au contexte vierge reçoit de l'orchestrateur : objectif, contexte, ce qui est hors périmètre, sources et outils, budget, une condition « terminé quand » et le format du résultat.
  3. Workers. Une sous-tâche bornée chacun, dans un contexte séparé, souvent sous forme de boucle ReAct avec un jeu d'outils minimal. Ils peuvent tourner sur un modèle moins cher que l'orchestrateur.
  4. Contrat de résultat. Une forme fixe pour ce qui revient : statut, résumé court, constats avec sources, contradictions, questions ouvertes, références d'artefacts.
  5. Stockage d'artefacts. Des fichiers ou un espace de stockage pour les sorties volumineuses. Les workers renvoient des références, si bien que les gros contenus ne passent pas par le contexte de l'orchestrateur.
  6. Orchestrateur, en synthèse. Fusionne les résultats, signale les contradictions, repère les lacunes et décide s'il peut répondre. Seul l'orchestrateur rédige la réponse finale.
  7. Nouveau tour. S'il manque quelque chose d'important et qu'il reste du budget, l'orchestrateur rédige de nouveaux briefs. C'est un jugement du LLM, borné par un plafond strict sur le nombre de tours.
  8. Runtime. Du code déterministe qui lance les workers et impose les limites. Le coût et la sécurité se contrôlent ici, pas dans le prompt.

Générateur de prompt

Décrivez les demandes que traite votre système et les types de workers que l'orchestrateur peut lancer. Vous obtenez deux prompts système : un pour l'orchestrateur, un commun à tous les workers, avec le format de résultat. Collez-les dans l'agent principal et dans les définitions de sous-agents de votre framework (par exemple des fichiers de sous-agents Claude Code, un agent OpenAI Agents SDK exposé avec as_tool(), ou des nœuds LangGraph), et imposez aussi les limites chiffrées dans le code.

Types de workers l'orchestrateur choisit parmi eux d'après leur description
Nature du travail

Prompt généré

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

Ce sont les briefs qui font la qualité

Anthropic a constaté que des briefs courts comme « recherche la pénurie de semi-conducteurs » amenaient les workers à mal comprendre la tâche ou à se répéter : l'un a couvert la crise des puces automobiles de 2021 pendant que deux autres traitaient tous deux les chaînes d'approvisionnement de 2025. Dire ce que chaque worker ne doit pas couvrir, et lui donner tous les faits dont il a besoin, évite l'essentiel de ces problèmes. Gardez aussi exactes les descriptions des workers dans le prompt de l'orchestrateur : il ne voit pas le prompt système d'un worker.

Quand l'utiliser

À utiliser quand

À éviter quand

Mise en œuvre

  1. Partez d'un agent unique. Ne passez à orchestrator–workers qu'après avoir constaté une défaillance précise : le contexte déborde, le travail en série est trop lent, ou le prompt et le jeu d'outils sont devenus un enchevêtrement. Anthropic comme LangChain disent qu'un agent unique avec de bons outils égale souvent un système multi-agent.
  2. Définissez les types de workers. Pour chacun : un nom et une description précise (l'orchestrateur aiguille en fonction d'elle), un prompt système court, le plus petit jeu d'outils qui fonctionne (lecture seule pour les explorateurs), un modèle, une limite de tours ou d'appels d'outils et un schéma de résultat. Un worker générique fait une très bonne première version.
  3. Rédigez le prompt de l'orchestrateur. Le rôle (planifier, déléguer, synthétiser), la manière de classer les demandes, les règles de dosage de l'effort, la manière de rédiger un brief, le lancement groupé des workers indépendants, une règle d'arrêt et des règles de synthèse. Sans règles d'effort, les modèles en font trop : le premier système d'Anthropic lançait 50 sous-agents pour des requêtes simples.
  4. Adaptez l'effort à la demande. Règles publiées par Anthropic : 1 sous-agent avec 3 à 10 appels d'outils pour une simple recherche de faits, 2 à 4 avec 10 à 15 appels chacun pour une comparaison directe, 10 ou plus aux responsabilités clairement réparties pour une recherche complexe. Leur prompt d'orchestrateur publié en open source plafonne à 20 et recommande des sous-agents moins nombreux et plus capables.
  5. Fixez le contrat de résultat. Statut (complete, partial, failed, out of scope), résumé d'environ 200 mots, constats avec sources, contradictions, questions ouvertes, références d'artefacts et consommation. Validez-le avec une sortie structurée si votre framework le permet. Le champ de statut permet à l'orchestrateur de distinguer « rien n'existe » de « le worker a abandonné ».
  6. Imposez les limites dans le code. Plafonds sur les tours, le nombre total de workers, la concurrence, la profondeur d'imbrication, la durée réelle et les tokens ou les dollars. Interceptez les timeouts et les erreurs et renvoyez-les à l'orchestrateur sous forme de résultat en échec au lieu de faire planter l'exécution.
  7. Prévoyez les exécutions longues. Enregistrez le plan hors du contexte de l'orchestrateur (celui d'Anthropic le fait parce que le contexte au-delà de 200 000 tokens est tronqué), posez des points de contrôle sur les résultats, et reprenez au point d'échec au lieu de tout relancer.
  8. Tracez et évaluez. Journalisez chaque plan, chaque brief et chaque résultat pour savoir si c'est le plan ou un worker qui a déraillé. Notez les sorties finales selon une grille ; Anthropic a commencé avec une vingtaine de requêtes réelles. Comparez avec un agent unique doté du même budget, et relancez les évaluations après chaque modification du prompt de l'orchestrateur : de petits changements modifient le comportement des workers de façon difficile à prévoir.
Prise en charge par les frameworks (vérifiez la documentation à jour avant usage)
FrameworkForme que prend ce pattern
Claude Code / Claude Agent SDKSous-agents définis dans .claude/agents/ ou comme AgentDefinition ; l'agent principal délègue avec l'outil Agent (anciennement Task) et choisit un type d'après sa description. Un sous-agent non forké ne voit pas l'historique du parent ; seul son dernier message revient. L'outil Workflow exécute un script d'orchestration écrit par le modèle pour les gros fan-outs.
LangGraphWorkflow orchestrator–worker : un planificateur à sortie structurée, puis une arête conditionnelle qui renvoie un Send par élément planifié, des workers qui ajoutent à une liste dans l'état, et un nœud de synthèse. LangChain documente aussi un pattern « subagents » où l'agent principal appelle des sous-agents comme des outils.
OpenAI Agents SDKagent.as_tool() (agents as tools, le pattern « manager ») : le manager garde la main et l'agent imbriqué n'hérite pas de sa conversation, sauf si vous passez la même session. À opposer aux handoffs, où le contrôle change de mains.
OpenAI CodexLes sous-agents ne démarrent que sur demande explicite ou quand AGENTS.md ou une skill les prévoit ; les réglages se trouvent sous [agents]. La documentation recommande de commencer par du travail de lecture.
Google ADKAgentTool enveloppe un agent dans un outil appelable, ce qui donne ce pattern. ParallelAgent exécute un ensemble fixe de sous-agents, ce qui relève plutôt d'une parallélisation définie par le développeur.
CrewAIProcess.hierarchical avec un LLM ou un agent manager. Le manager travaille sur une liste de tâches prédéfinie, ce qui se rapproche d'un superviseur.
AutoGen Magentic-OneUn orchestrateur avec des registres de tâches et de progression qui dirige quatre agents (voir Variantes).

Mise en garde. Ces API évoluent vite. La règle de Claude Code sur l'imbrication a changé : l'ancienne documentation disait que les sous-agents ne pouvaient pas lancer de sous-agents, la documentation actuelle autorise par défaut jusqu'à trois niveaux sous la conversation principale, et la version où ce changement a eu lieu n'est pas vérifiée. langgraph-supervisor a été archivé en septembre 2026, et LangChain oriente ses utilisateurs vers des sous-agents enveloppés dans des outils. Les noms d'outils de Managed Agents proviennent d'un cookbook en bêta et peuvent changer.

Variantes

Tour unique (forme workflow)

Un appel de planification produit N sous-tâches, le code les répartit, un appel de synthèse les fusionne. Il n'y a pas de boucle : c'est peu coûteux et facile à tester. C'est la forme décrite dans « Building effective agents » et dans le tutoriel Send de LangGraph.

Orchestrateur itératif (forme agent)

L'orchestrateur est une boucle d'agent dotée d'un outil « lancer un worker ». Il lit les résultats, puis lance d'autres workers ou change de stratégie. Le système Research d'Anthropic et les sous-agents de Claude Code fonctionnent ainsi.

Agents as tools

Chaque worker est exposé comme un outil ; l'appeler exécute un agent imbriqué dont la sortie constitue le résultat de l'outil. Le manager garde la conversation. as_tool() d'OpenAI, AgentTool d'ADK et les sous-agents de LangChain adoptent tous cette forme.

Workers asynchrones pilotables

Lancer un worker rend la main immédiatement. L'orchestrateur peut consulter leur statut, leur envoyer des messages complémentaires ou les arrêter, si bien qu'un worker lent ne bloque plus tout le lot. La coordination des résultats et la gestion des erreurs deviennent plus difficiles ; Anthropic range l'orchestration asynchrone parmi les problèmes ouverts.

Orchestrateur à registres

Magentic-One de Microsoft tient un registre de tâche (faits connus, faits à rechercher, suppositions, plan) et un registre de progression. À chaque étape, il se demande si la tâche est terminée, si elle tourne en rond ou si elle progresse, et replanifie après plus de deux étapes bloquées. Il envoie une étape à la fois, ce qui le rapproche d'un Supervisor.

Planifier en grand, exécuter en petit

Un orchestrateur sur un modèle de pointe sans outils propres, et des workers bon marché qui font la lecture gourmande en tokens. Dans le cookbook Managed Agents d'Anthropic, 84 à 98 % des tokens d'entrée étaient facturés au tarif des workers (exécutions des auteurs eux-mêmes, avec des écarts). Affiner les briefs a fait monter le coût, car chaque worker a un surcoût de démarrage fixe.

Recherche en largeur

Un worker par élément sur une longue liste d'éléments similaires, puis un tableau. C'est proche de map-reduce, sauf que c'est le modèle qui construit la liste des éléments et les briefs. Manus appelle cela Wide Research ; ses affirmations sur la qualité à l'échelle de centaines d'éléments sont des déclarations d'éditeur sans benchmark publié.

Plusieurs lecteurs, un seul rédacteur

Les workers ne font que recueillir des informations ou donner des avis ; un seul agent effectue toutes les écritures et produit le livrable final. C'est ainsi que fonctionne le système de recherche d'Anthropic, et c'est aussi la conclusion du texte de suivi publié par Cognition en 2026.

Workers forkés

Le worker hérite de la conversation du parent au lieu de démarrer à vide. Vous perdez un peu d'isolation et gagnez moins d'erreurs dues à un contexte manquant, ce qui aide quand les sous-tâches sont couplées.

Orchestration imbriquée

Certains workers sont eux-mêmes des orchestrateurs. C'est le pattern Hierarchical teams ; la plupart des systèmes s'arrêtent à deux niveaux.

Avantages et inconvénients

Avantages

  • Traite des tâches dont la forme n'est pas connue à l'avance : le découpage s'adapte à chaque demande.
  • Chaque worker dispose d'un contexte propre et ciblé et d'un petit jeu d'outils, si bien qu'il fait sa part mieux qu'un agent unique surchargé.
  • Le contexte de l'orchestrateur ne grossit que des briefs et des résultats condensés, ce qui permet au pattern de traiter un travail plus grand qu'une fenêtre de contexte.
  • Les workers parallèles réduisent la durée réelle sur les tâches larges. Anthropic a rapporté jusqu'à 90 % de temps de recherche en moins sur les requêtes complexes (mesure interne).
  • Répartir les modèles par niveau peut baisser le prix par token : un orchestrateur puissant, des workers bon marché.
  • L'orchestrateur filtre les erreurs. L'étude de Google a mesuré une amplification des erreurs de 4,4 fois pour les systèmes centralisés contre 17,2 fois pour des agents indépendants.

Inconvénients

  • Beaucoup plus de tokens : environ 15 fois une interaction de chat pour le système d'Anthropic. Google a mesuré un surcoût de coordination de 285 % et moins de réussites par token qu'avec un agent unique.
  • De l'information se perd chaque fois qu'un worker condense son travail en résumé.
  • L'orchestrateur est un point de défaillance unique : un mauvais plan gâche tous les résultats qui en découlent.
  • Un lot synchrone attend son worker le plus lent, et des workers au contexte vierge passent du temps à rassembler du contexte.
  • Difficile à déboguer : beaucoup de traces non déterministes, et de petites modifications du prompt de l'orchestrateur changent le comportement des workers.
  • Faible sur le travail séquentiel ou fortement couplé, où les workers prennent des décisions qui ne s'emboîtent pas.

Lisez les gains affichés avec prudence. Le +90,2 % d'Anthropic face à Opus 4 en agent unique vient d'une évaluation interne, et le système multi-agent dépensait aussi bien plus de tokens. Sur BrowseComp, Anthropic a constaté que le seul volume de tokens expliquait 80 % de la variance des performances. Une partie de « le multi-agent gagne » signifie en fait « dépenser plus de tokens en parallèle gagne ».

Modes de défaillance

Lancement excessif de workers

L'orchestrateur lance des dizaines de workers pour une question simple et le coût explose. Le premier système d'Anthropic en lançait 50 pour des requêtes simples.

Parade : des règles de dosage de l'effort dans le prompt de l'orchestrateur, plus des plafonds stricts sur les workers, la profondeur et le budget dans le code. Suivez le nombre de workers par requête selon le type de requête.

Réponse de mémoire

L'orchestrateur saute la délégation et rédige une réponse plausible sans rien vérifier.

Parade : exigez au moins un worker pour les demandes factuelles, et déclenchez une alerte sur les exécutions sans aucun lancement de worker.

Briefs vagues et travail en double

Deux workers étudient la même chose pendant qu'un autre domaine reste non couvert.

Parade : un modèle de brief avec objectif, format, consignes sur les outils et les sources, et limites, et dites à chaque worker ce que couvrent les autres. Mesurer le recouvrement (mêmes URL ou mêmes fichiers lus par plusieurs workers) montre quand cela se produit.

Décisions implicites contradictoires

Des sorties qui semblent correctes une par une ne s'emboîtent pas. L'exemple de Cognition : un worker construit un décor dans le style de Mario, un autre un oiseau dans un style différent, et la fusion hérite des deux.

Parade : gardez les écritures dans un seul agent, mettez les décisions communes dans chaque brief, et utilisez des workers forkés ou le contexte complet quand le couplage est fort.

Jeu du téléphone

Des détails se perdent ou se déforment à mesure que les résultats passent par les résumés de l'orchestrateur.

Parade : les workers écrivent les sorties volumineuses dans un stockage et renvoient des références, et l'étape finale relit les originaux quand la précision compte.

Prémisse non vérifiée

Chaque fait est vérifié, mais la liste elle-même est fausse. Dans le cookbook Managed Agents, l'exécution multi-agent comme l'exécution à agent unique ont dressé de mémoire une liste de parcs et se sont trompées sur une entrée.

Parade : confiez à un worker la tâche de vérifier la prémisse de la décomposition.

Workers qui s'arrêtent trop tard ou trop tôt

Un worker continue de chercher alors qu'il en sait assez, ou abandonne trop tôt. L'étude MAST attribue 6,2 % des défaillances à un arrêt prématuré et 12,4 % à une méconnaissance des conditions d'arrêt.

Parade : un budget d'appels d'outils et une condition « terminé quand » dans chaque brief. Le prompt de sous-agent d'Anthropic prévoit environ 15 appels avec un maximum strict de 20.

Retardataires et plantages

Un worker lent bloque le lot, ou un worker échoue et laisse un trou dans les résultats.

Parade : des timeouts, un statut d'échec renvoyé à l'orchestrateur, la réattribution des pannes d'infrastructure à un nouveau worker, des points de contrôle, ou des workers asynchrones qu'on peut interroger et arrêter.

Boucles

La même sous-tâche est déléguée encore et encore. MAST attribue 15,7 % des défaillances à la répétition d'étapes.

Parade : un compteur de blocages qui force une replanification (Magentic-One replanifie après plus de deux étapes bloquées) et un plafond strict sur le nombre de tours.

Injection de prompt via la sortie d'un worker

Un worker lit une page malveillante et renvoie un texte qui ressemble à des instructions, que l'orchestrateur suit ensuite.

Parade : traitez les résultats comme des données, pas comme des instructions. Claude Code analyse les rapports des sous-agents à la recherche de texte ayant la forme d'instructions avant que le parent ne les lise.

Liens avec les autres patterns

Pour aller plus loin

Les sources ci-dessous sont en anglais.