Créer un agent AI en Python pas à pas (76 lignes)

👁 115 lectures

Un agent AI en Python repose sur une boucle simple : le modèle reçoit une tâche et une liste d’outils, choisit un outil, votre code l’exécute, le résultat est renvoyé au modèle, et ce dernier décide de la suite. J’ai conçu un tel agent en 76 lignes de code, sans le moindre framework : il explore des fichiers, effectue des calculs, consulte des pages web, intègre une limite d’étapes et consigne chaque décision dans un journal. Je l’ai ensuite réécrit avec OpenAI Agents SDK et Claude Agent SDK. Toutes les exécutions présentées ci-dessous sont réelles et datent du 4 octobre 2026. Il s’agit de la troisième étape du guide Développer des agents AI de zéro.

En quoi un agent diffère d’un simple script avec IA

Un script standard doté d’une IA suit un cheminement figé : « récupérer l’e-mail, le résumer, l’enregistrer ». Le modèle n’intervient que pour remplir une case prédéfinie. Dans le cas d’un agent, l’ordre des étapes est déterminé par le modèle lui-même. Vous lui fixez un objectif (« calculer les dépenses à partir des factures ») et lui fournissez des outils ; il détermine de manière autonome qu’il doit d’abord inspecter les fichiers, vérifier le taux de change, puis faire l’addition. Pour explorer en détail ce concept et ses pièges, consultez l’article Qu’est-ce qu’un agent AI ?.

Sur le plan technique, un agent correspond à du function calling orchestré au sein d’une boucle. Si vous n’êtes pas encore familier avec la façon dont un modèle sollicite l’exécution d’une fonction, commencez par ce guide prérequis.

La boucle de l’agent en quatre temps

1. Le modèle analyse la consigne et l’historique complet des échanges.
2. La décision : soit il demande l’exécution d’un outil (avec ses paramètres), soit il juge la tâche accomplie et formule sa réponse finale.
3. L’outil : votre programme Python exécute la fonction correspondante.
4. L’observation : le retour de la fonction est ajouté à l’historique, puis la boucle repart au point 1.

Deux garde-fous essentiels doivent systématiquement encadrer ce processus : une limite d’étapes (pour prévenir les boucles infinies et la consommation inutile de crédits) et un journal des décisions (pour auditer précisément le raisonnement et les actions a posteriori).

Étape 1 : préparer l’environnement de développement

1. Installez Python 3.11 à 3.13 depuis python.org (en veillant à cocher « Add python.exe to PATH »).
2. Créez un environnement virtuel dans votre dossier : python -m venv .venv, puis activez-le avec .venv\Scripts\activate sous Windows (ou source .venv/bin/activate sous macOS/Linux).
3. Installez les dépendances : pip install openai requests beautifulsoup4 python-dotenv.
4. Générez une clé API sur OpenRouter et renseignez-la dans un fichier .env sous la forme OPENROUTER_API_KEY=.... Définissez un plafond budgétaire sur votre compte, par exemple 2 USD (environ 1,79 EUR). Pour en savoir plus sur les tarifs, lisez notre présentation d’OpenRouter.
5. Dans un sous-dossier dane/faktury, déposez quelques fichiers texte. Pour les besoins du test, nous utilisons trois factures factices : deux comportant des montants bruts et une libellée à hauteur de 120 EUR.

Étape 2 : définir les outils sous forme de fonctions Python

L’agent s’appuie sur trois outils. Chacun correspond à une fonction Python renvoyant une chaîne de caractères :

• szukaj_plikow liste et lit les fichiers .txt présents dans le dossier dane/. L’agent ne dispose d’aucun accès en dehors de cet emplacement ;
• kalkulator évalue les expressions mathématiques via le module ast (sans recourir au risqué eval). Les modèles linguistiques commettant régulièrement des erreurs d’arithmétique, nous leur imposons de déléguer les calculs ;
• czytaj_strone extrait le contenu d’une URL ou d’une API en tronquant le résultat à 4 000 caractères, car chaque fragment textuel réinjecté engendre des tokens facturés.

Étape 3 : l’agent complet en 76 lignes de code

