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 agent ReAct traite la demande sur les constructeurs automobiles avec sept appels successifs au grand modèle dont le contexte grossit à chaque fois, et le tableau final oublie un constructeur et utilise la mauvaise année de référence. Demande 3 groupes, 2 ans chaque appel renvoie tous les résultats de recherche précédents 1 2 3 4 5 6 7 appels au grand modèle, l'un après l'autre Tableau final 3e constructeur absent mauvaise année de base
Chaque barre est un appel au modèle de pointe, et sa hauteur correspond au contexte qu'il transporte. Le coût augmente à chaque étape, et les détails de la demande finissent enfouis sous les résultats de recherche.

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.

  1. 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.
  2. 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.
  3. 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.
  4. 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 »).
  5. 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

L'objectif est transmis à un planificateur qui écrit un plan ; un ordonnanceur lance les étapes prêtes sur des exécuteurs en parallèle ; leurs résultats vont à un replanificateur, qui répond ou renvoie au plan une version révisée ne contenant que les étapes restantes. plan révisé : étapes restantes uniquement répondre Objectif Planificateur modèle puissant Plan a. trouver les 3 constructeurs b–d. CA de chacun (après a) e. croissance, f. tableau Ordonnanceur code, sans LLM Exécuteur constr. 1 Exécuteur constr. 2 Exécuteur constr. 3 Résultats des étapes par id Replanificateur réponse ou nouveau plan Réponse 1 2 3 4 5 6
Les flèches pleines portent des instructions, les flèches en pointillés des résultats. Les étapes b, c et d s'exécutent en parallèle une fois l'étape a terminée. La flèche colorée est la boucle fermée ; la variante à plan unique (ReWOO) la supprime et remplace le replanificateur par un solveur qui répond toujours.
  1. 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.
  2. 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.
  3. Ordonnanceur. Du code ordinaire. Il sélectionne chaque étape dont les dépendances sont terminées, remplace les références comme $1 ou #E1 par les vraies sorties, puis lance l'étape. LLMCompiler l'appelle la task fetching unit.
  4. 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.
  5. 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.
  6. 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.

Outils de l'exécuteur une ligne par outil, moins il y en a, meilleur est le plan
Format du plan
Quand replanifier

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.

D'où vient la qualité

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

À éviter quand

Mise en œuvre

  1. 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.
  2. 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 $id quand 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.
  3. É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.
  4. É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.
  5. É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.
  6. 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.
  7. 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.md au fil du travail pour que l'objectif reste dans l'attention récente.
  8. 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.
Support dans les frameworks (vérifiez la documentation actuelle avant usage)
FrameworkComment ce pattern apparaît
LangGraphGraphes 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 deepagentsTodoListMiddleware ajoute un outil write_todos avec les statuts pending, in-progress et completed.
CrewAICrew(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 ADKLlmAgent(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.
smolagentsplanning_interval=N sur CodeAgent ou ToolCallingAgent insère une étape de planification toutes les N étapes.
LlamaIndexStructuredPlannerAgent enveloppe un autre agent et découpe l'entrée en sous-tâches avec sorties attendues et dépendances.
AutoGenMagenticOneGroupChat : un orchestrateur avec un registre des tâches et un registre de progression, qui replanifie en cas de blocage.
Semantic KernelSes planificateurs Stepwise et Handlebars sont dépréciés et retirés ; la documentation recommande à la place l'appel automatique de fonctions.
Claude Code, CursorMode 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

Pour aller plus loin