Comment fonctionne un agent IA : un modèle de langage en boucle avec des outils

La boucle raisonnement – appel d’outil – résultat sur une vraie tâche portant sur les articles du site, trois approches et leur coût en tokens, pourquoi le contexte grandit, plan et mémoire, la fiabilité des tâches longues avec et sans vérification, et pourquoi un agent a besoin d’approbation.

11 minutes Matěj Žalmánek 2026-10-16

Série Bases de l’IA Partie 50 sur 52

1. Carte de l’intelligence artificielle : qu’est-ce qui est quoi et comment tout s’emboîte
2. Brève histoire de l’intelligence artificielle : de Turing aux modèles de langage
3. Données, modèle, entraînement, inférence : les notions de base sur un seul exemple
4. Lire la notation mathématique : symboles, indices, sommes et quantificateurs
5. Ensembles et relations : les briques dont sont faites les définitions en IA
6. Fonctions et applications : pourquoi tout modèle d’IA est une fonction
7. Logique et démonstrations : les règles selon lesquelles on raisonne en IA
8. Graphes et arbres : la structure sur laquelle reposent la recherche et les réseaux de neurones
9. Algèbre linéaire pour l’apprentissage automatique : vecteurs, matrices et pourquoi l’IA multiplie surtout
10. Dérivées, gradient et règle de dérivation en chaîne : comment un modèle sait dans quelle direction apprendre
11. Descente de gradient : comment un modèle apprend
12. Qu’est-ce que la probabilité : du lancer de dé aux axiomes de Kolmogorov
13. Probabilité conditionnelle et théorème de Bayes : comment réviser une estimation quand on apprend du nouveau
14. Variable aléatoire et fonction de répartition : une seule fonction qui dit tout de la loi
15. Fonction de densité et fonction de masse : pourquoi une variable continue a une probabilité nulle en chaque point
16. Espérance, variance et covariance : où se situe une loi, quelle est sa largeur et ce qui varie avec quoi
17. Panorama des lois de probabilité : Bernoulli, binomiale, Poisson, uniforme, normale et exponentielle
18. Loi des grands nombres et théorème central limite : pourquoi les moyennes sont si prévisibles
19. Statistique et estimation de paramètres : maximum de vraisemblance, MAP et intervalles de confiance
20. Théorie de l’information : entropie, entropie croisée et divergence KL — d’où viennent les fonctions de perte
21. Recherche dans l’espace d’états : BFS, DFS, UCS et A* en animations
22. Jeux et adversaires : minimax, élagage alpha-bêta et Monte Carlo tree search
23. Satisfaction de contraintes : backtracking, propagation de contraintes et AC-3 sur un sudoku et une carte des régions tchèques
24. Logique et systèmes à base de connaissances : chaînage avant et arrière, résolution et systèmes experts
25. Planification : STRIPS, monde des blocs, heuristiques par relaxation et planification dans les agents IA
26. Recherche locale et recuit simulé : un voyageur de commerce à travers les chefs-lieux de région tchèques
27. Algorithmes génétiques : population, croisement, mutation et sélection sur un sac à dos de randonnée
28. Stratégies d’évolution et programmation génétique : de la règle du cinquième à la loi de Kepler
29. Optimisation par colonies de fourmis : comment une piste de phéromone trouve un chemin court
30. Optimisation par essaim de particules : inertie, expérience propre et expérience de l’essaim
31. Neuroévolution : faire évoluer les poids et la forme des réseaux de neurones, et l’algorithme NEAT
32. Ensembles flous et fonctions d’appartenance : comment écrire « un peu chaud »
33. Logique floue et probabilité : pourquoi « un peu chaud » ne veut pas dire « probablement chaud »
34. Logique floue : t-normes, implications et règles SI–ALORS
35. Commande floue : Mamdani et Sugeno, du ventilateur au pendule inversé sur un chariot
36. Clustering flou : l’algorithme fuzzy c-means et les points entre les clusters
37. Systèmes neuro-flous (ANFIS) : des règles floues qui apprennent à partir des données
38. Chaînes de Markov : matrice de transition, distribution stationnaire et PageRank
39. Modèles de Markov cachés : l’algorithme de Viterbi et le casino malhonnête
40. Réseaux bayésiens : pourquoi l’herbe est mouillée et ce que cela implique pour l’arroseur
41. Le filtre de Kalman : comment estimer, à partir de mesures imprécises, où se trouve une voiture et à quelle vitesse elle roule
42. Types d’apprentissage automatique : supervisé, non supervisé, semi-supervisé et plus
43. Prompts, contexte et RAG : comment donner au modèle les bonnes informations
44. Autoencodeurs variationnels (VAE) : de nouvelles images à partir d’un espace latent continu
45. Réseaux antagonistes génératifs (GAN) : le faussaire contre le détective
46. Modèles de diffusion : comment une image naît du bruit pur
47. Processus de décision markoviens : états, actions, récompenses et équations de Bellman
48. Q-learning et DQN : apprendre la valeur des actions, du tableau au réseau de neurones
49. Policy gradient et PPO : apprendre directement la politique
50. Comment fonctionne un agent IA : un modèle de langage en boucle avec des outils
51. Programmer avec des agents IA : consigne, tests et vérification
52. Évaluation et sécurité des systèmes d’IA : comment mesurer et comment surveiller

