Agents IA: la boucle qui change tout
Un agent IA, c'est pas juste un chatbot. C'est une boucle qui observe, réfléchit, et agit. Voici comment ça marche.
ChatGPT, c'est pas un agent.
Tu poses une question, il répond. Point.
Un agent, c'est différent. Il observe. Il réfléchit. Il agit. Et il recommence.
Enfin une définition claire
Pendant des années, "agent" était un terme flou. Chacun avait sa propre définition.
Aujourd'hui, il y a un consensus. Chip Huyen le résume dans son livre AI Engineering : un agent, c'est un système qui utilise un LLM pour décider quelles actions prendre, les exécute, observe les résultats, et recommence jusqu'à atteindre l'objectif.
Un LLM classique, c'est un aller simple. Tu envoies un prompt, tu reçois une réponse. Le modèle prédit les tokens suivants et s'arrête.
Un agent, c'est une boucle :
- Observer : L'agent regarde l'état actuel (fichiers, erreurs, résultats)
- Réfléchir : Il décide de la prochaine action
- Agir : Il exécute l'action (lire un fichier, exécuter du code, appeler une API)
- Répéter : Il observe le résultat et recommence
Cette boucle tourne jusqu'à ce que la tâche soit terminée.
En code, ça donne quoi ?
Voici une implémentation minimaliste de la boucle agent en TypeScript :
import Anthropic from "@anthropic-ai/sdk";
import { execSync } from "child_process";
const client = new Anthropic();
interface AgentState {
task: string;
history: { action: string; result: string }[];
completed: boolean;
}
async function agentLoop(task: string, maxIterations = 10): Promise<string> {
const state: AgentState = {
task,
history: [],
completed: false,
};
for (let i = 0; i < maxIterations; i++) {
// 1. OBSERVER - État actuel
const observation = `
Tâche: ${state.task}
Historique: ${JSON.stringify(state.history.slice(-3))}
`;
// 2. RÉFLÉCHIR - Le LLM décide
const response = await client.messages.create({
model: "claude-sonnet-4-20250514",
max_tokens: 1024,
messages: [
{
role: "user",
content: `${observation}
Décide de la prochaine action:
- EXECUTE: <commande shell>
- WRITE: <fichier> <contenu>
- DONE: <résultat final>
Réponds avec UNE seule action.`,
},
],
});
const decision =
response.content[0].type === "text" ? response.content[0].text : "";
console.log(`Itération ${i + 1}: ${decision.slice(0, 50)}...`);
// 3. AGIR - Exécuter la décision
if (decision.startsWith("DONE")) {
return decision.replace("DONE:", "").trim();
}
if (decision.startsWith("EXECUTE:")) {
const cmd = decision.replace("EXECUTE:", "").trim();
try {
const result = execSync(cmd, { encoding: "utf-8" });
state.history.push({ action: `Exécuté: ${cmd}`, result: result.slice(0, 200) });
} catch (err) {
state.history.push({ action: `Exécuté: ${cmd}`, result: `Erreur: ${err}` });
}
}
if (decision.startsWith("WRITE:")) {
state.history.push({ action: decision, result: "Fichier écrit" });
}
// 4. RÉPÉTER - La boucle continue
}
return "Max itérations atteintes";
}
// Exemple: agentLoop("Crée un fichier hello.ts qui print 'Hello'")
Ce code illustre le pattern fondamental. En prod, tu ajouterais :
- Gestion d'erreurs robuste
- Outils plus sophistiqués via MCP
- Mémoire persistante
- Limites de coûts
Pourquoi c'est puissant
Avec un simple prompt, tu dois tout prévoir à l'avance. Si le LLM fait une erreur, c'est foutu.
Avec un agent, les erreurs font partie du process. L'agent voit que ça n'a pas marché, ajuste son approche, et réessaie.
Swyx (Latent Space) parle de 2025 comme le début de la "Decade of Agents". Les agents de code comme Claude Code représentent un vrai changement de paradigme. Ils peuvent exécuter directement le code qu'ils écrivent, corriger les erreurs, fouiller dans les détails d'implémentation existants, et même mener des expériences.
C'est comme la différence entre donner une recette figée et avoir un cuisinier qui goûte et ajuste.
Les composants d'un agent
Le cerveau : Un LLM qui raisonne et prend des décisions.
Les outils : Des actions que l'agent peut exécuter. Lire des fichiers, exécuter du code, appeler des APIs. C'est là qu'intervient MCP.
La mémoire : L'historique des actions et observations. Limitée par le nombre de tokens que le modèle peut traiter, d'où l'importance d'un fichier CLAUDE.md pour fournir du contexte persistant.
La boucle : Le code qui orchestre tout ça.
AGENTS.md : le nouveau standard
En décembre 2025, la Linux Foundation a créé l'Agentic AI Foundation. Trois projets fondateurs : MCP (Anthropic), goose (Block), et AGENTS.md (OpenAI).
AGENTS.md, c'est comme un README pour agents. Un fichier standard qui dit à l'agent comment travailler sur ton projet. Quelles commandes lancer. Quels tests exécuter. Quelles conventions suivre.
Depuis août 2025, plus de 60 000 projets open source l'ont adopté. GitHub Copilot, Cursor, Devin, et la plupart des agents de code le supportent.
L'idée est la même que CLAUDE.md : donner du contexte à l'agent pour qu'il travaille efficacement. AGENTS.md est le format standardisé qui fonctionne avec tous les agents.
Les agents sont puissants mais pas magiques.
Ils peuvent tourner en rond. Si la tâche est mal définie ou impossible, l'agent va continuer à essayer. Il n'a pas toujours le recul pour dire "cette tâche ne peut pas être accomplie".
Chaque itération consomme des tokens. Et donc de l'argent. Un agent qui fait 50 itérations pour résoudre un bug peut coûter plusieurs dollars. Ce n'est pas anodin pour un projet avec beaucoup d'utilisateurs.
Plus la boucle est longue, plus le risque de dérive est grand. Le contexte s'accumule. L'agent peut "oublier" des instructions du début ou se contredire.
Un bon prompt engineering au départ réduit le nombre d'itérations nécessaires. Mais même le meilleur prompt ne garantit pas qu'un agent trouvera la solution.
Brute force vs intelligence
Voici un insight qui change la façon de voir les agents : ce sont des outils de force brute pour trouver des solutions aux problèmes de code. Si tu peux réduire ton problème à un objectif clair et un ensemble d'outils qui peuvent itérer vers cet objectif, un agent peut souvent forcer son chemin vers une solution efficace.
Les agents ne sont pas intelligents au sens humain. Ils essaient, échouent, réessaient. Ce qui les rend efficaces, c'est la vitesse à laquelle ils itèrent et le fait qu'ils ne se fatiguent pas.
Un chatbot répond. Un agent résout. Mais la résolution peut prendre 3 itérations ou 300. C'est le compromis à accepter.