Avant de construire un agent IA : la pyramide des systèmes IA

#Le réflexe qu'il faut désapprendre

Tu as un problème à résoudre, tu penses « IA », et tu sautes directement à la conclusion : « je vais construire un agent ». C'est le réflexe le plus courant en 2026, et c'est aussi l'une des sources d'échec les plus fréquentes.

Un agent, c'est un système où le modèle de langage décide lui-même quoi faire, dans quel ordre, et quels outils appeler. C'est puissant. Mais c'est aussi la solution la plus chère, la plus lente, et la plus difficile à déboguer. La vidéo « Don't build more AI agents until you watch this » résume le problème avec une image simple : la pyramide des systèmes IA.

L'idée centrale : il existe quatre niveaux de systèmes IA, du plus simple au plus complexe. Plus tu montes dans la pyramide, plus le coût, la complexité et le risque que tout casse augmentent. Et la plupart des problèmes se résolvent en bas de la pyramide, pas au sommet.

Dans ce guide, on va parcourir les quatre niveaux, avec un exemple concret pour chacun, et finir par une méthode simple pour choisir le bon niveau avant d'écrire la moindre ligne de code.

Ce n'est pas qu'une opinion d'un YouTuber. Anthropic dit exactement la même chose dans son guide d'ingénierie « Building Effective Agents » : commence simple, et n'ajoute de la complexité que lorsque c'est mesurablement utile.

#La pyramide en un coup d'œil

Avant de détailler, voici les quatre niveaux. Lis-les de bas en haut : le niveau 1 est la base la plus simple, le niveau 4 est le sommet le plus ambitieux.

Niveau	Type de système	Qui décide ?	Complexité
4	Agent autonome	Le modèle, dynamiquement	Très élevée
3	Workflow IA	Ton code, avec des appels au modèle	Moyenne
2	Automatisation simple	Ton code, sans IA	Faible
1	Assistant configuré (custom GPT)	L'utilisateur, en discutant	Très faible

La règle d'or tient en une phrase : descends aussi bas que possible dans la pyramide tout en résolvant ton problème. Si le niveau 1 suffit, n'utilise pas le niveau 2. Si le niveau 2 suffit, ne construis pas un agent.

#Niveau 1 — L'assistant configuré

C'est le niveau le plus bas, et souvent le plus sous-estimé. Tu prends un modèle existant (Claude, par exemple), tu lui donnes des instructions claires (un prompt système), éventuellement quelques documents de référence, et c'est tout. L'utilisateur interagit en discutant.

On parle ici de ce qu'on appelle parfois un « custom GPT » ou un assistant personnalisé : pas de code, pas d'infrastructure, pas de boucle automatique.

Exemple concret. Tu veux un assistant qui répond aux questions des nouveaux employés sur le règlement intérieur de ton entreprise. Tu colles le règlement dans le contexte, tu écris un prompt du type « Tu es l'assistant RH, réponds uniquement à partir du document fourni », et tu le partages. Problème résolu en une heure, sans développeur.

Demande-toi toujours : « Est-ce qu'un humain pourrait juste discuter avec le modèle pour obtenir ce résultat ? » Si oui, tu n'as probablement pas besoin de monter plus haut.

#Niveau 2 — L'automatisation simple (sans IA)

Surprise : le deuxième niveau ne contient parfois aucune IA. C'est juste de l'automatisation classique : quand un événement se produit, une suite d'actions s'enchaîne automatiquement.

Pourquoi inclure ça dans une pyramide « des systèmes IA » ? Parce que beaucoup de gens collent de l'IA sur des problèmes qui se règlent avec une simple règle « si ceci, alors cela ». Ajouter un modèle là où une condition logique suffit, c'est payer plus cher pour un résultat moins fiable.

Exemple concret. Quand un client remplit un formulaire de contact, tu veux : enregistrer ses infos dans une base, lui envoyer un email de confirmation, et notifier ton équipe sur Slack. Aucune de ces étapes ne demande de « comprendre » quoi que ce soit. Une automatisation déterministe fait le travail parfaitement, sans risque d'hallucination.

Le mot clé ici est déterministe : à entrée identique, le système produit toujours exactement la même sortie. C'est l'opposé d'un modèle de langage, qui peut varier d'une fois à l'autre.

#Niveau 3 — Le workflow IA

On commence à mélanger les deux mondes. Un workflow IA, c'est une automatisation dont ton code garde le contrôle, mais qui appelle un modèle de langage à des étapes précises et bien définies.

La différence cruciale avec un agent : c'est toi qui décides de l'enchaînement des étapes. Le modèle ne choisit pas quoi faire ; il accomplit une tâche ciblée (classer, extraire, résumer, reformuler) et rend la main à ton code.

