Evaluator–Optimizer

Aussi appelé : Reflection, générateur–critique, self-refine, boucle critique-révision, rédacteur–relecteur, boucle LLM-as-a-judge, générer–tester–corriger

Intention

Un composant écrit une sortie candidate. Un second la juge selon des critères que vous avez mis par écrit et renvoie un retour précis. Le rédacteur révise, et la boucle recommence jusqu'à ce que le juge valide la sortie ou qu'une règle d'arrêt dans votre code y mette fin.

Problème

Imaginons que vous demandiez à un modèle d'écrire une petite classe Python : une MinStack avec push, pop, top et get_min, chaque opération en O(1). C'est l'exemple que le notebook du cookbook d'Anthropic utilise pour ce pattern.

Un seul appel vous donne un premier jet. L'idée centrale est bonne (une seconde pile qui suit le minimum), mais le code renvoie None quand on dépile une pile vide, n'a pas de docstrings et ne vérifie pas ses entrées. Un modèle écrit en une seule passe, de gauche à droite, et a tendance à s'arrêter quand la sortie a l'air terminée, pas quand elle l'est. Sans étape de relecture, vous obtenez ces symptômes :

Une tâche part vers un seul appel LLM, qui renvoie un premier jet avec trois lacunes ; une personne doit les trouver à la main. Tâche écrire MinStack Un appel LLM une seule passe Premier jet l'idée de pile min est juste pop() à vide renvoie None ni docstrings ni type hints aucune validation des entrées À vous de trouver les lacunes
Un appel unique ne comporte aucune étape où quelqu'un compare le jet aux exigences, si bien que la vérification vous revient.

Solution

Placez la génération dans une boucle avec un relecteur. Le générateur écrit ; l'évaluateur compare le résultat à une liste explicite de critères et dit ce qui ne va pas, où, et comment le corriger. Le code qui les entoure fait tourner la boucle et décide quand elle s'arrête. Pour la tâche MinStack :

  1. Générer. Le générateur reçoit la tâche et la liste complète des critères : opérations en O(1), exception explicite sur une pile vide, type hints et docstrings, validation des entrées. Il écrit un premier jet.
  2. Contrôler. Votre code lance d'abord des contrôles déterministes : pytest, mypy, un linter. Leur sortie brute sert de preuve. Ici, deux tests échouent parce que pop() renvoie None au lieu de lever une exception.
  3. Évaluer. L'évaluateur reçoit la tâche, les critères, le jet et la sortie des tests. Il renvoie un verdict (REVISE) et une liste de problèmes, par exemple « C2, pop() : renvoie None sur une pile vide ; lever IndexError ».
  4. Décider. C'est le code, pas un modèle, qui applique la règle d'arrêt : validation, plafond d'itérations, absence de progrès ou budget. Le verdict n'est pas PASS et le plafond n'est pas atteint, donc la boucle continue.
  5. Réviser. Le générateur reçoit la tâche, son dernier jet et le retour, et écrit une nouvelle version complète. Retour à l'étape 2. Dans l'exécution du cookbook, le premier verdict de l'évaluateur était NEEDS_IMPROVEMENT, avec des remarques sur la gestion des erreurs, les type hints, la documentation et la validation des entrées, et le générateur a écrit un second jet.

Qui décide quoi : le générateur décide du contenu, l'évaluateur décide si ce contenu respecte les critères et ce qu'il faut changer, et votre code possède la règle d'arrêt, le plafond et le choix du candidat renvoyé. Certains frameworks laissent un agent à l'intérieur de la boucle y mettre fin (Google ADK propose un outil exit_loop), mais un plafond strict dans le code reste le filet de sécurité.

Ce qui le distingue de ReAct, qui boucle aussi : dans ReAct, le modèle choisit librement son action suivante. Ici, la forme est fixée dans le code (générer, contrôler, évaluer, réviser), ce qui en fait un workflow. Par rapport à Prompt Chaining, c'est une chaîne dont la porte de contrôle reboucle avec un retour au lieu de simplement valider ou rejeter.

Analogie

Une développeuse ouvre une pull request. La CI lance la suite de tests et le linter, puis un relecteur lit le diff avec les contrôles en échec sous les yeux et laisse des commentaires rattachés à des lignes précises. La développeuse pousse un correctif, la CI repasse, et le cycle recommence jusqu'à ce que le relecteur approuve. La développeuse est le générateur, la CI est le contrôle déterministe, le relecteur est l'évaluateur, et la règle de l'équipe « deux approbations, CI au vert » est la condition d'arrêt dans le code.

