Open · gratuit

Agents IA : comment ils fonctionnent vraiment

Du modèle qui répond au système qui agit, et que l’on peut mettre en production

Intermedio10 chapitres2 heures de lectureattestation inclusemis à jour le

Un cours écrit complet sur les agents IA, indépendant de tout fournisseur ou framework : ce qui distingue un agent d’un chatbot et d’un workflow automatisé, comment fonctionne la boucle qui le fait tourner, comment concevoir les outils par lesquels il agit, comment gérer la mémoire, le contexte et les tâches longues, quand plusieurs agents aident et quand ils compliquent les choses, comment évaluer un agent sur des cas réels et comment le protéger des permissions excessives et de l’injection de prompt. Le dernier chapitre explique pourquoi tant de projets s’arrêtent avant la production et ce qu’il faut pour y arriver. La réussite de l’épreuve finale donne droit à une attestation de suivi accompagnée d’un Open Badge vérifiable.

Ce que vous apprendrez7 objectifs
  • Distinguer un agent d’un chatbot et d’un workflow automatisé, et choisir quand un agent est vraiment nécessaire
  • Décrire la boucle agentique — observer, décider, agir, vérifier — et les choix de conception qu’elle contient
  • Concevoir des outils avec des descriptions claires, la bonne granularité, des résultats compacts et des erreurs qui permettent à l’agent de se corriger
  • Gérer le contexte, la mémoire et les tâches longues grâce au compactage, à la récupération à la demande, aux plans explicites et à l’état externe
  • Juger quand plusieurs agents aident et quand ils n’ajoutent que du coût et des pertes d’information
  • Construire une évaluation sur des cas réels qui mesure le résultat et le parcours et protège contre les régressions
  • Réduire le risque grâce au moindre privilège, aux défenses contre l’injection de prompt et à des confirmations humaines bien conçues

Prérequis

  • Avoir déjà utilisé un assistant conversationnel fondé sur un modèle de langage
  • Une familiarité de base avec des notions comme les API, le JSON et les tests logiciels : on n’écrit pas de code pendant le cours
  • Inutile de connaître le Model Context Protocol ou un framework d’agents : là où ils comptent, le cours les présente

Chapitre 01

Ce qui fait d’un système un agent

Un modèle de langage qui répond à une question produit du texte et s’arrête. Un workflow automatisé exécute une séquence d’étapes décidée par celui qui l’a écrit : à un moment donné, il appelle peut-être un modèle pour classer un e-mail ou résumer un document, mais l’ordre des opérations est figé dans le code. Un agent, en revanche, choisit lui-même l’étape suivante en fonction de ce qu’il observe, utilise des outils pour agir et continue jusqu’à ce qu’il estime l’objectif atteint, ou jusqu’à ce que quelque chose l’arrête.

La différence n’est pas une affaire de vocabulaire, elle est pratique : elle change qui décide. Dans un workflow prédéfini, chaque chemin possible a été prévu par un développeur, et le comportement peut donc être vérifié à l’avance, branche par branche. Dans un agent, le chemin émerge pendant l’exécution : la même tâche, confiée deux fois, peut être résolue par deux séquences d’étapes différentes. C’est plus souple et, pour la même raison, moins prévisible. Impossible d’avoir la première propriété sans payer la seconde ; on peut seulement décider combien la payer.

Entre les deux extrêmes s’étend un spectre, et il est utile d’en connaître les échelons. On peut enchaîner plusieurs appels au modèle dans un ordre fixe, chacun avec sa propre tâche. On peut ne laisser au modèle que le choix de la branche — cette demande va-t-elle au support technique ou à la comptabilité ? — en gardant tout le reste fixe. On peut lancer plusieurs appels en parallèle et comparer leurs résultats. Ce n’est qu’au dernier échelon que le modèle décide aussi du nombre d’étapes et des outils à utiliser. Chaque échelon ajoute de l’autonomie et, avec elle, des cas que personne n’a prévus.

Il en découle un critère de choix net. Si le processus est stable et que les étapes peuvent être énumérées, un workflow prédéfini est plus simple, moins cher, plus rapide et plus facile à vérifier. L’agent se justifie quand les cas sont trop variés pour être prévus un par un : une demande d’assistance qui peut nécessiter trois recherches ou aucune, une correction de code dont on ne connaît pas l’étendue à l’avance. Recourir à un agent là où un workflow suffirait est une erreur fréquente et coûteuse, car on paie une imprévisibilité dont on n’avait pas besoin. L’erreur inverse — enfermer dans un workflow rigide un problème réellement ouvert — produit une cascade de cas particuliers que, tôt ou tard, plus personne ne parvient à maintenir.

Un exemple concret aide à fixer l’idée. Un agent de code comme Claude Code, auquel Rinoova Academy consacre un cours à part, reçoit une demande comme « corrige le test qui échoue » : il lit les fichiers qu’il juge pertinents, modifie le code, lance les tests, regarde le résultat et décide s’il a terminé ou s’il doit réessayer. Personne n’a écrit cette séquence à l’avance. Tout le reste de ce cours porte précisément là-dessus : comment cette boucle est construite, ce dont elle a besoin pour bien fonctionner et ce dont ont besoin ceux qui la construisent pour pouvoir lui faire confiance.