Programme complet de la série 52 sur 83 sujets publiés

Un modèle de langage, à lui seul, ne fait que répondre : il reçoit du texte et renvoie du texte. Un agent est un modèle auquel on donne des mains — des outils avec lesquels il peut découvrir ou faire quelque chose — et qu’on laisse travailler en boucle jusqu’à ce qu’il ait terminé la tâche. C’est ainsi que fonctionnent les agents de programmation, qui lisent du code, lancent des tests et corrigent des bugs tout seuls, et les assistants qui cherchent sur le web. Et c’est ainsi que fonctionne aussi l’agent que vous pilotez depuis votre téléphone avec coden. Dans cette partie, nous démontons la boucle sur une vraie tâche et calculons ce qu’elle coûte et où elle casse.

Elle fait suite aux parties Prompts, contexte et RAG, Tokenisation et Processus de décision markoviens.

1. Un modèle dans une boucle

Définition — agent IA

Un agent est un programme dans lequel un modèle de langage, de manière répétée, (1) reçoit la tâche et le déroulement jusque-là, (2) décide de la suite — appeler un outil ou répondre —, (3) le programme hôte exécute réellement l’outil et ajoute le résultat au contexte. La boucle se termine quand le modèle écrit une réponse finale ou que le budget d’étapes est épuisé. L’alternance du raisonnement et de l’action a été décrite par Shunyu Yao et al. (2022) sous le nom de ReAct (reason + act).

v_k = M(c_k),   c_k+1 = c_k ⊕ v_k ⊕ N(v_k)

c_k

le contexte avant le k-ième appel du modèle : le prompt système, la tâche et tout ce qui s’est passé jusque-là. C’est tout l’« état » de l’agent — le modèle ne retient rien d’autre

M

le modèle de langage ; à partir du contexte, il écrit l’étape suivante. La seule partie qui « réfléchit », et la seule à laquelle on ne peut pas faire entièrement confiance

v_k

l’étape du modèle : raisonnement et appel d’outil, ou réponse finale (la boucle se termine alors)

N(v_k)

le résultat de l’outil, calculé par le programme hôte ; il ajoute au contexte ce que le modèle ne peut pas savoir par lui-même (le contenu d’un fichier, la sortie des tests)

kontext = [prompt système, description des outils, tâche]
for k = 1 … K_max:                       # budget d’étapes
    krok = model(kontext)                # lit TOUT le contexte
    kontext += krok
    if krok est la réponse finale: return cette réponse
    if l’outil exige un accord et l’humain ne l’a pas donné:
        kontext += "refusé"; continue
    výsledek = proveď(krok.nástroj, krok.parametry)   # programme hôte
    kontext += výsledek