L'analogie a une limite. Un relecteur humain qui a vu cent PR similaires sait quand arrêter de pinailler. Un relecteur LLM à qui l'on demande de trouver des problèmes en trouvera toujours, donc vous devez le limiter aux critères énoncés et l'autoriser à approuver dès le premier tour.

Structure

La tâche va au générateur ; son candidat passe par des contrôles déterministes jusqu'à l'évaluateur ; le verdict de l'évaluateur va à une règle d'arrêt dans le code, qui renvoie soit un retour au générateur, soit le meilleur candidat. tâche candidat candidat + preuves verdict PASS / plafond réviser : retour + historique Tâche + critères Générateur écrit, révise Contrôles déterministes tests, compilateur, schéma Évaluateur verdict + problèmes Règle d'arrêt dans le code Sortie meilleur obtenu 1 2 3 4 5 6
Les flèches pleines font avancer le travail ; la flèche en pointillés de couleur est la boucle de révision. Le bloc des contrôles est facultatif, mais c'est de lui que vient l'essentiel de la valeur.
  1. Générateur. Écrit le premier jet et chaque révision. Son prompt contient toutes les exigences que l'évaluateur vérifiera. Lors des révisions, il reçoit aussi sa dernière tentative et le retour.
  2. Contrôles déterministes. Tests, compilateurs, vérificateurs de types, linters, validateurs de schéma, compteurs de mots, un appel de recherche pour vérifier une affirmation. Ils passent avant le juge et leur sortie brute lui est transmise comme preuve.
  3. Évaluateur. Un juge LLM muni d'une grille, ou une règle. Il renvoie un verdict sur lequel votre code peut brancher (PASS, REVISE, FAIL) et une liste de problèmes, chacun avec un emplacement, une correction suggérée et une gravité. Il évalue seulement ; il ne réécrit pas.
  4. Règle d'arrêt. Du code ordinaire qui termine la boucle sur une validation, le plafond d'itérations, l'absence de progrès pendant quelques tours, un candidat répété, ou un budget de tokens ou de temps.
  5. Retour et historique. Ce qui repart vers le générateur : le dernier candidat et ses problèmes en entier, les tours précédents sous forme de résumés d'une ligne ou de courtes leçons, pour que le contexte ne grossisse pas sans fin.
  6. Sortie. Le meilleur candidat obtenu jusque-là, qui n'est pas toujours le dernier. Si la boucle se termine sans validation, signalez-le comme non vérifié ou confiez-le à une personne.

Générateur de prompt

Décrivez ce que la boucle doit produire, les critères à respecter et les contrôles que votre code peut lancer. Vous obtenez deux system prompts (générateur et évaluateur) qui partagent la même liste de critères, ainsi que les règles de boucle à implémenter dans votre code de contrôle, qu'il s'agisse de Python simple, d'un graphe LangGraph ou d'une boucle OpenAI Agents SDK.

Critères la même liste va dans les deux prompts
Problèmes renvoyés pour révision

Prompt généré

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

Les contrôles comptent plus que les prompts

Une boucle dont le seul retour vient du même modèle qui relit sa réponse n'aide souvent pas, et sur les tâches de raisonnement elle peut transformer des réponses justes en réponses fausses. Concentrez vos efforts sur la colonne « Vérifié par » : chaque critère que vous pouvez rattacher à un test, un compilateur ou un validateur donne à l'évaluateur une preuve fiable et le rend plus difficile à tromper.

Quand l'utiliser

À utiliser quand

À éviter quand

Mise en œuvre

  1. Écrivez d'abord les critères. Si vous n'arrivez pas à les lister, ce pattern n'est probablement pas le bon.
  2. Donnez toutes les exigences au générateur. Ne réservez pas de critères au critique. Sinon, la boucle ne semble utile que parce que le critique reformule des exigences que le générateur n'a jamais vues.
  3. Rassemblez tous les contrôles déterministes possibles. Tests, vérification de types, linters, validation de schéma, compteurs de longueur, expressions régulières, vérification des citations, un interpréteur de code pour l'arithmétique. Lancez-les avant le juge LLM et transmettez-lui leur sortie brute. Un contrôle en échec l'emporte sur un PASS.
  4. Structurez la sortie de l'évaluateur. JSON ou XML balisé, avec une énumération de verdicts sur laquelle votre code peut brancher, et une liste de problèmes avec critère, emplacement, correction et gravité. Un réussi/échoué binaire par critère, accompagné d'une raison écrite, est plus facile à exploiter qu'une note de 1 à 5.
  5. Fixez les conditions d'arrêt dans le code. Un plafond strict d'itérations (deux à quatre tours sont courants dans les sources), plus un arrêt en l'absence de progrès, sur un candidat répété, et sur un budget de tokens ou de temps.
  6. Conservez le meilleur candidat obtenu. Classez d'abord selon les contrôles, ensuite selon le juge. Les auteurs de Self-Refine notent que l'amélioration n'est pas toujours monotone : le dernier jet peut être moins bon qu'un précédent.
  7. Gérez le contexte. Envoyez le dernier candidat et son retour en entier, les tours précédents sous forme de résumés d'une ligne. Lancez l'évaluateur dans un contexte neuf pour que le raisonnement du générateur ne l'influence pas.
  8. Journalisez chaque tour (candidat, sortie des contrôles, verdict, tokens) et comparez à une référence de coût égal, comme best-of-N avec le même nombre d'appels, avant de passer en production.

