#planification-reflexion — IA agentique

Planification, réflexion et self-correction : de 60 % à 90 % de succès.

Ce que tu vas manipuler

Bienvenue dans #planification-reflexion. La scène est encore vide : pas d'arbre, jauge de confiance à 0 %. C'est le point de départ de tout agent — il ne sait pas comment décomposer sa tâche. Un agent robuste ne se contente pas de penser-agir-observer comme dans #boucle-agentique : il planifie d'abord (décompose l'objectif en 5 à 7 sous-tâches), exécute dans l'ordre, vérifie, et réfléchit sur ses échecs pour re-planifier. C'est Plan-and-Execute (Wang et al., 2023) prolongé par Reflexion (Shinn et al., 2023) : les agents avec plan explicite passent d'environ 60 % à 90 % de succès sur les tâches multi-étapes. En haut : le bandeau de phase et la jauge. En bas : l'objectif courant.
Charge un objectif prêt à l'emploi : /scenario refactor. L'agent doit refactorer un module en 3 fichiers — on va voir apparaître la sphère bleue « racine » (l'objectif) au-dessus, mais aucun sous-plan encore.
Décompose l'objectif : /planifier. Regarde les 5 sphères grises pousser une par une sous la racine — Analyser, Séparer en 3 fichiers, Extraire les types, Ajuster les imports, Lancer les tests.
Exécute le premier nœud : /pas. La sphère Analyser le module pulse en bleu (elle est en-cours), puis passe au vert avec un ✓. La jauge de confiance monte de 0 à environ 20 %.
Continue : /pas. Cette fois le nœud Séparer en 3 fichiers échoue (rouge, ✕). L'agent bloque en phase RÉFLEXION — la jauge redescend, un halo violet apparaît en douceur autour du nœud raté.
Répare le plan : /reflechir. Le nœud raté passe en or (☆ replanifié, l'ancien reste tracé mais gris et fin), et un nouveau Séparer + tests unitaires apparaît juste à côté, prêt à exécuter.
Laisse la boucle finir toute seule : /tourner. Elle enchaîne le correctif puis les nœuds restants, jusqu'au bandeau ✓ TERMINÉ. La jauge de confiance atteint son maximum et l'aperçu droit résume tout : 5 succès, 1 replanifié.
À toi. Essaie /scenario donnees, /planifier, /budget 5 1 puis /tourner — le plafond de pas tombe avant la fin, bandeau ✕ ÉCHEC DÉFINITIF (une leçon clé sur le halting problem des agents). Ou /scenario recherche, /planifier, /pas plusieurs fois, /verifier nok pour forcer un échec sur un nœud réussi, /objectif Migrer PostgreSQL 15 vers 16 pour redéfinir la cible, /reinit pour repartir. Prochaine étape : #multi-agents (Premium) où un planner, des workers et un verifier se répartissent explicitement le travail — ou revenir en gratuit sur #boucle-agentique.

Commandes du canal

/scenario <refactor|donnees|recherche> — Charge un objectif prêt à l'emploi (racine seule).
/planifier — Décompose l'objectif en 5 sous-tâches (arbre de plan).
/pas — Exécute le prochain nœud en attente (succès ou échec déterministe).
/tourner — Boucle exécution + réflexion jusqu'à terminé ou échec définitif.
/reflechir — Sur le dernier nœud en échec : replanifie (halo violet + sous-arbre en or).
/verifier <ok|nok> — Force le verdict du dernier nœud exécuté (utile pour explorer les branches).
/budget <pas=3..20> <reflexions=0..5> — Fixe les garde-fous : pas max et réflexions max.
/objectif <texte> — Redéfinit l'objectif et réinitialise l'arbre.
/reinit — Remet le canal dans son état initial (arbre vide).

Glossaire

Plan-and-Execute: Motif d'agent qui sépare deux rôles : le planificateur décompose l'objectif en sous-tâches ordonnées, puis l'exécuteur les traite une à une. Article de référence : Plan-and-Solve Prompting (Wang et al., 2023). Comparé à la boucle ReAct pure (canal #boucle-agentique), la trace est vérifiable avant exécution — on économise des appels LLM sur les mauvaises trajectoires.
Reflexion: Technique où l'agent, après un échec, produit une self-critique en langue naturelle qu'il ajoute à son contexte pour re-tenter en tenant compte de la leçon. Article : Reflexion: Language Agents with Verbal Reinforcement Learning (Shinn et al., 2023). Améliore drastiquement les taux de succès sur HumanEval, HotpotQA et ALFWorld.
Tree-of-Thought: Généralisation de la chaîne-de-pensée : plutôt qu'une seule ligne de raisonnement, l'agent explore un arbre de raisonnements possibles, en évaluant chaque branche. Article : Tree of Thoughts (Yao et al., 2023). Coûteux en tokens mais efficace sur les tâches qui exigent de revenir en arrière (planification, mots croisés, jeu de 24).
décomposition de tâche: Casser un objectif de haut niveau (« Refactorer ce module ») en 5-10 sous-tâches concrètes et exécutables. C'est la brique de base de Plan-and-Execute : sans elle, un LLM se perd à mi-parcours. Bonne heuristique : chaque sous-tâche tient dans une phrase et se vérifie en 1-2 minutes.
verifier: Composant (souvent un second appel LLM, parfois un test unitaire ou un typecheck) qui vérifie qu'une sous-tâche a réellement réussi. Sans verifier, l'agent croit sur parole ses propres actions et cumule les erreurs silencieuses. Le canal #multi-agents (Premium) formalise le rôle.
self-correction: Capacité d'un agent à détecter ses propres erreurs et à en corriger le tir. Concrètement : verifier → détecte l'échec → réflexion → nouvelle stratégie. Amplifie la fiabilité des agents mais ne suffit pas seul : sans ground truth externe, un LLM peut « corriger » vers une réponse tout aussi fausse.
halting problem des agents: Un agent LLM peut boucler éternellement (répéter la même action, penser sans agir, se perdre en réflexions). Il n'existe pas de garantie théorique d'arrêt : c'est pourquoi tout agent en production embarque un budget dur (pas max, réflexions max, coût max) et un kill-switch — pas une option, une nécessité.
budget d'itérations: Plafond dur au-delà duquel l'agent s'arrête, même sans réponse. Deux dimensions ici : pas (nombre de nœuds exécutés) et reflexions (nombre de replanifications). Tape /budget 5 1 avec le scénario donnees pour voir le plafond de pas déclencher un ÉCHEC DÉFINITIF.
replanification: Action d'ajouter (ou remplacer) une branche du plan initial après un échec. Ici : l'ancien nœud passe en or (marqué ☆), un nouveau sous-arbre apparaît. Différent d'une simple ré-exécution : on change la stratégie, pas seulement les arguments.
arbre de plan: Représentation hiérarchique d'un objectif : racine = objectif global, enfants = sous-tâches, petits-enfants = sous-sous-tâches. Rendu ici en 3D à deux niveaux (racine + feuilles) pour rester lisible ; les vrais agents peuvent aller à 3-4 niveaux avec des sous-plans imbriqués.

Autres canaux du thème IA agentique

#boucle-agentique — Boucle ReAct d'un agent : Pensée → Action → Observation en direct.
#outils-appel — Appel d'outil (function calling / MCP) : le JSON qui fait agir le LLM.
#slash-commands — Slash commands à la Claude Code / Cursor : templates, arguments, enchaînement.
#contexte-memoire — Fenêtre de contexte et mémoire d'agent : compter, tronquer, résumer, indexer.
#planification-reflexion — Planification, réflexion et self-correction : de 60 % à 90 % de succès.
#multi-agents — Multi-agents : planner, workers, verifier. Un DAG qui bat l'agent monolithique.