Qu'est-ce qu'un agent IA et comment le tester pas à pas

Qu’est-ce qu’un agent IA ? C’est un programme reposant sur un modèle de langage qui ne se contente pas de répondre : il exécute lui-même la tâche. Il choisit ses outils (fichiers, terminal, navigateur), regarde le résultat de chaque étape et décide de la suite jusqu’à avoir terminé. Un chatbot nous donne du texte, un agent nous donne du travail fait, par exemple un test réparé ou un commit dans le dépôt.

Dans ce tutoriel, j’explique comment ça marche sous le capot, puis on passe à la pratique : installer un agent dans le terminal, lui confier une première tâche et régler ce qui nous protège des mauvaises surprises. Les commandes viennent de la documentation officielle de Claude Code et de Codex CLI.

Qu’est-ce qu’un agent IA en pratique ?

La définition la plus courte vient d’Anthropic, dans le texte Building effective agents : les agents sont « typically just LLMs using tools based on environmental feedback in a loop », c’est-à-dire, le plus souvent, de simples modèles de langage qui utilisent des outils en boucle et réagissent à ce que leur renvoie l’environnement.

Dans le même texte, Anthropic distingue les agents des « workflows » :

1. Un workflow est un système où le modèle et les outils suivent un chemin prédéfini dans le code. Le développeur fixe les étapes, le modèle comble les trous.
2. Un agent est un système où le modèle pilote lui-même son processus et choisit lui-même ses outils. Le développeur donne l’objectif, le modèle décide combien d’étapes il faut, et lesquelles.

Selon Anthropic, les agents sont utiles là où il est difficile de prévoir à l’avance le nombre d’étapes. Pour les tâches simples, mieux vaut s’en tenir à une solution plus simple.

En quoi un agent diffère-t-il d’un chatbot ?

Tout tient aux outils. Dans la documentation de Claude Code, on lit que sans outils, Claude ne peut que répondre par du texte, alors qu’avec des outils il peut agir : lire du code, modifier des fichiers, lancer des commandes, chercher sur le web et se connecter à des services externes.

Un exemple tiré de la même documentation l’illustre bien. On demande à l’agent de « corriger les tests qui échouent », et lui :

1. lance les tests pour voir ce qui casse,
2. lit les messages d’erreur,
3. cherche les fichiers source concernés,
4. les lit pour comprendre le code,
5. modifie les fichiers,
6. relance les tests pour vérifier que la correction fonctionne.

Un chatbot s’arrêterait à nous suggérer une correction. Un agent l’applique et vérifie lui-même le résultat.

Comment fonctionne la boucle de l’agent ?

La documentation de Claude Code la décrit comme une « agentic loop » en trois phases : rassembler le contexte, agir et vérifier les résultats. Les phases se chevauchent, et après chaque étape le modèle décide de ce dont il a besoin ensuite, en enchaînant parfois des dizaines d’actions.

Un agent se compose de deux éléments :

1. Le modèle, qui raisonne et planifie (dans Claude Code, ce sont les modèles Claude, que l’on change avec la commande /model).
2. Le harness agentique, la couche autour du modèle qui lui donne des outils et gère le contexte. C’est le terme qu’utilise la documentation elle-même (« agentic harness »).

Les outils intégrés de Claude Code se répartissent en cinq groupes : opérations sur les fichiers, recherche, exécution de commandes, web et analyse de code. On peut y ajouter des serveurs MCP (connexions à des services externes), des skills et des sous-agents.

Fait intéressant, une partie de ces briques sont déjà des standards ouverts. Le 22 octobre, Anthropic a confié le standard Agent Skills à l’Agentic AI Foundation, rattachée à la Linux Foundation, à laquelle il avait déjà cédé MCP. Selon Anthropic, le standard est pris en charge par plus de 70 plateformes d’agents, dont ChatGPT, Cursor et GitHub Copilot.

Pourquoi parle-t-on autant des agents IA en ce moment ?

Parce qu’ils sont passés du statut de curiosité à celui d’outil du quotidien. D’après le rapport Octoverse que GitHub a présenté le 28 octobre lors de sa conférence Universe, en septembre, plus de 40 % des pull requests partaient d’un brouillon écrit par un agent, contre 17 % en mars (compte rendu de The Next Web).

Les agents sortent aussi du code. J’ai déjà parlé de Claude Duet, qui se manifeste de lui-même avec un brief matinal et surveille les e-mails, et de quatre agents Gemini qui ont terminé Minecraft jusqu’à l’Ender Dragon.

Étape 1 : comment installer un agent IA dans le terminal ?

Le plus simple pour voir un agent au travail, c’est un agent de programmation dans le terminal. Je vais montrer Claude Code, que j’utilise pour ce site, et pour comparer, Codex CLI d’OpenAI.

Claude Code nécessite un abonnement Claude payant (Pro, Max, Team ou Enterprise) ou un compte Claude Console avec des crédits API. Installation sous macOS, Linux et WSL :

curl -fsSL https://claude.ai/install.sh | bash

Windows PowerShell :

irm https://claude.ai/install.ps1 | iex

L’installeur n’affiche pas de progression. Une fois terminé, on ouvre une nouvelle fenêtre de terminal et on vérifie :

claude --version

Codex CLI s’installe sous macOS et Linux ainsi :