return "budget d’étapes épuisé"

2. Outils

Définition — appel d’outils (tool use, function calling)

On insère dans le prompt une description des outils : le nom, à quoi sert l’outil et quels paramètres il a (en général sous forme de schéma JSON). Le modèle est affiné pour savoir renvoyer, au lieu d’un texte ordinaire, un appel structuré, par exemple {"nastroj": "hledej", "text": "KL divergence"}. Le programme hôte vérifie l’appel, l’exécute et renvoie le résultat comme un message de plus. Le modèle lui-même ne lance rien — il écrit seulement ce qu’il faut lancer.

Notre agent travaille sur les textes de 21 articles plus anciens de ce site (les mêmes que dans les parties sur la tokenisation et le RAG ; ils sont en tchèque, donc l’agent travaille lui aussi en tchèque) et dispose de trois outils. Tout son prompt système compte 157 tokens :

Jsi agent, který odpovídá na otázky podle článků webu. Máš nástroje:
- seznam(): Vypíše články a jejich délku ve znacích.
- hledej(text, max): Najde výskyty textu ve všech článcích; vrátí článek, pozici a okolí.
- cti(clanek, od, do): Vrátí úsek článku od pozice do pozice (znaky).
V každém kroku napiš krátkou úvahu a zavolej jeden nástroj, nebo napiš konečnou odpověď s odkazem na článek. Když něco nenajdeš, zkus jiný dotaz.

Les vrais outils des agents de programmation sont similaires : chercher dans des fichiers, lire un passage d’un fichier, le modifier, lancer une commande dans le terminal. Depuis 2024, on peut aussi brancher des outils via le protocole commun MCP (Model Context Protocol), si bien que le même outil — une base de données, un agenda, un navigateur — peut être utilisé par n’importe quel agent.

3. Une question, trois approches

La question : « Pourquoi la divergence KL n’est-elle pas une distance ? Donne un exemple tiré des articles. » (dans l’original : « Proč KL divergence není vzdálenost? Uveď příklad z článků. »). La réponse se trouve dans l’article sur la théorie de l’information : la divergence KL n’est pas symétrique, D_KL(0,7 ‖ 0,5) = 0,119, mais D_KL(0,5 ‖ 0,7) = 0,126. Les étapes de l’agent, nous les avons écrites à la main — nous avons écrit les raisonnements et les appels à la place du modèle. Les outils, leurs résultats et les tokens sont en revanche réels.

Exemple — pourquoi D_KL(0,7 ‖ 0,5) ≠ D_KL(0,5 ‖ 0,7)

Pour deux distributions oui/non (pluie avec probabilité p, le modèle dit q), D_KL(p ‖ q) = p log₂(p/q) + (1 − p) log₂((1 − p)/(1 − q)) bits.

D_KL(0,7 ‖ 0,5) = 0,7 · log₂ 1,4 + 0,3 · log₂ 0,6 = 0,340 − 0,221 = 0,119.

D_KL(0,5 ‖ 0,7) = 0,5 · log₂(5/7) + 0,5 · log₂(5/3) = −0,243 + 0,368 = 0,126.

À chaque fois, on fait la moyenne selon une autre distribution (selon celle qui est la réalité), c’est pourquoi échanger les arguments donne un autre nombre — et une distance (une métrique) doit être symétrique. C’est la réponse que l’agent cherche.

1. Je cherche exactement les mots de la question.

   hledej(text: "KL divergence není metrika")

   nic nenalezeno

   +34 tokens, contexte 209

2. Rien. J’essaie juste le nom de la notion.

   hledej(text: "KL divergence")

   5 výskytů:
   informace:3258: … minimum je tam, kde model říká pravdu. KL divergence Definice — Kullbackova–Leiblerova diver…
   informace:3656: …,222 bitu. Podle Gibbsovy nerovnosti je KL divergence vždy nezáporná a nulová jen pro q = p .…
   informace:3717: …záporná  … (encore 310 caractères)

   +205 tokens, contexte 414