Chapitre 02

La boucle agentique : observer, décider, agir, vérifier

Sous n’importe quel agent, aussi sophistiqué soit-il, se trouve une boucle simple. Le modèle reçoit un contexte : l’objectif, les instructions, les outils disponibles et l’historique de ce qui s’est passé jusque-là. À partir de ce contexte, il produit une décision : donner une réponse finale, ou appeler un outil avec certains paramètres. Le code qui entoure le modèle — souvent appelé harness, ou environnement d’exécution de l’agent — exécute réellement l’appel, récupère le résultat et l’ajoute au contexte. Puis tout recommence. Le modèle n’exécute rien lui-même : il propose des actions, et quelque chose d’autre les exécute.

La boucle agentique réduite à l’essentiel, en pseudo-code. Chaque ligne cache un choix de conception.python
def run_agent(goal, tools, max_steps=20):
    context = [system_instructions, goal]
    for step in range(max_steps):
        decision = model(context, tools)          # observe + decide
        if decision.is_final_answer:
            return check(decision, goal)          # verify before declaring done
        result = execute(decision.tool, decision.args)  # act: the harness runs it
        context.append(decision)
        context.append(result)                    # the next observation
    return stop("step limit reached", context)

Ces dix lignes contiennent déjà presque tous les choix qui comptent. Ce qui entre dans le contexte initial. Quels outils sont disponibles et comment ils sont décrits. Combien d’étapes sont autorisées avant l’arrêt. Ce qui se passe quand un outil échoue. Et surtout, qui décide que le travail est terminé. La limite d’étapes, en particulier, n’est pas un détail : un agent sans plafond explicite peut tourner à vide, en répétant le même appel ou en oscillant entre deux stratégies, et chaque tour coûte du temps et de l’argent.

Les quatre phases n’ont pas le même poids. Observer, c’est avoir dans le contexte les bonnes informations, ni trop ni trop peu : c’est le sujet du chapitre sur la mémoire. Décider est le travail du modèle, et c’est la partie sur laquelle on a le moins de contrôle direct : on l’influence par les instructions, les exemples et des outils bien décrits. Agir passe toujours par les outils, qui sont votre propre code et donc la partie la plus maîtrisable du système. Vérifier est la phase que les prototypes sautent le plus souvent, et c’est elle qui sépare un agent utile d’un agent qui se déclare satisfait trop tôt.

La meilleure vérification est celle qui ne dépend pas de l’opinion du modèle sur lui-même. Un agent de code qui lance les tests après une modification dispose d’un signal objectif ; un agent qui se contente de relire son travail et de le juger bon en a un bien plus faible. Quand il existe un contrôle mécanique — un test, une validation par rapport à un schéma, la comparaison avec un total connu, le code de sortie d’une commande —, mieux vaut le donner à l’agent sous forme d’outil et lui demander explicitement de l’utiliser avant de conclure. Quand il n’en existe pas, le contrôle peut être confié à un second passage du modèle avec des instructions différentes, ou à une personne.

Enfin, la boucle doit savoir s’arrêter proprement. Les sorties légitimes sont au nombre de trois : objectif atteint et vérifié ; objectif inatteignable avec les outils et les informations disponibles, dit clairement ; limite atteinte — d’étapes, de temps ou de coût — avec un compte rendu de ce qui a été fait et de ce qui manque. Un agent qui, au lieu de s’arrêter, invente un résultat pour boucler la tâche est plus dangereux qu’un agent qui abandonne. Les instructions doivent dire explicitement que « je n’y suis pas arrivé, et voici pourquoi » est une réponse acceptable, et le code autour doit la traiter comme telle.

Chapitre 03

Les outils : comment un agent agit

Un agent n’agit sur le monde qu’à travers les outils que vous mettez à sa disposition : interroger une base de données, appeler une API, lire ou écrire un fichier. Chaque outil a un nom, une description et un schéma de paramètres, généralement exprimé en JSON Schema, et c’est en lisant précisément ces trois éléments que le modèle choisit lequel utiliser et avec quels arguments. Il ne voit pas le code qui se trouve derrière, ne sait pas comment il est implémenté, ne connaît pas les cas particuliers que vous avez gérés : il ne voit que ce que vous lui écrivez.

Une définition d’outil sous la forme utilisée par MCP : nom, description, schéma des paramètres. D’autres API nomment les champs un peu différemment, mais le fond est le même.json
{
  "name": "search_orders",
  "description": "Search a customer's orders by customer ID and optional date range. Returns at most 20 orders, newest first, with ID, date, status and total. Does not return line items: use get_order for those.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "customer_id": {
        "type": "string",
        "description": "Customer ID, e.g. C-10482. Not the email address."
      },
      "from_date": { "type": "string", "format": "date", "description": "Inclusive start date, YYYY-MM-DD." },
      "to_date": { "type": "string", "format": "date", "description": "Inclusive end date, YYYY-MM-DD." }
    },
    "required": ["customer_id"]
  }
}