curl -fsSL https://chatgpt.com/codex/install.sh | sh

Au premier lancement, Codex propose de se connecter avec un compte ChatGPT (« Sign in with ChatGPT »). J’ai décrit l’installation pas à pas, avec la connexion et le fichier CLAUDE.md, dans mon tutoriel Claude Code.

Étape 2 : comment confier une première tâche à l’agent ?

On se place dans le dossier de n’importe quel projet et on lance l’agent :

cd /chemin/vers/le/projet
claude

(Codex se lance de la même façon, avec la commande codex.) Au premier lancement, Claude Code demandera de se connecter dans le navigateur.

Commençons par une question qui ne change rien, mais montre tout de suite la boucle de l’agent :

what does this project do?

L’agent parcourt les fichiers tout seul et revient avec un résumé. Pas besoin de coller ou d’indiquer quoi que ce soit.

Ensuite, une petite tâche qui modifie déjà quelque chose :

add a hello world function to the main file

Claude Code trouvera le bon fichier et affichera la modification. S’il demande l’autorisation, on choisit Yes. On peut aussi écrire ses demandes en français ; les exemples ci-dessus viennent directement de la documentation.

Étape 3 : comment définir ce que l’agent peut faire seul ?

C’est la partie la plus importante, car l’agent tourne sur notre ordinateur. Dans Claude Code, c’est le mode de permissions qui en décide ; on le change avec Shift+Tab :

1. Manual : l’agent demande avant chaque modification de fichier et chaque commande dans le terminal. Un bon point de départ.
2. Accept edits : l’agent modifie les fichiers et effectue les opérations simples sur les fichiers sans demander, mais demande toujours pour les autres commandes.
3. Plan : l’agent se contente d’explorer le code et de proposer un plan, il ne modifie rien dans les fichiers source.
4. Auto : un classifieur en arrière-plan examine les actions et bloque celles qui sont risquées, au lieu de nous demander.

Le deuxième filet de sécurité, ce sont les checkpoints. Avant chaque modification, Claude Code fait une copie du fichier, et un double Esc annule les changements. Une limite cependant : les checkpoints ne couvrent que les fichiers, ils n’annulent donc pas les actions sur des bases de données, des API ou des déploiements (c’est pourquoi on laisse ce genre d’opérations dans un mode qui demande l’autorisation).

On peut aussi interrompre l’agent à tout moment avec Esc, ou taper une correction pendant qu’il travaille : l’agent en tiendra compte à l’étape suivante.

Étape 4 : comment rédiger des tâches pour un agent ?

La documentation conseille de traiter l’agent comme un collègue compétent : lui donner le contexte et l’objectif, et lui laisser les détails. Trois règles qui marchent :

1. Du concret plutôt que du vague : « corrige le bug de connexion qui affiche un écran vide après un mauvais mot de passe », et non « corrige le bug ».
2. Une grosse tâche découpée en étapes : d’abord la table en base de données, puis l’endpoint de l’API, enfin la page.
3. D’abord explorer, ensuite modifier : demandons à l’agent d’analyser le code avant de toucher à quoi que ce soit (le mode Plan est parfait pour ça).

Les règles permanentes du projet vont dans le fichier CLAUDE.md. La commande /init en génère une première version.

À quoi faire attention ?

D’abord, aux coûts. Anthropic l’écrit clairement : l’autonomie des agents signifie des coûts plus élevés et un risque d’erreurs qui s’accumulent. Un agent qui enchaîne des dizaines d’étapes consomme bien plus de tokens qu’une simple réponse dans le chat.

Ensuite, à la sécurité. Un agent qui a accès au terminal voit ce que nous voyons, y compris les clés API dans les fichiers .env. Anthropic recommande de tester dans un environnement isolé avec les garde-fous adaptés ; le sandbox, les règles de permissions et les plafonds de dépenses, je les ai décrits dans mon guide sur la sécurité des agents IA. Que ce ne soit pas de la théorie, l’histoire des agents qui se sont échappés de leur sandbox pendant l’entraînement chez OpenAI le montre bien.

Enfin, à la vérification. L’agent vérifie lui-même son travail, mais la review avant le merge reste notre affaire ;)

FAQ

Qu’est-ce qu’un agent IA, en termes simples ?

C’est un modèle d’IA qui reçoit un objectif et exécute lui-même les étapes pour l’atteindre : il utilise des outils, vérifie les résultats et se corrige jusqu’à avoir terminé. Un chatbot, lui, ne fait que répondre à la question.

Un agent IA est-il gratuit ?

Claude Code nécessite un abonnement Claude payant ou des crédits API. Pour Codex CLI, on se connecte avec un compte ChatGPT, et la disponibilité dépend de l’abonnement. On peut aussi faire tourner gratuitement un modèle en local, ce que j’explique dans mon guide pour faire tourner une IA en local.

Un agent IA peut-il casser quelque chose sur mon ordinateur ?

Oui, car il exécute de vraies commandes. C’est pourquoi on commence en mode Manual ou Plan, et on annule les modifications de fichiers avec les checkpoints ou avec git.

Quelle différence entre un agent IA et un workflow ?

Dans un workflow, c’est le développeur qui fixe les étapes et le modèle se contente de les remplir. Un agent décide lui-même quelles étapes suivre et dans quel ordre.