Comment construire votre premier agent IA : un modèle, quelques outils et une boucle

« Agent IA » sonne comme si cela devait exiger un framework, une base de données vectorielle et un week-end de configuration. Ce n'est pas le cas. La définition d'Anthropic elle-même est étonnamment réduite : un agent est un LLM qui utilise des outils de manière autonome dans une boucle. Une fois que vous avez saisi le schéma, vous pouvez construire un premier agent utile en bien moins de cent lignes de code — et, tout aussi important, savoir quand vous ne devriez pas le faire.

La boucle de base

Tout agent, aussi sophistiqué soit-il, repose sur le même cycle en quatre étapes :

1. Vous donnez au modèle un objectif et une liste d'outils qu'il est autorisé à appeler.
2. Le modèle décide s'il répond directement ou s'il appelle un outil.
3. Votre code exécute l'outil et renvoie le résultat au modèle.
4. On répète jusqu'à ce que le modèle indique qu'il a terminé.

Le modèle ne touche jamais lui-même à votre système de fichiers ni à votre réseau. Il ne fait jamais que demander l'exécution d'un outil ; c'est votre code qui décide si et comment le faire réellement. C'est dans cet écart que réside toute votre sécurité.

Un exemple concret

Voici un agent minimal capable de répondre à des questions à l'aide d'un outil calculatrice. C'est la structure qui compte — la même forme se transpose à l'édition de fichiers, à la recherche web ou aux requêtes en base de données.

import anthropic

client = anthropic.Anthropic()

tools = [{
    "name": "calculator",
    "description": "Evaluate a basic arithmetic expression and return the result.",
    "input_schema": {
        "type": "object",
        "properties": {"expression": {"type": "string"}},
        "required": ["expression"],
    },
}]

def run_tool(name, args):
    if name == "calculator":
        # In real code, use a safe parser, not eval()
        return str(eval(args["expression"], {"__builtins__": {}}))
    return "unknown tool"

messages = [{"role": "user", "content": "What is 1894 * 37 plus 12?"}]

while True:
    resp = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=1024,
        tools=tools,
        messages=messages,
    )
    messages.append({"role": "assistant", "content": resp.content})

    if resp.stop_reason != "tool_use":
        print(resp.content[0].text)
        break

    tool_results = []
    for block in resp.content:
        if block.type == "tool_use":
            result = run_tool(block.name, block.input)
            tool_results.append({
                "type": "tool_result",
                "tool_use_id": block.id,
                "content": result,
            })
    messages.append({"role": "user", "content": tool_results})

Cette boucle while est l'agent. Le modèle voit la question, demande d'appeler calculator avec "1894 * 37 + 12", votre code l'exécute, renvoie 70090, et le modèle rédige la réponse finale. Remplacez la calculatrice par une paire read_file/write_file et vous obtenez un agent de codage rudimentaire.

Les outils sont la partie qui compte vraiment

Le modèle n'est capable que dans la mesure des outils que vous lui fournissez, et la conception des outils est l'endroit où échouent la plupart des premiers agents. Les recommandations d'Anthropic sur l'écriture d'outils pour les agents se résument à quelques règles :

• Nommez et décrivez les outils comme si vous vous adressiez à un nouveau coéquipier. search_invoices(customer_id, date_range) vaut mieux qu'un vague query(sql) — plus le contrat est clair, moins il y a d'appels erronés.
• Renvoyez des résultats à fort signal, pas des décharges brutes. Si un outil renvoie 5 000 lignes de JSON, vous venez de dépenser le budget de contexte du modèle en bruit. Élaguez pour ne garder que l'utile.
• Rendez les erreurs instructives. « Fichier introuvable : vouliez-vous dire config.yaml ? » permet au modèle de se rattraper ; une simple trace d'appels n'y parvient généralement pas.

Des garde-fous avant de le laisser tourner

Comme c'est votre code qui exécute chaque appel d'outil, la sécurité vous incombe. Trois garde-fous à ajouter avant qu'un agent ne touche à quelque chose de réel :

• Plafonnez la boucle. Ajoutez un nombre maximal d'itérations pour qu'un agent désorienté ne puisse pas tourner indéfiniment (et faire grimper la facture).
• Verrouillez les actions destructrices. Tout ce qui supprime, envoie ou paie devrait nécessiter une confirmation ou s'exécuter d'abord dans un bac à sable.
• Validez les entrées des outils. Ne faites jamais eval() sur des chaînes non fiables et ne passez jamais la sortie du modèle directement dans un shell. Traitez chaque argument d'outil comme une entrée utilisateur non fiable — car c'est effectivement le cas.

Quand NE PAS construire un agent

La chose la plus utile à apprendre tôt : beaucoup de problèmes n'ont absolument pas besoin d'un agent. Si les étapes sont connues à l'avance — récupérer des données, les résumer, envoyer le résumé par e-mail — un simple script avec un ou deux appels au modèle est moins coûteux, plus rapide et plus facile à déboguer. Anthropic appelle cela des workflows et les recommande chaque fois que le chemin est prévisible. Ne recourez à un véritable agent que lorsque le modèle a réellement besoin de décider de la prochaine action en fonction de ce qu'il découvre.

Commencez par la boucle en quatre étapes ci-dessus, donnez-lui un ou deux outils bien décrits, plafonnez les itérations et ajoutez une vraie tâche. Vous apprendrez davantage d'un seul agent fonctionnel que de n'importe quelle quantité de documentation de framework.