"""02 - Agent AI sans framework : boucle modèle -> outil -> observation -> décision.
Lancement : python 02_agent_bez_frameworka.py "Additionne les montants des factures du dossier dane/faktury."
"""
import ast, json, operator, os, pathlib, sys, time
import requests
from bs4 import BeautifulSoup
from dotenv import load_dotenv
from openai import OpenAI

load_dotenv()
MODEL, MAX_KROKOW = os.getenv("MODEL", "openai/gpt-5.6-luna"), int(os.getenv("MAX_KROKOW", 8))
client = OpenAI(base_url="https://openrouter.ai/api/v1", api_key=os.environ["OPENROUTER_API_KEY"])
KATALOG = pathlib.Path("dane").resolve()  # L'agent n'a accès qu'à ce dossier spécifique

def szukaj_plikow(fraza: str = "") -> str:
    """Liste les fichiers .txt dans dane/ (avec contenu), filtrés éventuellement par une requête."""
    wynik = []
    for p in sorted(KATALOG.rglob("*.txt")):
        tekst = p.read_text(encoding="utf-8")
        if fraza.lower() in tekst.lower() or fraza.lower() in p.name.lower():
            wynik.append(f"== {p.relative_to(KATALOG)} ==\n{tekst[:1500]}")
    return "\n".join(wynik) or "aucun fichier trouvé"

OPS = {ast.Add: operator.add, ast.Sub: operator.sub, ast.Mult: operator.mul, ast.Div: operator.truediv, ast.USub: operator.neg}
def kalkulator(wyrazenie: str) -> str:
    def licz(n):
        if isinstance(n, ast.Constant): return n.value
        if isinstance(n, ast.BinOp): return OPS[type(n.op)](licz(n.left), licz(n.right))
        if isinstance(n, ast.UnaryOp): return OPS[type(n.op)](licz(n.operand))
        raise ValueError("uniquement des nombres et les opérateurs + - * /")
    return str(round(licz(ast.parse(wyrazenie, mode="eval").body), 4))

def czytaj_strone(url: str) -> str:
    r = requests.get(url, timeout=20, headers={"User-Agent": "promptif-agents-starter/1.0"})
    tekst = BeautifulSoup(r.text, "html.parser").get_text(" ", strip=True)
    return tekst[:4000]  # Tronqué : les pages trop volumineuses saturent le contexte

NARZEDZIA = {"szukaj_plikow": szukaj_plikow, "kalkulator": kalkulator, "czytaj_strone": czytaj_strone}
def opis(nazwa, tekst, param, typ="string"):
    return {"type": "function", "function": {"name": nazwa, "description": tekst,
            "parameters": {"type": "object", "properties": {param: {"type": typ}}, "required": [param]}}}
TOOLS = [opis("szukaj_plikow", "Affiche les fichiers .txt du dossier dane/ et leur contenu. Chaîne vide = tous les fichiers.", "fraza"),
         opis("kalkulator", "Calcule une expression, ex. 2214+1180.8. Utilisez toujours cet outil pour calculer.", "wyrazenie"),
         opis("czytaj_strone", "Récupère le texte d'une page web ou la réponse d'une API depuis une URL.", "url")]

def agent(zadanie: str) -> str:
    messages = [{"role": "system", "content": "Vous êtes un agent. Résolvez la tâche en utilisant les outils fournis. "
                 "Avant chaque appel d'outil, expliquez en une phrase l'objectif de l'action. "
                 "Consultez les taux de change via l'API de référence. Répondez de manière structurée."},
                {"role": "user", "content": zadanie}]
    log = open("agent_log.jsonl", "a", encoding="utf-8")
    koszt = 0.0
    for krok in range(1, MAX_KROKOW + 1):
        r = client.chat.completions.create(model=MODEL, messages=messages, tools=TOOLS)
        koszt += getattr(r.usage, "cost", 0) or 0
        msg = r.choices[0].message
        messages.append(msg.model_dump(exclude_none=True))
        if not msg.tool_calls:
            print(f"--- Fin après {krok} étapes, coût {koszt:.5f} USD")
            return msg.content
        if msg.content: print(f"[étape {krok}] PENSÉE : {msg.content.strip()[:300]}")
        for call in msg.tool_calls:
            args = json.loads(call.function.arguments or "{}")
            try:
                obs = NARZEDZIA[call.function.name](**args)
            except Exception as e:
                obs = f"ERREUR : {e}"
            print(f"[étape {krok}] ACTION : {call.function.name}({json.dumps(args, ensure_ascii=False)})")
            print(f"[étape {krok}] OBSERVATION : {obs[:160]!r}")
            log.write(json.dumps({"t": time.strftime("%H:%M:%S"), "krok": krok, "outil": call.function.name,
                                  "args": args, "observation": obs[:500]}, ensure_ascii=False) + "\n")
            messages.append({"role": "tool", "tool_call_id": call.id, "content": obs})
    return f"Interrompu : limite atteinte de {MAX_KROKOW} étapes (coût {koszt:.5f} USD)."

