IA agentique : comment fonctionne la boucle d'un agent

Le mot « agentique » s’est installé dans les annonces des éditeurs de logiciels, souvent sans explication. Derrière lui, il y a pourtant un mécanisme simple à décrire, et c’est ce mécanisme qui décide si un agent sera fiable ou seulement coûteux : la boucle. Ce guide de notre rubrique IA d’entreprise, privée et au juste coût la démonte pièce par pièce, puis montre deux boucles que nous faisons tourner nous-mêmes. Pour la définition d’un agent et ce qui le sépare d’un chatbot ou d’un workflow, commencez par Agent IA : ce que c’est, et ce que ce n’est pas.

En bref

• Un agent n’est pas un modèle plus intelligent : c’est un modèle placé dans une boucle, qui rassemble le contexte, agit, vérifie et recommence.
• La vérification fait la fiabilité, et des règles écrites valent mieux qu’un second modèle qui juge.
• Une boucle a toujours des freins : un nombre de tours, un budget, un critère de réussite, et l’arrêt quand elle bloque.
• Un agent n’a que les outils et les droits dont sa tâche a besoin, et un humain approuve ce qui engage l’entreprise.
• Chaque tour est un appel au modèle : une boucle bien conçue réserve le grand modèle aux étapes qui le demandent.

Qu’est-ce que l’IA agentique ?

On parle d’IA agentique quand un modèle de langage ne se contente plus de répondre à une demande, mais conduit lui-même une suite d’actions pour atteindre un but : chercher une information, appeler un logiciel, corriger ce qui n’a pas marché. Le mécanisme est moins mystérieux que le mot. Dans Building effective agents, publié en décembre 2024, Anthropic, l’éditeur des modèles Claude, décrit les agents comme, le plus souvent, « de simples modèles de langage qui utilisent des outils en fonction des retours de leur environnement, dans une boucle » (nous traduisons).

Ce qui change n’est donc pas le modèle, c’est ce qu’on lui laisse faire. Une IA générative classique produit une réponse et s’arrête. Un agent produit une action, regarde ce qu’elle a donné et s’en sert pour décider de la suivante. Toute la conception d’un système agentique tient dans la façon dont cette boucle est construite, freinée et surveillée.

Comment fonctionne la boucle d’un agent ?

En septembre 2025, en présentant son kit de développement d’agents, Anthropic résumait la boucle d’un agent (en anglais, l’agent loop) en quatre temps : rassembler le contexte, agir, vérifier le travail, recommencer. Prenons une demande simple, reçue par email : un client veut changer l’adresse de livraison de sa commande.

1. Rassembler le contexte. L’agent lit l’email, retrouve la commande dans le logiciel de gestion et regarde si elle est déjà partie. Il ne devine pas : il va chercher ce dont il a besoin, avec les outils qu’on lui a donnés.
2. Agir. Il modifie l’adresse, ou prépare la modification si l’action demande une validation.
3. Vérifier. Il relit la commande pour constater que l’adresse a bien changé, au lieu de supposer que l’appel a réussi.
4. Recommencer. Si la vérification échoue, parce que la commande est verrouillée ou l’adresse incomplète, il repart avec cette information : il tente une autre voie, pose une question ou s’arrête.

Le troisième temps est le plus important. Anthropic insiste, dans son texte de 2024, sur le fait qu’un agent doit obtenir à chaque étape une « vérité de terrain » de son environnement, comme le résultat d’un appel d’outil ou l’exécution d’un code, pour mesurer ses progrès. Une boucle agentique qui ne vérifie rien enchaîne des suppositions, et une erreur du premier tour se retrouve dans tous les suivants.

Comment un agent vérifie-t-il son propre travail ?

Il y a plusieurs façons de fermer la boucle, et elles ne se valent pas. L’article de septembre 2025 en distingue trois :

• Des règles écrites. « La meilleure forme de retour consiste à définir clairement des règles pour un résultat, puis à expliquer lesquelles ont échoué et pourquoi » (nous traduisons). Un format attendu, un champ obligatoire, un test qui passe ou non : la réponse est nette, et l’agent sait quoi corriger.
• Un retour visuel. Pour une interface ou un document mis en page, une capture d’écran permet de vérifier ce qu’un humain verrait.
• Un second modèle qui juge. Un modèle peut évaluer le travail d’un autre sur des critères plus flous, comme le ton d’un texte. C’est en général moins robuste, note Anthropic, et cela ajoute du temps de réponse.