D’où une conséquence qui surprend ceux qui viennent du développement traditionnel : la description d’un outil est du code à part entière. Celle de l’exemple dit ce que fait l’outil, ce qu’il renvoie, combien de résultats et dans quel ordre, ce qu’il ne fait pas, et vers quel autre outil se tourner dans ce cas. Les paramètres ont eux aussi leur description : « pas l’adresse e-mail » prévient une erreur que l’on découvrirait sinon en production. Une description ambiguë produit des appels erronés aussi sûrement qu’un mauvais type produit une erreur de compilation, et elle mérite le même soin : on l’écrit, on la relit, on la versionne.

Les outils se répartissent, en gros, en deux familles qu’il vaut mieux garder séparées. Les outils de lecture — rechercher, consulter, lister — ne changent rien dans le monde, et une mauvaise utilisation coûte au pire une étape perdue. Les outils d’écriture — créer, modifier, envoyer, supprimer — ont des effets, et certains de ces effets sont irréversibles. Les séparer permet de laisser à l’agent toute la liberté d’exploration dont il a besoin et de concentrer contrôles, limites et confirmations là où les conséquences sont réelles. Nous y reviendrons dans le chapitre sur la sécurité.

Le schéma des paramètres est la première ligne de défense, mais pas la seule. Un JSON Schema peut dire qu’un champ est une chaîne au format date ; il ne dit pas que la date de début doit précéder la date de fin, ni que ce client appartient réellement à l’utilisateur pour le compte duquel l’agent travaille. Ces contrôles se font dans le code de l’outil, à chaque appel, comme pour toute entrée venant de l’extérieur. Le modèle n’est pas un utilisateur de confiance : c’est une source d’entrées qui a généralement raison, et votre code doit tenir même quand elle a tort.

Quant à la manière dont les outils parviennent à l’agent, il existe deux voies. On peut les définir directement dans le code de l’application et les transmettre au modèle à chaque appel, ou les exposer via un protocole standard comme le Model Context Protocol, afin que le même ensemble d’outils soit utilisable par n’importe quelle application compatible. Le cours consacré à MCP explique le fonctionnement du protocole ; ce qui compte ici, c’est le point commun : dans les deux cas, le modèle voit un nom, une description et un schéma, et la qualité de ces trois éléments pèse sur la qualité de l’agent autant que le modèle lui-même.

Chapitre 04

Concevoir les outils : descriptions, granularité, erreurs utiles

Concevoir un outil pour un agent, ce n’est pas comme concevoir un endpoint pour un autre programme. Un programme appelle l’API exactement comme il a été écrit pour l’appeler ; un agent la choisit et l’utilise en raisonnant sur le texte qu’il a sous les yeux, avec une attention limitée et un contexte qui se remplit à chaque résultat. C’est pourquoi un bon outil pour un agent ressemble davantage à une bonne fonction expliquée à un nouveau collègue qu’à une API REST complète : il fait une chose reconnaissable, porte le nom de cette chose et renvoie ce dont l’étape suivante a besoin.

Sur la granularité, il existe un vrai compromis. Quelques outils génériques — un seul « exécuter une requête SQL », un seul « appeler une API » — sont souples mais difficiles à bien utiliser, et ils reportent sur le modèle un travail que le code ferait mieux. Beaucoup d’outils spécifiques sont plus fiables pris un par un, mais ils encombrent le contexte et brouillent le choix, surtout quand deux d’entre eux se ressemblent. La règle pratique qui résiste à l’épreuve des faits : un outil pour chaque opération que vous pourriez décrire à un collègue en une seule phrase. S’il faut un paragraphe pour expliquer quand utiliser l’outil A plutôt que l’outil B, A et B devraient probablement être fusionnés, ou renommés.

Ce que l’outil renvoie mérite autant de soin, car chaque résultat finit dans le contexte et y prend de la place. Renvoyer l’intégralité d’un enregistrement de base de données, avec des dizaines de champs techniques, quand l’agent n’en utilise que quatre, gaspille de l’espace et le distrait. Mieux vaut renvoyer les champs utiles, sous une forme lisible, avec des identifiants que l’agent pourra réutiliser dans les appels suivants. Les résultats potentiellement longs exigent pagination, filtres ou une troncature explicite qui indique à l’agent qu’il y a autre chose et comment le demander : une liste coupée en silence mène à des conclusions fausses, énoncées avec une grande assurance.

Les erreurs doivent revenir sous forme d’information utile, pas d’exceptions techniques. « Client introuvable » vaut mieux qu’une stack trace, mais un message qui explique ce qui ne va pas dans l’entrée et quel outil utiliser à la place vaut mieux encore, car il dit à l’agent quoi corriger et comment. MCP formalise cette idée : les erreurs d’exécution d’un outil reviennent sous forme de résultat, marquées par isError, précisément pour que le modèle puisse les lire et réessayer avec d’autres paramètres. Une erreur cryptique, au contraire, bloque l’agent ou, pire, le lance dans des tentatives au hasard.

Une erreur renvoyée comme résultat de l’outil, sous la forme de MCP : elle dit ce qui ne va pas et comment y remédier.json
{
  "content": [
    {
      "type": "text",
      "text": "Customer not found: 'mario.rossi@example.com' looks like an email address, but customer_id must look like C-10482. To find a customer by email, call find_customer first."
    }
  ],
  "isError": true
}