if __name__ == "__main__":
    print("\nRÉSULTAT :\n" + agent(" ".join(sys.argv[1:]) or "Additionne les montants des factures du dossier dane/faktury."))

Les éléments structurants du script :

• for krok in range(1, MAX_KROKOW + 1) matérialise la boucle d’exécution, bridée par un plafond strict (8 itérations par défaut) ;
• if not msg.tool_calls indique que le modèle s’abstient de requérir un outil : il a élaboré sa réponse finale ;
• une exception levée par un outil n’arrête pas le programme, mais est transmise au modèle sous forme de message d’erreur d’observation. Cela lui permet de rectifier son approche immédiatement ;
• chaque transaction est consignée dans agent_log.jsonl (horodatage, étape, fonction sollicitée, paramètres, retour) ;
• l’instruction système contraint le modèle à verbaliser sa logique avant chaque appel d’outil, produisant une trace de raisonnement indispensable lors du débogage.

Test 1 : consolidation de factures multidevises

Lors de nos tests, l’invite initiale a été exécutée en polonais pour traiter des factures locales et une facture de 120 EUR, en demandant à l’agent de convertir l’euro via un appel d’API bancaire en ligne. Voici la traduction fidèle de la trace d’exécution originale :

> python 02_agent_bez_frameworka.py "Calcule mes dépenses totales d'après les factures du dossier dane. Convertis la facture en euros selon le cours du jour de l'API NBP."
[étape 1] PENSÉE : Je vais d'abord lire tous les fichiers de factures du dossier `dane` et récupérer le cours actuel de l'EUR via l'API NBP pour pouvoir additionner les montants.
[étape 1] ACTION : szukaj_plikow({"fraza": ""})
[étape 1] OBSERVATION : '== faktury\\FV_2026_09_014.txt ==\nFAKTURA VAT nr FV/2026/09/014 (données d'exemple)\nDate d'émission : 2026-09-12\n...'
[étape 1] ACTION : czytaj_strone({"url": "https://api.nbp.pl/api/exchangerates/rates/a/eur/?format=json"})
[étape 1] OBSERVATION : '{"table":"A","currency":"euro","code":"EUR","rates":[{"no":"192/A/NBP/2026","effectiveDate":"2026-10-02","mid":4.3745}]}'
[étape 2] PENSÉE : Je vais maintenant convertir la facture de 120 EUR au taux de 4,3745 et l'ajouter aux deux factures de 2 214,00 et 1 180,80.
[étape 2] ACTION : kalkulator({"wyrazenie": "2214+1180.8+120*4.3745"})
[étape 2] OBSERVATION : '3919.74'
--- Fin après 3 étapes, coût 0.00104 USD (env. 0,00093 EUR)

RÉSULTAT :
Vos dépenses totales s'élèvent à 3 919,74.

Détail du calcul :
- Facture 1 : 2 214,00
- Facture 2 : 1 180,80
- Facture en EUR : 120 × 4,3745 = 524,94

Total : 2 214,00 + 1 180,80 + 524,94 = 3 919,74

Taux de change appliqué : 4,3745 (au 02/10/2026).

L’agent a défini sa stratégie sans guidage manuel : à l’étape 1, il a interrogé simultanément le système de fichiers et l’API de taux de change (table 192/A/NBP/2026 du 2 octobre, le 4 octobre étant un dimanche). À l’étape 2, il a agrégé l’ensemble au sein de la calculatrice. À l’étape 3, il a formulé sa synthèse. Le total de 3 919,74 correspond parfaitement au calcul arithmétique : 2 214 + 1 180,80 + 120 × 4,3745 = 3 919,74. L’opération a mobilisé 3 requêtes vers le modèle pour un coût d’environ 0,00093 EUR (0,00104 USD ; conversion BCE au 12/10/2026 : 1 EUR = 1,1181 USD).

