Apprendre les agents IA depuis zéro en 6 étapes

Le parcours en six étapes

Pour apprendre les agents IA depuis 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 seule chose de vos propres mains. Passer directement aux étapes suivantes 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 qui peut appeler des outils. Cette phrase résume tout le sujet. Tout le reste décrit ce qui entre dans la boucle, ce que les outils peuvent toucher et comment arrêter la boucle lorsqu’un problème survient. Si vous pouvez expliquer la boucle à quelqu’un d’autre, vous avez compris le sujet. Si vous pouvez 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é, cassez-le volontairement, puis passez à l’étape suivante. 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 honnête 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 package, modifier un fichier, lire un log.
• Vous disposez d'une clé API pour un modèle hébergé, ou d'une machine capable d'en exécuter un en local.

C'est toute la liste. Vous n'avez pas besoin de théorie du machine learning et vous n'avez pas besoin d'avoir entraîné un modèle. Le travail sur les agents n'implique ni gradients ni données d'entraînement. Une carte graphique est utile uniquement 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 en consultant héberger Ollama sur un VPS pour auto-héberger un LLM.

Ce que les utilisateurs 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 incite à 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 consultez 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) pour ses entrées. Le modèle n’exécute rien. Il répond par une demande structurée : appeler run_command avec ces arguments. Votre code exécute la fonction, renvoie sa sortie sous forme de message et interroge de nouveau le modèle. Le modèle est un planificateur qui lit du texte et écrit du texte. Votre code est l’élément qui exécute les actions.

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. Toute la différence est là. Les modes de défaillance diffèrent donc aussi. Un chatbot donne une mauvaise réponse une seule fois. Un agent agit 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 seule fois

Ne commencez pas par un framework. Écrivez environ trente lignes de Python pour vous approprier la structure.

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"))

Exécutez le programme avec python3 agent.py. Une exécution correcte affiche un paragraphe qui indique le nom de vos systèmes de fichiers et leur espace libre, car le modèle a demandé df -h, votre code l’a exécuté, 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 les valeurs changer.

Cassez ensuite volontairement le programme. Supprimez la ligne tool_use_id et lisez l’erreur, car l’API rejette un résultat d’outil sans identifiant correspondant. C’est le bug de débutant le plus courant. 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. Cela peut être acceptable sur une machine de test que vous pouvez reconstruire, 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 qui accèdent à des ressources externes au serveur : 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. 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 tient en une seule commande :

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

Node doit être installé. L’argument correspondant au répertoire est le seul chemin auquel le serveur accédera. C’est le modèle de sécurité en résumé : le serveur définit la limite, pas le modèle. Configurez un client pour l’utiliser. Votre agent pourra alors 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 une explication des choix de transport, est décrite dans exécuter des serveurs MCP sur un VPS pour des agents de codage IA.

La leçon de cette étape est que la conception des outils constitue le véritable travail. Une description vague oblige le modèle à deviner. Un outil qui renvoie quarante mille caractères empoisonne 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 utilisent ici une vector database. Ne le faites pas, du moins pas encore.

Un agent n’a aucune mémoire entre les appels. Vous 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 2 problèmes. Le premier concerne ce qui tient actuellement dans la context window. 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 n’en payer qu’une fraction. Le second concerne ce qui subsiste après 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 vector database 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 la plupart des avantages, et vous pouvez ouvrir le fichier pour voir ce que votre agent croit. Utilisez les embeddings et la retrieval lorsque les notes ne tiennent plus dans la context window, et 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 lorsque vous ne le surveillez pas.

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é ? Un agent qui corrige lui-même son travail réussit toujours. Quel budget l’arrête, en tokens ou en temps réel ? La conception réfléchie de ces quatre éléments constitue la discipline décrite dans l’ingénierie des boucles et ce que recouvre cette définition.

L’exercice : prenez votre agent de l’étape 2, donnez-lui une tâche qui nécessite quatre ou cinq étapes, puis ajoutez une limite stricte 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 par accident avec un budget important.

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