Enfin, les outils s’améliorent en observant la façon dont ils sont utilisés. Les traces d’exécution — quels outils l’agent a appelés, avec quels paramètres, ce qu’il a reçu — montrent tout de suite où les descriptions sont ambiguës : des paramètres erronés toujours de la même façon, un outil ignoré au profit d’un autre, des appels répétés parce que le premier résultat ne suffisait pas. Chaque erreur récurrente indique ce qu’il faut réécrire. C’est un travail itératif, qui repose sur l’évaluation systématique du chapitre 8 : sans un ensemble de cas à relancer, impossible de savoir si la nouvelle description est meilleure que l’ancienne ou simplement différente.

Chapitre 05

Mémoire et contexte

Un modèle de langage ne se souvient de rien d’un appel à l’autre : tout ce qu’il sait d’une tâche en cours, c’est ce qui se trouve dans son contexte à ce moment-là. La « mémoire » d’un agent est donc une construction du système qui l’entoure, et il est utile d’en distinguer trois niveaux. Le contexte de travail est la conversation en cours, avec les instructions, les résultats des outils et les décisions prises. La connaissance de référence, ce sont la documentation, les procédures et les données qui existent indépendamment de la tâche. La mémoire persistante est ce que l’agent lui-même, ou le système, décide de conserver pour les sessions futures.

La fenêtre de contexte est finie. Sur les tâches longues, vient un moment où tout ne tient plus, et il faut alors laisser quelque chose de côté. Mais le problème commence avant la limite technique : un contexte rempli de résultats intermédiaires, de tentatives ratées et de documents consultés une seule fois rend plus difficile pour le modèle de distinguer ce qui compte. La façon dont on choisit ce qu’on écarte détermine si l’agent reste cohérent ou commence à se contredire.

La stratégie la plus répandue est le compactage : résumer périodiquement ce qui s’est passé, en conservant les décisions et les résultats et en écartant les détails intermédiaires. Cela fonctionne, mais cela se conçoit. Un résumé qui perd la contrainte importante — « le client a demandé de ne pas toucher aux prix », « cette table ne doit pas être modifiée » — fera répéter à l’agent une erreur déjà commise vingt minutes plus tôt. Ce qu’il faut préserver, dans l’ordre : l’objectif et les contraintes, les décisions prises et leurs raisons, l’état actuel du travail, les tentatives ratées à ne pas répéter. Une variante plus simple consiste à retirer du contexte les résultats d’outils devenus anciens, en gardant la trace de l’appel mais pas son contenu, qu’on pourra redemander au besoin.

Pour la connaissance de référence, le bon choix est en règle générale la récupération à la demande plutôt que le préchargement. On donne à l’agent un outil de recherche — dans les documents, dans le code, dans la base de données — et l’agent cherche ce dont il a besoin au moment où il en a besoin. Remplir le contexte d’avance avec tout ce qui est disponible dégrade les résultats : les informations pertinentes se retrouvent noyées parmi celles qui ne servent à rien, et l’on paie à chaque étape pour du texte que personne n’utilise. Le préchargement n’a de sens que pour quelques informations stables, courtes et presque toujours nécessaires, comme les règles fondamentales du domaine ou les conventions d’un projet.

La mémoire persistante — des notes que l’agent écrit et relit lors des sessions suivantes — est à la fois utile et délicate. Utile, parce qu’elle évite de redécouvrir chaque fois les mêmes choses : la structure d’un projet, une préférence de l’utilisateur, un problème déjà compris. Délicate, parce qu’une note erronée ou périmée est relue avec la même confiance qu’une note correcte, et qu’une instruction glissée par un contenu malveillant peut survivre à la session par laquelle elle est entrée. C’est pourquoi la mémoire persistante doit être lisible et modifiable par une personne, avoir un périmètre clair — par utilisateur, par projet — et ne contenir aucune donnée qui ne doit pas passer d’un contexte à l’autre.

Chapitre 06

Planification et tâches longues

Une tâche courte peut se résoudre en réagissant : on observe, on fait l’étape évidente, on observe de nouveau. Une tâche longue — migrer un module, rapprocher un mois d’opérations, préparer une analyse à partir de vingt sources — exige en revanche un plan, car sans plan l’agent optimise l’étape suivante et perd de vue le résultat. Le symptôme est reconnaissable : beaucoup de travail local bien fait qui, au bout du compte, ne forme pas la solution demandée.

Pour un agent, planifier signifie produire explicitement un découpage de la tâche en étapes, avant de commencer à les exécuter. La forme compte moins que le fond : il faut une liste dans laquelle chaque étape a un résultat vérifiable. « Analyser le module » n’est pas une bonne étape, car on ne sait pas quand elle est terminée ; « lister les fonctions du module appelées depuis d’autres fichiers » en est une. Un plan écrit a aussi un avantage pratique : on peut le faire relire par une personne avant que l’agent ne commence, et c’est à ce moment-là qu’une correction coûte le moins.