Anthropic décrit plusieurs patterns de workflows réutilisables. Voici les trois plus utiles pour débuter :

Pattern	Principe	Exemple
Chaînage (prompt chaining)	Chaque étape traite la sortie de la précédente	Rédiger un texte, puis le traduire, puis le résumer
Routage (routing)	Classer l'entrée, puis l'envoyer vers le bon traitement	Trier les emails entrants : facture, plainte, ou question
Parallélisation	Lancer plusieurs tâches indépendantes en même temps	Analyser un document selon 5 critères simultanément

Exemple concret. Tu reçois des avis clients et tu veux les router automatiquement. Ton code récupère chaque avis, demande au modèle « Classe cet avis : positif, négatif, ou demande d'aide », puis — selon la réponse — envoie l'avis vers le bon canal. Le modèle ne fait qu'une chose : classer. Tout le reste est piloté par du code que tu peux tester, déboguer et prévoir.

C'est le niveau qui résout l'immense majorité des cas d'usage « IA » réels en entreprise. Et pourtant, c'est celui qu'on saute trop souvent pour foncer vers l'agent.

#Niveau 4 — L'agent autonome

Au sommet de la pyramide : l'agent. Ici, le modèle ne se contente pas d'exécuter une tâche. Il dirige lui-même le déroulement : il décide quels outils utiliser, dans quel ordre, et quand il a terminé. Tu lui donnes un objectif et une boîte à outils, pas un script.

C'est légitimement utile dans un cas précis : quand tu ne peux pas prévoir à l'avance le nombre d'étapes ni leur ordre. Pense à un assistant de codage qui explore une base de code inconnue, lit des fichiers, lance des tests, corrige, recommence — le chemin exact dépend de ce qu'il découvre en route.

Mais cette autonomie a un prix. Les agents souffrent de problèmes bien documentés :

Sorties prématurées : l'agent « croit » avoir fini alors que la tâche ne l'est pas.
Erreurs en cascade : une mauvaise décision en entraîne dix autres.
Hallucinations d'outils : l'agent invente un appel d'outil qui n'existe pas.
Opacité : quand ça plante, comprendre pourquoi est un cauchemar.
Coût : chaque étape consomme des tokens, et un agent peut en enchaîner des dizaines.

Un agent n'est pas une version « plus intelligente » d'un workflow. C'est un compromis : tu gagnes de la flexibilité, mais tu perds en prévisibilité, en coût et en facilité de débogage. Ne paie ce prix que si le problème l'exige vraiment.

Exemple concret. Un agent de support qui, face à une demande complexe, peut chercher dans la documentation, interroger la base de commandes, ouvrir un ticket, et décider de lui-même de l'enchaînement selon le cas. Ici, impossible de tout scripter à l'avance : chaque demande est différente. C'est un vrai cas d'agent.

#Comment choisir : la méthode en 3 questions

Avant de construire quoi que ce soit, pose-toi ces trois questions dans l'ordre. Arrête-toi à la première qui répond à ton besoin.

Est-ce qu'un humain pourrait obtenir le résultat juste en discutant avec le modèle ? Si oui → niveau 1 (assistant configuré).
Est-ce que je peux écrire à l'avance toutes les étapes du processus ? Si oui, et qu'aucune étape ne demande de « comprendre » du texte → niveau 2 (automatisation simple). Si oui, mais qu'une ou deux étapes ont besoin du modèle pour classer, extraire ou rédiger → niveau 3 (workflow IA).
Est-ce que le nombre et l'ordre des étapes dépendent de ce que le système découvre en cours de route, sans que je puisse les prévoir ? Seulement si oui → niveau 4 (agent autonome).

Cette progression n'est pas une question de paresse. C'est une question d'ingénierie : chaque niveau supplémentaire ajoute des points de défaillance. Le système le plus fiable est celui qui contient le moins de complexité inutile.

#Récapitulatif

La pyramide des systèmes IA t'évite l'erreur la plus coûteuse du moment : construire un agent là où une solution simple suffisait.

Niveau 1 — Un assistant configuré, sans code. La plupart des besoins « réponds à mes questions » s'arrêtent ici.
Niveau 2 — Une automatisation déterministe, souvent sans IA du tout.
Niveau 3 — Un workflow où ton code pilote et appelle le modèle pour des tâches ciblées. C'est le niveau qui résout la majorité des cas réels.
Niveau 4 — Un agent autonome, réservé aux problèmes dont tu ne peux pas prévoir le déroulement.

La règle à retenir tient en une ligne : commence en bas, et ne monte que quand c'est nécessaire. Anthropic, comme la vidéo qui a inspiré cet article, arrive à la même conclusion. La vraie compétence en 2026, ce n'est pas de savoir construire un agent — c'est de savoir quand ne pas en construire un.