Le texte de 2024 décrit la même idée sous le nom d’évaluateur-optimiseur : un appel au modèle produit une réponse, un autre l’évalue et renvoie ses remarques, en boucle. Ce schéma est surtout efficace, précise-t-il, quand les critères d’évaluation sont clairs et que chaque tour de correction apporte un gain mesurable. Autrement dit, si vous ne savez pas écrire ce qu’est un bon résultat, la boucle ne le saura pas mieux que vous.

Quand la boucle doit-elle s’arrêter ?

Une boucle sans fin n’est pas un agent plus travailleur : c’est une facture qui grossit et des erreurs qui s’additionnent. Anthropic note qu’il est courant d’ajouter des conditions d’arrêt, comme un nombre maximal d’itérations, pour garder le contrôle. Quatre freins se combinent :

• un nombre de tours au-delà duquel l’agent rend la main ;
• un budget par tâche, en appels au modèle ou en euros ;
• un critère de réussite écrit d’avance, que la vérification sait reconnaître ;
• l’arrêt sur blocage : quand l’agent ne peut plus avancer, il s’arrête et dit pourquoi, au lieu d’improviser.

Le principe vaut d’ailleurs hors de l’IA. Sur Palmora, une réparation de masse par API, lancée sans limite de débit, a produit 754 échecs ; relancée avec un débit limité et des reprises automatiques, elle a corrigé les 837 fiches visées. Ce n’était pas un agent, mais la leçon s’applique telle quelle : une boucle sans frein multiplie l’erreur au lieu de la corriger.

Quels garde-fous autour d’une boucle d’agent ?

Un agent agit avec les outils qu’on lui confie. Le risque ne tient donc pas seulement à ce qu’il écrit, mais à ce qu’il peut faire. L’OWASP, fondation à but non lucratif consacrée à la sécurité des logiciels, range ce risque dans son classement 2025 des dix principaux risques des applications de modèles de langage, sous le nom d’Excessive Agency : une autonomie excessive qui permet des actions dommageables en réponse à une sortie inattendue, ambiguë ou manipulée du modèle, quelle que soit la cause du dysfonctionnement. Il en désigne trois causes : trop de fonctions, trop de droits, trop d’autonomie.

Les parades qu’il recommande se lisent comme une liste de conception :

• ne donner à l’agent que les extensions strictement nécessaires à sa tâche ;
• réduire au minimum les droits de ces extensions sur les autres systèmes ;
• faire approuver par un humain les actions à fort impact avant qu’elles soient exécutées ;
• vérifier les autorisations dans les systèmes visés, plutôt que de laisser le modèle décider si une action est permise ;
• limiter le débit des actions, pour qu’un emballement reste petit.

Dans l’exemple de la commande, cela donne un agent qui peut lire les commandes et modifier une adresse, mais ni rembourser ni supprimer ; et un logiciel de gestion qui refuse de lui-même toute modification d’une commande expédiée, quoi qu’en pense l’agent.

Même logique pour ses clés d’accès : un agent n’a pas besoin de lire celles qu’il utilise. Un relais peut les ajouter au moment de l’appel, uniquement vers le service prévu, et le modèle ne les voit jamais passer. Nous détaillons ce principe dans notre article sur le coffre-fort de secrets.

Où se place l’humain dans la boucle ?

« Human in the loop », l’humain dans la boucle, ne veut pas dire un humain qui surveille chaque tour. Anthropic décrit des agents qui se mettent en pause pour obtenir un retour humain à des points de contrôle, ou quand ils rencontrent un blocage. L’OWASP, lui, demande une approbation humaine avant les actions à fort impact.

La bonne question est donc : quelle action est irréversible, ou engage l’entreprise ? C’est là que l’humain se place. Un agent qui demande une validation à chaque tour n’en est plus vraiment un ; un agent qui n’en demande jamais finira par publier, payer ou effacer ce qu’il n’aurait pas dû. Ce partage des rôles est développé dans notre article sur le rôle de l’humain face à l’IA.

Deux boucles que nous faisons tourner

Une boucle de contenu, chaque matin

Depuis début octobre 2026, une boucle prépare chaque matin des brouillons pour ce blog. Elle part d’une consigne écrite, toujours la même, et suit un ordre fixe : réparer avant de produire, trois articles au plus ; chercher les sujets qui manquent dans chaque rubrique ; rédiger deux brouillons au plus ; poser les liens entre articles ; améliorer une page d’offre sans toucher à ses prix. Ses vérifications sont des règles, pas des avis : un script contrôle chaque brouillon (vocabulaire, ponctuation, liens, structure), puis le site entier doit se construire sans erreur. Elle livre ses brouillons à relire, avec un rapport en trois parties : ce qui est fait, ce qui reste à décider, la prochaine itération.