Test 2 : croisement d’une page web et de données locales

Pour cette seconde évaluation, nous avons testé en polonais une requête hybride : résumer une page Wikipédia dédiée au protocole MCP tout en extrayant une échéance calendaire stockée dans un fichier local pour calculer un écart de jours.

> python 02_agent_bez_frameworka.py "Consulte la page https://pl.wikipedia.org/wiki/Model_Context_Protocol et résume en 3 points à quoi sert MCP. Vérifie ensuite dans le dossier dane si j'ai une note avec une date limite, et indique combien de jours il reste jusqu'à cette date à compter du 4 octobre 2026."
[étape 1] PENSÉE : Je vais lire la page Wikipédia indiquée pour synthétiser en 3 points l'utilité du protocole MCP.
[étape 1] ACTION : czytaj_strone({"url": "https://pl.wikipedia.org/wiki/Model_Context_Protocol"})
[étape 1] OBSERVATION : 'Model Context Protocol - Wikipédia... Aller au contenu Menu principal...'
[étape 2] PENSÉE : Je vais explorer le dossier « dane » pour trouver une note mentionnant une échéance.
[étape 2] ACTION : szukaj_plikow({"fraza": ""})
[étape 2] OBSERVATION : '== faktury\\FV_2026_09_014.txt == ...'
[étape 3] PENSÉE : Je calcule la différence entre le 4 et le 7 octobre 2026 pour fournir le nombre exact de jours.
[étape 3] ACTION : kalkulator({"wyrazenie": "7-4"})
[étape 3] OBSERVATION : '3'
--- Fin après 4 étapes, coût 0.00130 USD (env. 0,00116 EUR)

RÉSULTAT :
Le protocole MCP sert à :
1. Standardiser la façon dont les systèmes d'IA et LLM se connectent aux outils, systèmes et sources de données externes.
2. Fournir aux modèles une interface universelle pour lire des fichiers, appeler des fonctions et exploiter du contexte.
3. Intégrer l'IA à des cas d'usage concrets tels que les documents d'entreprise, CRM, bases de données et environnements de développement.

Dans le fichier note.txt, l'échéance relevée est : transmettre les factures de septembre au comptable avant le 7 octobre 2026.
Du 4 octobre 2026 à cette date, il reste 3 jours.

L’agent a correctement combiné deux sources hétérogènes. Détail instructif visible dans les journaux : le début de la page web correspondait aux éléments d’interface (« Aller au contenu… »). Avec une limite fixée à 4 000 caractères, le contenu principal restait accessible ; néanmoins, pour traiter des ressources plus volumineuses, cibler spécifiquement les balises <main> ou <article> s’avère plus robuste. La soustraction 7 - 4 via le module arithmétique peut sembler triviale, mais elle garantit la fiabilité en interdisant au modèle d’improviser des calculs mentaux.

Test 3 : gestion du dépassement de la limite d’étapes

En bridant volontairement la boucle à 2 étapes sur une tâche nécessitant des conversions supplémentaires, l’interruption s’effectue proprement :

> MAX_KROKOW=2 python 02_agent_bez_frameworka.py "Additionne les factures du dossier dane, convertis les euros au cours NBP, puis récupère le cours du dollar pour donner aussi la somme en USD."
[étape 1] PENSÉE : Je récupère le contenu des fichiers et en parallèle les cours EUR et USD pour préparer les calculs.
[étape 1] ACTION : szukaj_plikow({"fraza": ""})
[étape 1] ACTION : czytaj_strone({"url": "https://api.nbp.pl/api/exchangerates/rates/a/eur/?format=json"})
[étape 1] ACTION : czytaj_strone({"url": "https://api.nbp.pl/api/exchangerates/rates/a/usd/?format=json"})
[étape 2] PENSÉE : J'applique le calcul sur les montants identifiés.
[étape 2] ACTION : kalkulator({"wyrazenie": "2214+1180.80+120*4.3745"})
[étape 2] OBSERVATION : '3919.74'

RÉSULTAT :
Interrompu : limite atteinte de 2 étapes (coût 0.00079 USD, env. 0,00071 EUR).

