Les 5 composants
d'un agent.

1. L'analogie : un agent comme un nouveau collaborateur

Pour comprendre les 5 composants, imaginez que vous embauchez un nouveau collaborateur qui va faire un travail spécifique pour vous. Que faut-il pour qu'il soit opérationnel ?

1. Un cerveau qui réfléchit, comprend les instructions, prend des décisions. C'est le LLM (modèle de langage).
2. Des outils pour agir : ordinateur, accès aux logiciels métier, téléphone, badge d'accès. Ce sont les tools de l'agent.
3. Une mémoire : carnet de notes pour le court terme, fichiers archivés pour le long terme, documentation de l'entreprise. Ce sont les 3 types de mémoire de l'agent.
4. Une stratégie : capacité de découper un objectif en étapes, prioriser, planifier. C'est la planification.
5. Des règles et garde-fous : ce qui est autorisé, ce qui demande validation, ce qui est interdit. Ce sont les garde-fous.

Sans le cerveau, votre collaborateur ne comprend rien. Sans outils, il ne peut rien faire. Sans mémoire, chaque journée recommence à zéro. Sans stratégie, il bricole sans plan. Sans garde-fous, il prend des décisions catastrophiques.

Un agent IA, c'est exactement la même chose. Démontons chaque pièce.

2. Composant 1 : Le LLM (le cerveau)

Le LLM (Large Language Model) est le cœur de l'agent. C'est lui qui comprend les instructions, raisonne sur la situation, et décide de l'action à prendre. Sans LLM, pas d'agent.

Quel modèle choisir ?

4 familles principales accessibles aux PME en 2026 :

• Claude (Anthropic) : excellent en suivi d'instructions complexes et en sécurité. Claude Sonnet 4 pour les tâches difficiles, Claude Haiku pour les tâches simples économiques.
• GPT (OpenAI) : polyvalent, large écosystème. GPT-4o pour la qualité, GPT-4o-mini pour l'économie.
• Mistral (français !) : Mistral Large pour qualité, Mistral Small pour économie. Hébergement européen possible (Scaleway, OVH AI). Excellent pour la souveraineté.
• Modèles open-source (Llama 3, Qwen, DeepSeek) : à faire tourner soi-même. Plus complexe, mais zéro coût d'API et données strictement locales.

Les 3 paramètres clés à connaître

Trois paramètres modifient drastiquement le comportement du LLM dans votre agent :

• Temperature (0 à 1) : contrôle la "créativité". Pour un agent qui fait des actions précises (créer des tickets, formater des données), mettez à 0 ou 0.1 (résultats prédictibles). Pour un agent créatif (brainstorming, rédaction), mettez à 0.7-0.9.
• Max tokens : limite la longueur de la réponse. Pour les agents, gardez ça bas (200-500 tokens) pour aller vite et économiser. Sauf pour la génération de contenu.
• System prompt : les instructions permanentes données au modèle. C'est la pièce la plus importante. Un bon system prompt fait 80 % de la qualité de votre agent. On y revient au chapitre 8.

Modèle haut de gamme vs modèle économique : choisir intelligemment

Erreur fréquente : prendre Claude Sonnet 4 ou GPT-4o "par sécurité" pour tous les usages. Résultat : facture API 10 fois plus chère qu'avec un modèle économique, sans qualité significativement supérieure.

Règle pratique :

• Tâches simples (classification, extraction, formatage, réponse à FAQ) → modèle économique (Haiku, GPT-4o-mini, Mistral Small)
• Tâches complexes (raisonnement multi-étapes, rédaction nuancée, analyse stratégique) → modèle haut de gamme (Sonnet 4, GPT-4o, Mistral Large)
• Multi-agents : modèle haut de gamme pour l'orchestrateur, modèles économiques pour les agents spécialisés

3. Composant 2 : Les outils (les mains)

Sans outils, le LLM ne peut que générer du texte. Les tools (ou "function calling") sont ce qui permet à l'agent d'agir dans le monde réel.

