Comment créer des agents IA sur mesure : architecture, modèles de conception et passage à l’échelle

Étape 1 : définir l’architecture de l’agent IA et son cadre de contrôle

L’architecture d’un agent IA comporte deux éléments principaux : le modèle et le service qui l’encadre. Ce service regroupe le modèle, ses outils, sa mémoire et tous les autres composants. Il s’agit d’un logiciel déterministe, codé autour du modèle central avec une logique conditionnelle.

La distinction paraît évidente. Pourtant, les équipes qui apprennent à créer des agents IA sur mesure demandent souvent au modèle de tout faire, au détriment de la fiabilité.

Cette approche montre vite ses limites. Le modèle génère du texte, tandis que le service exécute la logique. Il faut donc considérer le modèle comme un moteur de raisonnement isolé, sans accès au code de routage.

Le service gère l’état, le routage et la reprise après erreur. Le modèle ne prend pas ces décisions. Après le déploiement de cette architecture pour une entreprise SaaS de taille intermédiaire, les délais de résolution du support ont baissé de 40 pour cent : le service déterministe assurait le routage au lieu de s’en remettre aux suppositions du modèle.

C’est le code qui prenait les décisions. Un schéma clair permet de visualiser cette séparation : c’est le service, et non le modèle, qui dicte le déroulement. Il faut donc un plan de mise en œuvre rigoureux.

Ne négligez pas les conditions logiques déterministes. Anthropic a publié une étude sur les modèles de conception possibles pour les agents IA. Elle présente quatre grands types de systèmes : agent unique, workflow séquentiel, workflow parallèle et évaluateur-optimiseur.

Vous voulez créer des agents IA sur mesure capables de passer à l’échelle ? Adaptez le modèle de conception au problème. Confier un workflow parallèle en plusieurs étapes à un seul agent fera exploser la latence du système. Un agent unique convient à une tâche bien délimitée.

• [ ] Définir une logique de routage déterministe
• [ ] Cartographier l’accès aux outils via MCP
• [ ] Choisir un modèle de fondation
• [ ] Concevoir le schéma d’état de la mémoire
• [ ] Prévoir des solutions de repli en cas d’erreur

Quel modèle de conception convient à votre agent sur mesure ?

Les agents uniques sont faciles à déboguer, mais leur champ d’action est limité. Dans un workflow séquentiel, chaque agent transmet son résultat au suivant. Ce modèle convient aux processus linéaires, comme les chaînes de recherche qui exigent une exécution étape par étape.

Une architecture de workflow parallèle mobilise plusieurs agents IA qui travaillent simultanément et de façon asynchrone, à l’image du multithreading en informatique classique, pour réduire la latence. Ce modèle réduit fortement les délais pour les tâches complexes. Dans une architecture évaluateur-optimiseur, deux systèmes d’agents fonctionnent par cycles : le groupe A réalise le travail, puis le groupe B l’évalue et l’améliore, comme en programmation en binôme.

On obtient ainsi de meilleurs résultats pour les tâches de programmation ou de rédaction. Voici un extrait Python qui configure un workflow parallèle dans lequel les agents travaillent de façon asynchrone. C’est ainsi que l’on exécute plusieurs agents sans attendre que chacun termine à son tour.

Examinez le code ci-dessous. `async def run_agent(task: str):`

# Simuler une tâche d’agent asynchrone await asyncio.sleep(1)

import asyncio


return f"Result for {task}" async def parallel_workflow(tasks: list[str]): # Agents act asynchronously like multithreading results = await asyncio.gather(*[run_agent(task) for task in tasks])


return results tasks = ["fetch_market_data", "analyze_sentiment", "check_compliance"] results = asyncio.run(parallel_workflow(tasks)) print(results)

Tenez compte de ces compromis lorsque vous concevez votre workflow. Pour créer un agent IA avec Claude, les développeurs associent Claude Agent SDK et Agent Skills. Ce sont deux pistes importantes si vous cherchez à créer des agents IA sur mesure.

Choisissez vos outils avec soin. Claude Agent SDK permet une intégration étroite, tandis que LangGraph convient à l’orchestration de machines à états complexes.

1. Latence : Les workflows parallèles réduisent considérablement le temps total.
2. Coût : Les workflows parallèles consomment davantage de tokens par seconde.
3. Précision : Les cycles évaluateur-optimiseur améliorent la précision, mais doublent les besoins de calcul.
4. Complexité : Les workflows séquentiels sont les plus faciles à déboguer.

Étape 2 : choisir le modèle de fondation et le framework d’orchestration

Pour concevoir un agent avec Claude, le principe est simple : le SDK fournit la boucle d’exécution, les outils et MCP définissent ce que l’agent peut faire, et les Skills définissent comment il sait le faire. Les responsabilités sont ainsi clairement séparées. Claude Agent SDK fournit une boucle d’agent (recueillir le contexte, appeler le modèle, exécuter un outil, réinjecter le résultat, recommencer) programmable en Python ou en TypeScript.

LangGraph offre davantage de contrôle. Il permet de définir des nœuds explicites pour la logique et de mettre en place des garde-fous stricts qui empêchent le modèle de lancer des appels d’outils non autorisés.

La couche d’orchestration fournit les garde-fous nécessaires pour que les agents restent concentrés sur leur tâche. On peut les coder avec des outils comme LangGraph ou les configurer dans une interface graphique comme Cursor Automations. Sans orchestration, un agent peut boucler indéfiniment sur une seule erreur.

La gestion sécurisée des identifiants est essentielle. Ne codez jamais de clés API en dur dans le prompt système : pour un système en production, elles doivent être injectées à l’exécution au moyen de variables d’environnement.

