1. De l'assistant qui répond à l'agent qui agit
Un assistant classique répond. Vous posez une question, il renvoie du texte, l'échange s'arrête là. Si la réponse est fausse, c'est à vous de le voir et de relancer.
Un agent fait. Vous lui donnez un objectif (« corrige ce bug », « prépare ce rapport », « range ces fichiers »), et il enchaîne les actions tout seul : il lit, il cherche, il lance des commandes, il regarde le résultat, il se corrige. Il ne rend la main qu'une fois le travail terminé.
La bascule tient en un mot : la boucle. Elle transforme un modèle passif en système qui va au bout d'une tâche. Tout le reste (les outils, le contexte, les garde-fous) sert à la faire tourner correctement.
Si vous évaluez un agent pour vos équipes, ou si vous en pilotez déjà un, voici ce qu'il y a sous le capot.
2. Qu'est-ce qu'un agent IA
Quatre ingrédients suffisent à définir un agent.
Un modèle de langage, qui raisonne et décide. Des outils, qui lui donnent prise sur le monde réel : lire un fichier, lancer une commande, interroger une API. Un objectif, fixé par l'humain. Et une boucle, qui relie tout ça : le modèle agit, observe le résultat, puis décide de l'étape suivante.
Retirez la boucle et les outils, il reste un chatbot. Ajoutez-les, et le modèle peut poursuivre un but sur des dizaines d'étapes sans qu'on lui tienne la main.
Schéma 1 · La boucle agentique
Le cycle est toujours le même. L'agent rassemble le contexte dont il a besoin (il lit, il cherche, il observe l'état du système). Il agit en appelant un outil. Il vérifie : le résultat de l'outil lui revient et il l'examine. Puis il recommence, en tenant compte de ce qu'il vient d'apprendre. La boucle s'arrête quand l'objectif est atteint, c'est-à-dire quand le modèle répond sans plus avoir besoin d'appeler d'outil.
Ce qui sépare un agent d'un chatbot tient moins à l'intelligence du modèle qu'à cette capacité à agir, constater et ajuster, sans repasser par l'humain à chaque pas.
3. Claude Code, un agent incarné
Claude Code est un agent qui vit dans le terminal. On lui parle en langage naturel ; il travaille sur le code et les fichiers d'un projet. On peut aussi le brancher dans un IDE, ou le faire tourner dans une chaîne d'intégration continue.
Il a un avantage pour qui veut comprendre les agents : il ne cache rien. Chaque outil appelé, chaque fichier lu, chaque commande lancée est visible. C'est un agent qu'on peut observer en train de réfléchir.
Le modèle n'est qu'une pièce. Autour de lui, un harnais (en anglais, le harness) fait tout le reste : il entretient la boucle, gère la mémoire de travail, expose les outils, applique les règles de sécurité. Le modèle est le cerveau ; le harnais est ce qui le rend capable d'agir dans le monde réel.
Schéma 2 · L'anatomie de Claude Code
On retrouve, empilées : le modèle ; la boucle et la gestion du contexte ; une couche d'outils intégrés ; des extensions qui élargissent ses capacités (MCP, sous-agents, skills, mémoire) ; et, tout autour, la gouvernance. Le même harnais peut se brancher sur un terminal, un IDE ou un pipeline. Les sections qui suivent ouvrent chacune de ces boîtes.
4. Sous le capot : la boucle qui tourne
Le contexte, mémoire de travail
À chaque tour, le modèle ne « se souvient » de rien par lui-même. On lui renvoie, à chaque appel, tout ce dont il a besoin pour décider : les instructions de départ, l'historique de la conversation, les résultats des outils déjà appelés. Cet ensemble s'appelle la fenêtre de contexte. Elle est grande (de l'ordre de quelques centaines de milliers de mots pour les modèles actuels, soit plusieurs centaines de pages), mais elle reste finie.
Sur une tâche longue, c'est elle qui vient à manquer en premier.
Schéma 3 · La fenêtre de contexte
Au démarrage, la fenêtre contient peu : les instructions système, la mémoire du projet, la description des outils. Puis elle se remplit. Chaque fichier lu, chaque recherche, chaque résultat de commande s'y empile. Sur une longue tâche, les résultats d'outils finissent par tout envahir.
Deux conséquences directes. Plus la fenêtre est pleine, plus chaque tour coûte cher et ralentit. Et quand elle approche de la limite, l'agent doit faire le ménage : il résume l'historique ancien pour libérer de la place, c'est la compaction. Savoir gérer le contexte, c'est savoir garder un agent rapide et concentré sur les tâches longues.
Agir : le cycle d'un appel d'outil
Quand le modèle décide d'agir, il n'exécute rien lui-même. Il émet une demande structurée : le nom de l'outil, ses arguments, et un identifiant unique. Le harnais exécute l'outil, puis renvoie le résultat (étiqueté avec le même identifiant) dans le contexte. Le modèle reprend alors la main.
Schéma 4 · Le cycle d'un appel d'outil
Le modèle décide, le harnais exécute, jamais l'inverse. L'identifiant relie chaque appel à son résultat : c'est ce qui permet à l'agent de suivre qui a fait quoi, même quand plusieurs outils tournent. Et la boucle ne s'arrête jamais d'elle-même tant que le modèle continue d'appeler des outils. Elle se termine quand il juge l'objectif atteint et répond en clair, ou quand une limite externe (nombre de tours, budget) coupe court.
5. Les briques qui étendent l'agent
Un agent ne vaut que par ce qu'il sait faire. Les extensions qui suivent élargissent son rayon d'action.
Les outils intégrés
Claude Code arrive avec une trousse de base : lire et écrire des fichiers, modifier un passage précis dans un fichier, lancer une commande shell, chercher dans le code par nom ou par contenu, faire une recherche web ou récupérer une page, tenir une liste de tâches, et déléguer à un sous-agent.
Chaque outil est décrit au modèle par un nom, une description et la liste de ses arguments. C'est cette description qui guide le modèle : un outil bien décrit est un outil bien utilisé.
MCP : se brancher au monde extérieur
Les outils intégrés s'arrêtent au poste de travail. Pour atteindre Jira, un dépôt Git, une base de données ou un outil maison, Claude Code parle un protocole standard : MCP (Model Context Protocol), ouvert, publié par Anthropic fin 2024.
Schéma 5 · MCP, un port universel
Le principe est celui d'une prise normalisée. D'un côté, un client (ici Claude Code). De l'autre, des serveurs qui exposent des outils. Le client découvre ces outils à la connexion, et le modèle les utilise comme s'ils étaient natifs. La communication passe en local (l'outil tourne comme un sous-processus) ou à distance (en HTTP). L'intérêt du standard : un même serveur sert n'importe quel client compatible. On écrit l'intégration une fois, elle vaut pour tout l'écosystème.
Les sous-agents : déléguer pour préserver le contexte
Certaines sous-tâches sont lourdes : parcourir cinquante fichiers, relire un module entier. Les faire absorber par l'agent principal sature sa fenêtre de contexte. La parade : déléguer à un sous-agent.
Schéma 6 · Déléguer à un sous-agent
Le sous-agent démarre avec un contexte vierge, isolé de celui du parent, et souvent des outils restreints. Il mène sa propre boucle, puis ne renvoie qu'une synthèse compacte. Le détail reste chez lui ; l'agent principal ne récupère que l'essentiel et garde sa fenêtre légère. On peut définir ses propres sous-agents spécialisés (un « relecteur de code », un « explorateur »), chacun avec son rôle, son modèle et sa liste d'outils.
Mémoire, skills et commandes
Trois dernières couches personnalisent l'agent. La mémoire de projet est un fichier (CLAUDE.md) chargé automatiquement au démarrage : conventions, contexte, règles à respecter sans qu'on les répète. Les skills sont des savoir-faire rangés dans des fichiers, que l'agent va chercher lui-même quand le sujet s'y prête. Les commandes (les /slash) sont des raccourcis déclenchés par l'humain pour une tâche cadrée.
Ces trois briques se ressemblent mais ne jouent pas le même rôle.
Commande /slash |
Skill | Sous-agent | |
|---|---|---|---|
| Déclenchement | l'humain l'appelle | l'agent la mobilise quand c'est pertinent | l'agent délègue une tâche |
| Contexte | la conversation en cours | injecté dans la conversation | neuf et isolé |
| Sert à | lancer un geste cadré | apporter un savoir-faire | absorber une tâche lourde |
Une commande répète, une skill apporte un savoir-faire, un sous-agent isole. Trois usages à ne pas confondre.
6. Gouverner l'autonomie : permissions, hooks, sandbox
Un agent qui agit seul peut effacer un fichier de trop, lancer une commande dangereuse, exposer un secret. Donner de l'autonomie sans garde-fous, c'est laisser tourner une machine sans frein. La bonne réponse : encadrer ce qu'il a le droit de faire, plutôt que brider le modèle.
Schéma 7 · Trois filtres avant qu'un agent agisse
Trois filtres se succèdent à chaque action. Les permissions disent, par type d'outil, ce qui est autorisé, ce qui demande validation, ce qui est interdit. Les hooks sont des règles déterministes, écrites en code, qui s'exécutent avant ou après un outil : bloquer une commande, masquer un secret, tout journaliser. La sandbox confine l'exécution : accès limité au disque et au réseau.
À chaque filtre, l'action peut être refusée, ou renvoyée à l'humain pour validation (ce qu'on appelle le HITL, human in the loop). C'est de la défense en profondeur : aucune couche n'est parfaite seule, mais ensemble elles rendent l'autonomie exploitable en entreprise. Et tout passe au journal, ce qui rend l'agent auditable.
On ne gouverne pas ce qu'un agent pense. On gouverne ce qu'il a le droit de faire. C'est cette frontière, déterministe et traçable, qui sépare une démo d'un déploiement sérieux.
Ce qu'il faut retenir
Un agent IA tient en quatre pièces : un modèle qui décide, des outils qui lui donnent prise sur le réel, une boucle qui enchaîne, un objectif qui la borne. Claude Code est un bon exemple : un harnais qui gère le contexte, expose les outils, se branche au monde via MCP, délègue à des sous-agents et encadre chaque action. Le modèle compte, mais l'essentiel se joue autour de lui.
Reste la question que tout cela pose. Une fois qu'on sait comment un agent fonctionne, comment s'en sert-on vraiment ? C'est l'objet du second volet, « Utiliser un agent IA : augmenter un humain, ou automatiser un workflow » : les deux modes d'usage, des cas concrets, et ce qu'il faut réunir pour laisser un agent tourner seul sans mauvaise surprise.
Lexique
Agent IA : un modèle de langage placé dans une boucle, équipé d'outils et lancé sur un objectif.
Boucle agentique : le cycle rassembler le contexte, agir, vérifier, puis recommencer jusqu'à l'objectif.
Outil (tool) : une fonction que l'agent peut appeler (lire un fichier, lancer une commande, interroger une API).
Harnais (harness) : tout ce qui entoure le modèle pour le rendre capable d'agir (boucle, contexte, outils, gouvernance).
Fenêtre de contexte : la mémoire de travail de l'agent à chaque tour. Grande mais finie ; c'est elle qui vient à manquer en premier.
MCP (Model Context Protocol) : un standard ouvert pour brancher un agent sur des outils et des données externes.
Sous-agent : un agent délégué, au contexte isolé, qui traite une sous-tâche et ne renvoie qu'une synthèse.
Hook : une règle déterministe (du code) exécutée avant ou après un outil, pour valider, bloquer ou journaliser.
HITL (human in the loop) : un point où l'agent s'arrête et demande une validation humaine avant d'agir.
Sources : documentation officielle Claude Code (code.claude.com/docs) et dépôt public
anthropics/claude-code. Protocole MCP : modelcontextprotocol.io.