3. C’est dans l’article informace. Je lis les alentours.

   cti(clanek: "informace", od: 3660, do: 3960)

   ivergence vždy nezáporná a nulová jen pro q = p . Pozor, KL divergence není vzdálenost: není symetrická. D KL (0,7 ‖ 0,5) = 0,119, ale D KL (0,5 ‖ 0,7) = 0,126. Záleží na tom, co je skutečnost a co model. Informační zisk Definice — podmíněná entropie H ( Y | X … (encore 40 caractères)

   +146 tokens, contexte 560

Trois appels d’outils, et le quatrième appel du modèle écrit la réponse. La première recherche ne trouve rien — les mots de la question ne sont pas dans le texte. L’agent le voit et essaie une requête plus générale ; c’est l’avantage de la boucle sur une recherche unique. À la fin, le contexte compte 560 tokens.

1. Je ne sais pas où c’est. Je parcours les articles l’un après l’autre.

   cti(clanek: "co-je-pravdepodobnost")

   Jazykový model nevybírá další slovo, ale pravděpodobnosti všech slov. Klasifikátor neříká „je to kočka“, ale „s pravděpodobností 0,93 je to kočka“. Celé strojov … (encore 7 175 caractères)

   +1 933 tokens, contexte 2 108

2. Pas ici, article suivant.

   cti(clanek: "csp")

   Rozvrh hodin, ve kterém žádný učitel neučí dvě třídy naráz. Sudoku. Rozmístění součástek na desce, směny v nemocnici, přidělení letadel k branám. Všechny tyhle  … (encore 11 914 caractères)

   +3 148 tokens, contexte 5 256
3. … encore 8 étapes du même genre (contexte à la fin : 24 927 tokens)

Sans recherche, l’agent parcourt les articles dans l’ordre alphabétique. Il ne tombe sur la réponse qu’au 10^e article, et le contexte a entre-temps grossi jusqu’à 24 927 tokens.

Et la troisième approche, le RAG en une passe de la partie précédente : retrouver les trois passages les plus similaires et les insérer dans le prompt. Les trois passages proviennent du bon article (informace, informace, informace), mais aucun ne contient l’exemple avec les nombres 0,119 et 0,126 — la réponse serait sans exemple. Un agent en boucle peut se dire « ça ne suffit pas, je continue à lire ». Une recherche unique, non.

4. Le contexte coûte cher

Définition — le coût de la boucle

Le modèle n’a pas de mémoire entre les appels ; à chaque étape, il relit tout le contexte — le prompt système, la tâche et toutes les étapes et tous les résultats d’outils jusque-là. Si c_k est la longueur du contexte avant le k-ième appel, le modèle traite au total ∑_k c_k tokens. Comme le contexte grandit à chaque étape, le coût total croît à peu près comme le carré du nombre d’étapes.

L’approche « tout lire » coûte 141 820 tokens traités, « chercher et lire un extrait » seulement 1 358 — 104 fois moins, pour la même réponse. C’est pourquoi les bons agents de programmation cherchent d’abord (grep) et ne lisent que des morceaux de fichiers. Et c’est pourquoi une longue session est de temps en temps compactée : la partie la plus ancienne de la conversation est remplacée par un résumé, pour que le contexte tienne et que le modèle ne s’y perde pas. La mise en cache du début du prompt (prompt caching) aide aussi : relire le même début est alors facturé moins cher.

Z = ∑_k=1^K c_k,   c_k = c₁ + ∑_j<k (v_j + o_j)

Z

le total des tokens traités — ce qu’on paie et ce qu’on attend

K

le nombre d’appels du modèle (étapes avec outil + réponse finale) ; chaque appel relit le contexte depuis le début

c₁

le prompt système et la tâche ; ils sont dans le contexte dès le premier appel, donc payés K fois — c’est pourquoi il vaut la peine de les garder courts et de les mettre en cache

v_j + o_j

les tokens ajoutés par l’étape j : l’appel et le résultat de l’outil. L’étape j est relue dans tous les appels ultérieurs, c’est pourquoi un long résultat d’outil se paie de nombreuses fois

Théorème — le coût croît comme le carré du nombre d’étapes

Si chaque étape ajoute le même nombre d de tokens, alors c_k = c₁ + (k − 1) d et

Z = K c₁ + d · K(K − 1) / 2.

Démonstration : ∑_k=1^K (k − 1) = 0 + 1 + … + (K − 1) = K(K − 1) / 2. ∎ Pour K grand, le second terme ≈ d K² / 2 l’emporte : une session deux fois plus longue coûte environ quatre fois plus.

Exemple — recalcul des deux approches

Chercher et lire un extrait. Le prompt système compte 157 tokens, la question 18, donc c₁ = 175. Après les trois étapes, le contexte compte 209, 414, 560 tokens. Les quatre appels du modèle lisent Z = 175 + 209 + 414 + 560 = 1 358 tokens.

Tout lire. K = 11 appels, le contexte passe de 175 à 24 927 tokens, en moyenne de d = (24 927 − 175) / 10 ≈ 2 475 par étape. D’après le théorème, Z ≈ 11 · 175 + 2 475 · 11 · 10 / 2 = 138 050 ; en réalité, c’est 141 820 (les articles n’ont pas la même longueur, donc les étapes n’ajoutent pas exactement la même quantité). Le prompt système avec la question n’en représente que 1 925 tokens — presque tout le reste est la relecture des articles.

5. Plan et mémoire

Définition — planification et mémoire de l’agent

Un plan est une liste d’étapes que l’agent écrit au début dans son contexte, puis coche et ajuste au fur et à mesure. La mémoire de travail est le contexte d’une seule session. La mémoire à long terme, ce sont des fichiers ou des bases de données hors du modèle — des notes que l’agent écrit et relit à la session suivante. Les sous-agents reçoivent un contexte séparé pour une sous-tâche et ne renvoient que le résultat, si bien qu’ils n’encombrent pas le contexte principal de détails.

Chez les agents de programmation, la mémoire à long terme est en général un simple fichier texte dans le projet (règles, commandes, points d’attention) que l’agent lit au début de chaque session. C’est la mémoire la plus simple et la plus transparente : un humain peut la lire et aussi la corriger.

6. Tâches longues et vérification

Un agent qui fait la bonne étape dans 90 % des cas a l’air fiable. Seulement, une tâche se compose de nombreuses étapes, et une erreur dans n’importe laquelle la gâche. Si une étape réussit avec la probabilité p, toute la tâche de n étapes réussit avec la probabilité pⁿ — tant que l’agent ne reconnaît pas ses erreurs.

Définition — boucle fermée avec rétroaction

Après une étape, l’agent vérifie le résultat (lance les tests, lit la sortie d’une commande, compare avec ce qui était attendu). S’il reconnaît une erreur avec la probabilité d et peut répéter une étape jusqu’à r fois, le taux de réussite d’une étape est q = p ∑_k=0^r ((1 − p) d)^k et celui de toute la tâche qⁿ.

q = p ∑_k=0^r ((1 − p) d)^k = p + p (1 − p) d + p ((1 − p) d)² + …

p

la tentative réussit ; chaque terme se termine par exactement une tentative réussie

1 − p

la tentative échoue ; chaque échec avant le succès coûte un tel facteur

d

la vérification reconnaît l’échec ; c’est seulement alors que l’agent répète l’étape — une erreur non reconnue passe et gâche la tâche

∑_k=0^r, k

k = combien de tentatives ont échoué avant qu’une réussisse ; au plus r répétitions, pour que l’agent n’essaie pas indéfiniment

Avec p = 0,9 et vingt étapes, seules 12 % des tâches réussissent sans vérification, et 79 % avec. Une simulation de 20 000 tâches donne 12 % et 79 % : la formule colle. Même une très bonne étape (p = 0,99) échoue, sur cent étapes sans vérification, plus souvent qu’elle ne réussit (37 %) ; avec vérification, elle réussit dans 90 % des cas. C’est la raison principale pour laquelle les agents de programmation fonctionnent si bien : le code peut être exécuté et testé, si bien que presque chaque étape reçoit un retour. L’organisation METR (2025) mesure que la longueur des tâches que les agents réussissent une fois sur deux double à peu près tous les sept mois.

Exemple — p = 0,9, d = 0,9, r = 2, vingt étapes

Taux de réussite d’une étape : q = 0,9 + 0,9 · 0,1 · 0,9 + 0,9 · (0,1 · 0,9)² = 0,9 + 0,081 + 0,00729 = 0,98829.

Toute la tâche : sans vérification 0,9²⁰ = 0,122, avec vérification 0,98829²⁰ = 0,790. L’étape ne s’est améliorée que de 90 % à 98,8 %, mais la tâche de 12 % à 79 % — la puissance n amplifie les petites différences d’une étape.

Définition — la longueur de tâche qu’un agent réussit une fois sur deux

C’est le plus grand n pour lequel qⁿ ≥ 1/2, c’est-à-dire n_½ = ln 0,5 / ln q ≈ 0,69 / (1 − q) pour q proche de 1.

Dans notre modèle : p = 0,9 sans vérification 6,6 étapes, avec vérification 58,8 ; p = 0,99 sans vérification 69,0, avec vérification 686. La tâche qu’un agent réussit une fois sur deux s’allonge à peu près en proportion du nombre de fois que baisse le taux d’erreur d’une étape 1 − q.

METR mesure la même grandeur (la longueur de tâche qu’un agent réussit dans 50 % des cas) — mais pas en étapes : en temps que la tâche prendrait à un humain (Thomas Kwa et al., Measuring AI Ability to Complete Long Tasks, 2025). Notre formule est un modèle simplifié à étapes indépendantes, pas leur méthode.

7. Autorisations et supervision

Un agent qui a le droit de lancer des commandes peut aussi faire des dégâts — par erreur (il supprime le mauvais dossier) ou sur une instruction qu’il a lue dans un texte tiers (prompt injection). La défense ne repose pas sur le modèle, mais sur le programme hôte : des outils aux droits limités, une exécution dans un environnement isolé, et surtout l’approbation — les étapes dangereuses ou irréversibles ne sont exécutées qu’après l’accord d’un humain. C’est aussi le principe de coden : l’agent travaille sur votre ordinateur et vous approuvez ses étapes depuis votre téléphone.

8. Résumé

• Agent = un modèle de langage en boucle : raisonnement, appel d’outil, résultat dans le contexte, et on recommence.
• Le modèle ne fait que décrire les outils par un appel structuré ; c’est le programme hôte qui les lance, et il peut imposer des règles.
• Une boucle peut rattraper une recherche infructueuse — le RAG en une passe, non.
• Chaque appel relit tout le contexte : « tout lire » a coûté 141 820 tokens, « chercher et lire un extrait » 1 358.
• Un plan, des notes dans des fichiers et des sous-agents gardent le contexte petit et lisible.
• Sans vérification, le taux de réussite baisse avec la longueur de la tâche comme pⁿ ; les tests et la vérification changent cela (20 étapes avec p = 0,9 : 12 % → 79 %).

Envie d’essayer par vous-même ? Demandez à un agent IA de vous décrire chaque appel d’outil qu’il fait pendant une tâche et, à la fin, d’estimer combien de tokens la tâche lui a coûté. Donnez-lui ensuite la même tâche avec la consigne « cherche d’abord, ne lis que des extraits ».

Vous voyez les choses autrement ? Écrivez à support@coden-app.com.