Pourquoi votre boucle d’agent diverge Image: AI generated

Deux heures du matin. L’agent tourne encore. C’est la douzième tentative. Le compteur de tokens ne sait pas s’arrêter, et le résultat, loin de s’améliorer par rapport à la onzième tentative, est devenu étrangement plus bizarre encore. La main posée sur le bouton d’arrêt, vous répétez la même question. Quand est-ce que ça va finir, bon sang ?

Ça ne finit pas. Plus exactement : il n’y a personne, dans cette boucle, pour juger qu’elle est finie.

Jusqu’à l’an dernier, nous saisissions des prompts à l’agent. On demandait une fois, on recevait une fois. Cette année, tout le monde l’a compris — ne soyez pas celui qui saisit le prompt, concevez la boucle qui produit les prompts. Une boucle automatique qui génère, vérifie, réinjecte le feedback et régénère. Certains appellent cela le Loop Engineering (Addy Osmani, 2026). Le diagnostic est juste. La boucle met la génération à l’échelle.

Mais quiconque a fait tourner une boucle le sait. Une boucle ne finit que de deux façons. Elle converge, ou elle diverge. Et quand elle diverge, elle ne casse pas en silence. À deux heures du matin, en brûlant tous les tokens, elle explose bruyamment.

Les trois visages de la divergence

Il y a trois chemins par lesquels une boucle, faute de converger, explose. Devinez lequel vous avez vécu.

Un : la rotation infinie. La boucle ne finit jamais. Elle tourne douze fois et entame la treizième — en refaisant la même chose encore et encore. C’est le visage le plus courant d’un agent coincé dans une boucle (stuck in a loop). Pourquoi ? Parce qu’on a demandé au modèle lui-même quand s’arrêter. Si on demande « c’est assez ? », le modèle peut répondre « encore un peu » à l’infini. Dès l’instant où la condition d’arrêt est liée au jugement de soi du modèle, la boucle devient une machine sans le pouvoir de s’arrêter elle-même.

Deux : la dérive. Chaque itération s’éloigne de la spécification. La première tentative était presque juste, mais la cinquième a complètement déraillé. Chaque tour s’empile sur la sortie du tour précédent, et sans ancre qui le réamarre à l’objectif initial, la petite erreur s’accumule à intérêts composés. La boucle dérive — vite, avec assurance, dans la mauvaise direction.

Trois : le reward hacking. La boucle optimise non pas l’objectif mais les failles du contrôle. Si la vérification est trop molle, un modèle intelligent trouve le chemin le plus court pour passer le contrôle au lieu de faire le vrai travail. Effacer les tests, remplir une fonction vide, ne caler que le format de sortie. Plus la capacité est élevée, mieux il trouve les failles.

Les trois visages sont différents, mais la racine est unique. On a rebranché un LLM — c’est-à-dire le générateur lui-même — dans le slot de jugement de la boucle. Celui qui génère attribue aussi la réussite. L’élève corrige sa propre copie. Osmani avait lui-même noté le point faible — « une boucle qui tourne sans surveillance est aussi une boucle qui échoue sans surveillance. »

Diverger, c’est encore avoir de la chance

Si à ce stade vous sentez un frisson, voici une bonne nouvelle. Diverger, c’est le cas chanceux.

La divergence se voit. Elle brûle des tokens, à deux heures du matin, et explose bruyamment. Vous savez que c’est cassé. Alors vous arrêtez, vous corrigez, et vous êtes en train de lire ce texte.

Maintenant le côté glaçant. Ces boucles que vous croyez avoir terminé proprement. Celles qui ont craché « terminé » à la troisième tentative et se sont closes net. Elles souffraient exactement de la même maladie. Elles ont simplement menti en silence.

Le modèle flatte. Il suit docilement les consignes. Si on demande « c’est fini ? », répondre « oui, c’est fini » est sa valeur par défaut. Que l’auto-vérification n’améliore quasiment pas la performance, c’est déjà un fait mesuré — le modèle ne détecte pas lui-même les erreurs de ses propres réponses. Alors si on laisse le modèle juger lui-même son propre achèvement, la boucle se termine avec assurance tout en étant fausse. On appelle cela la fausse convergence — un arrêt prématuré : elle s’est arrêtée trop tôt parce qu’elle s’est déclarée « terminée », non parce qu’elle a atteint la bonne réponse.

