En mars, la série sur l’IA se terminait sur une question ouverte : vers où va-t-on ? Six mois plus tard, une bonne partie de la réponse tient dans un mot qu’on entend partout, et dans une boucle qu’on peut écrire au tableau.

Commençons par retirer au mot son air de nouveauté. En intelligence artificielle, un agent est depuis longtemps une entité qui perçoit un environnement et agit sur lui¹. La définition est antérieure aux modèles de langage de plusieurs décennies : un thermostat y répond, un robot aspirateur aussi. Ce qui est nouveau n’est pas la notion. C’est ce qu’on a mis au milieu.

Ce qu’un modèle ne sait pas faire

Un modèle de langage ne fait qu’une chose : on lui donne du texte, il produit du texte.

Il n’a pas de mémoire d’une question à l’autre. Il n’agit sur rien. Il ne tourne pas entre deux sollicitations — entre vos deux questions, il n’existe pas plus qu’une fonction que personne n’appelle.

Un agent n’est donc pas un modèle plus puissant. La formule à retenir tient en une ligne :

L’agent, c’est la boucle. Pas le modèle.

La boucle

Elle a quatre temps, et le troisième est celui qu’on oublie systématiquement.

graph LR
    O[Objectif
+ historique] --> M[Modèle]
    M -->|réponse| F[Terminé]
    M -->|appel d'outil| X[Le programme
exécute l'outil]
    X -->|résultat ajouté à l'historique| O
    class M neutre
    class F ok

1. On donne au modèle l’objectif, l’historique de ce qui s’est passé, et la liste des outils dont il dispose.
2. Il produit soit une réponse — c’est terminé —, soit une demande d’outil.
3. Le programme, pas le modèle, exécute l’outil et ajoute le résultat à l’historique.
4. On recommence.

En pseudo-code, l’agent entier tient en dix lignes :

historique = [objectif]

tant que vrai :
    sortie = modèle(historique, outils_disponibles)

    si sortie est une réponse :
        renvoyer sortie

    résultat = exécuter(sortie.outil, sortie.arguments)
    historique.ajouter(sortie)
    historique.ajouter(résultat)

Le point important est à l’étape 3. Le modèle n’appelle rien : il produit du texte que le programme reconnaît comme une demande. Lire un fichier, lancer une commande, interroger une base — c’est du code ordinaire qui le fait, écrit par quelqu’un, avec les droits que ce quelqu’un lui a donnés.

Autrement dit : un agent ne peut faire que ce que ses outils permettent. Ni plus, ni moins.

Pourquoi ça marche mieux qu’on ne s’y attendrait

Ce qui a changé en six mois n’est pas que les modèles seraient devenus plus intelligents. C’est qu’on les a mis dans une position où ils se font corriger.

Un modèle qui écrit du code sans l’exécuter devine. Le même modèle, placé dans une boucle qui exécute et lui renvoie le message d’erreur, peut se reprendre. La boucle transforme une réponse unique en une recherche avec retour d’information — c’est l’idée que formalise l’article qui a donné son nom au motif, en alternant raisonnement et action².

Une conséquence directe, et utile si vous en construisez un : la qualité d’un agent dépend autant de ses outils que du modèle. Un outil qui renvoie une erreur claire rend l’agent meilleur ; un outil qui renvoie « échec » sans dire lequel le rend bête, quel que soit le modèle derrière.

Les quatre façons dont ça casse

C’est la partie qui vous servira le plus, parce que vous utilisez déjà ces outils et que les quatre pannes se reconnaissent à l’œil nu.

graph TD
    B1[Ne converge pas] -.-> M
    B3[Contexte qui déborde] -.-> M
    M[Modèle] -->|appel d'outil| X[Exécution]
    B2[Échec silencieux] -.-> X
    X -->|résultat| M
    M -->|réponse| F["« C'est fait »"]
    B4[Jamais vérifié] -.-> F
    class B1,B2,B3,B4 alerte
    class F attention

La boucle qui ne s’arrête pas. Rien, dans ce qu’on a écrit plus haut, n’assure qu’elle se termine. Le modèle peut retenter indéfiniment une approche qui échoue, avec de légères variations. Le plafond d’itérations n’est donc pas un réglage de confort : c’est la seule chose qui garantisse que le programme rende la main un jour.

L’outil qui échoue en silence. Une commande qui renvoie « ok » sans avoir rien fait produit, dans l’historique, un texte identique à celui d’une réussite. Le modèle n’a aucun moyen d’en douter : il ne voit pas le monde, il voit l’historique. Un outil qui ment rend l’agent incapable de le savoir.

Le contexte qui déborde. Tout l’historique est renvoyé au modèle à chaque tour, et il grossit à chaque tour. Passé une certaine taille, il faut le résumer — et un résumé jette précisément le détail dont on aura besoin trois étapes plus loin. D’où un comportement contre-intuitif : un agent devient moins bon à mesure que la tâche s’allonge, exactement l’inverse d’une personne qui s’imprègne d’un dossier.

Le rapport de succès qui n’en est pas un. Le dernier est le plus coûteux, et il découle de ce qu’est un modèle de langage : une machine à produire du texte plausible. Or « j’ai corrigé le bug » est du texte parfaitement plausible, que le bug soit corrigé ou non.

« C’est corrigé » est une phrase, pas une preuve.

La seule parade est un contrôle que l’agent n’a pas écrit lui-même : un test qui existait avant, une compilation, une page qu’on ouvre, quelqu’un qui relit. Tout ce qu’un agent exécute et évalue en même temps ne vous apprend rien — il vous rend compte de sa propre opinion sur son travail.

La question à garder

Vous allez utiliser ces outils tous les jours, et les prochains seront meilleurs que ceux d’aujourd’hui. Le réflexe utile n’est pas la méfiance de principe, qui fait perdre le bénéfice, ni la confiance, qui fait perdre le reste.

C’est une question, la même que devant n’importe quel système qui rend compte de lui-même :

Qu’est-ce qui aurait échoué si ça n’avait pas marché — et est-ce que ça a tourné ?

Si vous ne savez pas répondre, vous n’avez pas un résultat. Vous avez une phrase.

Références