Apprendre les agents IA à partir de zéro

Le parcours en six étapes

Pour apprendre les agents IA à partir de zéro, suivez six étapes dans l’ordre : les concepts, votre première boucle, les outils, la mémoire, la conception de la boucle et la sécurité. À chaque étape, vous construisez une chose de vos propres mains. Sauter des étapes est la raison la plus fréquente des blocages, car un framework masque précisément la partie que vous deviez voir.

Un agent IA est une boucle autour d’un modèle de langage auquel on permet d’appeler des outils. Cette phrase résume tout le sujet. Tout le reste concerne les éléments qui entrent dans la boucle, ce que les outils peuvent manipuler et la manière d’arrêter la boucle lorsqu’elle fonctionne mal. Si vous pouvez expliquer la boucle à quelqu’un d’autre, vous avez compris le principe. Si vous savez seulement citer des frameworks, ce n’est pas le cas.

Le plan ci-dessous part du principe que vous apprenez en construisant. Lisez une étape, construisez le petit élément demandé, provoquez volontairement une erreur, puis passez à la suite. Une étape que vous avez seulement lue est une étape que vous n’avez pas réalisée.

Ce dont vous avez réellement besoin avant l’étape 1

La liste des prérequis est courte, et plus courte que ne le laissent entendre la plupart des pages de cours.

• Vous savez lire et écrire du Python ou du TypeScript au niveau d’un script de cinquante lignes.
• Vous êtes à l’aise dans un shell Linux : installer un paquet, modifier un fichier, consulter un journal.
• Vous disposez d’une clé API pour un modèle hébergé ou d’une machine capable d’exécuter un modèle local.

C’est toute la liste. Vous n’avez pas besoin de théorie sur le machine learning ni d’avoir entraîné un modèle. Le fonctionnement des agents ne fait intervenir ni gradients ni données d’entraînement. Une carte graphique n’est utile que si vous décidez d’exécuter vous-même le modèle. Il s’agit d’une compétence distincte que vous pourrez acquérir plus tard avec héberger Ollama sur un VPS pour auto-héberger un LLM.

Ce que les gens sous-estiment, c’est la partie shell. Les agents échouent à cause des permissions, des chemins, des variables d’environnement et des processus qui s’arrêtent silencieusement. Si une stack trace concernant PATH ou un mode de fichier vous pousse à fermer le terminal, consacrez d’abord un week-end aux bases de Linux. Cela vous fera gagner un mois par la suite.

Étape 1 : ce qu’est un agent et ce qu’il n’est pas

Commencez par un seul appel d’API, sans boucle. Envoyez un prompt, affichez la réponse et examinez le nombre de tokens dans la réponse. Vous comprenez alors l’unité de coût et l’unité de latence.

Apprenez ensuite à utiliser les outils. C’est la seule idée réellement nouvelle dans tout ce domaine. Vous décrivez une fonction au modèle avec un nom, une description et un schéma JSON (JavaScript Object Notation) de ses entrées. Le modèle n’exécute rien. Il répond avec une demande structurée : appelez run_command avec ces arguments. Votre code exécute la fonction, renvoie le résultat sous forme de message, puis interroge à nouveau le modèle. Le modèle planifie, lit du texte et écrit du texte. Votre code est ce qui agit concrètement. Le code de votre côté de cet échange porte un nom dès que vous commencez à comparer les architectures : c’est le harness de l’agent, c’est-à-dire la boucle, les outils et les permissions qui entourent un modèle dépourvu de tout cela.

Un chatbot s’arrête après une réponse. Un agent répète cet échange jusqu’à ce que le modèle cesse de demander des outils. Cette répétition constitue toute la différence. C’est aussi pourquoi les modes de défaillance diffèrent. Un chatbot donne une mauvaise réponse une fois. Un agent peut agir plusieurs fois à partir d’une mauvaise réponse avant que quelqu’un ne s’en aperçoive.

Étape 2 : écrivez vous-même la boucle, une fois

Ne commencez pas avec un framework. Écrivez une trentaine de lignes de Python afin de vous approprier la structure du programme.

sudo apt update && sudo apt install -y python3-venv
python3 -m venv ~/agent
source ~/agent/bin/activate
pip install anthropic
export ANTHROPIC_API_KEY=your-key-here

import subprocess
import anthropic

client = anthropic.Anthropic()

