Boucle de feedback d'agents IA : méthode en 5 étapes

Une boucle de feedback d'agents IA relie cinq blocs : une tâche, une production, un signal de vérification, une correction et une condition d'arrêt. L'agent ne se contente plus d'affirmer que son travail est bon : il doit le confronter à un test, une donnée, une grille ou un humain. Voici la méthode concrète pour construire cette boucle sans créer une machine coûteuse qui se valide elle-même.

Le principe en 30 secondes

Un agent sans boucle de feedback fonctionne en ligne droite : tu demandes, il produit, tu récupères. Si c'est raté, c'est toi qui corriges. Tout le contrôle qualité repose sur tes épaules, et l'agent ne s'améliore jamais pendant le travail.

Avec une boucle, le circuit change : l'agent produit, quelque chose évalue la production contre un critère, et le verdict repart dans l'agent pour un nouveau tour. Le cycle s'arrête quand le critère est atteint, ou après un nombre maximal d'itérations. Anthropic a formalisé ce pattern sous le nom d'evaluator-optimizer dans son guide de référence sur la construction d'agents : un appel qui génère, un appel qui critique, en boucle. Leur analogie est parlante : c'est le processus d'un écrivain qui relit, rature et réécrit jusqu'à ce que le texte tienne.

Le point important que beaucoup ratent : le feedback ne vient pas forcément d'un humain. Les meilleures boucles tournent toutes seules, avec un signal objectif au milieu.

La méthode en 5 étapes

1. Définis le résultat observable. « Rédiger un bon article » est inutilisable. « Répondre à la requête dès l'introduction, citer trois sources primaires, garder une meta sous 155 caractères et obtenir une page HTTP 200 » donne des prises au système.

2. Choisis le signal le plus externe possible. Un test, un état en base, une URL publique ou une donnée de conversion vaut mieux que l'avis du modèle qui vient de produire le travail.

3. Transforme le signal en scorecard. Mélange des critères binaires, comme HTTP 200 ou lien présent, et des critères gradués, comme clarté ou fidélité au ton. Anthropic recommande de combiner des graders fondés sur le code, des graders modèle et une calibration humaine selon la nature du résultat.

4. Autorise une correction ciblée. Le feedback doit dire quoi corriger et fournir la preuve de l'écart. « Améliore » relance une génération aveugle. « Le titre fait 74 caractères, ramène-le sous 60 sans perdre la requête » crée une vraie itération.

5. Pose une condition d'arrêt. Arrêt si tous les critères bloquants passent, après trois tours maximum, ou dès qu'une action irréversible exige un humain. Si le score n'avance plus entre deux tours, escalade au lieu de brûler des crédits.

La distinction la plus utile vient des évaluations d'agents : le transcript raconte ce que l'agent a fait, mais l'outcome décrit l'état réel obtenu. Un agent peut écrire « réservation confirmée » dans son transcript ; le bon contrôle vérifie qu'une réservation existe réellement. Cette séparation évite de confondre récit de réussite et réussite.

Une scorecard minimale à copier

Tu peux adapter les seuils, mais pas supprimer la colonne « preuve ». Une note sans trace exploitable est juste une opinion avec un chiffre.

Les 4 sources de feedback, de la plus fiable à la moins fiable

1. La réalité exécutable

Le feedback le plus honnête, c'est celui qui ne peut pas mentir. Du code qui compile ou pas. Des tests qui passent ou pas. Une URL qui répond 200 ou 404. Un PDF dont le texte déborde de la page ou pas. Quand un agent de code lance les tests après chaque modification et repart corriger tant que ça casse, il est dans une boucle de feedback avec la réalité, pas avec une opinion. C'est exactement pour ça que les agents ont d'abord explosé chez les développeurs : leur terrain fournit un signal de vérité gratuit et instantané.

2. Les données de résultat

Un cran au-dessus en horizon de temps : les chiffres que ton travail produit dans le monde réel. Notre exemple vécu, celui qui fait tourner ce blog : chaque semaine, les requêtes réelles de la Search Console alimentent le choix des articles suivants. Une page qui prend des impressions sans clics déclenche une réécriture de son titre. Une requête qui monte sans page dédiée déclenche un article. L'article que tu lis est lui-même né de cette boucle : la donnée a montré une recherche sans réponse, la machine a produit la réponse. Le contenu s'améliore parce que le système écoute ce que Google lui renvoie, pas parce que quelqu'un a des intuitions.

3. Un autre agent en évaluateur

Le pattern evaluator-optimizer au sens strict : un agent génère, un second agent critique avec une grille explicite (exactitude, style, complétude), et le premier révise. Ça marche à une condition non négociable : l'évaluateur doit avoir des critères précis et le droit de dire non. Un évaluateur à qui on demande « c'est bien ? » répond oui. Un évaluateur à qui on demande « vérifie chaque chiffre contre sa source et rejette au moindre écart » trouve des erreurs. Nous, on fait tourner ce pattern sur les contenus : un agent rédige, un vérificateur passe derrière avec la consigne de réfuter, et ce qui ne survit pas à la critique ne part pas en ligne.

4. L'humain dans la boucle

Le feedback le plus riche et le plus cher. Ta correction vaut de l'or à une condition : qu'elle soit capturée quelque part où l'agent la retrouvera. Si tu corriges la même erreur de ton chaque semaine dans les textes de ton agent, et que rien ne l'enregistre, tu n'as pas une boucle, tu as une roue de hamster. La version qui marche : chaque correction humaine finit dans les instructions permanentes du système (un fichier de consignes, une mémoire, une règle datée). Corrigé une fois, appliqué pour toujours. C'est le geste qui transforme un agent IA en collaborateur qui progresse.

Ce qu'une boucle change concrètement