Faute de tours suffisants, l’agent s’est arrêté net en renvoyant une notification explicite plutôt que d’entrer dans un cycle infini. Dans une application en production, un seuil de 8 à 15 étapes offre une marge confortable, couplé à une sauvegarde d’état pour reprendre le fil. Voici les dernières lignes du fichier de journalisation produit lors de cet arrêt :

> type agent_log.jsonl
{"t": "13:50:52", "krok": 1, "outil": "czytaj_strone", "args": {"url": "https://api.nbp.pl/api/exchangerates/rates/a/eur/?format=json"}, "observation": "{\"table\":\"A\",\"currency\":\"euro\",\"code\":\"EUR\",\"rates\":[{\"no\":\"192/A/NBP/2026\",\"effectiveDate\":\"2026-10-02\",\"mid\":4.3745}]}"}
{"t": "13:50:52", "krok": 1, "outil": "czytaj_strone", "args": {"url": "https://api.nbp.pl/api/exchangerates/rates/a/usd/?format=json"}, "observation": "{\"table\":\"A\",\"currency\":\"dollar\",\"code\":\"USD\",\"rates\":[{\"no\":\"192/A/NBP/2026\",\"effectiveDate\":\"2026-10-02\",\"mid\":3.8881}]}"}
{"t": "13:50:56", "krok": 2, "outil": "kalkulator", "args": {"wyrazenie": "2214+1180.80+120*4.3745"}, "observation": "3919.74"}

Dysfonctionnements fréquents des agents (et solutions)

Le même agent avec OpenAI Agents SDK

Dès lors que la logique de boucle est assimilée, l’emploi d’un framework devient transparent. Le SDK OpenAI Agents reproduit précisément notre implémentation manuelle : sollicitation du modèle, dispatching des outils, vérification de max_turns et suivi d’exécution. Les spécifications de fonctions sont directement déduites de leur typage et docstrings via le décorateur @function_tool. Ce composant s’interface sans difficulté avec des modèles tiers via OpenRouter :

"""03 - Même agent qu'en 02, réécrit avec OpenAI Agents SDK (package openai-agents).
La boucle, l'exécution des outils et la limitation des tours sont prises en charge par Runner.
Lancement : python 03_agent_openai_sdk.py "Additionne les factures du dossier dane."
"""
import asyncio, os, sys
from dotenv import load_dotenv
from openai import AsyncOpenAI
from agents import Agent, OpenAIChatCompletionsModel, Runner, function_tool, set_tracing_disabled

import importlib
narz = importlib.import_module("02_agent_bez_frameworka")  # Réutilisation des fonctions outils du script de base

load_dotenv()
set_tracing_disabled(True)  # Le traçage transmettant les données à OpenAI, désactivez-le avec OpenRouter
model = OpenAIChatCompletionsModel(
    model=os.getenv("MODEL", "openai/gpt-5.6-luna"),
    openai_client=AsyncOpenAI(base_url="https://openrouter.ai/api/v1", api_key=os.environ["OPENROUTER_API_KEY"]))

@function_tool
def szukaj_plikow(fraza: str = "") -> str:
    """Liste les fichiers .txt du dossier dane/ et leur contenu. Chaîne vide = tous les fichiers."""
    return narz.szukaj_plikow(fraza)

@function_tool
def kalkulator(wyrazenie: str) -> str:
    """Évalue une expression mathématique, ex. 2214+1180.8. Utilisez toujours cet outil pour calculer."""
    return narz.kalkulator(wyrazenie)

@function_tool
def czytaj_strone(url: str) -> str:
    """Récupère le texte brut d'une page web ou d'une API depuis une URL."""
    return narz.czytaj_strone(url)

agent = Agent(
    name="Assistant factures",
    instructions="Résolvez la tâche à l'aide des outils fournis. "
                 "Consultez les taux de change requis via l'API. Structurez votre réponse.",
    model=model, tools=[szukaj_plikow, kalkulator, czytaj_strone])

