Qu'est-ce qu'un agent IA ? Autonomie, décision et loops de feedback

L'évolution : De LLM à Agents

Niveau 1 : LLM (une réponse)

User : "Résume cet article" Claude : "Voici le résumé..." End.

Niveau 2 : LLM avec Tools (une réponse, multi-step)

User : "Quel est le prix bitcoin aujourd'hui ?" Claude : "Je vais chercher... [appelle API prix]... Bitcoin = $X" End.

Niveau 3 : Agent (boucle d'exécution autonome)

User : "Analyse mon portefeuille et recommend rebalancing" Agent :

Récupère données via API
Analyse (utilise Claude)
Identifie gaps (besoin autre API ?)
Cherche info supplémentaire
Synthétise recommandation
Itère jusqu'à confiant End.

Key diff : Agent = autonome, multi-step, décide des prochaines actions.

Trois niveaux d'autonomie : le LLM seul répond en un échange, le LLM avec outils fait un appel d'outil avant de répondre, l'agent enchaîne une boucle autonome — agir, vérifier, itérer — avant sa réponse — Du LLM seul à l'agent : à chaque niveau, le système gagne en autonomie.

Les 4 composants d'un Agent

1. LLM (le cerveau)

Claude, utilisé pour :

Interpréter la requête
Décider quelle tool utiliser
Raisonner sur les résultats
Itérer

2. Tools (les mains)

Fonctions que l'agent peut appeler :

APIs (Weather, Stripe, Slack, etc.)
Databases
Search engines
Code execution

3. Memory (la mémoire)

Contexte de la conversation :

Messages précédents
Résultats de tools
State (ce qui a été fait)

4. Feedback Loop (le jugement)

Processus :

1. Agent décide : "Je vais appeler tool X"
2. Appelle tool X → résultat Y
3. Regarde le résultat
4. Décide : "Est-ce que Y répond à la requête ?"
   SI NON → Appelle autre tool
   SI OUI → Retourne réponse finale

Les quatre composants d'un agent : le LLM qui interprète et raisonne, les outils comme les APIs et bases de données, la mémoire qui garde messages et résultats, et la boucle de feedback qui évalue chaque résultat — Les 4 briques d'un agent : un cerveau, des mains, une mémoire et un jugement.

Exemple : Un agent de recherche d'emploi

User: "Trouve-moi un job en data science à Paris, 50k+ salary"

Agent loop :
1. Pense : "Je besoin de chercher des jobs. Quels tools j'ai ?"
2. Appelle : search_jobs_api(city="Paris", role="data science", min_salary=50000)
3. Récupère : [10 jobs trouvés]
4. Pense : "10 résultats. Assez. Mais je dois valider salary et détails."
5. Appelle : fetch_job_details(job_id) pour les top 3
6. Formatte : Crée un résumé pour le user
7. Décide : "J'ai répondu à la question. Fait."

Types d'agents

Agent "Réactif"

Pas de mémoire à long terme. Répond à chaque requête indépendamment.

User 1 : "Quel est le prix Bitcoin ?"
Agent : "Bitcoin = $X"

(Oublie)

User 2 : "Quel était le prix qu'on a parlé ?"
Agent : "Je sais pas, je garde pas la mémoire"

Agent "Avec mémoire"

Garde l'historique de la conversation.

User 1 : "Quel est le prix Bitcoin ?"
Agent : "Bitcoin = $X"

User 2 : "C'est plus cher que hier ?"
Agent : "Oui, hier c'était $Y (vient de sa mémoire)"

Agent "Proactif"

Peut initier actions (pas juste répondre).

Configuré : "Si Bitcoin dépasse $100k, m'envoyer une alerte Slack"
Agent : Monitor en background, envoie alert si ça dépasse

Trois types d'agents illustrés par des mini-dialogues : le réactif qui oublie tout entre deux questions, l'agent avec mémoire qui enchaîne les questions grâce à l'historique, et le proactif qui déclenche une alerte quand un seuil est franchi — Réactif, avec mémoire ou proactif : trois niveaux de sophistication.

Les défis des agents

❌ Défi 1 : Tool hallucination

Agent pense qu'il a une tool qu'il n'a pas :

Agent : "Je vais appeler send_email tool"
Mais... send_email n'existe pas
→ Erreur

Solution : Clear tool definitions, include dans système prompt.

❌ Défi 2 : Infinite loops

Agent appelé tool → résultat pas bon → appelle tool → loop forever

User: "Fais-moi $1 million"
Agent : Essaie différentes approches → loop forever

Solution : Max iteration limit (e.g., max 10 tool calls).

❌ Défi 3 : Context explosion

Trop de messages → token limit exceeded.

Agent accumule 1000 messages → Claude capacity exceeded

Solution : Summarize old messages, keep only recent + important.

Trois défis des agents et leurs parades : l'outil halluciné se corrige en déclarant chaque outil dans le prompt système, la boucle infinie avec un plafond d'appels, et le contexte qui explose en résumant l'ancien pour garder l'essentiel — À chaque défi classique sa parade — les trois garde-fous d'un agent fiable.

Quand utiliser agents

✅ Agents sont bons pour :

Multi-step workflows (need data → process → return)
Dynamic decision-making (l'agent décide le next step)
Automation (run autonomous, humans review results)

❌ Agents pas nécessaires pour :

Simple QA (one LLM call = enough)
Real-time (agents trop slow)
Privacy-critical (avoid too many API calls to external services)

Checklist : Êtes-vous prêt pour un agent ?

[ ] Vous avez identifié les tools (APIs, databases)
[ ] Tools ont définitions claires (what does it do ?)
[ ] Vous pouvez gérer max 10-20 tool calls par query
[ ] Vous avez logging (track what the agent does)
[ ] Humans peuvent valider résultats before action

: la modale et son overlay sont volontairement HORS de .tutoriel-container (ci-dessous) pour ne jamais être capturés par le split de contenu de tutoriel-gating.js, qui vide et reconstruit innerHTML de part et d'autre du marqueur — sinon la modale se retrouvait imbriquée dans .tutoriel-gated (donc cachée avec lui) et devenait impossible à afficher. -->