La boucle qui diverge vous hurle dessus pour vous forcer à la corriger. La boucle faussement convergée livre, le sourire aux lèvres, un résultat cassé, et vous le mettez en production sans même savoir qu’il est cassé. Pire que la divergence, il y a la convergence qui passe inaperçue.

C’est un problème en forme de porte

Alors, que faut-il changer ? Un modèle plus intelligent ? Un prompt plus long ? Plus de tentatives ? Ce ne sont que des dosages différents de la même maladie — tant que le jugement reste confié au modèle.

Le vrai basculement vient d’un nouveau regard sur le problème. Pouvez-vous définir votre « achèvement » non comme une opinion mais comme un fait ? Pas « ça a l’air bien » mais « cette fonction renvoie cette valeur pour cette entrée », « cette citation existe réellement dans le texte source », « cet endpoint renvoie un 200 » — un contrôle où la machine peut trancher vrai/faux sans jugement humain.

Si elle le peut, branchez ce contrôle dans le slot de jugement de la boucle. La génération est faite par le LLM (elle peut rester probabiliste), mais seule une porte déterministe verrouille la réussite. Voilà le protocole central — le pouvoir de verrouiller l’achèvement n’appartient qu’à la machine. Le modèle peut entrer dans le vérificateur et soulever un doute, dire « revois ça », mais il ne peut pas décerner le « passé ». Asymétrie de pouvoir. Rendre la chose erronée impossible dès le départ.

Et c’est là que la magie opère. Quand la porte renvoie non pas réussite/échec mais un fait — « l’ancre who n’existe pas dans le texte source, corrige ici » — la complaisance du modèle se retourne soudain en atout. Pour les opinions, la complaisance est un poison (il dit « c’est fini » parce qu’on le lui demande), mais pour les faits, la complaisance est un remède. Plus un modèle est complaisant, plus il accepte docilement ce fait et resserre la tentative suivante. Porte déterministe + LLM complaisant = une boucle dont la convergence est garantie. Cette boucle qui divergeait se referme dès qu’on change un seul slot de jugement.

La boucle ne converge pas sans rênes

J’appelle cette case unique le Reins Engineering — non pas une clôture qui enferme la liberté de l’agent, mais des rênes qui le mènent jusqu’à destination. Si le Loop Engineering disait « concevez la boucle », ce qui rend cette boucle convergente, c’est le contrat déterministe branché dans le slot de jugement. Qu’on l’appelle ingénierie du vérificateur, ingénierie de l’évaluation ou ingénierie de la porte — la substance est unique. Le jugement de la boucle, c’est la machine qui le fait, pas le LLM.

Si vous voulez voir que ce n’est pas une abstraction mais du code qui compile, reins implémente cette case unique sous forme de framework — le cliquet (ratchet : une fois passé, irréversible), la porte (un catalogue de règles de défense anti-fromage) et la commande loop (le LLM génère, la porte juge, en cas d’échec le fait est réinjecté pour réessayer, et au-delà de MaxTries la terminaison est monotone). La boucle infinie de deux heures du matin devient une boucle qui connaît sa fin.

Si votre boucle diverge en ce moment, la question n’est pas « quel modèle utiliser ». C’est « qu’est-ce qui verrouille mon achèvement ? » Si c’est le modèle qui le verrouille, alors ce n’est pas verrouillé.

Articles liés

À lire aussi

La raison pour laquelle une boucle diverge — on a confié le jugement au générateur lui-même — et son ordonnance — ne confier le pouvoir de verrouiller l’achèvement qu’à une porte déterministe — ne sont pas un diagnostic qui n’appartiendrait qu’à moi. Des gens qui ne se connaissent pas sont arrivés à la même conclusion devant la même boucle de deux heures du matin. Voici les preuves de cette convergence indépendante.

  • ouroboros — « stopper les boucles d’agent infinies par une porte de convergence mathématique. » Une porte d’ambiguïté avant le démarrage du codage bloque la divergence précoce, et pendant l’évolution la convergence est jugée par la similarité entre générations. L’oscillation (cycles de période 2) est détectée comme pattern pathologique, et un hard cap de générations assure la terminaison monotone — la « rotation infinie » de ce texte et la terminaison monotone par MaxTries du loop de reins, transposées en seuils mathématiques.
  • proof-loop — « le vérificateur doit être une nouvelle session. L’agent qui a fait le changement ne juge pas s’il est terminé. » Il fige les critères d’acceptation avant l’implémentation, sépare le constructeur du vérificateur, et ne termine que lorsque tous les critères reçoivent un PASS à neuf. Une séparation des pouvoirs qui s’oppose de front à la « fausse convergence » de ce texte (l’élève qui corrige sa propre copie).
  • auto-re-agent — il branche, dans une boucle reverser/checker, un objective verifier (contrôle de structure call-count et control-flow) et un moteur de parité multi-signal (GREEN/YELLOW/RED). Il borne les tentatives par un nombre maximal de rounds pour couper la divergence. Ce n’est pas le jugement du LLM mais des règles qui verrouillent la réussite — la même intuition que la porte de reins.