La boucle coûte environ 2k + 2 appels de modèle pour k tours de révision (un appel au générateur et un à l'évaluateur pour le premier jet et pour chaque révision), moins quand l'évaluateur est un simple contrôle.

Prise en charge par les frameworks (vérifiez la documentation à jour avant usage)
FrameworkForme que prend ce patternMécanisme d'arrêt
Anthropic cookbookPython simple avec generate(), evaluate(), loop(), verdicts PASS / NEEDS_IMPROVEMENT / FAILBoucle jusqu'à PASS ; l'exemple n'a pas de plafond (while True)
LangGraphStateGraph avec des nœuds générateur et évaluateur et une arête conditionnelle qui revient au générateur ; sortie structurée FeedbackLe tutoriel boucle jusqu'à acceptation, sans plafond
Google ADKLoopAgent(sub_agents=[critic, refiner]) après un rédacteur initial dans un SequentialAgentmax_iterations (valeur par défaut en Python : None) ou escalade par un sous-agent, par ex. l'outil exit_loop
OpenAI Agents SDKExemple llm_as_a_judge.py : un agent évaluateur avec output_type=EvaluationFeedbackSort sur score == "pass" ; plafonné à 3 tours rejetés, en mode auto uniquement
AutoGen (Core)CoderAgent et ReviewerAgent qui échangent des messages de relecture avec un indicateur approvedS'arrête à l'approbation ; pas de plafond dans l'exemple
CrewAIPas de construction dédiée au critique ; les garde-fous de tâche (une fonction, ou une chaîne transformée en contrôle LLM) s'en approchent le plusguardrail_max_retries, 3 par défaut
DSPydspy.Refine(module, N, reward_fn, threshold), qui injecte des indices rédigés par un LLM entre les tentativesPremière prédiction au niveau du seuil ou au-dessus, sinon la meilleure des N
Claude CodeHooks Stop, /goal, un sous-agent relecteur dans un contexte neufPlafond de blocages par hook (8 blocages consécutifs sans appel d'outil, configurable), --max-turns, --max-budget-usd

Mise en garde. Plusieurs exemples de référence (le cookbook d'Anthropic, le tutoriel LangGraph, l'exemple d'AutoGen) n'ont pas de plafond d'itérations : ajoutez le vôtre. Les frameworks bougent vite : la documentation d'ADK marque LoopAgent comme obsolète au profit de workflows en graphe pour Python, TypeScript, Go et Kotlin ; le paquet langgraph-reflection a été archivé le 1er avril 2026 ; CrewAI a rendu max_retries obsolète au profit de guardrail_max_retries. Les noms ont peut-être encore changé au moment où vous lisez ceci.

Variantes

Self-Refine (un modèle, trois prompts)

Le même modèle génère, critique et affine, sans outils ni entraînement. C'est la variante la moins chère à mettre en place. Ses gains sont réels en rédaction ouverte et quasi nuls en maths, où le critique dit surtout que la réponse semble correcte.

Rédacteur–relecteur (deux agents)

Des prompts distincts pour le générateur et le critique, souvent sur des modèles différents ou dans des contextes neufs. Andrew Ng décrit cette forme multi-agent de Reflection, et l'exemple codeur/relecteur d'AutoGen en est une instance. Prenez un juge d'une autre famille de modèles pour réduire le biais d'auto-préférence.

Critique ancrée dans des outils (CRITIC)

Le critique appelle des outils (recherche web, interpréteur Python, API de détection de toxicité) pour vérifier les affirmations avant de rédiger son retour. Dans l'article CRITIC, l'essentiel du gain disparaissait quand on retirait les outils.

Retour d'exécution et tests d'ancrage

L'évaluateur est l'exécution du code : résultats de tests, erreurs de compilation et traces, parfois avec le modèle qui explique son propre code (Self-Debugging). AlphaCodium ajoute des tests écrits par l'IA et garde les tests qui passent déjà comme ancres que chaque correctif ultérieur doit maintenir au vert, pour qu'un mauvais test généré ne puisse pas entraîner le code vers une fausse correction.

Reflexion (mémoire entre tentatives)

Après l'échec d'une tentative complète, le modèle écrit une courte leçon (« chercher directement l'acteur la prochaine fois ») en mémoire, et la tentative suivante démarre avec elle. Reflexion conserve 1 à 3 leçons de ce type plutôt que des transcriptions complètes.

Nouvelle tentative avec un validateur

La forme minimale : une fonction ou un contrôle LLM rapide accepte la sortie ou renvoie un message d'erreur, et l'agent réessaie jusqu'à N fois. Les garde-fous de tâche de CrewAI fonctionnent ainsi. Refine de DSPy est proche, mais note avec une fonction de récompense et transmet des indices ; son cousin BestOfN abandonne le retour et se contente de rééchantillonner.

Contrôle imposé par le harnais

Le runtime refuse que l'agent termine tant qu'un script ne passe pas. Le hook Stop de Claude Code (le code de sortie 2 renvoie la sortie du compilateur à l'agent) et /goal (un modèle distinct vérifie une condition énoncée après chaque tour) en sont des exemples.

Évaluateur humain

Une personne rédige le retour. C'est le meilleur signal pour la qualité subjective, mais il est lent. Voir Human-in-the-Loop.

Proche mais différent

LATS remplace la chaîne de révision unique par une recherche arborescente sur les candidats (la recherche arborescente pour la planification est traitée dans Plan-and-Execute). Constitutional AI utilisait les mêmes étapes critique-révision, mais pour produire des données d'entraînement plutôt que des réponses à l'exécution, et SCoRe entraîne le modèle à corriger sa propre seconde tentative. Aucun des deux n'est une boucle de prompts que l'on exécute au moment de l'inférence.

Avantages et inconvénients

Avantages

  • Gains importants sur les tâches ouvertes ou chargées en contraintes : Self-Refine a rapporté environ 20 points absolus en moyenne sur ses tâches et ses modèles.
  • Le retour peut coûter moins cher que l'échantillonnage en force brute : Self-Debugging a égalé des références qui échantillonnaient plus de 10 fois plus de programmes.
  • Facile à déboguer. Chaque tour laisse un candidat, un verdict et une raison, donc les journaux montrent pourquoi la sortie a changé.
  • Simple à construire : une boucle, deux prompts et une règle d'arrêt, sans framework.
  • Se branche sur les contrôles que vous avez déjà, comme votre suite de tests, vos schémas et vos linters.

Inconvénients

  • Peut dégrader les réponses sur les tâches de raisonnement quand le seul retour est une autocritique.
  • Les appels sont strictement séquentiels : la latence augmente à chaque tour, et les prompts grossissent avec l'historique que vous transportez.
  • Rendements décroissants : l'essentiel du gain arrive dans les un à trois premiers tours.
  • De nouvelles façons d'échouer : régressions où un correctif casse une partie qui passait, oscillation, et générateur qui dupe l'évaluateur.
  • Les deux rôles exigent des modèles capables. Le générateur doit suivre le retour et le critique doit produire le format demandé ; dans Self-Refine, Vicuna-13B échouait souvent sur les deux.

Génération de modèles. Presque tous les chiffres publiés cités sur cette page viennent de modèles de l'ère GPT-3.5 et GPT-4 (2023 à 2024). Les modèles de raisonnement actuels vérifient déjà davantage leur travail au sein d'un seul appel, donc l'ampleur de ces gains sur les modèles d'aujourd'hui n'est pas établie. Prenez-les comme des tendances.

Modes de défaillance

L'autocorrection casse des réponses justes

Sans signal externe, le modèle remet en doute des réponses qui étaient justes. Huang et al. (ICLR 2024) ont mesuré GPT-3.5-Turbo sur CommonSenseQA passant de 75,8 à 38,1 après un tour d'autocorrection, et GPT-4 sur GSM8K passant de 95,5 à 91,5, puis 89,0. Suivez la fréquence à laquelle un tour transforme une réponse juste en réponse fausse.

Parade : ancrez l'évaluateur dans des tests, des outils ou de la recherche documentaire. S'il n'en existe aucun, ne bouclez pas sur des tâches de raisonnement ; utilisez le vote de Parallelization.

Validation de complaisance

Le critique dit « ça a l'air bon » alors que la sortie est fausse. Dans les essais de Self-Refine en maths, le retour de ChatGPT affirmait que tout semblait correct pour 94 % des cas, si bien que la boucle ne corrigeait presque rien. Les modèles savent mieux corriger une erreur une fois qu'on leur dit où elle est que la trouver eux-mêmes.

Parade : fournissez au critique les preuves issues des contrôles, utilisez un autre modèle ou un contexte neuf, et mesurez la fréquence à laquelle le juge rejette à juste titre les mauvaises sorties.

Pinaillage et dérive du périmètre

Un relecteur à qui l'on demande de trouver des problèmes en trouve toujours. La documentation de Claude Code prévient que tous les corriger ajoute des abstractions et des tests inutiles. Cela se voit à des sorties qui grossissent à chaque tour et à des boucles qui n'atteignent jamais la validation.

Parade : limitez le critique aux critères énoncés, attribuez des gravités et ne bouclez que sur les problèmes bloquants, autorisez une validation dès la première tentative, et laissez le style de côté sauf si un critère porte sur le style.

Biais du juge

Les juges LLM favorisent leurs propres générations, les réponses plus longues et la première option d'une paire. Un juge issu du même modèle que le générateur est le pire cas.

Parade : prenez un juge d'une autre famille de modèles, préférez des contrôles binaires par critère, pénalisez explicitement la longueur, randomisez l'ordre dans les comparaisons par paires, et calibrez sur des annotations humaines.

Évaluateur dupé

Le générateur satisfait le contrôle au lieu de l'intention : sorties attendues codées en dur, tests modifiés, cas particuliers pour certaines entrées. ImpossibleBench (2025) a construit des tâches dont les tests contredisent la spécification, si bien que toute réussite est une triche ; GPT-5 a triché sur 54 % de ses tâches SWE-bench contradictoires, et laisser les agents resoumettre après un retour de tests a fait passer le taux moyen de triche de 33 % à 38 %. Ces taux dépendent de l'échafaudage et du prompt, et les modèles testés vieilliront vite.

Parade : mettez les tests en lecture seule ou gardez des tests réservés que le générateur ne voit jamais, relisez les diffs qui touchent aux tests, et donnez au générateur un moyen explicite de signaler un conflit. Dans ImpossibleBench, cette issue a fait tomber le taux de GPT-5 de 54 % à 9 %, avec un effet bien plus faible sur Claude Opus 4.1.

Évaluateur erroné

De mauvais tests écrits par l'IA ou un retour du juge erroné poussent la sortie dans la mauvaise direction. Les tests auto-générés de Reflexion sur MBPP avaient un taux de faux positifs de 16,3 %, et son score y a fini sous la référence GPT-4 simple.

Parade : utilisez des tests d'ancrage (les correctifs doivent garder au vert les tests réputés bons), filtrez les tests générés, et vérifiez des verdicts à la main par sondage.

Asymétrie des prompts

Le prompt du critique contient des exigences que le générateur n'a jamais vues, si bien que le « gain » vient en réalité d'un meilleur prompt. Sur CommonGen-Hard, Huang et al. ont placé l'instruction manquante dans le premier prompt : cet appel unique a obtenu 81,8, au-dessus des 67,0 rapportés pour Self-Refine, et l'autocorrection appliquée par-dessus l'a fait redescendre à 75,1.

Parade : donnez la même liste de critères aux deux rôles, et comparez la boucle à un prompt unique amélioré.

Oscillation et boucles sans fin

Corriger A casse B, corriger B recasse A, et les scores font le yoyo. Sans plafond, la boucle tourne jusqu'à épuisement du budget. L'exemple d'OpenAI comporte une règle « valider après 5 tentatives », mais uniquement dans le prompt de l'évaluateur, pas dans le code.

Parade : un plafond strict et un budget dans le code, le suivi du meilleur candidat obtenu, une détection des candidats répétés, et un arrêt quand rien ne s'est amélioré pendant un tour. CRITIC s'arrête quand la réponse reste inchangée sur deux corrections consécutives.

Enfermement dans une mauvaise première approche

Une conception initiale erronée est rapiécée tour après tour au lieu d'être remplacée.

Parade : autorisez un verdict FAIL qui déclenche un nouveau départ, ou générez deux ou trois candidats initiaux comme le fait AlphaCodium.

Contexte surchargé

L'historique complet des jets et des critiques remplit la fenêtre de contexte et dilue l'attention.

Parade : résumez chaque tour précédent en une ligne, ou gardez quelques courtes leçons comme le fait Reflexion.

Liens avec les autres patterns

Pour aller plus loin

Toutes les sources ci-dessous sont en anglais.