Vous avez sûrement déjà vécu ça. Vous demandez un bout de code à une IA, elle vous le rend avec assurance, vous le collez, et il plante à la première ligne. Ou vous lui demandez un tableau de chiffres, elle vous le sort proprement formaté, et deux des totaux sont faux.
Le problème n'est pas que le modèle soit bête. Le problème, c'est qu'il n'a jamais essayé. Il a produit quelque chose qui ressemble à une bonne réponse, il vous l'a donnée, et il est passé à autre chose. Personne n'a lancé le code. Personne n'a refait l'addition.
C'est exactement la différence entre un chatbot et un agent. Et cette différence tient dans un mécanisme assez simple qu'on appelle la boucle d'agent, ou agent loop.
Répondre une fois, ou travailler jusqu'à ce que ce soit fait
Un chatbot fonctionne en un aller simple : vous parlez, il répond, terminé. Même s'il se trompe, il n'a aucun moyen de s'en rendre compte, parce qu'il n'a aucun contact avec le monde réel. Il ne peut ni ouvrir votre fichier, ni exécuter votre script, ni consulter votre base.
Un agent, lui, tourne. Il reçoit votre demande, il regarde ce qu'il a sous la main, il décide d'une action, il l'exécute avec un outil, il lit le résultat de cette action, puis il recommence en tenant compte de ce qu'il vient d'apprendre. Il continue comme ça, tour après tour, jusqu'au moment où il estime avoir terminé.
Si vous avez déjà regardé Claude Code travailler dans un terminal, vous avez vu cette boucle en direct : il lit trois fichiers, il modifie une fonction, il lance les tests, un test échoue, il retourne dans le fichier, il corrige, il relance. Ce n'est pas une animation décorative. Chaque ligne qui défile est un tour de boucle.
Rassembler, agir, vérifier
La boucle se décompose en trois gestes qui reviennent en permanence.
Rassembler. L'agent va chercher le contexte dont il a besoin au lieu qu'on le lui serve à l'avance. Il liste un dossier, ouvre les deux fichiers qui l'intéressent, cherche une occurrence dans le code, interroge une API. C'est un changement de mentalité important : on ne prépare plus un prompt monstrueux qui contient tout, on donne à l'agent les moyens d'aller se servir.
Agir. Modifier un fichier, lancer une commande, écrire en base, publier un article. Toute action passe par un outil, et l'agent ne dispose que des outils qu'on lui a donnés.
Vérifier. Relancer les tests, recharger la page, comparer le résultat à ce qui était attendu. C'est le geste qui fait toute la différence, et j'y reviens plus bas parce qu'il mérite sa propre section.
Puis on recommence, parce que le résultat de la vérification devient le point de départ du tour suivant.
Votre travail, quand vous montez un agent, ce n'est pas d'écrire la séquence des étapes. C'est de fournir de quoi rassembler, de quoi agir, de quoi vérifier. La séquence, l'agent la trouve tout seul, et elle change d'une exécution à l'autre selon ce qu'il rencontre.
Un tour, concrètement
Prenons une demande banale : « corrige les tests qui échouent dans le module d'authentification ».
Au premier tour, Claude lance la commande de test et lit la sortie : trois échecs. Deuxième tour, il ouvre le fichier source et le fichier de test pour comprendre. Troisième tour, il modifie le code, puis relance les tests, qui passent tous. Quatrième et dernier tour, il ne demande plus rien : il écrit simplement que le bug est corrigé et que les trois tests passent.
Quatre tours, dont trois avec appel d'outil. La boucle s'est arrêtée toute seule au moment où l'agent n'a plus eu besoin de rien.
Notez au passage que rien de tout ça n'était planifié à l'avance. Si les tests étaient passés du premier coup, il y aurait eu deux tours. Si la correction avait cassé autre chose, il y en aurait eu douze.
La mémoire se remplit, et la facture suit
Tout ce petit monde vit dans ce qu'on appelle la fenêtre de contexte : la mémoire de travail de la session. Elle ne se vide pas entre deux tours. Le prompt système, la définition des outils, votre demande, chaque réponse de l'agent, chaque commande lancée et chaque sortie de commande, tout s'empile.
Ça a deux conséquences très concrètes.
La première, c'est le coût. Comme chaque tour renvoie l'historique accumulé, une tâche de quarante tours ne coûte pas quarante fois un tour isolé, elle coûte nettement plus. Un fichier volumineux lu au tour 3 continue de peser au tour 30. Une partie de ce coût est amortie par un mécanisme de cache sur les éléments qui ne bougent pas d'un tour à l'autre, mais l'historique, lui, gonfle vraiment.
La seconde, c'est la limite physique. Une fenêtre de contexte a une taille maximale. Quand on s'en approche, le système résume automatiquement l'historique ancien pour libérer de la place : c'est ce qu'on appelle la compaction. Elle sauve les sessions longues, mais elle a un effet de bord qu'il vaut mieux connaître : une consigne donnée au tout début de la conversation peut disparaître dans le résumé. Si une règle doit tenir sur toute la durée, elle n'a rien à faire dans le prompt de départ, elle doit être réinjectée à chaque tour par un autre moyen.
Quand est-ce que ça s'arrête
La règle est courte : la boucle se termine au tour où l'agent répond sans appeler aucun outil. Pas d'appel d'outil, fin de partie.
Deux conséquences pratiques.
Si votre agent s'arrête trop tôt, ce n'est presque jamais de la mauvaise volonté. Soit il lui manque un outil pour aller plus loin, soit votre consigne ne dit pas clairement à quoi ressemble une tâche terminée. « Nettoie ce fichier » n'a pas de critère de fin. « Nettoie ce fichier, puis relance le script de contrôle jusqu'à ce qu'il ne signale plus aucune erreur » en a un.
Et si votre agent ne s'arrête jamais, ou pas assez vite à votre goût, il existe des garde-fous : on peut plafonner le nombre de tours, ou fixer un budget maximum en dollars au-delà duquel la session se coupe d'elle-même. Sur un agent qui tourne sans surveillance, c'est le genre de réglage qu'on met dès le premier jour.
L'étape que personne n'écrit dans son prompt
Sur les trois gestes de la boucle, rassembler et agir viennent naturellement. Vérifier, beaucoup moins. C'est pourtant le seul qui sépare un agent qui produit du plausible d'un agent qui produit du juste.
Il y a une nuance importante ici. Demander à une IA de « vérifier son travail » sans lui donner de quoi le faire ne sert à rien : elle va relire sa propre production, la trouver bonne, et vous annoncer que tout est en ordre. Elle n'a rien vérifié, elle s'est auto-évaluée dans le vide.
Une vraie vérification vient du monde extérieur. Un test qui tourne et qui renvoie vert ou rouge. Une page qu'on recharge et qu'on regarde. Une requête HTTP qui répond 200 ou 404. Un fichier qu'on rouvre pour compter les lignes. Le point commun de tout ça : le résultat ne dépend pas de l'avis de l'agent sur lui-même.
Quand le signal est binaire et reproductible, c'est l'idéal. Quand il ne peut pas l'être, par exemple pour juger le ton d'un texte, on peut faire évaluer la sortie par un second agent selon des critères explicites. C'est moins fiable qu'un test, mais infiniment mieux que rien.
La phrase qui change tout, dans une consigne d'agent, tient en une ligne : écris le code, lance les tests, corrige jusqu'à ce que tout passe. Elle transforme un assistant bavard en quelque chose qui livre. La boucle se charge du reste.
À quoi ça sert quand on n'est pas développeur
Trois exemples que je croise dans mon propre travail.
Un agent qui, avant de relayer un article sur les réseaux sociaux, va vérifier que la page est bien en ligne, qu'elle renvoie un code 200 et que l'illustration s'affiche. S'il manque quelque chose, il ne publie pas, il signale. La vérification est ici la fonction principale, pas un bonus.
Un agent qui relit une base de contenu et corrige les incohérences de statut : une ligne marquée « programmé » alors que la date est passée, une URL manquante, un visuel absent. Il lit, il compare, il corrige, il repasse pour contrôler.
Un agent qui construit un fichier de redirections lors d'une refonte de site, teste chaque ancienne URL une par une, et retourne réparer celles qui tombent en 404. Sur trois cents URL, c'est une soirée de travail humain, et c'est le genre de tâche où l'humain se lasse au bout de quarante lignes.
Aucun de ces trois exemples ne demande de savoir coder. Ils demandent de savoir décrire une tâche, choisir les bons outils, et surtout définir à quoi ressemble un résultat correct.
Et maintenant
La théorie s'arrête là, et honnêtement elle ne vaut pas grand-chose tant qu'on n'a pas regardé une boucle tourner sous ses yeux. C'est l'objet du prochain article : monter votre premier agent, d'abord sans écrire une seule ligne de code, puis en une quinzaine de lignes de Python quand vous aurez envie d'aller plus loin.
Avec, au passage, le moment le plus instructif de l'exercice : celui où on retire volontairement la vérification pour voir l'agent se planter avec aplomb.