Mode agentique.

De l'auto-complétion à l'exécution de tâches

En mode conversation classique, la boucle est linéaire : vous écrivez, le modèle écrit, fin. Si la réponse est incomplète ou erronée, c'est à vous de corriger.

En mode agentique, le modèle dispose d'outils qu'il peut appeler de sa propre initiative : lecture d'un fichier, exécution d'un script, recherche web, requête sur une base de données, modification d'un fichier source. À chaque appel, il reçoit le résultat, l'observe, planifie l'étape suivante, et recommence jusqu'à ce que l'objectif soit atteint ou qu'un budget soit dépassé.

C'est l'équivalent du passage du copilote au système de navigation automatique. Le pilote humain garde la responsabilité, fixe la destination, surveille, peut intervenir, mais ne tient plus le volant à chaque virage.

La boucle ReAct, mécanique de base

Le pattern dominant s'appelle ReAct (Yao et al., 2022), pour Reasoning + Acting. À chaque tour, l'agent alterne trois temps :

Pensée :   Je dois connaître la version actuelle du fichier
           package.json avant de pouvoir y ajouter une
           dépendance.
Action :   appel de l'outil Read(file="package.json")
Observation : { "dependencies": { "react": "^18.0.0", ... } }
Pensée :   La version de React est suffisante. Je peux
           ajouter la dépendance sans conflit.
Action :   appel de l'outil Edit(file="package.json", ...)
Observation : ok, fichier modifié.
Pensée :   Je relance l'installation pour valider.
Action :   appel de l'outil Bash(cmd="npm install")
Observation : exit code 0
Pensée :   Tâche terminée. Réponse à l'utilisateur :
           « Dépendance ajoutée et installée. »

Cette boucle est tellement utile qu'elle a donné naissance à une nouvelle catégorie d'outils : les agents codeurs (Claude Code, Cursor, Antigravity de Google DeepMind, Codex), des assistants conversationnels qui ont accès au système de fichiers et au shell.

Les outils, ce qui donne du pouvoir à l'agent

Un agent sans outils n'agit pas, il imagine. La qualité de l'agent dépend autant des outils qu'on lui met à disposition que du modèle qui le pilote. Inventaire des outils utiles, classés par usage :

• Système de fichiers : lire, écrire, éditer, supprimer. Indispensable pour tout agent de codage.
• Shell : exécuter une commande arbitraire. Permet de lancer des tests, des builds, des scripts. À encadrer fortement (cf. garde-fous).
• Recherche web : pour tout ce qui dépend du temps réel ou qui sort de la fenêtre de connaissance du modèle.
• Base de données : requêtes en lecture seule pour analyser, en écriture pour produire.
• APIs métier : envoyer un mail, créer un ticket, modifier un calendrier, déclencher un déploiement.
• Outils visuels : capture d'écran d'une page web, génération d'image, lecture d'un PDF, analyse d'une photo.

Chaque outil est décrit au modèle par sa signature (nom, paramètres, type de retour) et sa documentation. L'agent choisit lui-même quand l'appeler.

Model Context Protocol, le standard qui change tout

En 2024, Anthropic a publié MCP (Model Context Protocol), un standard ouvert qui décrit comment un agent et un outil dialoguent. Avant MCP, chaque éditeur connectait ses propres outils à sa façon (Cursor avait son écosystème, Cline le sien, Continue le sien). Avec MCP, tout outil exposé via MCP est utilisable par tout agent compatible.

Concrètement : si un service interne expose un serveur MCP (« cherche dans Notion », « lis le calendrier équipe », « interroge la base ressources humaines »), tous les agents IA de l'organisation y ont accès uniformément. Cela transforme la stratégie d'adoption : on ne se demande plus quel agent acheter, mais quels serveurs MCP construire. C'est analogue à ce qu'a été REST pour les APIs ou USB pour les périphériques.

Cas d'usage, le codage agentique

C'est le premier domaine où le mode agentique a démontré une utilité massive. Les outils dominants en mai 2026 :

• Claude Code (Anthropic) : agent CLI qui tourne dans le terminal, accès complet au projet, orchestration de tâches longues avec sous-agents spécialisés. C'est ce qui a produit ce site.
• Cursor : éditeur dérivé de VS Code avec agent intégré. Forte adoption côté entreprises tech.
• Antigravity (Google DeepMind) : environnement agentique, intégration native avec l'écosystème Google.
• Codex CLI (OpenAI), GitHub Copilot Workspace : alternatives crédibles, écosystème différent.

Cas d'usage où le gain est massif :

