Construire un AI agent soi-meme

Ce qu'est vraiment un AI agent

Un AI agent est un logiciel qui utilise un modele de langage pour decider et agir dans une boucle, au lieu de repondre une seule fois. Le modele est le cerveau, mais un cerveau sans mains ne peut rien faire, donc vous lui donnez des tools: des fonctions qu'il peut appeler pour lire un fichier, interroger une base de donnees, chercher sur le web ou taper une API. L'agent tourne en boucle: le modele recoit l'objectif et la liste des tools disponibles, il repond ou demande d'appeler un tool, votre code execute ce tool et renvoie le resultat, et le modele utilise le resultat pour decider de son prochain pas. Cette boucle est toute l'idee. "Agentic AI" est le terme plus large pour les systemes construits ainsi; un "AI agent" est un tel systeme. Pour les definitions precises, voir les entrees de glossaire sur AI agent, agentic AI, tool calling et l'agent harness.

• Modele: le coeur de raisonnement qui decide quoi faire (un LLM qui supporte le tool calling).
• Tools: des fonctions que le modele peut appeler pour agir sur le monde, chacune avec un nom, une description et un schema d'input.
• Boucle: le modele decide, votre code execute le tool choisi, le resultat revient, on repete jusqu'a la fin.
• Voir le glossaire: AI agent, agentic AI, tool calling, agent harness pour les definitions formelles.

La boucle de build, etape par etape

Chaque agent, du script de dix lignes a Claude Code, tourne la meme boucle. Vous envoyez au modele la conversation jusqu'ici plus les definitions de tools. Le modele repond de l'une de deux facons: avec une reponse finale (il a fini) ou en demandant d'appeler un ou plusieurs tools. S'il veut un tool, votre code execute ce tool, capture la sortie, l'ajoute a la conversation comme resultat de tool et renvoie le tout. Le modele lit le resultat et decide de nouveau. Vous bouclez jusqu'a ce que le modele donne une reponse finale ou que vous atteigniez une limite de securite d'iterations. Les deux garde-fous non negociables sont un nombre maximum de tours, pour qu'un agent confus ne boucle pas indefiniment, et la validation des inputs de tools, car le modele vous demande d'executer du vrai code avec des arguments qu'il choisit lui-meme.

• Envoyez l'objectif, l'historique de conversation et les definitions de tools au modele.
• Si le modele renvoie une reponse finale, arretez et renvoyez-la.
• S'il demande un tool, validez l'input, executez le tool, ajoutez le resultat et bouclez.
• Limitez toujours le nombre d'iterations et validez les arguments de tools avant d'executer.

Un agent minimal que vous pouvez construire

Voici le plus petit agent qui fait quelque chose de reel: un modele avec un tool (une calculatrice) qui tourne la boucle de tool calling a la main contre l'API Anthropic Messages. Le motif est identique pour tout fournisseur qui supporte le tool calling. Le modele recoit la question et la definition du tool; quand il repond avec stop_reason "tool_use", nous executons le tool, renvoyons un tool_result et bouclons jusqu'a ce qu'il donne une reponse en texte pur. Lisez-le une fois, et la magie disparait: un agent est une boucle, un modele et un dictionnaire de fonctions.

# pip install anthropic
# A minimal agent: one tool, the tool-calling loop by hand.
import anthropic

client = anthropic.Anthropic()  # reads ANTHROPIC_API_KEY from the env

# 1) Define the tools: a name, a description, and an input schema.
tools = [
    {
        "name": "calculator",
        "description": "Evaluate a basic arithmetic expression.",
        "input_schema": {
            "type": "object",
            "properties": {"expression": {"type": "string"}},
            "required": ["expression"],
        },
    }
]

# 2) Map tool names to the real functions that run them.
def calculator(expression: str) -> str:
    # Real code: validate hard. A toy eval is fine only for a demo.
    allowed = set("0123456789+-*/(). ")
    if not set(expression) <= allowed:
        return "error: invalid characters"
    return str(eval(expression))  # demo only; never eval untrusted input in prod

TOOLS = {"calculator": calculator}

# 3) The loop.
def run_agent(goal: str, max_turns: int = 8) -> str:
    messages = [{"role": "user", "content": goal}]
    for _ in range(max_turns):
        resp = client.messages.create(
            model="claude-sonnet-4-5",
            max_tokens=1024,
            tools=tools,
            messages=messages,
        )
        if resp.stop_reason != "tool_use":
            return "".join(b.text for b in resp.content if b.type == "text")
        messages.append({"role": "assistant", "content": resp.content})
        results = []
        for block in resp.content:
            if block.type == "tool_use":
                out = TOOLS[block.name](**block.input)
                results.append({
                    "type": "tool_result",
                    "tool_use_id": block.id,
                    "content": out,
                })
        messages.append({"role": "user", "content": results})
    return "stopped: hit the turn limit"

print(run_agent("What is 4321 * 1234, then add 99?"))

C'est vraiment tout ce qu'est un agent. Pour le rendre utile, vous ajoutez plus de tools (lire un fichier, appeler votre API, interroger une base de donnees), vous donnez a chacun une description precise pour que le modele sache quand l'utiliser, et vous durcissez le chemin d'execution. Le eval dans la calculatrice est juste pour la demo; n'executez jamais de code ou d'expressions choisis par le modele sans validation stricte ou une sandbox.

Utilisez un framework des que vous comprenez la boucle