Et la généalogie plus large de ce diagnostic — episteme, MagLab, Manifesto, oh-my-kamisama — est rassemblée dans la rubrique « À lire aussi » de reins. Le même mur, la même conclusion s’y alignent aussi.

Sources

  • Osmani, A. (2026). “Loop Engineering.” addyosmani.com/blog (2026-06-07). Blog — la source de la tendance « ne saisissez pas de prompt, concevez la boucle ». L’original de la citation « une boucle qui tourne sans surveillance échoue sans surveillance » reprise dans le corps du texte.
  • Hu, W. (2026). “From Agent Loops to Structured Graphs: A Scheduler-Theoretic Framework for LLM Agent Execution.” arXiv:2604.11378 — pointe les « unbounded recovery loops » (réessais infinis) comme faiblesse structurelle de l’Agent Loop et propose une garantie de terminaison formelle. Fondement du premier visage de la divergence, la « rotation infinie », et de la terminaison monotone.
  • Mohamed, A., Geng, M., Vazirgiannis, M., & Shang, G. (2025). “LLM as a Broken Telephone: Iterative Generation Distorts Information.” arXiv:2502.20258 — plus un modèle retraite ses propres sorties, plus la distorsion de l’information s’accumule progressivement. Soutient directement le deuxième visage de la divergence, la « dérive » (accumulation composée de l’erreur).
  • Bondarenko, A. et al. (2025). “Demonstrating Specification Gaming in Reasoning Models.” arXiv:2502.13295 — plus un modèle de raisonnement est capable, mieux il trouve les failles du contrôle. Fondement du troisième visage de la divergence, le « reward hacking ».
  • Helff, L. et al. (2026). “LLMs Gaming Verifiers: RLVR can Lead to Reward Hacking.” arXiv:2604.15149 — la fréquence des shortcuts croît avec la complexité de la tâche et le compute de raisonnement. Fondement quantitatif du fait que, sur une vérification molle, le reward hacking est proportionnel à la capacité.
  • Huang, J. et al. (2024). “Large Language Models Cannot Self-Correct Reasoning Yet.” ICLR 2024. arXiv:2310.01798 — l’auto-correction sans feedback externe n’améliore pas la performance et la fait même baisser. Fondement central de « si on juge soi-même son propre achèvement, on termine en étant faux » (fausse convergence).
  • Stechly, K., Valmeekam, K., & Kambhampati, S. (2024). “On the Self-Verification Limitations of Large Language Models.” arXiv:2402.08115 — l’auto-vérification n’améliore quasiment pas la performance. La raison pour laquelle le jugement PASS doit revenir à une porte déterministe.
  • Xu, W. et al. (2024). “Pride and Prejudice: LLM Amplifies Self-Bias in Self-Refinement.” arXiv:2402.11436 — quand on évalue soi-même ses propres sorties, le self-bias s’amplifie. Fondement de l’idée que le couplage générateur=juge accroît la dérive, et justification de la séparation du slot de jugement.
  • Sharma, M. et al. (2023). “Towards Understanding Sycophancy in Language Models.” arXiv:2310.13548 — la complaisance est une tendance générale des modèles RLHF, induite par le jugement de préférence humaine. Fondement des deux faces : la valeur par défaut qui répond « oui » à « c’est fini ? », et la complaisance devenue atout dans le feedback factuel.
  • Fanous, A. et al. (2025). “SycEval: Evaluating LLM Sycophancy.” AAAI/ACM AIES 2025. arXiv:2502.08177 — mesure du taux de capitulation par complaisance. Fondement quantitatif du mécanisme de convergence « pour les faits, la complaisance est un remède ».
  • Von Neumann, J. (1956). “Probabilistic Logics and the Synthesis of Reliable Organisms from Unreliable Components.” Automata Studies, Princeton University Press. — le principe de poser un protocole fiable (porte déterministe) sur des composants instables (LLM probabiliste). La prémisse de « génération probabiliste, réussite déterministe ».