async def main():
    zadanie = " ".join(sys.argv[1:]) or "Additionne le montant des factures du dossier dane."
    wynik = await Runner.run(agent, zadanie, max_turns=8)
    for item in wynik.new_items:  # Journal de bord des opérations
        if item.type == "tool_call_item":
            print("ACTION :", item.raw_item.name, item.raw_item.arguments)
        elif item.type == "tool_call_output_item":
            print("OBSERVATION :", str(item.output)[:120].replace("\n", " "))
    u = wynik.context_wrapper.usage
    print(f"\nRÉSULTAT :\n{wynik.final_output}\n\nRequêtes modèle : {u.requests}, tokens : {u.input_tokens} entrée / {u.output_tokens} sortie")

asyncio.run(main())

Voici la restitution de la commande exécutée en environnement de test avec les paramètres originaux :

> python 03_agent_openai_sdk.py "Additionne le montant des factures du dossier dane en convertissant les euros au cours officiel."
ACTION : szukaj_plikow {"fraza":""}
ACTION : czytaj_strone {"url":"https://api.nbp.pl/api/exchangerates/rates/a/EUR/?format=json"}
OBSERWACJA : == faktury\FV_2026_09_014.txt == FAKTURA VAT nr FV/2026/09/014...
OBSERWACJA : {"table":"A","currency":"euro","code":"EUR","rates":[{"no":"192/A/NBP/2026","effectiveDate":"2026-10-02","mid":4.3745}]}
ACTION : kalkulator {"wyrazenie":"2214+1180.8"}
ACTION : kalkulator {"wyrazenie":"120*4.3745"}
ACTION : kalkulator {"wyrazenie":"2214+1180.8+120*4.3745"}
OBSERWACJA : 3394.8
OBSERWACJA : 524.94
OBSERWACJA : 3919.74

RÉSULTAT :
Total calculé : 3 919,74.

Détail :
- Montants de base : 2 214,00 + 1 180,80 = 3 394,80
- Montant converti : 120 EUR × 4,3745 = 524,94
- Somme totale : 3 394,80 + 524,94 = 3 919,74

Requêtes modèle : 3, tokens : 1970 entrée / 323 sortie

Le résultat obtenu est identique : 3 requêtes d’inférence, 1 970 tokens en entrée et 323 en sortie. Deux précisions techniques importantes :

• set_tracing_disabled(True) : le SDK tente nativement d’acheminer les métriques vers l’infrastructure d’OpenAI. Lorsque l’on passe par OpenRouter sans compte OpenAI lié, cela génère des avertissements dans la console ; de plus, dans un cadre professionnel, vous pouvez souhaiter bloquer toute fuite de métadonnées ;
• OpenAIChatCompletionsModel : la bibliothèque utilise par défaut les nouvelles spécifications Responses API d’OpenAI. Des passerelles comme OpenRouter exploitent l’API standard Chat Completions, d’où l’intérêt de recourir à cette classe adaptatrice.

Implémentation avec Claude Agent SDK

Le Claude Agent SDK met à disposition les mécanismes au cœur de Claude Code sous la forme d’un package Python. Il intègre d’office des connecteurs pour manipuler les fichiers et le terminal, tandis que vos fonctions personnalisées s’interfacent via un serveur MCP virtuel hébergé en mémoire. Pour une mise en perspective détaillée, consultez notre dossier sur les frameworks d’agents AI. Lors de nos tests sous Windows, deux spécificités ont été constatées :

• Le SDK instancie l’exécutable claude sous forme de sous-processus et rejette les lanceurs claude.cmd créés par npm pour des impératifs de sécurité. Il convient de pointer vers le binaire compilé claude.exe via l’argument cli_path ou d’utiliser une installation native autonome ;
• Le package lit les configurations globales situées dans ~/.claude/settings.json. Si une variable ANTHROPIC_BASE_URL y est déclarée, vos requêtes y seront redirigées au détriment des variables de code. Spécifier setting_sources=[] résout cette priorité.

En employant Claude Haiku 4.5 via OpenRouter, l’analyse des factures a nécessité 15 à 18 secondes pour un coût oscillant entre environ 0,0116 EUR et 0,0161 EUR (0,013-0,018 USD sur 3 passes). Notre script personnalisé de 76 lignes exécuté avec ce même modèle a requis 7,1 secondes et environ 0,0063 EUR (0,007 USD). Cet écart s’explique par la densité des consignes structurelles et le temps de délibération propres au moteur Claude Code. En contrepartie, la bibliothèque apporte une gestion native des permissions, des sessions de persistance et de la délégation multi-agents.