Le plan n’est pas un contrat. Les observations faites pendant l’exécution peuvent le démentir : un fichier qui n’existe pas, une API qui ne se comporte pas comme le dit sa documentation, une donnée qui change la nature du problème. Un bon agent replanifie quand les observations contredisent ses hypothèses, au lieu de forcer la réalité à entrer dans le plan initial, et il le dit, car la personne qui supervise doit savoir que la route a changé. Les instructions devraient aussi prévoir quand s’arrêter pour demander : quand l’écart touche une contrainte, ou quand le nouveau plan coûte beaucoup plus cher que le premier.

Les tâches vraiment longues dépassent la durée d’un seul contexte, et c’est là que la planification rejoint la mémoire. La technique la plus robuste consiste à conserver l’état du travail hors du contexte, dans un artefact qui survit : un fichier d’avancement, une liste de tâches, l’historique des commits d’un dépôt. Une nouvelle session, ou un autre agent, lit cet artefact et reprend là où l’on s’était arrêté, sans devoir tout reconstruire à partir de la conversation précédente. Pour que cela fonctionne, l’artefact doit être mis à jour à chaque étape terminée, pas à la fin, et contenir aussi les décisions et les contraintes apparues en chemin : ce sont précisément les informations qu’un résumé automatique risque de perdre, et celles sans lesquelles la personne qui reprend le travail répète les mêmes erreurs.

Un fichier d’avancement : fait, prochaines étapes, décisions et contraintes. Une nouvelle session le lit et repart sans reconstruire l’historique.markdown
# Task: move the invoices module to the new billing API

## Done
- [x] List callers of legacy_invoice.py (14 files, see callers.txt)
- [x] Port create_invoice; its tests pass

## Next
- [ ] Port cancel_invoice (needs refund handling, see decisions)
- [ ] Remove legacy_invoice.py once no callers remain

## Decisions and constraints
- Do not change the public JSON format: the mobile app depends on it
- Refunds keep per-line rounding, as the old API did (confirmed by finance)

Deux règles pratiques complètent le tableau. La première : dimensionner les étapes de sorte que chacune laisse le système dans un état cohérent et vérifiable, pour qu’une interruption à mi-parcours ne laisse pas un chantier à moitié fait. La seconde : donner à la tâche un critère d’achèvement explicite, écrit avant de commencer — tous les tests passent, toutes les lignes sont rapprochées, chaque affirmation du rapport a une source. Sans ce critère, un agent sur une tâche longue a tendance soit à s’arrêter trop tôt, en déclarant terminé un travail partiel, soit à ne jamais s’arrêter.

Chapitre 07

Plusieurs agents ensemble : quand ils aident et quand ils n’aident pas

Quand un agent seul commence à peiner, la tentation est de le diviser en plusieurs agents : un qui planifie, un qui cherche, un qui rédige, un qui contrôle. C’est parfois le bon choix. Plus souvent, c’est une façon de déplacer la complexité d’un endroit à un autre, tout en en ajoutant de la nouvelle. Avant de le faire, il vaut la peine de comprendre précisément ce qu’un système multi-agents apporte vraiment, et ce qu’il coûte.

Le principal avantage est l’isolement du contexte. Un sous-agent part d’un contexte vierge, reçoit une tâche circonscrite, fait tout le travail d’exploration nécessaire — en lisant peut-être des dizaines de documents — et ne renvoie à l’agent principal qu’un résultat compact. Le contexte de l’agent principal reste dégagé pour les décisions qui comptent. Le deuxième avantage est le parallélisme : des sous-tâches réellement indépendantes, comme examiner dix sources différentes pour la même recherche, peuvent avancer en même temps. Le troisième est la spécialisation : des instructions et des outils différents pour des rôles différents, chacun plus simple à décrire et à évaluer.

Les coûts sont tout aussi concrets. Chaque passage de relais perd de l’information : le sous-agent ne sait que ce qui a été écrit dans sa tâche, et l’agent principal ne sait que ce que le sous-agent a choisi de rapporter. Plus d’agents, c’est plus d’appels au modèle, donc plus de coût et souvent plus de temps au total. Et quand deux agents travaillent en parallèle sur le même objet — le même document, le même code —, ils prennent des décisions implicites incompatibles qu’aucun des deux ne voit : l’un choisit un format, l’autre un autre, et recomposer les résultats devient un travail à part entière. Le débogage se complique aussi, car une erreur peut naître dans un agent et se manifester dans un autre.

D’où un critère pratique. Les systèmes multi-agents fonctionnent bien quand le travail se décompose en parties qu’on peut exécuter sans connaître les autres, et dont les résultats se combinent facilement : recherches sur des sources différentes, analyses indépendantes, vérifications séparées. Ils fonctionnent mal quand les parties dépendent étroitement les unes des autres et exigent un contexte partagé dense, comme écrire à plusieurs mains le même composant. Dans ce cas, un agent seul, avec une bonne gestion du contexte, fait généralement mieux. Le schéma le plus facile à maîtriser reste le schéma hiérarchique : un agent coordonne, délègue des tâches bien délimitées et garde la responsabilité du résultat final.

