J'ai donné une liste de tâches à mon IA. Elle l'a vraiment faite.

J'ai donné une liste de tâches à mon IA. Elle l'a vraiment faite.

---

Ça fait deux ans que je discute avec des chatbots. La plupart du temps, ils répondent. Parfois, ils hallucinent une recette de pizza à la colle. Rarement, ils *font* quoi que ce soit.

Mardi dernier, j'ai regardé un agent que j'ai construit se connecter à mon email, trouver trois factures impayées, rédiger des réponses avec des liens de paiement, et programmer des relances pour la semaine prochaine. Aucun prompt après le premier. Aucune surveillance. Je suis allé prendre un café. Ça a marché.

C'est là que ça a cliqué : on ne construit plus de meilleurs chatbots. On construit des collègues qui n'ont pas besoin de dormir.

Le piège du chatbot

Voici la partie gênante : j'ai passé six mois à concevoir des chaînes de prompts élaborées. « Tu es un analyste senior. D'abord, lis le document. Ensuite, extrais les métriques clés. Ensuite, écris un résumé. Ensuite, vérifie les erreurs. »

Ça marchait environ 60 % du temps. Les autres 40 % ? Le modèle oubliait l'étape deux, hallucinait une métrique, ou résumait avec assurance un document qu'il n'avait jamais lu. J'ajoutais des instructions. Ça empirait. Rendements décroissants classiques.

Le problème n'est pas le modèle. C'est l'architecture. Un seul prompt, c'est un monologue. Le vrai travail, c'est un dialogue — avec soi-même, avec des outils, avec des données, avec d'autres gens.

Place au graphe

Je suis tombé sur l'orchestration par graphe presque par hasard. Un pote m'a envoyé un repo GitHub à 23h avec pour objet « ça a changé ma façon de voir les agents ». Je n'ai pas dormi avant 3h du mat.

L'idée est bête comme chou : au lieu d'un gros prompt, tu construis une machine à états. Les nœuds font des trucs — appellent une API, interrogent une base, écrivent du code, demandent à un humain. Les arêtes décident de la suite selon ce qui vient de se passer. Le graphe *se souvient* où il en est.

Mon premier vrai test : les notes de frais. Je déteste les notes de frais. Vous détestez les notes de frais. Tout le monde déteste les notes de frais.

Ancienne méthode : je balance mes reçus dans un dossier. Panique trimestrielle. Saisie manuelle. Fautes de frappe. Remboursements refusés.

Nouvelle méthode : je transfère un reçu à un bot Slack. Le graphe se réveille. Nœud OCR extrait marchand, date, montant. Nœud catégorisation vérifie mon historique — « ça ressemble à un dîner client, la dernière fois tu l'as mis en frais de repas ». Nœud politique vérifie le plafond. Nœud validation ping mon manager sur Slack avec un bouton valider en un clic. Nœud compta pousse vers QuickBooks. Nœud final archive le PDF.

Trois minutes. Zéro frappe. Mon manager a validé un reçu depuis la file de taxis à SFO.

La mémoire qui n'est pas un LLM

Voici ce que personne ne vous dit : la partie la plus maline de mon système d'agents n'appelle pas de LLM du tout.

C'est un magasin clé-valeur avec instantanés versionnés. Chaque nœud lit l'état, écrit l'état. Le graphe sait *pourquoi* il a pris une décision trois étapes plus tôt parce que l'objet état transporte le reçu. Pas de bourrage de fenêtre de contexte. Pas de « rappelle-moi ce qu'on faisait ». La mémoire, c'est juste... des structures de données.

Coût : millisecondes. Zéro token. Contexte infini.

Compromis : faut concevoir le schéma. Tu peux pas juste « laisser le modèle deviner ». Je l'ai appris à mes dépens quand mon agent de réservation voyage a essayé de stocker un numéro de passeport comme une chaîne, puis un dictionnaire, puis une liste de dictionnaires — tout dans la même exécution. Le graphe n'a pas planté. Il a juste produit des sorties pourries jusqu'à ce que j'ajoute de la validation.

