Créer un agent IA : le guide complet, du no-code au code

Créer un agent IA, c’est relier un modèle de langage à des instructions, à des outils qu’il peut déclencher et à une boucle qui le laisse agir jusqu’à ce que la tâche soit terminée. Vous pouvez le faire sans coder sur une plateforme visuelle ou avec un framework en Python ou TypeScript : ce guide vous donne la méthode commune, puis les deux chemins, du choix de la tâche jusqu’à la mise en production.

Ce que vous construisez vraiment

Un agent IA n’est pas un chatbot amélioré. Un chatbot répond à un message. Un agent reçoit un objectif, décide seul des étapes, utilise des outils (chercher une information, lire un fichier, envoyer une requête à un logiciel) et observe les résultats avant de choisir la suite.

Techniquement, tout repose sur l’appel d’outils : le modèle ne lance rien lui-même. Il produit une demande structurée du type « appelle l’outil météo avec la ville Lyon ». Votre programme, ou la plateforme, exécute l’outil et renvoie le résultat au modèle. Le modèle lit ce résultat, puis décide : nouvel appel d’outil ou réponse finale. Cette alternance réflexion, action, observation porte un nom, le schéma ReAct.

Voici la boucle réduite à l’essentiel. C’est du pseudo-code, pour comprendre le principe ; les frameworks présentés plus bas l’écrivent pour vous.