Bien déléguer est une compétence qui vaut pour les agents comme pour les personnes. La tâche confiée à un sous-agent doit dire quel objectif est visé, ce qui est déjà connu ou exclu, quelles contraintes respecter, quand s’arrêter et sous quelle forme rendre le résultat. Une tâche vague produit un sous-agent qui refait un travail déjà fait, ou qui explore tout autre chose. Et le résultat doit être traité comme celui d’un outil : une entrée à vérifier, pas une vérité. Le cours sur Claude Code montre un exemple concret de ce schéma, avec des sous-agents qui travaillent dans un contexte séparé et ne renvoient qu’une synthèse.

Chapitre 08

Évaluer un agent : cas réels, métriques, régressions

On n’évalue pas un agent en l’essayant à la main jusqu’à ce qu’il ait l’air de fonctionner. Son comportement n’est pas déterministe, les cas sont nombreux et variés, et chaque modification — d’une instruction, de la description d’un outil, du modèle sous-jacent — peut améliorer un cas et en dégrader deux autres. Tant qu’on teste à la main, chaque modification est un pari : on corrige le cas qu’on a sous les yeux et on casse celui que personne ne réessaie.

La base, c’est un ensemble de cas d’évaluation tirés de la réalité : des demandes réelles, ou très proches de demandes réelles, chacune avec son résultat attendu. On commence avec quelques dizaines de cas choisis avec discernement — les plus fréquents, les plus coûteux en cas d’erreur, ceux sur lesquels l’agent a déjà échoué — et on fait grandir l’ensemble : chaque erreur découverte en production devient un nouveau cas. Les cas où la bonne réponse consiste à ne rien faire, ou à demander une précision, comptent aussi, car un agent qui agit toujours finit tôt ou tard par agir mal à propos.

Un cas d’évaluation : demande réelle, état de départ, résultat attendu et contraintes sur le parcours. Le contrôle porte sur l’état final, pas sur les paroles de l’agent.yaml
id: refund-duplicate-charge-017
input: "I was charged twice for order A-5531, please sort it out"
setup:
  orders: fixtures/a5531_double_charge.json
expect:
  outcome: refund_issued
  refund_amount: 49.90        # one charge, not both
  tools_must_include: [get_order, issue_refund]
  tools_must_not_include: [cancel_order]
  max_steps: 8
grader: final_state          # deterministic: no model involved in the check

Il y a deux choses à mesurer, et il faut les deux. Le résultat : la tâche a-t-elle été menée à bien correctement ? Chaque fois que c’est possible, on le vérifie sur l’état final du système — le remboursement existe et porte le bon montant, les tests passent — et non sur la réponse textuelle, car un agent peut très bien décrire un travail qu’il n’a pas fait. Le parcours : combien d’étapes, quels outils, quel coût, quel temps, et s’il a touché à quelque chose qu’il ne devait pas toucher. Deux agents avec le même taux de réussite peuvent se comporter très différemment en production si l’un y parvient en cinq étapes et l’autre en quarante.

Tout ne se contrôle pas avec une règle. Pour juger la qualité d’un résumé ou le ton d’une réponse, on utilise souvent un autre modèle comme évaluateur, avec des critères écrits explicitement. Cela fonctionne, à une condition : l’évaluateur doit lui-même être vérifié, en comparant ses jugements à ceux d’une personne sur un échantillon de cas, jusqu’à avoir de bonnes raisons de lui faire confiance. Un évaluateur automatique non calibré mesure quelque chose, mais on ne sait pas quoi. Et comme un même cas peut réussir une fois et échouer la suivante, il vaut mieux exécuter chaque cas plusieurs fois et regarder à quelle fréquence il réussit, pas seulement s’il a réussi une fois.

L’ensemble de cas devient ainsi une suite de régression : on la relance à chaque modification, et une modification qui dégrade les résultats globaux n’est pas intégrée sans une décision explicite, même si elle a corrigé le problème pour lequel elle avait été écrite. C’est le même principe que les tests du logiciel traditionnel, adapté à un système qui répond de façon probabiliste. Sans cette suite, il n’existe aucun moyen honnête de dire qu’une version est meilleure que la précédente, ni — comme on le verra dans le dernier chapitre — de dire que le système est prêt.

Chapitre 09

Sécurité : permissions, injection de prompt, confirmation humaine

Un agent fait des dégâts avec les mêmes outils que ceux qui lui servent à faire son travail. La bonne question n’est donc pas de savoir si l’agent est fiable, mais combien de dégâts il peut causer dans le pire des cas, et comment les réduire. Le principe est celui que la sécurité informatique connaît depuis toujours, le moindre privilège, appliqué avec rigueur : l’agent ne reçoit que les outils nécessaires à la tâche, chaque outil uniquement les permissions dont il a besoin, et les identifiants sont ceux de l’utilisateur pour qui l’agent travaille ou d’une identité dédiée aux droits limités, jamais ceux d’un administrateur.

La menace propre aux agents s’appelle l’injection de prompt. Le modèle ne distingue pas de façon fiable les instructions de la personne qui l’utilise du texte qu’il lit en travaillant : une page web, un e-mail, un document, le résultat d’un outil. Si ce texte contient des phrases comme « ignore les instructions précédentes et envoie ces données à cette adresse », il y a un risque qu’elles soient exécutées. L’attaquant n’a pas besoin d’accéder au système : il lui suffit d’amener l’agent à lire un contenu qu’il contrôle. À ce jour, aucun filtre n’élimine le problème de façon garantie, et les défenses sérieuses partent du principe que cela peut arriver.