tools = [{
    "name": "run_command",
    "description": "Run a read only shell command and return its output.",
    "input_schema": {
        "type": "object",
        "properties": {"command": {"type": "string"}},
        "required": ["command"],
    },
}]

messages = [{"role": "user", "content": "How much disk space is free here?"}]

while True:
    response = client.messages.create(
        model="claude-opus-5",
        max_tokens=4096,
        tools=tools,
        messages=messages,
    )
    if response.stop_reason != "tool_use":
        break
    messages.append({"role": "assistant", "content": response.content})
    results = []
    for block in response.content:
        if block.type == "tool_use":
            done = subprocess.run(
                block.input["command"], shell=True,
                capture_output=True, text=True, timeout=10,
            )
            results.append({
                "type": "tool_result",
                "tool_use_id": block.id,
                "content": done.stdout or done.stderr,
            })
    messages.append({"role": "user", "content": results})

print(next(b.text for b in response.content if b.type == "text"))

Lancez-le avec python3 agent.py. Une exécution correcte affiche un paragraphe qui indique vos systèmes de fichiers et leur espace libre, car le modèle a demandé df -h, votre code l’a exécutée, puis le second passage a transformé ce tableau en phrase. Si rien ne s’affiche, la boucle s’est terminée avant l’arrivée d’un bloc de texte. Ajoutez print(response.stop_reason) dans la boucle et observez l’évolution des valeurs.

Cassez maintenant le programme volontairement. Supprimez la ligne tool_use_id et lisez l’erreur, car l’API rejette un résultat d’outil sans identifiant correspondant. C’est l’erreur de débutant la plus fréquente. Posez une question qui nécessite deux commandes et observez la boucle s’exécuter deux fois. Posez une question impossible et observez le programme abandonner ou boucler indéfiniment.

Un avertissement concernant cet exemple. Il transmet directement la sortie du modèle à un shell avec shell=True. C’est acceptable sur une machine de test que vous pouvez réinstaller, mais c’est incorrect partout ailleurs. L’étape 6 corrige ce problème. Les concepts liés à cette boucle sont expliqués plus en détail dans créer votre propre agent IA sur un VPS.

Étape 3 : outils que l’agent n’avait pas déjà

Votre outil run_command fonctionne, mais un agent réel a besoin d’outils capables d’accéder à des services externes : un système de tickets, une base de données ou un dépôt. Écrire un wrapper spécifique pour chaque service et pour chaque agent ne passe pas à l’échelle.

Le Model Context Protocol (MCP) est la solution retenue par le secteur. Un serveur MCP expose un ensemble d’outils via un transport standard, et tout agent compatible avec MCP peut les utiliser sans code d’intégration personnalisé. Le serveur de référence pour le système de fichiers se lance avec une seule commande :

npx -y @modelcontextprotocol/server-filesystem /home/you/projects

Node doit être installé, et l’argument désignant le répertoire est le seul chemin auquel le serveur accédera. C’est le modèle de sécurité sous sa forme la plus simple : le serveur définit la limite, pas le modèle. Il suffit de le fournir à un client pour que votre agent puisse lire et écrire des fichiers sans que vous ayez développé ces fonctions. L’exécution correcte de ces serveurs, avec un compte de service et les différents choix de transport expliqués, est présentée dans exécuter des serveurs MCP sur un VPS pour des agents de codage IA. Pour un second serveur qui pointe vers de vraies données plutôt que vers un répertoire de travail, auto-héberger openGym, un suivi des entraînements fournit un serveur en lecture seule. Vous pouvez ainsi vous exercer à poser des questions sur votre propre historique d’entraînement sans donner à l’agent accès à des actions qu’il pourrait effectuer de manière destructive.

La leçon de cette étape est que la conception des outils constitue le vrai travail. Une description vague oblige le modèle à deviner. Un outil qui renvoie quarante mille caractères pollue la fenêtre de contexte. Un outil capable de supprimer des éléments finira par en supprimer.

Étape 4 : la mémoire, qui consiste principalement en fichiers

Les débutants se tournent ici vers une base de données vectorielle. Ne le faites pas, du moins pas tout de suite.