Un outil, c'est une fonction que l'agent peut appeler avec des paramètres pour effectuer une action. Quelques exemples :

• send_email(destinataire, sujet, contenu) → envoie un email via Gmail/Outlook
• create_ticket(titre, description, priorite) → crée un ticket dans votre helpdesk
• search_crm(critere, valeur) → recherche dans votre CRM
• get_calendar_availability(jour, durée) → consulte votre Google Calendar
• fetch_invoice(numéro) → récupère une facture dans Pennylane

L'agent décide quel outil appeler, avec quels paramètres, en fonction du contexte. Le LLM produit un appel structuré (souvent en JSON), le système exécute l'appel, et la réponse revient au LLM pour la suite du raisonnement.

Comment fournir des outils à un agent

4 mécanismes principaux :

• Function calling natif (OpenAI, Anthropic) : on déclare les fonctions disponibles dans l'appel API, le modèle les appelle quand pertinent. C'est le standard.
• MCP (Model Context Protocol) : protocole ouvert lancé par Anthropic en 2024-2025, devenu standard de facto en 2026. Permet de connecter facilement plein d'outils existants à un agent. Claude Code l'utilise massivement. Le chapitre 4 entre dans le détail.
• Webhooks : l'agent envoie une requête HTTP à votre système, qui exécute l'action. Simple et puissant.
• Nœuds n8n : si vous travaillez en no-code, chaque nœud n8n peut devenir un outil pour votre agent. C'est l'approche qu'on utilise dans ce cours.

Combien d'outils donner à un agent ?

Erreur classique : donner 50 outils à un agent et espérer qu'il choisisse le bon. Plus il y a d'outils, plus l'agent se trompe.