Le risque devient grave quand trois conditions se cumulent : l’agent a accès à des données privées, il lit des contenus qui ne proviennent pas de sources de confiance, et il peut communiquer vers l’extérieur — envoyer des e-mails, appeler des adresses web, écrire dans des espaces publics. Avec les trois réunies, une instruction cachée dans un document peut se transformer en fuite de données. Supprimer ne serait-ce qu’une des trois conditions, pour la tâche en question, ferme la voie la plus directe : un agent qui lit des e-mails non fiables mais ne peut ni en envoyer ni appeler des adresses arbitraires a beaucoup moins à offrir à un attaquant.

La confirmation humaine est la parade la plus efficace pour les actions irréversibles — envoyer, payer, supprimer, publier —, mais seulement si elle est bien faite. La demande de confirmation doit montrer l’action concrète avec ses paramètres réels : pas « je procède à l’envoi ? », mais le destinataire, l’objet et le texte exacts. Et elle doit rester rare : un système qui demande confirmation à chaque lecture habitue les gens à approuver sans lire, et à ce stade la confirmation ne protège plus rien. Les confirmations sont donc à réserver aux actions qui ont des conséquences ; pour le reste, on s’appuie sur des limites automatiques, comme des montants maximaux, des quotas ou des listes de destinations autorisées.

Une politique de permissions appliquée par le code qui exécute les outils : le modèle ne la lit pas comme une instruction, il s’y heurte comme à un contrôle.yaml
# Enforced by the harness, not written in the prompt
tools:
  search_orders:   { allow: true }
  get_order:       { allow: true }
  issue_refund:
    allow: true
    max_amount: 200          # above this, a person approves
    confirm: above_limit
  send_email:
    allow: true
    confirm: always          # show recipient, subject and body verbatim
    allowed_domains: [example.com]
  delete_customer: { allow: false }

Toutes ces règles doivent vivre dans le code qui exécute les outils, pas dans les instructions données au modèle. « N’envoie jamais d’e-mail à des domaines externes » écrit dans le prompt est une consigne que le modèle suit presque toujours, et qu’une injection de prompt réussie peut le convaincre d’ignorer ; la même limite appliquée par le harness ne se contourne pas avec des mots. Viennent compléter le tableau l’exécution dans des environnements isolés pour les agents qui exécutent du code, et un journal de chaque action effectuée, avec ses paramètres et son résultat, qui permette de reconstituer après coup ce qui s’est passé et pourquoi. Le cours sur MCP approfondit les risques propres aux serveurs connectés à un agent, comme le confused deputy.

Chapitre 10

De la démo à la production

Construire une démo convaincante d’un agent est relativement facile ; le mettre en production, non. Une cause fréquente n’est pas technique : il manque un critère de réussite partagé. Le prototype convainc en démo, mais personne n’a établi quel taux d’erreur est acceptable, sur quels cas et avec quelles conséquences. Sans ce seuil, il n’existe aucun moment où déclarer le système prêt, et le projet reste indéfiniment au stade de prototype. Le seuil doit être fixé en amont, avec ceux qui utiliseront le système, et comparé à l’alternative réelle, qui n’est souvent pas un processus parfait mais une personne qui fait le même travail, avec ses propres erreurs.

La deuxième cause est l’absence d’évaluation systématique, dont il a été question au chapitre 8 : sans une suite de cas réels, chaque modification est un pari et chaque discussion sur la qualité reste une affaire d’opinion. La troisième est le coût découvert trop tard. Un agent qui itère consomme bien plus de ressources qu’une requête unique, car à chaque étape il renvoie au modèle un contexte qui s’allonge, et le coût par tâche varie beaucoup d’un cas à l’autre. Il faut l’estimer en amont, en exécutant la suite d’évaluation et en mesurant consommation et durée par cas, et non après la première facture. Les leviers sont connus : limites d’étapes et de budget par tâche, résultats d’outils plus compacts, modèles plus petits pour les sous-tâches simples, et la question de départ — a-t-on vraiment besoin d’un agent ici ?

En production, un agent doit être surveillé de plus près qu’un logiciel traditionnel, car il peut se tromper sans générer la moindre erreur technique : il répond, clôt la tâche, et le résultat est faux. Il faut des traces complètes de chaque exécution — instructions, appels aux outils, résultats, décisions — consultables quand quelque chose tourne mal, et des indicateurs agrégés à suivre : taux d’achèvement, tâches transmises à une personne, nombre moyen d’étapes, coût par tâche, signalements des utilisateurs. Un changement soudain de l’un de ces chiffres est souvent le premier signe d’un problème, avant même que quelqu’un ne se plaigne.

Le passage en production doit lui aussi être progressif. Une voie prudente consiste à faire d’abord travailler l’agent en binôme — il propose, une personne décide —, puis sur une part limitée des cas ou des utilisateurs, et seulement ensuite à élargir. À chaque phase, il doit exister une porte de sortie claire vers une personne : pour l’agent, quand il ne sait pas comment poursuivre, et pour l’utilisateur, quand il ne fait pas confiance au résultat. Les cas transmis à une personne ne sont pas un échec : c’est la matière première des prochains cas d’évaluation.