Conception schéma d'abord, ça parait lent au début. Puis tu réalises que c'est le seul truc qui te laisse déboguer *pourquoi* l'agent a fait une connerie mardi dernier.

L'humain dans la boucle, c'est pas un bug

Le plus gros changement de mentalité : s'arrêter *est* une feature.

Mes premiers agents essayaient d'être totalement autonomes. Ils réservaient le mauvais vol, envoyaient un email au mauvais client, supprimaient la mauvaise base. « Move fast and break things », c'est bon pour les prototypes. C'est catastrophique en prod.

Maintenant, chaque nœud à enjeu élevé a un drapeau `interrupt_before`. Le graphe met en pause. M'envoie un message Slack : « Je vais envoyer ce contrat au juridique. Confirmer ? » J'appuie « oui » sur mon téléphone. Le graphe continue.

C'est pas un échec d'autonomie. C'est de l'autonomie *calibrée*. L'agent fait les 90 % — recherche, rédaction, mise en forme, vérification — et demande les 10 % qui comptent.

Astuce pro : rendez le message d'interruption actionnable. « Confirmer ? » ça sert à rien. « Envoyer contrat v3 à legal@boite.com ? Changements : plafond responsabilité porté à 500k, durée étendue à 24 mois. [Oui] [Non] [Modifier] » — ça obtient une réponse en secondes.

Les modes d'échec que j'ai collectionnés

Laissez-moi vous épargner de la peine.

**La boucle infinie.** Nœud A appelle Nœud B appelle Nœud A. Le graphe tourne jusqu'au timeout. Fix : ajoutez un compteur d'étapes dans l'état. Limite dure : 50 étapes. Log quand vous tapez 30.

**L'échec silencieux.** L'API renvoie 500. Le nœud attrape l'exception, écrit « erreur » dans l'état, continue. Les nœuds en aval hallucinent sur la chaîne « erreur ». Fix : nœuds d'erreur qui *stoppent* le graphe et vous alertent. Laissez pas les erreurs devenir des données.

**La dérive de contexte.** Workflow de trois heures. L'utilisateur change les exigences à la minute 45. Le graphe continue d'exécuter l'ancien plan. Fix : versionnez vos entrées. Vérifiez à chaque nœud majeur : « la demande a-t-elle changé ? » Si oui, replanifiez.

**La prolifération d'outils.** 47 nœuds. 12 API externes. Personne ne comprend le flux. Fix : visualisez le graphe. Imprimez-le. Collez-le au mur. Si vous pouvez pas l'expliquer en 30 secondes, c'est trop complexe.

Ce que je construis ensuite

Agent planification trimestrielle. Chaque lundi, il tire mon calendrier, mes notes Notion, mon activité GitHub, mes conversations Slack. Construit un plan hebdo brouillon. Montre les conflits. Sugger des blocs focus. Je valide. Il bloque le temps, crée les tâches, décline les réunions low-priority.

Agent fiscal. Toute l'année. Chaque transaction catégorisée en temps réel. Estimations trimestrielles auto-calculées. Trouve les déductions que je loupe. Dépose les prolongations si besoin. (En test encore. Les pénalités IRS, c'est pas un environnement de debug que je veux.)

Agent revue de code. Pas des bots « lgtm ». Vraie revue : tire la PR, lance les tests, vérifie le guide de style, vérifie que les tickets matchent l'implémentation, suggère des refactorings, *écrit le fix* pour les trucs triviaux. Je relis sa revue.

Prédictions 2026

**Les agents remplacent les tableaux de bord.** Vous regarderez plus les graphiques. Vous demanderez « pourquoi le churn a pété ? » et un agent interrogera le warehouse, corrélera avec les tickets support, checkera les logs de déploiement, et vous filera un récit avec preuves. En 30 secondes.