historique = [consignes, demande de l'utilisateur]
répéter au plus N fois :
    réponse = modèle(historique, liste des outils)
    si réponse est une réponse finale : renvoyer réponse
    pour chaque appel d'outil demandé :
        résultat = exécuter(outil, arguments)
        ajouter résultat à historique
arrêter et signaler l'échec

Deux détails comptent déjà. La limite « au plus N fois » évite qu’un agent tourne en rond et vous coûte cher. Et tout l’historique est renvoyé au modèle à chaque tour : plus l’agent travaille, plus chaque appel est long.

Agent ou workflow : la question à se poser d’abord

Beaucoup de projets « d’agent » sont en réalité des workflows : une suite d’étapes connues à l’avance, où l’IA intervient à un endroit précis (résumer, classer, rédiger). Un workflow est plus prévisible, moins cher et plus facile à tester. Un agent devient intéressant quand le chemin n’est pas connu à l’avance : enquêter sur un incident, répondre à des demandes variées, fouiller plusieurs sources.

Étape 1 : choisir une tâche qui s’y prête

Le succès d’un agent se joue avant la première ligne de configuration. Une bonne tâche de départ réunit quatre critères :

1. Elle est fréquente. Construire un agent pour une tâche mensuelle de dix minutes ne vaut pas l’effort.
2. Elle demande un peu de jugement. Si une règle fixe suffit, une automatisation classique fera mieux.
3. Son résultat se vérifie facilement. Vous devez pouvoir dire, en quelques secondes, si l’agent a bien travaillé.
4. Une erreur est rattrapable. Évitez pour commencer les paiements, les suppressions et les messages envoyés à des clients sans relecture.

Exemples de bons candidats : trier les demandes entrantes et proposer une réponse en brouillon, préparer une note de synthèse à partir de plusieurs documents, vérifier qu’une fiche produit respecte un modèle, enrichir une liste de contacts à partir de sources publiques.

Vérifiez-vous Un agent qui virerait automatiquement les factures fournisseurs reçues par e-mail est-il un bon premier projet ?

Non. L’action est irréversible, la vérification demande du temps et une erreur coûte de l’argent. Un meilleur premier projet : un agent qui lit les factures, extrait le montant, l’échéance et le fournisseur, compare avec le bon de commande et prépare une liste à valider par une personne. Le paiement reste une décision humaine.

Étape 2 : assembler les quatre briques

Quel que soit l’outil, no-code ou code, vous retrouverez les mêmes briques.

Le modèle

C’est le « cerveau » qui lit la situation et décide. Pour un agent, trois propriétés comptent plus que le score général : la fiabilité de l’appel d’outils, la capacité à suivre des consignes longues et le prix, puisque l’agent appelle le modèle de nombreuses fois. Un modèle rapide et peu cher suffit souvent pour classer ou extraire ; un modèle plus puissant se justifie pour planifier une tâche longue ou écrire du code.

Les instructions

Le prompt système décrit le rôle de l’agent, son objectif, ses limites et le format attendu. Pour un agent, ajoutez trois choses qu’on oublie souvent : quand s’arrêter, quoi faire en cas de doute (demander plutôt que deviner) et ce qu’il ne doit jamais faire. Notre guide consacré au prompt engineering détaille les techniques de rédaction.

Les outils

Chaque outil est une fonction décrite par un nom, une description et des paramètres. Le modèle choisit l’outil d’après cette description : une description vague donne des appels au hasard. Règle utile : peu d’outils, bien nommés, chacun faisant une seule chose. Un outil « lire_commande » et un outil « rembourser_commande » valent mieux qu’un outil « gérer_commande » à tout faire, notamment parce que vous pourrez soumettre le second à une validation.

La mémoire et le contexte

Un agent a une mémoire de travail, sa fenêtre de contexte, qui contient l’historique de la tâche en cours. Elle a une taille limitée et chaque token relu se paie. Pour se souvenir d’une session à l’autre, ou pour consulter vos documents, il faut une mémoire externe : base de données, fichiers, ou recherche dans vos documents par RAG (voir plus bas). Choisir ce qui entre dans le contexte à chaque étape est devenu une discipline à part entière, l’ingénierie du contexte.

Étape 3 : choisir son chemin, sans code ou avec code

Critère	Sans code (plateforme visuelle)	Avec un framework de code
Profil	Indépendant, équipe métier, « no-codeur »	Développeur Python ou TypeScript
Démarrage	Rapide, par blocs et formulaires	Plus long, mais tout est sous contrôle
Connecteurs	Nombreux connecteurs prêts à l’emploi	À écrire ou à importer (MCP, bibliothèques)
Tests automatisés	Limités, souvent manuels	Tests unitaires, évaluations, intégration continue
Hébergement	Chez l’éditeur, parfois chez vous (n8n)	Où vous voulez, à vous de l’exploiter
Coût	Abonnement de la plateforme + modèle	Modèle + hébergement (bibliothèque souvent gratuite)
Limite typique	Logique complexe difficile à maintenir	Plus de travail d’ingénierie au départ

Il n’y a pas de mauvais choix, seulement des choix mal adaptés. Une équipe sans développeur obtiendra plus vite un résultat utile avec une plateforme visuelle ; une équipe qui doit intégrer l’agent dans son propre produit aura besoin de code. Voici quelques outils représentatifs des deux mondes, avec leurs caractéristiques relevées par le site :

Outil	Type	Licence	MCP	Multi-agents	Niveau
n8n	Low-code	fair-code	Oui	Oui	Intermédiaire
Make	Sans code	proprietary	Oui	—	Débutant
Zapier Agents	Sans code	proprietary	—	—	Débutant
OpenAI Agents SDK	Code	MIT	Oui	Oui	Intermédiaire
Claude Agent SDK	Code	proprietary	Oui	Oui	Intermédiaire
Pydantic AI	Code	MIT	Oui	Oui	Intermédiaire
LangGraph	Code	MIT	Oui	Oui	Avancé

Chemin 1 : créer un agent sans coder

Sur une plateforme d’automatisation comme n8n, Make ou Zapier Agents, la construction suit toujours la même logique :

1. Un déclencheur : un e-mail reçu, un formulaire, une heure fixe, un message dans une messagerie.
2. Un bloc agent : vous choisissez le modèle, collez vos instructions et cochez les outils autorisés. Dans n8n, c’est le nœud AI Agent, qui peut aussi déléguer à des agents spécialisés.
3. Des outils : les connecteurs de la plateforme (agenda, tableur, CRM, messagerie) ou un serveur MCP.
4. Une sortie : un brouillon, une ligne dans un tableau, une notification, idéalement avec une étape de validation humaine avant toute action sensible.

Ce chemin est détaillé, avec un exemple complet, dans notre tutoriel pour créer un agent IA sans coder.

Deux points de vigilance sur ce marché qui bouge vite. D’abord, vérifiez le statut de l’outil : selon les données du site au 22 octobre 2026, OpenAI a annoncé la dépréciation d’Agent Builder (AgentKit) le 3 juin 2026, avec une fermeture prévue le 30 novembre 2026, et l’équipe de Flowise a annoncé la fin de vie du projet le 29 juillet 2026. Ne démarrez pas un nouveau projet sur ces outils. Ensuite, lisez le mode de facturation : crédits, « activités » ou exécutions, chaque plateforme compte différemment, et le coût du modèle s’ajoute souvent à l’abonnement.

Chemin 2 : créer un agent avec un framework de code

Un framework d’agents vous épargne la boucle, la gestion de l’historique, le format des appels d’outils et une partie de la sécurité. Vous écrivez la logique métier. Les exemples qui suivent reprennent la syntaxe des documentations officielles, consultées le 22 octobre 2026 ; ils sont volontairement courts et doivent être adaptés à votre cas. Pour comparer les options en détail, consultez notre comparatif des frameworks d’agents IA.

Un premier agent avec l’OpenAI Agents SDK

L’OpenAI Agents SDK est un SDK léger sous licence MIT, disponible en Python et en TypeScript. Il s’installe avec pip install openai-agents. D’après sa documentation officielle, un agent se définit par un nom, des instructions et des outils, puis se lance avec le Runner :

import asyncio
from agents import Agent, Runner
from agents.decorators import tool

@tool
def statut_commande(numero: str) -> str:
    """Renvoie le statut d'une commande à partir de son numéro."""
    return "Expédiée le 20 octobre, livraison prévue sous 48 heures."

agent = Agent(
    name="Support commandes",
    instructions="Tu réponds aux questions sur les commandes. "
                 "Utilise l'outil de statut, n'invente jamais une date.",
    tools=[statut_commande],
)

async def main():
    result = await Runner.run(agent, "Où en est ma commande A-1042 ?")
    print(result.final_output)

asyncio.run(main())

La docstring de la fonction sert de description de l’outil : soignez-la, c’est elle que le modèle lit. Le SDK prévoit aussi des transferts (handoffs) vers des agents spécialisés, des sessions, des garde-fous et un traçage intégré.

Un agent outillé avec le Claude Agent SDK

Le Claude Agent SDK d’Anthropic reprend le moteur de Claude Code : l’agent sait d’emblée lire et modifier des fichiers, lancer des commandes ou chercher sur le web, selon les outils que vous autorisez. Il ne fonctionne qu’avec les modèles Claude et son usage relève des conditions commerciales d’Anthropic. Ses pages de référence Python montrent comment ajouter vos propres outils sous forme de petit serveur MCP intégré :

import asyncio
from claude_agent_sdk import tool, create_sdk_mcp_server, ClaudeAgentOptions, query

@tool("statut_commande", "Statut d'une commande", {"numero": str})
async def statut_commande(args):
    texte = f"Commande {args['numero']} : expédiée."
    return {"content": [{"type": "text", "text": texte}]}

boutique = create_sdk_mcp_server(name="boutique", version="1.0.0",
                                 tools=[statut_commande])

options = ClaudeAgentOptions(
    system_prompt="Tu réponds aux questions sur les commandes.",
    mcp_servers={"boutique": boutique},
    allowed_tools=["mcp__boutique__statut_commande"],
)

async def main():
    async for message in query(prompt="Où en est la commande A-1042 ?", options=options):
        print(message)

asyncio.run(main())

Le paramètre allowed_tools est votre première ligne de défense : n’autorisez que ce dont l’agent a besoin.

Des réponses typées avec Pydantic AI

Pydantic AI mise sur le typage : vous décrivez la forme exacte de la réponse, et le framework la valide. Une sortie structurée invalide est détectée au lieu de casser votre application. Changer de fournisseur revient à changer la chaîne qui désigne le modèle. Exemple inspiré de la documentation officielle :

from pydantic import BaseModel
from pydantic_ai import Agent, RunContext

class Ticket(BaseModel):
    categorie: str
    urgent: bool
    resume: str

# identifiant exact du modèle : voir la documentation de votre fournisseur
agent = Agent("openai:nom-du-modele", output_type=Ticket,
              instructions="Classe la demande du client.")

@agent.tool
def historique_client(ctx: RunContext, email: str) -> str:
    """Renvoie les dernières demandes du client."""
    return "2 demandes en octobre, aucune urgente."

result = agent.run_sync("Mon colis n'est jamais arrivé, c'est la deuxième fois !")
print(result.output)

result.output est un objet Ticket validé : votre code peut s’en servir directement pour router la demande.

Un déroulé contrôlé avec LangGraph

LangGraph décrit l’agent comme un graphe : des nœuds (étapes), des arêtes (transitions) et un état partagé. C’est plus exigeant, mais vous obtenez, selon sa documentation, l’exécution durable, l’intervention humaine à n’importe quel point et la mémoire à court et long terme. Le squelette minimal ressemble à ceci :

from langgraph.graph import StateGraph, MessagesState, START, END

def classer(state: MessagesState):
    return {"messages": [{"role": "ai", "content": "catégorie : livraison"}]}

graph = StateGraph(MessagesState)
graph.add_node(classer)
graph.add_edge(START, "classer")
graph.add_edge("classer", END)
graph = graph.compile()

graph.invoke({"messages": [{"role": "user", "content": "Colis non reçu"}]})

Dans un vrai projet, le nœud appelle un modèle, et des arêtes conditionnelles envoient vers un nœud « outil », un nœud « validation humaine » ou la fin.

Étape 4 : brancher l’agent sur vos outils avec MCP

Écrire un connecteur différent pour chaque framework devient vite lourd. Le Model Context Protocol (MCP) standardise la façon dont un agent découvre et appelle des outils : vous exposez vos outils une fois, sous forme de serveur MCP, et tout client compatible peut s’en servir. Selon les données du site, tous les frameworks de code cités dans ce guide prennent en charge MCP, de même que n8n et Make.

Concrètement, un serveur MCP déclare une liste d’outils (nom, description, paramètres), éventuellement des ressources à lire, et répond aux appels. C’est exactement ce que fait l’exemple du Claude Agent SDK ci-dessus, en version intégrée au programme. Pour un serveur autonome, réutilisable par plusieurs agents, suivez notre tutoriel pour créer un serveur MCP.

Un conseil de conception : un serveur MCP est une porte d’entrée vers vos systèmes. Donnez-lui des droits limités (lecture seule quand c’est possible), journalisez les appels et ne branchez que des serveurs dont vous connaissez l’origine.

Étape 5 : donner vos documents à l’agent

Un modèle ne connaît ni vos procédures, ni vos contrats, ni votre catalogue. Pour qu’un agent s’appuie dessus sans tout charger dans son contexte, on utilise le RAG : les documents sont découpés en morceaux, indexés, et l’agent dispose d’un outil « rechercher dans la base » qui lui renvoie les passages pertinents. Il cite alors ses sources au lieu de répondre de mémoire.

Dans un agent, le RAG devient simplement un outil parmi d’autres. L’agent décide quand chercher, reformule sa requête si le premier résultat est pauvre, et peut croiser plusieurs recherches. La qualité dépend surtout du découpage des documents et de la recherche elle-même ; notre explication du RAG pour donner vos documents à une IA détaille ces choix.

Étape 6 : choisir le modèle et maîtriser le coût

Un agent multiplie les appels : un tour de boucle, c’est un appel complet avec tout l’historique. Le prix par million de tokens pèse donc beaucoup plus que pour une conversation. Voici quelques modèles récents, avec leur prix et leur fenêtre de contexte selon models.dev, relevés le 22 octobre 2026 :

Modèle	Éditeur	Sortie	Contexte (tokens)	Entrée ($/M tokens)	Sortie ($/M tokens)	Poids ouverts
Claude Haiku 5.5	Anthropic	7 octobre 2026	1 M	0,10 $US	0,50 $US	Non
GPT-6 Luna	OpenAI	22 septembre 2026	1,05 M	0,10 $US	0,50 $US	Non
Claude Sonnet 5.5	Anthropic	28 septembre 2026	1 M	2 $US	10 $US	Non
GPT-6.1 Sol	OpenAI	29 septembre 2026	1,05 M	2 $US	10 $US	Non
Gemini 4 Argon	Google DeepMind	13 octobre 2026	1,05 M	2 $US	10 $US	Non
Claude Opus 5.5	Anthropic	22 septembre 2026	1 M	4 $US	20 $US	Non

Une stratégie courante consiste à mélanger les niveaux : un petit modèle peu cher pour trier, classer ou extraire, un modèle plus puissant seulement pour les étapes qui exigent de planifier ou de raisonner longuement. Selon le même relevé, Claude Haiku 5.5 et GPT-6 Luna sont affichés à 0,1 $ par million de tokens en entrée et 0,5 $ en sortie, contre 4 $ et 20 $ pour Claude Opus 5.5 : le prix est quarante fois plus élevé.

D’autres leviers réduisent la facture : limiter le nombre de tours, résumer l’historique au lieu de tout renvoyer, réutiliser un début de prompt identique grâce à la mise en cache du prompt quand le fournisseur la propose. Le calculateur de coût d’un agent permet de simuler un scénario, et notre guide sur les prix des API d’IA explique comment lire et réduire la facture.

Étape 7 : tester avant de lancer

Un agent qui marche sur trois exemples n’est pas un agent fiable. Avant toute mise en service, constituez un jeu de test : une vingtaine de cas réels au minimum, dont des cas faciles, des cas ambigus et des cas pièges (demande hors sujet, information manquante, outil qui renvoie une erreur). Pour chaque cas, notez le résultat attendu.

Mesurez ensuite trois choses : la réponse finale est-elle juste, l’agent a-t-il appelé les bons outils avec les bons paramètres, et combien a coûté l’exécution. Rejouez ce jeu de test à chaque changement de modèle, d’instructions ou d’outil : une amélioration à un endroit casse souvent autre chose. Pour les réponses difficiles à noter automatiquement, un second modèle peut servir d’évaluateur, une méthode appelée LLM comme juge, à condition de vérifier vous-même un échantillon de ses notes.

L’observabilité complète les tests : enregistrer chaque étape (appels au modèle, outils, durées, coûts) pour comprendre une erreur après coup. Plusieurs frameworks intègrent un traçage, comme l’OpenAI Agents SDK, ou s’appuient sur OpenTelemetry, comme Pydantic AI. Toute la démarche est détaillée dans notre guide pour évaluer un agent IA.

Étape 8 : sécuriser l’agent

Un agent agit, donc il peut mal agir. Le risque principal a un nom : l’injection de prompt. Un texte lu par l’agent, dans un e-mail, une page web ou un document, contient des instructions cachées qui détournent son comportement. Aucune technique ne l’élimine totalement ; on réduit donc les dégâts possibles.

• Moindre privilège. L’agent n’a accès qu’aux outils et aux données strictement nécessaires, en lecture seule quand c’est possible.
• Humain dans la boucle. Toute action irréversible (paiement, envoi, suppression) passe par une validation : c’est le principe de l’humain dans la boucle.
• Bac à sable. Un agent qui exécute du code ou des commandes tourne dans un environnement isolé, sans accès à vos fichiers sensibles.
• Garde-fous. Des garde-fous vérifient ce qui entre et ce qui sort : demande hors sujet, données personnelles, format non conforme.
• Limites. Nombre de tours, budget de tokens et délai maximum par tâche.

Les frameworks fournissent souvent ces briques. Dans l’OpenAI Agents SDK, par exemple, un garde-fou d’entrée est une fonction qui peut déclencher un « tripwire » et interrompre l’exécution ; voici une version abrégée de l’exemple de la documentation sur les garde-fous :

from agents import Agent, GuardrailFunctionOutput, Runner
from agents.decorators import input_guardrail

@input_guardrail
async def hors_sujet(ctx, agent, input):
    result = await Runner.run(agent_verificateur, input, context=ctx.context)
    return GuardrailFunctionOutput(
        output_info=result.final_output,
        tripwire_triggered=result.final_output.hors_sujet,
    )

agent = Agent(name="Support", instructions="...", input_guardrails=[hors_sujet])

Quand le tripwire se déclenche, le SDK lève l’exception InputGuardrailTripwireTriggered, que votre code intercepte pour répondre poliment. Avant de confier une tâche, l’outil Puis-je confier ça à un agent ? aide à évaluer le niveau de risque, et notre guide pour sécuriser un agent IA détaille les attaques et les parades.

Étape 9 : mettre en production

Passer du prototype au service utilisé tous les jours demande quelques précautions supplémentaires.

1. Versionnez tout : instructions, liste d’outils, modèle et paramètres. Une réponse inattendue doit pouvoir être reliée à une version précise.
2. Fixez le modèle. Indiquez une version précise plutôt qu’un alias qui change seul, et rejouez vos tests avant chaque changement.
3. Prévoyez les pannes. Fournisseur indisponible, limite de débit atteinte, outil en erreur : l’agent doit échouer proprement et prévenir quelqu’un.
4. Surveillez le coût jour par jour, avec une alerte et un plafond.
5. Recueillez les retours des utilisateurs et ajoutez chaque échec réel à votre jeu de test.
6. Vérifiez le cadre légal. Si l’agent traite des données personnelles, le RGPD s’applique ; pour des usages sensibles, le règlement européen sur l’IA peut imposer des obligations. Un juriste ou le délégué à la protection des données de votre structure reste le bon interlocuteur.

Récapitulatif : votre feuille de route

Étape	Question à se poser	Livrable
1. Tâche	Fréquente, vérifiable, rattrapable ?	Une description en une phrase
2. Briques	Quel modèle, quelles instructions, quels outils ?	Un prompt système et une liste d’outils
3. Chemin	Plateforme visuelle ou framework de code ?	Un prototype
4. MCP	Mes outils sont-ils réutilisables ?	Un serveur MCP ou des connecteurs
5. Documents	L’agent a-t-il besoin de mes données ?	Un outil de recherche (RAG)
6. Coût	Combien coûte une exécution réelle ?	Une estimation et un budget
7. Tests	L’agent réussit-il mes cas réels ?	Un jeu de test et des traces
8. Sécurité	Que se passe-t-il s’il est manipulé ?	Droits limités et validations humaines
9. Production	Que faire en cas de panne ou de dérive ?	Versions, alertes, retours utilisateurs