Construire la boucle a la main une fois est le meilleur moyen de comprendre les agents, mais en production vous recourez a un framework qui gere la boucle, les retries, le streaming, les sessions et les permissions pour vous. En 2026, les deux voies les plus directes sont le Claude Agent SDK, qui offre la meme boucle d'agent, le meme jeu de tools et la meme gestion de contexte qui animent Claude Code (installez @anthropic-ai/claude-agent-sdk pour TypeScript ou claude-agent-sdk pour Python), et le OpenAI Agents SDK, un framework Python et TypeScript leger qui transforme toute fonction en tool avec generation automatique de schema (pip install openai-agents). Les deux vous donnent le tool calling, les boucles multi-etapes, les checkpoints human-in-the-loop, les subagents et un support MCP de premiere classe out of the box. Le principe est le meme que celui que vous venez de construire; le SDK enleve juste la plomberie.

• Claude Agent SDK: la meme boucle et les memes tools qui font tourner Claude Code, programmables en Python et TypeScript, avec MCP et subagents integres.
• OpenAI Agents SDK: un framework multi-agents leger qui transforme toute fonction en tool valide (pip install openai-agents).
• Les deux gerent la boucle, les retries, le streaming, les sessions et les permissions que vous ecririez sinon a la main.
• Connectez des tools externes via le MCP plutot que via de la colle sur mesure; voir Qu'est-ce qu'un serveur MCP.

Les niveaux d'autonomie

Tout agent ne devrait pas etre pleinement autonome, et choisir le bon niveau est une decision de conception, pas un defaut. Pensez a une echelle. Tout en bas, le modele ne fait que proposer, et un humain fait tout. Un barreau plus haut, il redige, et un humain approuve chaque action. Plus haut, il agit de maniere autonome sur les etapes a faible risque mais fait une pause pour tout ce qui est sensible, pour approbation (un checkpoint human-in-the-loop). Tout en haut, il execute un workflow entier sans surveillance. Le bon niveau depend du cout d'une erreur: plus une erreur fait mal, plus vous gardez de supervision humaine. La plupart des agents de production fiables siegent au milieu, pleinement autonomes sur les actions sures et reversibles et gates sur le reste. Le cours Automation and Agentic Systems traite cela comme les 5 niveaux d'autonomie des LLM.

• Proposer seulement: l'agent propose, un humain fait tout. Risque le plus faible, effet de levier le plus faible.
• Rediger et approuver: l'agent prepare l'action, un humain confirme avant qu'elle ne tourne.
• Autonome avec checkpoints: il agit sur les etapes sures et fait une pause sur les risquees pour approbation.
• Pleinement sans surveillance: il execute tout le workflow seul; reservez cela aux taches a faible risque et reversibles.

Rendre votre agent pret pour la production

Un agent de demo et un agent de production different en tout ce qui entoure la boucle. Le modele et les tools sont la partie facile; la fiabilite est le travail. Validez chaque input de tool, car le modele choisit les arguments. Executez tout ce qui execute du code ou touche le monde exterieur dans une sandbox avec des timeouts et des limites de ressources, jamais sur une machine qui compte pour vous. Loggez chaque etape (l'objectif, chaque appel de tool, chaque resultat), pour voir ce que l'agent a fait et pouvoir le debugger quand ca tourne mal. Limitez les iterations et les couts, pour qu'un agent confus ne boucle pas indefiniment ni ne fasse grimper une facture. Et gardez un humain dans la boucle pour les actions irreversibles ou sensibles. Ce sont les memes lecons que les builds du fondateur ont apprises a la dure: CallAssistant a donne a son agent vocal des tools etroitement definis parce qu'il n'y a pas de "vous etes sur ?" au telephone, et CodeCourier n'a execute du code non fiable que dans une sandbox jetable.

• Validez les inputs de tools et executez les tools qui executent du code dans une sandbox avec timeouts et limites.
• Loggez l'objectif, chaque appel de tool et chaque resultat, pour que l'agent soit observable et debuggable.
• Limitez les iterations et les depenses, pour qu'une boucle emballee ne vous coute ni temps ni argent.
• Gatez les actions irreversibles ou sensibles derriere une etape d'approbation human-in-the-loop.
• Apprenez des vrais builds: CallAssistant (tools etroits) et CodeCourier (sandboxing) sur la page Builds.

Pas à pas

1. 01

   Choisir un modele de tool calling

   Choisissez un modele qui supporte le tool calling (par exemple un tier Claude ou GPT) et obtenez une cle API. La boucle d'agent est identique sur tous les fournisseurs qui supportent les tools.

2. 02

   Definir vos tools

   Pour chaque action dont l'agent a besoin, ecrivez une fonction et une definition de tool avec un nom, une description claire et un schema d'input. La description est ce que le modele lit pour decider quand l'appeler.

3. 03

   Ecrire la boucle

   Envoyez l'objectif, la conversation et les definitions de tools au modele. S'il donne une reponse finale, arretez. S'il demande un tool, validez l'input, executez le tool, ajoutez le resultat et renvoyez le tout.

4. 04

   Ajouter des garde-fous

   Limitez le nombre d'iterations, validez chaque argument de tool et executez chaque tool qui execute du code dans une sandbox avec des timeouts. Loggez chaque etape pour voir ce que l'agent a fait.

5. 05

   Choisir un niveau d'autonomie

   Decidez quelles actions l'agent peut executer sans surveillance et lesquelles ont besoin d'une approbation humaine, selon le cout d'une erreur. Gatez les actions irreversibles ou sensibles derriere un checkpoint.

6. 06

   Passer a un SDK pour la production

   Une fois la boucle claire, adoptez le Claude Agent SDK ou le OpenAI Agents SDK pour obtenir retries, streaming, sessions, permissions et support MCP sans ecrire la plomberie vous-meme.

Questions fréquemment posées

Continuez à apprendre