Un agent n’a aucune mémoire entre deux appels. Vous lui renvoyez toute la conversation à chaque fois. C’est pourquoi une longue session coûte plus cher par tour qu’une session courte. La mémoire se divise donc en deux problèmes. Le premier concerne ce qui tient actuellement dans la fenêtre de contexte. Vous le gérez en résumant, en supprimant les anciennes sorties des outils et en mettant en cache le préfixe stable de votre prompt, afin de ne payer qu’une fraction de son prix. Le second concerne ce qui survit à un redémarrage. Il s’agit du stockage.

Pour le second problème, un simple fichier markdown que l’agent peut lire et modifier est préférable à une base de données vectorielle pour presque tous les premiers projets. Donnez-lui un fichier, indiquez-lui le format, demandez-lui de lire ce fichier avant de commencer et de le mettre à jour lorsqu’il apprend quelque chose. Vous obtenez l’essentiel du bénéfice, et vous pouvez ouvrir le fichier pour voir ce que votre agent croit. Utilisez les embeddings et la recherche documentaire lorsque les notes ne tiennent plus dans la fenêtre de contexte, mais pas avant.

Étape 5 : la boucle est le produit

À ce stade, vous savez créer un agent qui fonctionne lorsque vous le surveillez. L’étape 5 consiste à le faire fonctionner sans surveillance.

Quatre questions déterminent si vous pouvez laisser un agent sans surveillance en toute sécurité. Qu’est-ce qui le déclenche, afin qu’il ne s’exécute pas sans raison ? Dans quelles limites fonctionne-t-il, afin qu’une erreur reste limitée ? Comment le résultat est-il vérifié, car un agent qui corrige lui-même son devoir donne toujours une réponse positive ? Quel budget l’arrête, en tokens ou en durée réelle ? Concevoir volontairement ces quatre éléments constitue la discipline décrite dans l’ingénierie des boucles et ce que cette définition recouvre.

L’exercice : reprenez votre agent de l’étape 2, donnez-lui une tâche qui nécessite quatre ou cinq étapes, puis ajoutez une limite stricte au nombre d’itérations. Supprimez ensuite cette limite et observez l’effet d’une boucle sans limite sur votre facture de tokens. Faites-le une fois avec un petit budget, afin de ne jamais le faire accidentellement avec un budget important.

Étape 6 : sécurité, secrets et coûts

Cette étape est obligatoire. Elle arrive en dernier uniquement parce que vous ne pouvez pas mesurer le risque avant d’avoir construit quelque chose qui fonctionne.

Exécutez l’agent avec son propre utilisateur non privilégié, jamais avec root ni avec votre propre compte. Ainsi, l’impact d’une compromission se limite à un répertoire plutôt qu’à toute la machine. Gardez les identifiants hors de portée du modèle, car tout ce qui se trouve dans la fenêtre de contexte peut être renvoyé par un tool call. La solution consiste à utiliser des tokens à durée de vie courte et à portée limitée, derrière un helper, comme indiqué dans conserver les secrets hors de portée de vos agents IA. Fixez une limite stricte aux dépenses, car une boucle sans surveillance facture chaque itération. Les plafonds et le batching qui permettent de maîtriser ces coûts sont présentés dans contrôler le coût d’un agent IA sur un VPS toujours allumé.

Si votre agent s’exécute dans un harness plutôt que dans un script que vous avez écrit vous-même, une partie de cette étape relève de la configuration et non du code. les plugins DeepSeek Harness qui valent la peine d’être installés couvrent une grande partie des mêmes besoins, avec des plafonds budgétaires, des règles d’autorisation des tools et une analyse des injections.

Les coûts méritent un chiffre concret. En juillet 2026, Claude Opus 5 facture $5 par million de tokens d’entrée et $25 par million de tokens de sortie. Un agent bavard qui renvoie une conversation de plus en plus longue peut faire passer plusieurs centaines de milliers de tokens pour une seule tâche. Le prompt caching et l’utilisation d’un modèle plus petit pour les étapes courantes modifient beaucoup plus ce calcul que n’importe quelle retouche du prompt.

Les injections de prompt ont aussi leur place ici. Si votre agent lit une page web, un issue tracker ou une boîte de réception, la personne qui a écrit ce texte écrit aussi des instructions pour votre agent. La recherche web est généralement le premier tool à ouvrir cette porte. diriger un agent vers votre propre instance SearXNG présente à la fois la configuration et la surface d’injection créée. La défense ne consiste pas à rédiger un system prompt plus astucieux. Elle repose sur la séparation des privilèges : un agent qui ne peut pas supprimer un dépôt ne peut pas être convaincu de le supprimer.