1. Refactoring sur l'ensemble d'un projet. Renommer une fonction utilisée à 200 endroits, mettre à jour une dépendance majeure, migrer une syntaxe : tâches mécaniques mais coûteuses en temps qui se ramènent à quelques minutes en pilotant un agent.
2. Prototypage rapide. Passer d'une idée à un MVP fonctionnel en quelques heures, parce que l'agent gère le boilerplate, la configuration, le déploiement.
3. Réparation guidée. Coller un message d'erreur, laisser l'agent lire le code concerné, faire ses hypothèses, tester ses corrections.
4. Migration de stack. Passer d'un framework à un autre, ce qui a été fait pour ce site (Next.js → HTML/CSS vanilla).

Cas d'usage hors codage

• Analyse autonome de données. L'agent écrit un script Python, l'exécute, voit les résultats, corrige les erreurs, produit un graphique exploitable. Sans intervention à chaque étape.
• Recherche documentaire structurée. Pour une question complexe (état de l'art sur un sujet, comparaison de fournisseurs), l'agent interroge le web, recoupe les sources, produit une synthèse argumentée avec liens.
• Veille. Un agent peut être déclenché à intervalle régulier pour surveiller une publication, une réglementation, un dépôt git, et alerter en cas de changement significatif.
• Automation administrative. Préparer une réunion : lire les emails liés, extraire les points, générer un ordre du jour, l'envoyer aux participants.
• Pédagogie individualisée. Évaluer un exercice, générer un feedback ciblé, proposer un exercice suivant calibré sur les erreurs constatées.

Garde-fous, sans lesquels rien ne tourne

Un agent qui se trompe et qui agit fait plus de dégâts qu'un modèle qui se trompe et qui parle. Cinq garde-fous non négociables :

1. Budget d'itérations. Un nombre maximum d'appels d'outils par tâche. Sans ça, un agent peut tourner en boucle pour rien et coûter cher.
2. Validation humaine sur les actions irréversibles. Suppression de fichiers, push sur une branche partagée, envoi d'email, écriture en base de production : l'agent demande confirmation avant d'exécuter, par défaut.
3. Permissions explicites. Plutôt qu'un accès complet « tout le shell », des permissions fine-grain : « peut lancer npm test et npm run build, ne peut pas faire rm ni git push. »
4. Sandbox. Pour les agents qui exécutent du code généré, isoler dans un conteneur ou une VM. Pas sur la machine de prod.
5. Observabilité. Trace de chaque appel d'outil (quoi, quand, pourquoi). Sans trace, on ne sait ni déboguer ni améliorer.

Coût et observabilité

Une session agentique coûte plus cher qu'une conversation simple, parce qu'à chaque tour, le modèle reçoit en entrée tout le contexte accumulé (prompt initial, outils disponibles, historique de pensées et d'observations). Cumulé sur une heure de travail, on peut atteindre plusieurs millions de tokens.

Bonnes pratiques pour contenir le coût :

• Compactage du contexte. Les bons agents résument périodiquement les vieilles observations pour libérer de la fenêtre.
• Délégation à des sous-agents avec leur propre contexte. Une tâche de recherche est confiée à un agent isolé qui revient avec un résumé court.
• Cache de prompts. La portion stable du prompt (instructions, outils disponibles) est mise en cache et facturée beaucoup moins cher à chaque appel.
• Mesure. Suivre le coût par tâche aboutie pour pouvoir comparer modèles et configurations.

Ce qui a été produit ainsi sur ce site

Pour donner un repère concret, voici trois exemples tirés de mon travail récent, tous menés en mode agentique :

• Reconstruction de ce site portfolio. Passage d'une stack Next.js complète à du HTML/CSS/JS vanilla, en environ une journée. L'agent a lu l'ancien code, extrait le contenu utile, généré le nouveau site avec son design system, et migré les contenus.
• Atelier d'écriture cursive du jeu Renard Astucieux. Les courbes SVG des lettres (« f », « g », liaisons) demandent une précision quasi mathématique pour correspondre aux conventions scolaires. Un agent a itéré pixel par pixel jusqu'à obtenir le tracé correct, en testant chaque essai. À la main, plusieurs jours ; en mode agentique, quelques heures.
• Composants devices CSS de la page d'accueil (smartphone portrait et tablette portrait pour intégrer les vidéos de présentation des projets) : spécifiés en langage naturel, ajustés par allers-retours avec l'agent jusqu'au rendu visuel souhaité.

Le journal de bord documente ces sessions en cours.

Ce que l'agent ne fait pas

Pour rester précis, l'agent ne décide pas du quoi, il exécute le comment. Tous les choix de fond restent humains :

• Quelle compétence cibler dans un mini-jeu éducatif.
• Quelle structure architecturale est juste pour un projet donné.
• Quel arbitrage faire entre simplicité d'usage et richesse fonctionnelle.
• Quelles données peuvent légitimement entrer dans un système et lesquelles doivent rester dehors.

Un agent qu'on laisse décider sans cadre produit des sorties techniquement correctes mais souvent inappropriées au contexte humain réel. Le métier de « pilote d'agent » est précisément celui qui maintient ce cadre.