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 :
- Des exigences passent à la trappe. Une spécification avec dix contraintes (longueur, ton, citations, gestion des erreurs) revient souvent avec une ou deux qui manquent sans le moindre signal.
- Les bugs restent cachés. Le code « tourne » dans la tête du modèle mais échoue à un test, ou sur un cas limite que personne n'a exécuté.
- La qualité reste superficielle. Une traduction est littérale là où elle devrait être idiomatique, ou une réponse fondée sur la recherche s'arrête après une requête alors qu'il en fallait trois.
- Vous devenez la suite de tests. La documentation de Claude Code décrit ce cas : sans vérification que l'agent peut lancer lui-même, c'est l'utilisateur qui finit par relever chaque erreur à la main.
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 :
- 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.
- 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 quepop()renvoieNoneau lieu de lever une exception. - É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(): renvoieNonesur une pile vide ; leverIndexError». - 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
PASSet le plafond n'est pas atteint, donc la boucle continue. - 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
- 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.
- 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.
- É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. - 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.
- 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.
- 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.
Prompt généré
Le texte surligné vient du formulaire. Le texte [entre crochets] reste à remplir.
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
- Vous pouvez mettre les critères par écrit. Anthropic cite deux signes d'une bonne adéquation : un humain qui signale les problèmes améliore nettement la sortie, et un LLM peut fournir ce même type de retour.
- Un signal externe existe. Tests, compilateurs, vérificateurs de types, validateurs de schéma, recherche documentaire et vérification des faits, ou contraintes mesurables donnent à l'évaluateur une vérité de terrain sur laquelle s'appuyer.
- La qualité compte plus que la latence. Rapports, code, traductions et extraction structurée stricte peuvent se permettre quelques appels séquentiels de plus.
- Une seule passe tend à oublier des contraintes. Listes de vérification, guides de style et génération sous contraintes, où un relecteur repère de façon fiable ce que le premier jet a manqué.
- La sortie est subjective mais vous avez une grille. Cela fonctionne si vous avez calibré le juge sur des annotations humaines, pas seulement écrit un prompt.
À éviter quand
- Le seul retour est une autocritique sur une tâche de raisonnement. Maths, logique ou QCM sans outils : les scores mesurés ont baissé (voir Modes de défaillance). Échantillonnez plutôt plusieurs réponses et faites-les voter, comme dans Parallelization.
- Vous ne savez pas dire ce que « mieux » veut dire. Sans critères, le critique dérive vers ses goûts et vers des sorties plus longues.
- La latence est serrée. Autocomplétion de chat ou voix : chaque tour ajoute au moins deux appels de modèle séquentiels. Utilisez un seul appel bien formulé, ou un Prompt Chaining linéaire avec une seule porte de contrôle.
- Un seul bon prompt atteint déjà le niveau requis. Anthropic conseille de commencer simple et de n'ajouter des boucles que lorsqu'elles apportent un gain mesurable.
- Best-of-N fait aussi bien pour moins cher. Testez un simple rééchantillonnage avec le même nombre d'appels avant de vous engager sur une boucle.
- L'évaluateur est facile à duper et vous ne pouvez pas le durcir. Le générateur apprendra à satisfaire le contrôle au lieu de la tâche.
Mise en œuvre
- Écrivez d'abord les critères. Si vous n'arrivez pas à les lister, ce pattern n'est probablement pas le bon.
- 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.
- 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. - 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.
- 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.
- 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.
- 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.
- 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.
| Framework | Forme que prend ce pattern | Mécanisme d'arrêt |
|---|---|---|
| Anthropic cookbook | Python simple avec generate(), evaluate(), loop(), verdicts PASS / NEEDS_IMPROVEMENT / FAIL | Boucle jusqu'à PASS ; l'exemple n'a pas de plafond (while True) |
| LangGraph | StateGraph avec des nœuds générateur et évaluateur et une arête conditionnelle qui revient au générateur ; sortie structurée Feedback | Le tutoriel boucle jusqu'à acceptation, sans plafond |
| Google ADK | LoopAgent(sub_agents=[critic, refiner]) après un rédacteur initial dans un SequentialAgent | max_iterations (valeur par défaut en Python : None) ou escalade par un sous-agent, par ex. l'outil exit_loop |
| OpenAI Agents SDK | Exemple llm_as_a_judge.py : un agent évaluateur avec output_type=EvaluationFeedback | Sort 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 approved | S'arrête à l'approbation ; pas de plafond dans l'exemple |
| CrewAI | Pas 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 plus | guardrail_max_retries, 3 par défaut |
| DSPy | dspy.Refine(module, N, reward_fn, threshold), qui injecte des indices rédigés par un LLM entre les tentatives | Première prédiction au niveau du seuil ou au-dessus, sinon la meilleure des N |
| Claude Code | Hooks Stop, /goal, un sous-agent relecteur dans un contexte neuf | Plafond 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
FAILqui 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
- Prompt Chaining : une chaîne peut inclure une porte de validation qui valide ou rejette. Evaluator–Optimizer en est la version où une porte en échec reboucle vers le générateur avec un retour.
- Parallelization : le vote et best-of-N échantillonnent plusieurs candidats sans retour. Ils constituent la référence à coût égal que cette boucle doit battre. Un panel de juges dont les notes sont agrégées sans discussion relève aussi de ce pattern.
- Orchestrator–Workers : se combine bien. Un orchestrateur peut faire tourner une boucle Evaluator–Optimizer sur la sortie de chaque worker avant la synthèse.
- ReAct (tool-use loop) : souvent confondu avec ce pattern parce que les deux bouclent. ReAct laisse le modèle choisir ses actions ; cette boucle a une forme fixe. Les agents de code font tourner des boucles générer–tester–corriger à l'intérieur d'une boucle ReAct.
- Plan-and-Execute : le replanificateur qui inspecte les résultats et révise le plan est une étape d'évaluation. La recherche arborescente sur les candidats (LATS, Tree of Thoughts) y est traitée.
- Council / Debate : plusieurs pairs ou juges se lisent et argumentent entre eux, au lieu d'un générateur et d'un évaluateur. À coût égal, Huang et al. ont constaté que le débat ne faisait pas mieux qu'un simple vote.
- Group Chat : un rédacteur et un relecteur qui parlent à tour de rôle dans un group chat sont une façon de construire cette boucle sur un framework de group chat.
- Human-in-the-Loop : une personne comme évaluateur, ou comme destinataire de l'escalade quand la boucle atteint son plafond.
Pour aller plus loin
Toutes les sources ci-dessous sont en anglais.
- Building effective agents (Anthropic, 2024) : définit le workflow evaluator–optimizer, les deux signes d'une bonne adéquation, et les exemples de traduction et de recherche en plusieurs tours.
- evaluator_optimizer.ipynb (cookbook d'Anthropic) : une version courte et exécutable avec l'exemple MinStack. Notez qu'elle n'a pas de plafond d'itérations.
- Self-Refine: Iterative Refinement with Self-Feedback (Madaan et al., 2023) : la boucle à un seul modèle, les résultats par tâche et l'ablation du retour.
- Large Language Models Cannot Self-Correct Reasoning Yet (Huang et al., ICLR 2024) : le contrepoint, avec les baisses dues à l'autocorrection sans ancrage et l'argument en faveur de références à coût égal.
- ImpossibleBench: Measuring LLMs' Propensity of Exploiting Test Cases (Zhong, Raghunathan, Carlini, 2025) : comment les générateurs dupent les tests, et quelles défenses fonctionnent.
- Best practices (documentation de Claude Code) : donner à l'agent un contrôle à lancer, relecteurs en contexte neuf, hooks
Stopet options de budget.