Faut-il coder son agent ou choisir un SDK existant ?

• Développement sur mesure (script nu) : indispensable pour comprendre intimement la mécanique, idéal pour des agents légers mobilisant 2 à 5 outils et pour maîtriser le coût de chaque token.
• OpenAI Agents SDK : préconisé dès lors que votre architecture exige des transferts entre agents spécialisés (handoffs), des règles de filtrage (guardrails) et une traçabilité avancée.
• Claude Agent SDK : pertinent si l’agent doit directement modifier des arborescences de code et exécuter des commandes en console à la manière de Claude Code.
• LangGraph : à privilégier pour les graphes d’états complexes impliquant des embranchements conditionnels, des sauvegardes de points d’étape et des validations humaines.
• Solutions no-code : tournez-vous vers n8n, Make ou Gumloop si vous souhaitez bâtir des chaînes d’automatisation visuelles sans rédiger de code.

Foire aux questions

Faut-il obligatoirement être développeur pour concevoir un agent ?

Pour assimiler l’architecture sous-jacente, la lecture d’un script élémentaire suffit. Le script de 76 lignes présenté ici peut être utilisé tel quel. Si vous ne souhaitez pas programmer, des plateformes comme n8n ou Gumloop permettent de prototyper des agents équivalents via des interfaces graphiques.

Combien coûte l’exécution d’un agent AI ?

La tarification dépend du modèle retenu et du volume d’étapes. Avec un modèle léger et économique, chaque tâche revient à environ 0,0009 EUR (0,001 USD). La même chaîne sur Claude Haiku s’élève entre environ 0,0063 EUR et 0,0161 EUR (0,007-0,018 USD). Sur des modèles très haut de gamme dont les tarifs atteignent environ 4,47 EUR (5 USD) par million de tokens en entrée, la facture augmente proportionnellement. Dans la mesure où chaque nouveau tour de boucle retransmet l’intégralité du contexte passé, le coût croît plus rapidement que le simple nombre d’étapes.

Quel modèle choisir pour propulser un agent ?

Sélectionnez un modèle entraîné spécifiquement pour le function calling. Pour débuter, un modèle économique filtré avec la capacité « tools » sur OpenRouter convient parfaitement. Pour des flux comportant de multiples ramifications ou des entrées bruitées, les modèles plus élaborés réduisent nettement le risque d’égarement.

Peut-on faire tourner cet agent avec un modèle local ?

Oui. Ollama expose une interface calquée sur les spécifications d’OpenAI (http://localhost:11434/v1). Il suffit d’ajuster base_url et l’identifiant du modèle dans le script. Gardez à l’esprit que les petits modèles exécutés localement respectent parfois moins rigoureusement le schéma JSON des outils.

Comment sécuriser l’environnement face aux actions de l’agent ?

Appliquez le principe du moindre privilège : donnez uniquement accès aux fonctions strictement requises, de préférence en lecture seule. Isolez les chemins de fichiers accessibles (ici confinés au sous-dossier dane/). Pour toute écriture ou action critique, conditionnez l’appel à une validation humaine explicite et archivez toutes les opérations dans des journaux.

Le traitement dans d’autres langues impacte-t-il les performances ?

Les LLM actuels gèrent le multilinguisme de manière très fluide. Les instructions et descriptions d’outils peuvent être formulées en français ou dans toute autre langue sans dégrader la logique de sélection des fonctions. Veillez simplement à conserver des identifiants de fonctions simples (caractères ASCII sans accents ni caractères spéciaux).

Sources et vérifications techniques

• Anthropic : Building effective agents (consulté le 4 octobre 2026).
• Documentation officielle : OpenAI Agents SDK (consulté le 4 octobre 2026).
• Documentation officielle : Claude Agent SDK (consulté le 4 octobre 2026).
• Données de cours monétaires : API publique de banques centrales (table A).
• Tests d’exécution : réalisés sur machine locale le 4 octobre 2026, entre 13h50 et 13h55.

// lire la suitePremière requête API IA en Python : guide pratique pas à pasGuidesOpenAI API : clé, tarifs et première requête en PythonGuidesRoutage de tickets avec l’IA : Strands Decider 2B en PythonGuides

Kinetyra