Prenons une tâche banale : rédiger une page de vente.

Sans boucle : tu prompts, tu reçois un texte correct et générique, tu passes 40 minutes à le retravailler. À chaque nouvelle page, rebelote. La qualité dépend de ton énergie du jour.

Avec une boucle : l'agent rédige, un évaluateur vérifie contre ta grille (promesse claire dans le premier écran, zéro claim invérifiable, un appel à l'action par section), l'agent révise, et le texte ne t'arrive que quand la grille est verte. Toi, tu fais la passe finale de goût, 5 minutes. Et ta correction de goût est enregistrée pour la page suivante.

La différence n'est pas subtile : c'est celle entre relire des brouillons à vie et recevoir du travail pré-vérifié qui s'améliore tout seul. C'est aussi ce qui explique pourquoi certains domaines s'automatisent bien et d'autres pas : là où le feedback est objectif et rapide, les agents progressent vite. Là où personne ne peut dire si le résultat est bon, ils stagnent.

Les erreurs qui coûtent cher

• La boucle sans condition d'arrêt. Un agent qui itère « jusqu'à la perfection » peut brûler ton budget en tournant à vide. Toute boucle sérieuse a un critère de sortie ET un plafond d'itérations. Trois tours suffisent presque toujours ; au-delà, c'est le critère qui est flou, pas l'agent qui est mauvais

• L'évaluateur complaisant. Les modèles ont un biais naturel vers l'approbation. Un évaluateur sans grille précise valide tout, et ta boucle devient du théâtre. Le fix : des critères binaires, vérifiables, et une consigne explicite de chercher les défauts

• Le faux feedback. Un agent peut produire le travail puis raconter qu'il l'a vérifié. La parade : faire venir le verdict d'un canal que le générateur ne contrôle pas, comme une exécution réelle, une donnée externe ou un évaluateur séparé

• Optimiser le signal au lieu du travail. Un agent jugé uniquement sur « zéro test rouge » peut contourner le problème en affaiblissant les tests. Vérifie le résultat final et lis les traces, pas seulement le score. Anthropic insiste sur cette lecture des transcripts pour distinguer une vraie erreur d'un grader mal conçu

• Le feedback jeté. Corriger en chat et ne rien consigner. La correction meurt avec la conversation, et tu repayes la même erreur la semaine suivante

Par où commencer, sans code

Tu n'as pas besoin d'infrastructure pour ta première boucle. Trois gestes, ce soir :

• Donne un critère de sortie à tes tâches. Au lieu de « rédige un email », essaie : « rédige, puis relis en te demandant si chaque phrase apporte une information, coupe ce qui n'en apporte pas, et ne me montre que la version qui survit ». Une auto-boucle en un prompt

• Sépare le générateur du critique. Sur un travail qui compte, fais produire par une conversation et critiquer par une autre, avec une grille explicite. Deux perspectives valent mieux qu'une auto-évaluation

• Crée ta mémoire de corrections. Un simple fichier de consignes que tu enrichis à chaque correction (« ne jamais dire X », « toujours vérifier Y en premier ») et que tu redonnes à chaque session. C'est la boucle la plus rentable qui existe, et c'est celle que presque personne ne tient

Et si tu veux voir le mécanisme à l'échelle d'un système complet, comprendre comment une IA raisonne aide à saisir pourquoi la critique externe change tout : le modèle qui produit est rarement le mieux placé pour juger sa production.

La limite honnête

Une boucle de feedback améliore ce qui est mesurable. Elle ne sauve pas une tâche mal définie : si tu ne peux pas dire ce qu'est un bon résultat, aucun évaluateur ne le dira à ta place. Elle a aussi un coût réel : chaque itération consomme des tokens, et sur les modèles chers, une boucle mal bornée se paie. Enfin, elle ne remplace pas la supervision sur les actions irréversibles : un agent qui envoie, publie ou supprime doit garder un humain dans sa boucle, précisément parce que le feedback arrive après l'action. Les modèles récents vont plus loin que ton intention plus souvent qu'on ne croit, on l'a détaillé dans notre comparatif des modèles frontière.

FAQ

C'est quoi une boucle de feedback d'agents IA, en une phrase ?
Un circuit où la production d'un agent est évaluée (par des tests, des données, un autre agent ou un humain) et où cette évaluation nourrit l'itération suivante, jusqu'à atteindre le critère de qualité fixé.

Quelle différence avec le RLHF ou le fine-tuning ?
Le RLHF améliore le modèle lui-même pendant son entraînement, chez le fournisseur. La boucle de feedback d'agents améliore le travail et le système autour du modèle, chez toi, sans rien réentraîner : mêmes modèles, résultats très différents.

Faut-il savoir coder pour mettre ça en place ?
Non. La version minimale tient en deux conversations (une qui génère, une qui critique avec une grille) et un fichier de consignes enrichi à chaque correction. Le code devient utile quand tu veux brancher du feedback objectif automatique, comme des tests ou des données de performance.

Combien d'itérations faut-il autoriser ?
Deux à trois tours couvrent l'immense majorité des cas. Si un agent n'atteint pas le critère en trois itérations, le problème est presque toujours dans la définition du critère ou de la tâche, pas dans le nombre de tours. Et toujours fixer un plafond : une boucle sans limite est une facture sans limite.

Avant de partir

Si cet article t'a donné envie de construire au lieu de juste lire : j'ai condensé le démarrage en un guide d'une soirée. Ton premier agent qui produit du travail réel, étape par étape, sans code. Gratuit, contre ton email. Tu recevras aussi Kryve Weekly quand elle sortira : le condensé hebdo de ce qui compte en IA, sans le bruit.

Recevoir le guide

Un email pour te l'envoyer. Pas de spam, désinscription en un clic.