**Réseaux d'agents personnels.** Votre agent calendrier négocie avec mon agent calendrier. Plus d'emails ping-pong. Ils trouvent le créneau optimal, réservent les salles, commandent le déjeuner selon les régimes, envoient les invites. Vous, vous vous pointez.

**Places de marché d'agents.** Pas des app stores. Des *skill* stores. « Installer skill déclaration impôts. » « Installer skill négociation fournisseurs. » Les skills sont des graphes composables avec interfaces standardisées. Vous mélangez comme des LEGO.

**La mort de « prompt engineering » comme titre de poste.** Ça devient « architecture d'agents ». La compétence, c'est pas pondre la phrase parfaite. C'est concevoir le bon graphe : où mettre en pause, quoi retenir, comment échouer proprement, quand demander.

**La régulation arrive.** Premier procès : « votre agent a signé un contrat engageant pour moi sans autorisation. » Précédent : les agents ont besoin de délégations explicites. Pistes d'audit obligatoires. Les instantanés versionnés de mon graphe ressemblent tout à coup à de l'or de conformité.

La vérité inconfortable

Construire des agents, c'est plus dur que prompter. Vous écrivez pas des instructions. Vous écrivez du logiciel — avec des graphes au lieu de fonctions, de l'état au lieu de variables, les LLM comme *composants* au lieu du système entier.

Mais le retour est asymétrique. Un prompt vous fait gagner des minutes. Un agent vous fait gagner des heures, pour toujours. Le premier prend un week-end. Le dixième prend un après-midi. Le centième ? Vous comptez plus.

Mon agent notes de frais a traité 347 reçus depuis janvier. J'en ai regardé exactement trois. Les trois étaient des cas limites qu'il a correctement signalés.

C'est l'objectif. Pas « l'IA fait tout ». L'IA fait le *chiant* tout. Vous, vous faites le truc intéressant.

---

FAQ

**Faut-il connaître la théorie des graphes ?**
Non. Faut connaître les machines à états. Si vous avez déjà construit un reducer Redux ou un store Vuex, vous pigez déjà. Nœuds = reducers. Arêtes = routage d'actions. État = le store.

**Quelle est la courbe d'apprentissage ?**
Week-end pour premier agent qui marche. Mois pour prêt prod. La partie dure, c'est pas le framework — c'est apprendre à penser en graphes au lieu de prompts.

**Puis-je utiliser ça avec des modèles locaux ?**
Oui. Le graphe s'en fiche du LLM que vous branchez. Je fais tourner certains nœuds sur un 7B en local, d'autres sur un gros modèle cloud. L'optimisation des coûts, c'est juste un autre nœud.

**Comment débugger un agent qui tourne ?**
Replay. Chaque exécution produit une trace : entrées, sorties des nœuds, changements d'état, timing. Vous pouvez rejouer n'importe quelle étape avec des entrées modifiées. C'est du débogage voyage dans le temps gratos.

**C'est réservé aux devs ?**
Actuellement, oui. Mais les builders visuels arrivent. Dans six mois, les product managers feront du drag-and-drop de workflows d'agents. Commencez à apprendre maintenant — vous serez l'expert quand ils débarqueront.

**Quelle est la plus grosse erreur des débutants ?**
Essayer de construire un gros graphe unique pour tout. Construisez des petits graphes à but unique. Composez-les. Un graphe qui fait notes de frais *et* voyage *et* calendrier, c'est le cauchemar. Trois graphes qui se parlent ? Maintenable.

**Combien ça coûte à faire tourner ?**
Dépend de vos appels LLM. Mon agent notes de frais : ~0,03 $ par reçu. Agent fiscal : ~2 $/mois. Revue de code : ~0,50 $ par PR. La surcharge du graphe est négligeable — millisecondes de CPU.

**Les agents vont-ils me remplacer ?**
Les agents remplacent des *tâches*. Celles que vous détestez. Celles qui vous fatiguent. Vous gardez le jugement, la créativité, les relations. À moins que votre job entier soit de la saisie de données. Là oui, mettez peut-être votre CV à jour.