La dernière cause est la confiance des utilisateurs. Un système qui se trompe rarement mais de façon spectaculaire est abandonné plus vite qu’un système médiocre et prévisible : on tolère bien mieux une limite connue qu’une surprise. D’où un conseil qui résume tout le cours : dire clairement ce que l’agent fait et ce qu’il ne fait pas, le faire s’arrêter et demander quand il sort de son périmètre, et n’élargir ce périmètre que lorsque les chiffres le justifient. Un agent à la mission étroite qui fonctionne de façon fiable vaut mieux qu’un agent ambitieux qui fonctionne presque toujours.

Épreuve finaleseuil 80%

Obtenez votre attestation

Réussissez l’épreuve finale en répondant correctement à au moins 80 % des questions. L’attestation est délivrée automatiquement et reste vérifiable en ligne grâce à un lien permanent : il s’agit d’un Open Badge conforme à la norme 2.0, que vous pouvez ajouter à LinkedIn et à vos portefeuilles numériques de compétences.

Aucune inscription. Votre nom figurera sur l’attestation ; l’adresse e-mail sert uniquement à identifier l’attestation numérique et à éviter les doublons.

Votre nom et l’intitulé du cours seront visibles publiquement sur la page de vérification de l’attestation, accessible à toute personne disposant du lien.

Questions fréquentes

Attestation, badge et accès au cours

Le cours est-il gratuit ? Est-ce que je reçois une attestation ?

Oui aux deux questions. Le cours est entièrement gratuit : les contenus, l’épreuve finale et l’attestation, sans module payant et sans qu’aucun moyen de paiement ne vous soit jamais demandé. Lorsque vous réussissez l’épreuve finale avec au moins 80 % de bonnes réponses, vous recevez une Attestation de suivi à votre nom, avec un code de vérification, une page publique que chacun peut consulter pour en confirmer l’authenticité, le PDF à télécharger et un Open Badge à ajouter à votre profil LinkedIn. Votre nom et votre e-mail ne vous sont demandés qu’à la fin, si vous décidez de passer l’épreuve.

Est-il lié à un fournisseur ou à un framework particulier ?

Non. C’est un cours indépendant de Rinoova Academy, sans affiliation avec aucun fournisseur de modèles ni de frameworks d’agents, et l’attestation est délivrée par Rinoova. Le cours explique des concepts et des pratiques valables quel que soit le modèle ou la bibliothèque que vous utilisez : la boucle agentique, la conception des outils, la gestion du contexte, l’évaluation et la sécurité. Les seuls formats concrets présentés sont ceux du Model Context Protocol, qui est un standard ouvert, et Claude Code n’apparaît que comme exemple d’agent de code.

Combien de temps dure le cours et comment les heures sont-elles calculées ?

Environ deux heures. Dix chapitres pour environ 5 000 mots de texte technique, qui demandent un peu moins d’une heure de lecture attentive, plus six exemples de code et de configuration sur lesquels il vaut la peine de s’arrêter, et l’épreuve finale. Ce n’est pas un cours en vidéo : vous pouvez le lire à votre rythme, l’interrompre et le reprendre quand vous le souhaitez.

Quels sont les prérequis ? Faut-il savoir programmer ?

Le cours est de niveau intermédiaire : il suppose que vous avez déjà utilisé un assistant fondé sur un modèle de langage et que des notions comme les API, le JSON et les tests logiciels ne vous sont pas étrangères. On n’écrit pas de code pendant le cours : les exemples sont courts, ils servent à montrer à quoi ressemble réellement une définition d’outil ou un cas d’évaluation, et ils sont expliqués par le texte qui les entoure. Inutile de connaître MCP ou un quelconque framework d’agents.

Quelle différence avec les cours sur MCP et sur Claude Code ?

Ce cours explique comment un agent fonctionne et comment le concevoir, de façon générale. Le cours sur le Model Context Protocol approfondit le protocole par lequel les outils se connectent à un agent ; le cours sur Claude Code montre comment bien utiliser un agent de code précis. Vous pouvez les suivre dans n’importe quel ordre, mais commencer par celui-ci vous donne le cadre dans lequel les deux autres s’inscrivent.

Que se passe-t-il si je ne réussis pas l’épreuve finale ?

Vous pouvez la repasser. Le seuil est de 80 % et les questions couvrent tous les chapitres : si une partie n’est pas claire, mieux vaut revenir au chapitre concerné et le relire avant de réessayer. L’attestation n’est délivrée qu’en cas de réussite, et jamais deux fois pour le même cours à la même personne.

Le cours est-il à jour ? Le domaine évolue vite.

Oui, et c’est justement pour cela qu’il est écrit d’une certaine manière. Le cours se concentre sur ce qui reste valable quand les modèles et les produits changent — comment concevoir une boucle, un outil, une évaluation, un système de permissions —, et c’est là-dessus que porte l’épreuve. Les noms de modèles, les versions, les prix et les statistiques sont volontairement laissés de côté, parce qu’ils vieillissent plus vite que le reste. La date de la dernière révision est indiquée en haut de la page.

Pour continuer

Autres cours Open