Plan-and-Execute
Aussi appelé : planificateur–exécuteur, plan-then-act, décomposition de tâche, planification explicite. Conceptions connues : ReWOO, LLMCompiler, HuggingGPT, BabyAGI, le mode plan des agents de code.
Intention
Demander à un modèle puissant d'écrire d'abord toute la suite d'étapes, sous forme de liste ou de graphe que le système conserve. Exécuter ces étapes avec des moyens moins coûteux (appels d'outils, petit modèle, code ordinaire), puis rappeler un modèle puissant uniquement pour vérifier les résultats et, au choix, répondre ou écrire un plan révisé pour ce qui reste.
Problème
Vous construisez un assistant de recherche au-dessus d'un moteur de recherche web. Un utilisateur demande : « Pour chacun des trois plus grands constructeurs automobiles de l'UE, trouve le chiffre d'affaires 2024 et 2023, calcule la croissance et donne-moi un tableau classé avec les sources. »
Une boucle ReAct simple sur un modèle de pointe traite cette demande une action à la fois : chercher le constructeur 1, lire, chercher à nouveau le constructeur 1 pour 2023, lire, et ainsi de suite. Cela fait environ 7 à 10 appels au grand modèle pour cette seule demande, strictement l'un après l'autre. Là où ça casse :
- Un appel au grand modèle par résultat d'outil. Chaque étape renvoie au modèle le plus cher une transcription qui grossit, pleine de résultats de recherche bruts. Le coût et la latence augmentent avec le nombre d'étapes.
- Des décisions à courte vue. Le modèle ne raisonne que sur le sous-problème suivant, si bien que le parcours s'égare et répète des recherches. Le billet de LangChain sur les agents de planification et l'état de l'art sur la planification de Huang et al. le relèvent tous les deux.
- Dérive de l'objectif. Après de nombreuses étapes, la demande initiale se retrouve loin en arrière dans le contexte. L'agent oublie le troisième constructeur, ou calcule la croissance à partir de la mauvaise année. Manus indique environ 50 appels d'outils pour une tâche typique et constate que des boucles aussi longues dérivent de leurs objectifs.
Solution
Découpez l'agent en un planificateur qui décide des étapes une fois pour toutes, un exécuteur qui les réalise et un replanificateur qui examine les résultats. Le plan est un artefact explicite (une liste JSON, un graphe d'appels d'outils, un fichier) que du code peut lire, valider, ordonnancer et montrer à une personne.
- Planifier. Un seul appel au modèle le plus puissant reçoit la demande et la liste des outils, et renvoie : (a) trouver les trois plus grands constructeurs automobiles de l'UE ; (b, c, d) pour chaque constructeur, trouver le chiffre d'affaires 2024 et 2023 avec une source ; (e) calculer la croissance ; (f) classer et mettre en forme. Les étapes b à d dépendent de a, mais pas les unes des autres.
- Valider. Du code ordinaire vérifie que le plan se lit correctement, n'utilise que des outils connus, ne contient pas de cycle et reste sous le budget d'étapes. Dans un produit interactif, une personne peut le relire ou le modifier à ce stade.
- Exécuter. Un ordonnanceur lance a, puis envoie b, c et d en même temps. Chaque exécuteur (un outil de recherche plus un petit modèle) ne voit que sa propre sous-question et la sortie de l'étape a, pas l'historique complet.
- Replanifier ou répondre. Un modèle puissant lit la demande, le plan et les résultats condensés. Si les six chiffres sont là, il rédige le tableau classé. S'il manque le chiffre 2023 du constructeur 2, il renvoie un nouveau plan contenant uniquement cette étape (« chercher le rapport annuel 2023 du constructeur 2 »).
- S'arrêter. L'exécution se termine quand le replanificateur répond, quand un budget d'étapes ou de replanifications est atteint, ou quand le plan est vide.
La tâche demande maintenant deux ou trois appels au grand modèle au lieu d'une dizaine, l'exigence « trois constructeurs » est fixée dans une liste d'étapes au lieu d'être enfouie dans une transcription, et vous pouvez lire le plan avant que quoi que ce soit ne s'exécute.
Qui décide du déroulement : le modèle planificateur, en amont. C'est la différence avec ReAct, où le modèle décide après chaque observation, et avec le prompt chaining, où le développeur fixe les étapes à la conception. Un plan de plan-and-execute est une chaîne que le modèle écrit à l'exécution. Le code de l'ordonnanceur impose l'ordre, et le replanificateur ne reprend la main qu'aux points que vous choisissez.
Analogie
Un chef de cuisine écrit la liste de mise en place du matin avant le service : émincer deux kilos d'oignons, faire le fond, portionner le poisson. Chaque cuisinier prend une ligne et l'exécute sans lire le menu. Les lignes qui ne dépendent pas les unes des autres sont faites en même temps. Avant le service, le chef fait le tour des postes, vérifie le résultat et réécrit la liste pour ce qui manque. Le chef est le planificateur et le replanificateur, la liste de mise en place est le plan, et les cuisiniers sont les exécuteurs.
L'analogie s'arrête à l'attention. Un vrai chef remarque à neuf heures du matin que le poisson n'a pas été livré. Le système ne regarde les résultats qu'aux points de replanification que vous avez définis : une étape en échec peut donc passer inaperçue jusque-là, et dans la variante à plan unique elle ne sera jamais remarquée.
Structure
- Planificateur. En général le modèle le plus puissant. Il reçoit l'objectif, une description d'une ligne par outil et les budgets, et renvoie un plan dans un format strict (schéma JSON ou grammaire ligne par ligne), idéalement après deux ou trois exemples commentés de bons plans.
- Plan et état. Le plan courant, les étapes terminées et leurs sorties, conservés hors du prompt (état du graphe, fichier JSON, gestionnaire de tâches) pour survivre aux longues exécutions et aux redémarrages. Un validateur en code ordinaire rejette les outils inconnus, les arguments invalides, les cycles et les plans hors budget avant toute exécution. Une étape d'approbation humaine, si vous en avez une, se place ici.
- Ordonnanceur. Du code ordinaire. Il sélectionne chaque étape dont les dépendances sont terminées, remplace les références comme
$1ou#E1par les vraies sorties, puis lance l'étape. LLMCompiler l'appelle la task fetching unit. - Exécuteurs. Ils réalisent une étape et renvoient un résultat condensé. Un exécuteur peut être un appel d'outil, un petit modèle ou un sous-agent ReAct doté de quelques outils. S'il devient un agent complet avec sa propre fenêtre de contexte, vous êtes plus proche d'Orchestrator–Workers.
- Résultats des étapes. Stockés par id d'étape, erreurs comprises sous forme de valeurs (« échec : aucun chiffre 2023 trouvé »), pour qu'un échec isolé n'interrompe pas toute l'exécution.
- Replanificateur. Appelé aussi joiner (LLMCompiler) ou solver (ReWOO). Il lit l'objectif, le plan et les résultats, et renvoie soit une réponse finale, soit un nouveau plan ne contenant que les étapes encore nécessaires. Des compteurs de replanifications, d'étapes et de temps l'empêchent de tourner en boucle.
Générateur de prompt
Décrivez les demandes que traite votre agent, les outils que l'exécuteur peut appeler et les limites. Le générateur écrit trois prompts (planificateur, exécuteur, et replanificateur ou solveur) ainsi que les vérifications que votre code d'exécution doit faire. Collez-les dans les trois nœuds d'un graphe plan-and-execute LangGraph, ou dans votre propre boucle autour de n'importe quelle API de chat avec sortie structurée.
Prompt généré
Le texte surligné vient du formulaire. Le texte [entre crochets] reste à remplir. Le texte entre {accolades} est rempli par votre code d'exécution à chaque appel.
La plupart des échecs ne viennent pas du plan. Dans l'analyse des échecs de LLMCompiler sur son benchmark ParallelQA, 64 % des échecs venaient des exécuteurs, 28 % de la réponse finale et seulement 8 % du planificateur. Travaillez les prompts des exécuteurs, les descriptions d'outils et la règle « seulement les étapes restantes » du replanificateur avant de peaufiner le planificateur.
Quand l'utiliser
À utiliser quand
- La tâche demande plusieurs appels d'outils et vous pouvez deviner sa forme à partir de la demande. Questions multi-étapes, rapports de recherche, tâches « collecter puis calculer » et modifications de code sur plusieurs fichiers s'y prêtent.
- Beaucoup d'étapes sont indépendantes. C'est en les exécutant en parallèle que LLMCompiler obtient l'essentiel de ses gains de latence.
- Le coût ou la latence du grand modèle compte. Les étapes peuvent aller à des modèles moins chers ou à du code ordinaire, et seules la planification et la replanification ont besoin du modèle puissant.
- Quelqu'un doit voir ou approuver ce qui va se passer avant les effets de bord. Un plan écrit se relit facilement avant un déploiement, un e-mail ou une modification du code.
- Les exécutions sont longues et l'agent dérive. Un plan stocké sert de point d'ancrage pour la demande initiale.
- Vous voulez limiter ce que peut faire une injection de prompt. Si le plan provient uniquement de la demande de confiance, un texte non fiable lu plus tard ne peut pas ajouter de nouveaux appels d'outils.
À éviter quand
- L'étape suivante dépend réellement de la dernière observation. La navigation web, le débogage d'une panne inconnue et les jeux conviennent mieux à ReAct. L'étude MobilityBench a trouvé ReAct généralement plus efficace que le plan-and-execute statique face à un retour dynamique.
- La tâche prend un à trois appels d'outils. L'appel de planification n'est alors que du surcoût. Utilisez ReAct, ou routez les demandes simples hors du planificateur.
- Les étapes sont toujours les mêmes. Codez-les en dur dans une chaîne de prompts.
- Chaque sous-tâche a besoin de son propre agent et de sa propre fenêtre de contexte. Utilisez Orchestrator–Workers ou un Supervisor, éventuellement avec un agent principal qui planifie.
- Votre modèle est bon sur les longues séquences d'outils et la tâche est de taille moyenne. Une simple boucle d'outils planifie peut-être déjà assez bien seule. Semantic Kernel qui remplace ses planificateurs par l'appel de fonctions, et Claude Code qui n'active plus les outils de to-do par défaut sur les modèles récents, vont dans ce sens. Cette lecture est une interprétation de ces deux décisions, pas un résultat mesuré.
Mise en œuvre
- Listez les outils. Écrivez pour chaque outil une description d'une ligne parmi lesquelles un planificateur peut choisir. Gardez la liste courte : les auteurs de ReWOO ont vu la précision baisser à mesure qu'ils ajoutaient des outils, surtout à cause d'outils mal utilisés.
- Choisissez le format du plan. Une simple liste ordonnée est la plus facile à produire et à lire. Prenez un graphe avec des dépendances explicites et des références
$idquand vous devez passer des valeurs entre étapes ou exécuter des étapes en parallèle. Utilisez du JSON avec un schéma et le mode de sortie structurée du modèle pour tout ce que du code devra analyser. - Écrivez le prompt du planificateur. Indiquez le format, les règles (un outil par étape, des étapes autonomes, une dernière étape qui produit ce dont la réponse a besoin, un plafond d'étapes) et deux ou trois exemples commentés. smolagents demande d'abord au planificateur un inventaire des faits (donnés, à rechercher, à déduire), ce qui l'amène à repérer ce qu'il ne sait pas.
- Écrivez l'exécuteur. Commencez par un sous-agent ReAct générique qui dispose de tous les outils, comme dans le tutoriel LangGraph. Spécialisez-le par type d'étape plus tard si le coût compte.
- Écrivez le prompt du replanificateur. Donnez-lui une sortie structurée à deux options : une réponse, ou un plan ne contenant que les étapes encore nécessaires. La ligne « seulement les étapes restantes » est l'instruction clé du replanificateur LangGraph.
- Ajoutez des budgets et des conditions d'arrêt. Plafonnez les replanifications, les étapes, les tokens et le temps réel. Traitez un plan vide sans réponse comme un échec. Le tutoriel LangGraph tourne avec
recursion_limit=50; Magentic-One réécrit son plan dès que son compteur d'étapes sans progrès dépasse 2. - Persistez le plan hors du prompt pour les longues tâches, et réinjectez le plan courant vers la fin du contexte à chaque tour. Manus réécrit un fichier
todo.mdau fil du travail pour que l'objectif reste dans l'attention récente. - Comparez avec une base ReAct sur les mêmes tâches, le même modèle et les mêmes outils : taux de réussite, total de tokens, nombre d'appels au grand modèle, latence et coût. Le pattern ne vaut la peine que s'il gagne sur vos tâches.
| Framework | Comment ce pattern apparaît |
|---|---|
| LangGraph | Graphes de tutoriel pour plan-and-execute (nœuds planner, agent, replan, exécuteur construit avec create_react_agent), ReWOO et LLMCompiler. L'ancienne URL de la documentation redirige désormais vers la page du middleware de to-do list ; le notebook se trouve dans le dépôt LangGraph. |
| LangChain deepagents | TodoListMiddleware ajoute un outil write_todos avec les statuts pending, in-progress et completed. |
| CrewAI | Crew(planning=True) lance un planificateur avant les tâches ; au niveau de l'agent, PlanningConfig expose des champs comme max_replans et observe_steps. |
| Google ADK | LlmAgent(planner=...) avec BuiltInPlanner (réflexion native) ou PlanReActPlanner, qui fait écrire au modèle des sections balisées de planification, d'action et de replanification. |
| smolagents | planning_interval=N sur CodeAgent ou ToolCallingAgent insère une étape de planification toutes les N étapes. |
| LlamaIndex | StructuredPlannerAgent enveloppe un autre agent et découpe l'entrée en sous-tâches avec sorties attendues et dépendances. |
| AutoGen | MagenticOneGroupChat : un orchestrateur avec un registre des tâches et un registre de progression, qui replanifie en cas de blocage. |
| Semantic Kernel | Ses planificateurs Stepwise et Handlebars sont dépréciés et retirés ; la documentation recommande à la place l'appel automatique de fonctions. |
| Claude Code, Cursor | Mode plan : recherche en lecture seule et plan modifiable que l'utilisateur approuve avant toute modification. Les outils de tâches de Claude Code tiennent une to-do list vivante pendant l'exécution. |
Mise en garde. Ces API évoluent vite et ont été lues dans la documentation en novembre 2026. La liste des champs de PlanningConfig dans CrewAI et le passage du middleware de to-do de deepagents en option dans la v0.7 ne sont pas vérifiés. Depuis Claude Code v2.1.268, les outils de tâches ne sont activés par défaut que pour les modèles plus anciens ; la documentation d'Anthropic indique que les modèles récents suivent un travail en plusieurs étapes sans liste écrite.
Variantes
Planifier une fois, sans replanification (ReWOO)
Le planificateur écrit toutes les étapes avant qu'aucun outil ne s'exécute, avec des variables de preuve (#E1 = Search[...], #E2 = LLM[extract X from #E1]). Des workers remplissent les preuves et un solveur rédige la réponse. Aucune observation n'atteint jamais le planificateur. Sur HotpotQA avec gpt-3.5-turbo, l'article ReWOO rapporte 9 795 tokens par requête pour ReAct contre 1 986 pour ReWOO, et une précision de 40,8 contre 42,4. C'est la variante la moins coûteuse, et elle ne peut pas se remettre d'un mauvais plan.
Planifier, exécuter, replanifier
La boucle fermée du diagramme, comme dans le tutoriel LangGraph et la boucle de liste de tâches de BabyAGI. Pour réduire le coût, n'appelez le replanificateur que lorsqu'une étape échoue, lorsque le plan est vide, ou toutes les N étapes. Dans l'ablation de Plan-and-Act sur WebArena-Lite, l'ajout de la replanification dynamique a fait passer la réussite d'environ 43,6 % à 53,9 %, le plus grand gain d'une seule étape ; ses auteurs notent aussi que replanifier après chaque action est lent.
DAG avec exécution parallèle (LLMCompiler)
Le plan est un graphe d'appels de fonctions avec des références $k, transmis en streaming pour que l'exécution commence avant la fin de la planification. Une task fetching unit lance les étapes prêtes en parallèle et un joiner décide de répondre ou de replanifier. L'article rapporte une latence jusqu'à 3,7 fois plus faible et un coût jusqu'à 6,7 fois plus faible que ReAct ; ce sont les meilleurs cas, sur son benchmark Movie Recommendation, et les gains sur HotpotQA sont plus modestes (1,80 et 3,37 fois). HuggingGPT utilise une liste de tâches typée similaire, avec des id de dépendance, pour enchaîner des modèles.
Un plan dans une boucle ReAct
L'agent reste un agent ReAct mais tient un plan : smolagents le rafraîchit toutes les N étapes, le PlanReActPlanner de Google ADK a une balise de replanification, et Claude Code, deepagents et Manus tiennent une to-do list que l'agent réécrit à mesure qu'il apprend. Le plan sert d'aide-mémoire et d'affichage de la progression plutôt que de programme. C'est un bon choix par défaut quand l'environnement est imprévisible.
Planifier, puis approuver (mode plan)
Une phase de recherche et de planification en lecture seule, puis une personne approuve ou modifie le plan, puis l'exécution. Claude Code, Cursor et ChatGPT deep research fonctionnent ainsi. Cursor recommande de revenir en arrière et d'affiner le plan plutôt que de rafistoler un mauvais résultat avec des prompts de suivi. L'étape d'approbation elle-même est traitée dans Human-in-the-Loop.
Plan-then-execute pour la sécurité
Fixez les appels d'outils autorisés à partir de la demande de confiance de l'utilisateur, avant que l'agent ne lise la moindre donnée non fiable (Beurer-Kellner et al., 2025). Une instruction injectée dans une page web ou un e-mail ne peut pas ajouter de nouvel appel d'outil. Elle peut toutefois modifier les arguments d'un appel prévu, par exemple le corps d'un e-mail que le plan devait envoyer.
Fichier de plan à long horizon
Dans le harnais de code de longue durée d'Anthropic, une session d'initialisation développe une spécification en une liste JSON de plus de 200 fonctionnalités, chacune avec des étapes de test et un indicateur passes: false. Chaque session suivante prend une fonctionnalité en échec, y travaille, et ne peut modifier que son indicateur. Anthropic a choisi le JSON parce que les modèles avaient moins tendance à le réécrire de façon inappropriée qu'une liste Markdown.
Plan-and-Solve prompting
Ni outils ni exécuteur : un seul prompt demande au modèle de faire un plan puis de l'appliquer. Avec text-davinci-003, l'article rapporte une moyenne zero-shot en arithmétique qui passe de 70,4 % (chain of thought) à 76,7 % (PS+). Utile comme première étape bon marché, mais c'est une technique de prompting, pas une architecture.
La planification par recherche (Tree of Thoughts, LATS) et l'association du modèle à un planificateur classique ou à un vérificateur (LLM+P, LLM-Modulo) relèvent aussi de la « planification », mais elles explorent des plans candidats et coûtent beaucoup plus cher. Elles sortent du cadre de cette page.
Avantages et inconvénients
Avantages
- Moins d'appels au modèle coûteux, et des contextes courts et ciblés pour chaque étape. ReWOO rapporte environ 5 fois moins de tokens que ReAct sur HotpotQA.
- Les étapes indépendantes s'exécutent en parallèle, ce qui réduit le temps réel.
- Le plan est un artefact que vous pouvez journaliser, montrer aux utilisateurs, modifier et approuver.
- Les échecs peuvent être attribués au planificateur, à un exécuteur ou au replanificateur, ce qui vous indique où améliorer.
- Le plan écrit garde toute la demande en vue lors des longues exécutions.
- Un plan construit à partir d'une entrée de confiance limite les outils qu'une injection peut déclencher.
Inconvénients
- Un plan fait avant toute observation peut être faux. Les variantes à plan unique ne peuvent pas s'en remettre ; la replanification le peut, au prix d'appels supplémentaires.
- La planification et la jonction sont un surcoût séquentiel. Sur WebShop, LLMCompiler a mis 10,48 s contre 5,98 s pour ReAct avec gpt-3.5-turbo, mais avec un taux de réussite bien supérieur (48,2 % contre 19,8 %).
- Plus de pièces mobiles : schéma de plan, validateur, ordonnanceur, substitution de variables, prompt du replanificateur.
- Moins souple que ReAct dans les contextes exploratoires ou réactifs.
- La plupart des gains publiés ont été mesurés sur des modèles de l'époque 2023 comme gpt-3.5-turbo, sans réplication sur les modèles de pointe actuels dans les sources ; prenez-les comme des tendances.
Modes de défaillance
- Mauvais plan fondé sur de mauvaises hypothèses
-
Le planificateur suppose qu'un fait figurera dans les résultats de recherche, ou choisit la mauvaise décomposition. Les auteurs de ReWOO l'ont observé. Toutes les étapes suivantes exécutent fidèlement un plan qui ne peut pas marcher.
Parade : un inventaire des faits avant de planifier, une étape de clarification, une replanification en cas d'échec, et des exécuteurs capables de signaler explicitement « hypothèse fausse ».
- Exécution en boucle ouverte fragile
-
L'étape 2 échoue, les étapes 3 à 6 tournent sur des déchets, et le solveur répond quand même avec assurance.
Parade : stocker les erreurs comme des valeurs et les vérifier, sauter les étapes dont une dépendance a échoué, et placer un replanificateur ou un joiner avant la réponse finale.
- Replanification en boucle
-
Le replanificateur réécrit sans cesse des plans similaires, ou un exécuteur faible déclenche replanification sur replanification. Les plans grossissent au lieu de rétrécir.
Parade : un plafond
max_replans, un compteur de blocage comme dans Magentic-One, une limite de récursion du graphe, une raison obligatoire pour chaque changement, ou un exécuteur plus puissant. - Refaire le travail déjà fait
-
Le nouveau plan répète des étapes qui avaient déjà réussi, ce qui double le coût.
Parade : demander au replanificateur de ne renvoyer que les étapes restantes, et dédoublonner dans le code par rapport aux étapes terminées.
- « Terminé » prématuré
-
L'agent marque des éléments comme terminés sans les vérifier, ou déclare toute la tâche finie trop tôt.
Parade : donner un test à chaque élément du plan, et ne laisser qu'un vérificateur le passer à terminé, comme dans le harnais de longue durée d'Anthropic. Voir Evaluator–Optimizer.
- Surplanification
-
Un plan en dix étapes pour une tâche qui en demande deux, où la latence du planificateur domine.
Parade : router les demandes simples vers une réponse directe ou une boucle ReAct, et ajouter au prompt du planificateur des règles qui proportionnent l'effort à la tâche, comme le fait le système de recherche d'Anthropic.
- Plans mal formés
-
Outils inconnus, JSON invalide, cycles, références à des id d'étape qui n'existent pas.
Parade : des sorties structurées avec un schéma, une détection de cycles, et le renvoi de l'erreur de validation au planificateur une ou deux fois.
- Injection par la sortie d'un outil
-
Une page récupérée demande au replanificateur d'ajouter une étape « envoyer un e-mail ».
Parade : planifier uniquement à partir d'une entrée de confiance et figer les outils autorisés, garder le texte non fiable à l'intérieur des exécuteurs, et garder en tête que les arguments peuvent encore être empoisonnés.
- Retardataires en parallèle
-
Un appel lent retarde la jonction. LLMCompiler note que sa recherche la plus lente prenait environ deux fois la moyenne (1,13 s contre 0,61 s).
Parade : un délai maximal par étape et des jonctions partielles qui répondent avec ce qui est arrivé.
Liens avec les autres patterns
- ReAct (tool-use loop) : la principale alternative. ReAct décide après chaque observation ; Plan-and-Execute décide la plupart des étapes en amont. Des hybrides se situent entre les deux : replanification périodique, to-do lists dans une boucle ReAct, sous-agents ReAct comme exécuteurs.
- Orchestrator–Workers : l'orchestrateur décompose aussi la tâche, mais confie les sous-tâches à des agents distincts qui ont leur propre fenêtre de contexte. Ici, les étapes sont généralement des appels uniques. Les deux sont souvent combinés sous la forme d'un orchestrateur qui planifie.
- Prompt Chaining : le développeur fixe les étapes à la conception. Ici, un plan est une chaîne générée par le modèle à l'exécution.
- Parallelization : les variantes en DAG répartissent des étapes indépendantes puis les rassemblent, mais c'est le planificateur qui choisit la répartition, pas le développeur.
- Evaluator–Optimizer : le replanificateur est une forme d'évaluation, et les vérificateurs qui marquent les éléments du plan comme terminés relèvent de ce pattern.
- Supervisor : un superviseur peut planifier, mais il décide une délégation à la fois au lieu d'exécuter un plan stocké.
- Hierarchical teams : les plans peuvent être décomposés niveau par niveau, chaque responsable ne planifiant que sa propre part.
- Group Chat : Magentic-One ajoute un registre des tâches et un suivi de progression à une discussion de groupe.
- Blackboard : un fichier de plan persistant ou un registre des tâches est un petit espace de travail partagé que plusieurs composants lisent et mettent à jour.
- Human-in-the-Loop : l'approbation et la modification du plan sont les points de contrôle humains les plus courants.
- Routing : écarter les demandes triviales du planificateur pour éviter la surplanification.
Pour aller plus loin
- Plan-and-Execute Agents (LangChain, 2024) : les trois styles côte à côte (plan-and-execute, ReWOO, LLMCompiler) et les inconvénients de chacun.
- LangGraph plan-and-execute tutorial (LangChain) : un petit graphe fonctionnel avec les prompts du planificateur, de l'exécuteur et du replanificateur.
- ReWOO: Decoupling Reasoning from Observations (Xu et al., 2023) : la conception à plan unique avec variables de preuve, des mesures de tokens et un test de panne d'outil.
- An LLM Compiler for Parallel Function Calling (Kim et al., ICML 2024) : plans en DAG, lancement parallèle, le joiner, et une répartition de l'origine des échecs.
- Plan-and-Act (Erdogan et al., ICML 2025) : des modèles planificateur et exécuteur entraînés, avec une ablation qui montre ce qu'apporte la replanification.
- Design Patterns for Securing LLM Agents against Prompt Injections (Beurer-Kellner et al., 2025) : plan-then-execute comme pattern de sécurité, et ce qu'il laisse sans protection.