Aller au contenu principal

Module 1 — Ce qu'un agent ajoute, et ce qu'il coûte

Le mot « agent » s'est mis à décrire à peu près tout ce qu'un grand modèle de langage peut faire. Ce cours commence par le remettre à sa place, parce que le choix entre un appel unique, une chaîne fixe et un agent n'est jamais neutre : chaque marche coûte des appels, du temps et des surprises.

Trois régimes, trois coûts​

Un appel simple est une seule requête vers le modèle. On lui passe un texte, on récupère un texte. Le coût est prévisible — un aller-retour, quelques centaines de millisecondes, un tarif que l'on peut multiplier par le nombre d'utilisateurs. La logique reste dans le code qui appelle : c'est vous qui décidez quoi faire du résultat.

Une chaîne enchaîne plusieurs appels dans un ordre décidé à l'avance. Résumer un document puis répondre à une question, ou reformuler une requête puis interroger une base vectorielle, sont des chaînes. Le nombre d'étapes est connu, et donc le coût aussi. La chaîne ne prend aucune décision structurelle — l'ordre est écrit, seuls les contenus varient.

Un agent, lui, décide à chaque étape ce qu'il va faire ensuite : appeler tel outil, relire un document, s'arrêter et répondre, réessayer autrement. Le nombre d'étapes n'est plus fixé par le code, il est fixé par le modèle. C'est cette délégation du contrôle qui définit un agent, pas la présence d'outils.

Cette différence a un prix. Un agent qui prend en moyenne huit étapes coûte huit fois un appel simple, plus la latence cumulée, plus une variance qui explose : un jour trois étapes, un autre vingt. On ne conçoit un agent en connaissant ce prix ; on ne le conçoit pas en imaginant qu'il sera « plus intelligent ».

Degrés d'autonomie​

Entre la chaîne rigide et l'agent complet, il existe une échelle qu'il vaut la peine de nommer. Aucune autonomie : l'humain écrit chaque étape. Autonomie de sélection : le modèle choisit un outil dans une liste courte mais la boucle est bornée à une étape. Autonomie de boucle : le modèle décide de continuer ou de s'arrêter, avec une limite d'itérations. Autonomie de plan : le modèle rédige son propre plan puis l'exécute. Autonomie de replanification : le plan est révisé en cours de route.

Plus l'autonomie monte, plus l'agent devient utile sur des tâches ouvertes, et plus il devient difficile à mesurer, à reproduire, à corriger. Le module 5 revient sur ce compromis, le module 7 pose les garde-fous, le module 8 catalogue ce qui casse.

Quand un agent est la mauvaise réponse​

Trois signaux orientent vers autre chose qu'un agent.

Le nombre d'étapes est connu à l'avance. Extraire un champ, résumer une pièce, traduire un texte : ce sont des chaînes. Un agent qui « décide » d'appeler l'unique outil disponible n'apporte rien qu'un peu de latence.

La tolérance aux erreurs est faible et le coût de vérification est élevé. Un agent qui envoie un courriel client, exécute une commande shell, met à jour une base : chaque décision doit être auditée par un humain avant de partir. Dans ces cas, l'agent n'est pas mauvais par nature, mais il doit être équipé de confirmations et de bacs à sable — c'est le contenu du module 7.

La question de l'utilisateur est mal cadrée. Un agent lancé sur « améliore mon site » ne peut que dériver. Le module 5 montre qu'un plan explicite négocié en amont vaut mieux qu'une autonomie totale : c'est le rôle de la décomposition.

Le fil rouge du cours​

L'agent que nous allons construire répond à des questions de recherche pour une équipe produit — par exemple « quels concurrents ont ajouté un tableau Kanban en 2025, avec quelle intégration Slack ? ». Il dispose d'un moteur de recherche web, d'un lecteur d'URL, d'une base interne de comptes rendus et d'un outil de rédaction de note.

C'est un bon cas parce qu'il est ouvert mais borné : le nombre de pages à lire n'est pas connu, mais le format de sortie l'est. Il est peu risqué : rien n'écrit dans un système extérieur. Et il est coûteux à vérifier : lire cinquante pages soi-même prend des heures, ce qui rend la comparaison avec un baseline humain lisible.

Chaque module suivant lui ajoute une brique. Le module 2 lui donne sa boucle, le module 3 ses outils. Nous verrons au module 10 que sur trente questions d'évaluation, l'agent trouve un taux de bonnes réponses honorable pour un coût moyen de trente-cinq centimes — mais que ce coût est fait de dix étapes en médiane et de deux étapes ou de vingt-cinq aux extrêmes. C'est ce chiffre qu'un agent ajoute et qu'il coûte, et c'est le sujet de tout le cours.

En résumé​

  • Un agent délègue au modèle le choix des étapes ; ce n'est ni la présence d'outils ni la longueur du prompt qui le définit.
  • Le coût d'un agent, c'est le nombre d'étapes multiplié par le prix d'un appel, plus la latence cumulée, plus une variance importante.
  • L'autonomie se dose : sélection, boucle, plan, replanification — chaque degré monte l'utilité et la difficulté de mesure.
  • On préfère un appel ou une chaîne quand les étapes sont connues, quand le coût de vérification est élevé, ou quand la question n'est pas cadrée.

Module suivant : la boucle qui rend un agent possible — observer, penser, agir, recommencer — en soixante lignes de Python.