Nous privilégions LangGraph pour les routages complexes. Il oblige à réfléchir aux transitions d’état, tandis que Claude SDK convient mieux au prototypage rapide et aux tâches utilisant de nombreux outils, qui demandent des itérations courtes.

{
 "orchestration": {
 "guardrails": {
 "max_iterations": 5,
 "timeout_seconds": 30
 },
 "secrets_manager": {
 "provider": "aws_secrets_manager",
 "keys": ["ANTHROPIC_API_KEY", "FIRECRAWL_API_KEY"]
 }
 }
}

Étape 3 : intégrer les outils, l’accès au web et la gestion de la mémoire

Les agents IA accèdent aux outils par MCP (Model Context Protocol), des outils en ligne de commande et des frameworks comme LangChain. Savoir créer des agents IA sur mesure, c’est aussi savoir les ancrer dans le réel. Leurs connaissances doivent s’appuyer sur des données réelles et actualisées : sans cela, elles se limitent aux informations stockées en mémoire et aux données d’entraînement.

Les outils de récupération intégrés proposés par des entreprises comme OpenAI et Anthropic n’offrent qu’un accès limité au web. Des outils dédiés comme Firecrawl sont donc nécessaires. Récupérer du HTML brut gaspille de l’espace de contexte et perturbe le modèle.

Firecrawl propose trois points d’accès principaux pour le web : /search (recherches en direct sur le web), /scrape (récupération de sites sous forme de données structurées ou de Markdown) et /interact (ouverture d’un vrai navigateur pour cliquer sur des boutons et remplir des formulaires).

Sur une page type, une extraction propre avec Firecrawl produit environ 2,788 tokens de Markdown, contre 38,381 tokens de HTML brut. Firecrawl réduit ainsi de 94 pour cent le nombre de tokens en entrée par rapport à la récupération de HTML brut. Les performances de l’agent s’en trouvent directement améliorées.

La structure des pages web peut changer, et celles-ci peuvent contenir des éléments de navigation ou des scripts sans intérêt. Privilégiez un point d’accès structuré et documenté lorsqu’il existe, puis testez l’extraction sur des pages représentatives et après des changements de mise en page.

import requests


def search_web(query: str):
    response = requests.post("https://api.firecrawl.dev/v1/search", 
        json={"query": query, "limit": 5},
        headers={"Authorization": f"Bearer {API_KEY}"})
    return response.json()


def scrape_site(url: str):
    response = requests.post("https://api.firecrawl.dev/v1/scrape",
        json={"url": url, "formats": ["markdown"]},
        headers={"Authorization": f"Bearer {API_KEY}"})
    return response.json()

La mémoire est indispensable aux systèmes IA de longue durée, car tous les modèles disposent d’une fenêtre de contexte limitée, qu’il faut reconstruire une fois sa limite atteinte. Cette fenêtre peut, par exemple, contenir 200,000 tokens avant de devoir être réinitialisée et reconstituée à partir de la mémoire.

Stockez l’historique des échanges et l’état dans une base de données externe. Quand la fenêtre de contexte est pleine, récupérez un résumé et les faits pertinents, puis reconstituez le prompt. Ne supposez jamais que le modèle se souvient de quoi que ce soit au-delà de l’entrée qu’il reçoit.

Comment gérer les coûts, les clés API et les tests ?

Si vous exécutez cinq agents en parallèle, vous payez cinq appels au modèle en même temps. Un agent individuel coûte moins cher par exécution, mais met nettement plus longtemps à terminer. Il faut donc trouver le bon équilibre entre rapidité et budget.

Prenons un exemple concret : un agent de support traitant un volume intermédiaire de 10,000 demandes par mois. À $5 par ticket traité manuellement, le coût atteint $50,000. Le coût de l’automatisation se répartit autrement.

L’hébergement coûte $100. Le seuil de rentabilité est atteint presque immédiatement. Tester le code qui encadre l’agent est indispensable : simulez les défaillances des outils et testez rigoureusement la gestion des délais d’expiration avant toute mise en production.

Nous utilisons des cas de test déterministes pour le code qui encadre l’agent et des batteries d’évaluations probabilistes pour le modèle. Nous ne déployons jamais un agent sans avoir testé sa capacité à se remettre des erreurs. Cessez de surcharger les instructions système.

Les Agent Skills sont des dossiers contenant un fichier SKILL.md qui enseignent à l’agent des tâches spécialisées. Ils sont chargés à la demande, par dévoilement progressif, pour préserver l’espace dans la fenêtre de contexte. Pour maîtriser la création d’agents IA personnalisés, vous devez séparer ces différents aspects.

Un point souvent négligé : pourquoi les procédures ont leur place dans les Skills

Pour concevoir un agent Claude, retenez cette distinction : le SDK gère la boucle d’exécution, les outils et MCP définissent ce que l’agent peut faire, et les Skills lui apprennent comment le faire. Les outils sont des verbes, les Skills sont des modes d’emploi. Si vous placez toutes les instructions dans les instructions système, vous gaspillez de l’espace dans la fenêtre de contexte : le modèle lit des consignes inutiles pour la tâche en cours.

Le dévoilement progressif résout ce problème. L’agent ne charge le fichier SKILL.md que lorsqu’il en a besoin pour une tâche précise. La fenêtre de contexte reste ainsi moins encombrée et le risque d’hallucinations diminue.

Vos agents deviennent aussi modulaires : vous pouvez mettre à jour un skill sans toucher à la logique centrale d’orchestration.