Bonne pratique : 5 à 10 outils maximum par agent. Si vous avez besoin de plus, c'est probablement le signe qu'il faut plusieurs agents spécialisés (chacun avec son propre lot d'outils) plutôt qu'un seul agent monstrueux. C'est l'approche multi-agents qu'on verra au chapitre 3.

4. Composant 3 : La mémoire (le cahier)

Sans mémoire, un agent ne peut traiter qu'une seule requête à la fois et oublie tout entre les exécutions. C'est très limitant. Trois types de mémoire complémentaires existent.

Mémoire 1 : Court terme (le contexte de conversation)

C'est la mémoire active pendant une exécution ou une conversation. Elle est stockée dans le contexte du LLM (les messages précédents qui restent visibles). Limitée à la fenêtre de contexte du modèle (200 k tokens pour Claude Sonnet 4, 128 k pour GPT-4o, etc.).

Usage typique : "Tu m'as posé telle question il y a 2 messages, voici ma réponse". L'agent se souvient parfaitement de ce qui s'est dit.

Mémoire 2 : Long terme (la base de connaissances)

Pour qu'un agent se souvienne entre deux exécutions ou entre deux conversations, il faut une mémoire externe. Stockée dans une base de données classique : Postgres, Airtable, Notion, Google Sheets.

Usage typique : agent commercial qui se souvient que le prospect Jean Dupont a déjà été relancé 3 fois, n'aime pas les emails le lundi, préfère le téléphone. À chaque interaction, l'agent va chercher l'historique de Jean dans la base et adapte sa stratégie.

Mémoire 3 : Vectorielle (la recherche sémantique)

C'est la mémoire la plus puissante mais aussi la plus complexe. Elle permet à l'agent de retrouver une information par sens, pas par mot-clé exact. Si vous avez 500 documents internes et qu'un agent reçoit une question, il peut trouver les 3 documents les plus pertinents même si les mots de la question ne sont pas exactement dans les documents.

Comment ça marche : chaque document est transformé en "vecteur" (une longue liste de chiffres) qui capture son sens. La question est aussi transformée en vecteur. On compare les vecteurs pour trouver les plus similaires. C'est ce qu'on appelle RAG (Retrieval-Augmented Generation).

Usage typique : agent de support client qui consulte automatiquement la base de connaissances de l'entreprise pour répondre. Agent juridique qui retrouve les bonnes jurisprudences. Agent commercial qui retrouve les produits adaptés à un besoin client exprimé en langage naturel.

Outils pour démarrer : Pinecone, Qdrant, Weaviate, Chroma, ou pgvector (extension Postgres). En no-code dans n8n, le nœud "Vector Store" gère ça pour vous. Le chapitre 5 du cours entre dans le détail.

5. Composant 4 : La planification (la stratégie)

Pour les tâches simples, l'agent réagit directement (recevoir un email → classer dans le bon dossier). Pour les tâches complexes, il faut une planification : décomposer un objectif en étapes, ordonner ces étapes, anticiper les obstacles.

Trois niveaux de planification

1. Réactif (pas de planif explicite) : l'agent agit étape par étape selon ce qu'il observe. C'est le pattern ReAct (Reason + Act). Suffisant pour 70 % des cas TPE/PME.
2. Plan-and-Execute : l'agent commence par établir un plan complet (par exemple : "1. récupérer la liste des prospects ; 2. enrichir chaque profil ; 3. rédiger un message ; 4. valider ; 5. envoyer"). Puis il exécute le plan étape par étape. Plus fiable pour les workflows complexes à étapes multiples.
3. Reflection : après avoir agi, l'agent évalue son propre résultat et corrige si besoin avant de poursuivre. "J'ai rédigé cet email, est-il suffisamment personnalisé ? Non, je manque de détails sur l'entreprise du prospect, je vais d'abord faire de la recherche."

Le chapitre 3 entre dans le détail de ces patterns d'architecture. Pour le chapitre 2, retenez juste que la planification est ce qui distingue un agent qui exécute aveuglément d'un agent qui réfléchit.

Comment activer la planification dans un agent

Pour un agent réactif simple : aucune planification explicite, le LLM décide à chaque étape. C'est ce qui se fait par défaut.

Pour Plan-and-Execute : on ajoute dans le prompt système une instruction du type "Avant d'agir, formule un plan détaillé en 3 à 8 étapes. Présente le plan, puis exécute-le". C'est aussi simple que ça.

Pour Reflection : on ajoute après chaque action "Évalue ton résultat. Note 1 à 5. Si moins de 4, recommence en corrigeant le problème identifié".

6. Composant 5 : Les garde-fous (les filets)

Sans garde-fous, l'agent peut prendre des décisions catastrophiques : envoyer un email mal écrit à 1000 clients, supprimer une base de données, dépenser 500 € d'API en boucle infinie. Les garde-fous sont ce qui rend l'autonomie acceptable.

Cinq garde-fous indispensables

1. Limite d'itérations : "L'agent ne fait pas plus de 10 itérations dans une boucle". Évite les boucles infinies coûteuses.
2. Validation humaine (Human-in-the-Loop) : "Avant d'envoyer un email à un client, demande validation à un humain". Indispensable pour les actions externes irréversibles. Détaillé au chapitre 6.
3. Limite de coût : "Si l'agent a consommé plus de 5 € d'API sur cette tâche, arrête et alerte". Prévient les dépassements.
4. Validation de format : "Vérifie que le résultat est du JSON valide / un email valide / un numéro existant dans le CRM". Évite les erreurs en aval.
5. Filtre de contenu : "Refuse de générer du contenu insultant, médical, juridique précis". Cadre les usages acceptables.

Garde-fous techniques vs garde-fous métier

Garde-fous techniques : limites d'itérations, timeouts, retries. Configurés dans le code/workflow.

Garde-fous métier : "Cet agent ne peut jamais accorder une remise supérieure à 10 % sans validation". Configurés dans le prompt système et les workflows. Plus subtils, plus importants.

Le chapitre 6 du cours est entièrement dédié aux garde-fous. C'est un sujet majeur, sous-estimé par 90 % des projets agents IA.

7. Comment ces 5 composants interagissent : la boucle d'exécution

Les 5 composants ne sont pas indépendants : ils s'articulent dans une boucle d'exécution. Voici la version simplifiée :

Cette boucle peut tourner 1 fois (tâche simple), 5 fois (tâche complexe), 50 fois (mission étendue). Les garde-fous limitent le nombre d'itérations pour éviter les emballements.

8. Matrice de choix par cas d'usage

Tous les agents n'ont pas besoin de tous les composants au même niveau de sophistication. Voici une matrice indicative :

Cas d'usage	LLM	Outils	Mémoire	Planif	Garde-fous
Tri d'emails	Haiku/mini	1 (move)	Court terme	Réactif	Léger
FAQ chatbot	Haiku/mini	1-2 (search)	Vectorielle	Réactif	Filtre contenu
Agent commercial	Sonnet/4o	5-8	Long terme + Vect.	Plan-Execute	HITL envois
Reporting financier	Sonnet/4o	3-5	Long terme	Plan-Execute	Validation chiffres
Multi-agents recrutement	Mix	Variable par agent	Tout	Reflection	HITL strict

Cette matrice n'est pas absolue, mais elle vous donne un point de départ pour cadrer votre projet.

9. Erreurs fréquentes dans le choix des composants

Erreur 1 : Donner trop d'outils

"Je vais donner accès à 30 nœuds n8n à mon agent, comme ça il pourra tout faire". Catastrophe garantie. Le LLM se perd, choisit le mauvais outil 1 fois sur 3, génère des erreurs. Maximum 5 à 10 outils par agent. Sinon, multi-agents.

Erreur 2 : Sous-estimer la mémoire

"Ma conversation tient dans le contexte du modèle, pas besoin de mémoire externe". Vrai pour 1 conversation. Faux dès qu'on veut un agent qui se souvient entre les sessions. Une simple table Airtable ou Postgres suffit pour démarrer.

Erreur 3 : Pas de garde-fous

"Je teste d'abord, je mettrai les garde-fous après". Très mauvaise idée. Vous risquez de générer des centaines d'euros de coûts API en boucle infinie, ou pire, d'envoyer des emails ridicules à des vrais clients. Garde-fous dès le jour 1, même basiques.

Erreur 4 : Modèle trop puissant pour la tâche

Utiliser Claude Sonnet 4 pour classer des emails dans 5 catégories, c'est utiliser un Boeing pour traverser la rue. Mistral Small ou GPT-4o-mini font ça aussi bien pour 10x moins cher.

Erreur 5 : Pas de planification quand il en faudrait

Pour des tâches en 5+ étapes, un agent réactif se perd, oublie des étapes, mélange l'ordre. Activez Plan-and-Execute. C'est juste une instruction dans le prompt, ça change tout.

10. À retenir avant le chapitre suivant

• Tout agent IA est composé de 5 briques : LLM (cerveau), outils (mains), mémoire (cahier), planification (stratégie), garde-fous (filets)
• Le LLM choisi doit correspondre à la complexité de la tâche : économique pour le simple, premium pour le complexe
• 5 à 10 outils maximum par agent. Sinon, multi-agents
• 3 types de mémoire : court terme (contexte LLM), long terme (DB classique), vectorielle (RAG)
• 3 niveaux de planification : réactif, Plan-and-Execute, Reflection
• 5 garde-fous indispensables : limite itérations, validation humaine, limite coût, validation format, filtre contenu
• La boucle d'exécution articule les 5 composants : trigger → mémoire → LLM → garde-fou → outil → observation → (reflection) → stockage

Au chapitre 3, on plonge dans les patterns d'architecture : ReAct, Plan-and-Execute, Reflection, multi-agents (orchestrateur). Vous apprendrez quand utiliser quel pattern, et comment combiner plusieurs agents pour des missions complexes.