Cette étape est obligatoire. Elle vient 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 sans privilèges, jamais avec root et jamais avec votre propre compte. Ainsi, le rayon d’impact se limite à un répertoire plutôt qu’à la machine entière. Gardez les identifiants hors de portée du modèle. Tout ce qui se trouve dans la fenêtre de contexte peut être renvoyé par un appel d’outil. La solution consiste à utiliser des tokens à durée de vie courte, dont la portée est limitée, via un helper, comme indiqué dans garder les secrets hors de portée de vos agents IA. Fixez un plafond de dépenses strict. Une boucle sans supervision facture chaque itération sans personne pour la surveiller. Les plafonds et le traitement par lots qui permettent de maîtriser ces coûts sont décrits dans contrôler les coûts d’un agent IA sur un VPS toujours actif.

Les coûts nécessitent 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 quelques centaines de milliers de tokens dans une seule tâche. La mise en cache des prompts et l’utilisation d’un modèle plus petit pour les étapes courantes modifient bien davantage ce calcul que n’importe quel ajustement du prompt.

L’injection de prompt doit également être prise en compte. 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 destinées à votre agent. La protection 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 devez-vous suivre ?

Choisissez un seul programme 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 ci-dessus. Les listes de dépôts d’agents populaires sont utiles pour voir ce qui existe. Elles le sont beaucoup moins comme programme d’apprentissage, car un classement par nombre d’étoiles reflète la popularité et non l’ordre pédagogique.

Pour vous exercer sur un projet réel, commencez de préférence par un coding agent. Le feedback est immédiat, les outils sont évidents et les erreurs sont faciles à annuler. Exécuter un agent IA de programmation sur un VPS présente toute la procédure de bout en bout. Si vous préférez étudier des systèmes fonctionnels plutôt que de partir de zéro, la comparaison dans les meilleurs agents IA auto-hébergés montre comment plusieurs projets implémentent différemment la même boucle.

Combien de temps cela prend-il ?

Pour une personne qui programme déjà, les étapes 1 et 2 prennent 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 découvrez uniquement ce que votre agent oublie en l’observant oublier. L’étape 6 ne se termine jamais vraiment, car chaque nouvelle capacité que vous accordez relance le processus.

Deux mois de soirées régulières suffisent à la plupart des personnes pour obtenir un agent fonctionnel, aux capacités délimitées et utile. Les personnes qui y consacrent un an sont généralement celles qui ont continué à lire au lieu de construire.

FAQ

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

Non. Créer un agent consiste à appeler un modèle via une API et à relier ses demandes d’outils à de vraies fonctions. Il s’agit de programmation d’applications classique. Vous ne manipulez jamais l’entraînement, les gradients ou les 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 pertinente uniquement si vous décidez ensuite d’affiner un modèle. Il s’agit d’un autre travail, avec d’autres prérequis.

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

Écrivez d’abord 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 une fois que vous savez ce qu’il remplace, mais déroutant avant cela. Lorsque votre agent se comporte mal, vous devez examiner directement 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 votre propre boucle, un framework vous fait gagner du temps au lieu de masquer le fonctionnement.

Combien coûte l’apprentissage des agents d’IA ?

Moins que la plupart des gens ne le pensent, si vous fixez une limite. Une clé d’API hébergée et un petit VPS suffisent pour ces six étapes. Le véritable risque ne vient pas du tarif horaire. Il vient 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. Utilisez un modèle moins cher pour les étapes courantes. L’exécution du modèle en local supprime la facture liée aux tokens, mais impose du matériel adapté.

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

Un chatbot répond une fois. Un agent répète un cycle : le modèle demande un outil, votre code l’exécute, le résultat est renvoyé, puis le modèle décide quoi faire ensuite. Cette répétition permet à un agent d’achever 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 tout ce qu’il a fait ensuite.