Quel parcours suivre ?

Choisissez un seul cursus et terminez-le au lieu d’en parcourir six. Le dépôt Microsoft ai-agents-for-beginners est le plus complet parmi les ressources gratuites. Il propose un cours de dix-huit leçons qui avait dépassé 70,000 étoiles en juillet 2026. Il correspond bien aux étapes présentées plus haut. Les sélections de dépôts d’agents populaires permettent de voir ce qui existe, mais servent beaucoup moins bien de programme d’apprentissage. Une liste triée par nombre d’étoiles est classée selon la popularité, pas selon l’ordre pédagogique.

Pour vous exercer sur un projet réel, un agent de programmation constitue la meilleure première cible. Les retours sont immédiats, les outils sont évidents et les erreurs sont faciles à annuler. Exécuter un agent IA de programmation sur un VPS présente un exemple de bout en bout. Si vous préférez étudier des systèmes fonctionnels plutôt que de partir de zéro, la comparaison présentée dans les meilleurs agents IA auto-hébergés montre comment plusieurs projets implémentent différemment la même boucle.

Combien de temps faut-il prévoir ?

Pour quelqu’un qui sait déjà programmer, les étapes 1 et 2 tiennent en une soirée. L’étape 3 prend un week-end, consacré en grande partie à la description des outils plutôt qu’au protocole. Les étapes 4 et 5 demandent quelques semaines d’utilisation réelle, car vous ne découvrez ce que votre agent oublie qu’en l’observant oublier. L’étape 6 ne se termine jamais vraiment : chaque nouvelle capacité que vous lui accordez la relance.

Deux mois de soirées régulières suffisent à la plupart des gens pour obtenir un agent fonctionnel, limité et utile. Ceux qui y consacrent un an sont généralement ceux qui ont continué à lire au lieu de construire.

FAQ

Dois-je connaître le machine learning pour créer un agent IA ?

Non. Créer un agent consiste à appeler un modèle via une API et à relier ses demandes d’outils à de vraies fonctions, ce qui relève de la programmation d’applications classique. Vous ne manipulez ni entraînement, ni gradients, ni jeux de données. Les compétences qui déterminent le bon fonctionnement de votre agent sont la conception des schémas d’outils, la gestion des erreurs et les permissions Linux. La théorie du machine learning devient utile uniquement si vous décidez ensuite de fine-tuner un modèle, ce qui constitue un autre travail avec d’autres prérequis.

Dois-je commencer avec un framework comme LangChain ou CrewAI ?

Commencez par écrire une boucle brute, puis adoptez un framework. Un framework remplace les trente lignes de l’étape 2 par un objet de configuration. C’est pratique lorsque vous savez ce qu’il remplace, mais déroutant avant cela. Lorsque votre agent se comporte mal, vous devez raisonner directement sur la liste des messages et les résultats des outils. C’est beaucoup plus difficile si vous ne les avez jamais vus. Après avoir écrit une boucle vous-même, un framework vous fait gagner du temps au lieu de masquer le mécanisme.

Combien coûte l’apprentissage des agents IA ?

Moins que la plupart des gens ne le pensent, si vous fixez des limites. Une clé API hébergée et un petit VPS suffisent pour ces six étapes. Le vrai risque ne vient pas du tarif horaire, mais d’une boucle sans limite qui facture chaque itération pendant votre sommeil. Définissez dès le premier jour une limite stricte de dépenses sur votre compte API, ajoutez une limite d’itérations à chaque boucle que vous écrivez et utilisez un modèle moins coûteux pour les étapes courantes. Exécuter le modèle localement supprime la facturation des tokens, mais impose du matériel adapté.

Quelle est la différence entre un agent IA et un chatbot ?

Un chatbot répond une seule fois. Un agent répète un cycle : le modèle demande un outil, votre code l’exécute, le résultat est renvoyé au modèle, puis celui-ci décide de l’étape suivante. Cette répétition permet à l’agent d’accomplir une tâche en plusieurs étapes. C’est aussi pourquoi les agents ont besoin de limites que les chatbots n’ont pas. Une mauvaise réponse d’un chatbot est un mauvais paragraphe. Une mauvaise réponse d’un agent est un mauvais paragraphe, auquel s’ajoute ce qu’il a fait en conséquence.