Ses freins sont écrits dans la consigne : elle ne publie jamais, n’intègre jamais rien au site elle-même, et quand elle bloque, elle s’arrête et le dit. Le seul geste qui met un article en ligne est humain : relire, puis valider. Ce sont des choix de conception ; nous n’avons pas encore le recul pour en chiffrer le gain.

Un moteur SEO à quatre agents

Le référencement de ce site repose sur un autre montage. Chaque jour, un scan sans IA lit la Search Console de Google et dresse la file du travail. Chaque semaine, quatre agents (mots-clés, contenu, rafraîchissement, audit) y puisent ; l’audit fait ses contrôles techniques sur échantillon et passe avant l’écriture, et la passe livre au plus deux contenus, en brouillons. Sa première passe sans surveillance, le 30 août 2026, n’a rien produit : l’agent qui l’orchestrait a posé une question au lieu de trancher, et sans personne pour répondre, une question posée met fin à la passe. Sa consigne interdit depuis toute question en cours de route. Le détail de ce montage est dans notre guide sur l’agent IA en production, de la démo au produit.

Ce que coûte un tour de boucle

Chaque tour est un appel au modèle, et ce qu’il lit grandit à mesure que la boucle avance : le contexte rassemblé, les résultats des outils, les vérifications. Comme chaque tour relit en général ce qui précède, le coût d’une boucle augmente plus vite que son nombre de tours. Le calcul est détaillé dans notre guide sur le coût de l’IA en entreprise.

C’est pourquoi une boucle bien conçue ne confie pas chaque tour au même modèle. Vérifier un format ne demande aucune IA, trier une demande se fait avec un petit modèle, et le grand modèle n’intervient que là où il apporte quelque chose. Nous appliquons ce routage partout : sur Palmora, passer la traduction à un modèle d’IA adapté a divisé son coût par 60, et 95 % des segments sont servis depuis un cache, sans appel au modèle. C’est le principe de notre offre IA au juste coût : chaque tâche au modèle juste suffisant, avec un budget et des plafonds par usage.

Par où commencer

Avant de construire une boucle, regardez la tâche telle qu’elle se fait aujourd’hui : ce qui arrive, ce qui doit en sortir, qui le vérifie et ce qui serait grave en cas d’erreur. Si vous ne savez pas encore écrire ce qu’est un bon résultat, commencez par là, car c’est la condition pour que la vérification fonctionne. C’est aussi ce que nous faisons avant de recommander quoi que ce soit : regarder vos workflows, vos outils et ce qui s’intègre entre eux, les freins de l’équipe et ses besoins de formation. Notre audit de maturité numérique et IA sert à cela, avec un GO ou un NOGO écrit pour chaque chantier.

Questions fréquentes

Quelle différence entre IA agentique et IA générative ?

L’IA générative produit un contenu en réponse à une demande : un texte, une image, un résumé. L’IA agentique place un modèle génératif dans une boucle, avec des outils : il agit dans des logiciels, regarde le résultat de son action et décide de la suivante, jusqu’au but ou jusqu’à une limite. Le modèle peut être le même ; ce qui change, c’est qu’on lui laisse enchaîner les actions.

Que veut dire « human in the loop » ?

L’expression désigne un humain placé à des points précis de la boucle d’un agent, là où une décision engage : publier, payer, supprimer, écrire à un client. L’OWASP recommande une approbation humaine avant toute action à fort impact. L’humain n’a pas à surveiller chaque tour : il valide ce qui ne se rattrape pas, et il est prévenu quand l’agent bloque.

Combien de tours un agent doit-il faire avant de s’arrêter ?

Il n’existe pas de nombre universel : il dépend de la tâche et de ce que coûte un tour. Fixez un maximum dès la conception, avec un budget par tâche et un critère de réussite écrit d’avance. Si l’agent atteint la limite sans avoir réussi, il doit rendre la main avec ce qu’il a essayé, plutôt que continuer à dépenser.

Une boucle d’agent peut-elle tourner sans surveillance ?

Oui, à condition qu’elle ne puisse rien engager seule. Notre boucle de contenu tourne chaque matin sans personne pour la regarder, mais elle ne publie rien : elle livre des brouillons qu’un humain relit avant toute mise en ligne. Ce qui reste sous contrôle humain, ce sont les actions irréversibles ou qui engagent l’entreprise, et les blocages, que la boucle signale au lieu d’improviser.