Il répond vite. Il a confiance en lui. Il sait utiliser Gmail, Slack, Notion, GitHub, Linear, le terminal, et parfois même Docker.

Et pourtant, dès qu’on lui donne une tâche un peu longue, tout commence à partir en vrille.

Pas parce que le modèle est mauvais.

Parce que le système autour est chaotique.

La démo est toujours la même :

“Regarde, mon agent peut réserver un vol, envoyer un mail, créer un ticket Jira et déployer en production.”

Techniquement, oui.

Mais dans la réalité, la plupart des agents ressemblent à ça :

• ils ouvrent trop d’outils

• oublient le contexte initial

• exécutent des actions dans le mauvais ordre

• hallucinent des états intermédiaires

• improvisent quand ils ne savent pas

• et surtout : ils ne savent pas quand s’arrêter.

Le problème n’est plus :

“est-ce que le modèle sait faire ?”

Le problème devient :

“comment est-ce qu’on orchestre proprement ses actions ?”

ChatGPT, Claude, Gemini ou Qwen sont capables de :

• résumer des documents

• écrire du code

• comprendre du langage naturel

• raisonner sur plusieurs étapes

• manipuler des outils.

Mais un agent, ce n’est pas juste un LLM.

C’est :

LLM + mémoire + outils + permissions + orchestration + validation + logs + contraintes + checkpoints humains

Et aujourd’hui, la plupart des stacks IA ressemblent encore à :

“brancher plein d’APIs ensemble et espérer que ça marche.”

Imagine un orchestre sans chef.

Les musiciens sont excellents individuellement :

• très bons violons

• très bonne batterie

• très bons cuivres.

Mais personne ne décide :

• du tempo

• des entrées

• des transitions

• des priorités

• de la fin.

Résultat : ça fait du bruit.

C’est exactement ce qui se passe quand on empile :

• prompts

• tools

• MCP servers

• APIs

• agents autonomes

• workflows

• memory systems sans définir :

• qui décide quoi

• dans quel ordre

• avec quel droit de veto

• et avec quelles limites.

Un agent IA sans garde-fous, c’est rarement “Jarvis”.

C’est plutôt :

• un alternant qui a accès à la prod

• sans checklist

• sans supervision

• sans notion du risque

• avec énormément de confiance.

Le plus dangereux n’est pas qu’il se trompe.

Le plus dangereux, c’est que :

ses erreurs ont souvent l’air plausibles.

Il répond avec assurance. Il génère des plans crédibles. Il explique ses décisions.

Même quand il invente complètement.

Beaucoup de systèmes “agents” actuels sont en réalité :

• des boucles de prompts

• des wrappers d’outils

• des routers

• des chaînes d’appels.

Très peu possèdent réellement :

• une mémoire stable

• une hiérarchie de décisions

• une stratégie

• une capacité d’arrêt

• une gestion claire des permissions

• une orchestration déterministe.

On a énormément travaillé l’intelligence brute.

Pas assez :

• le contrôle

• la coordination

• la supervision

• la traçabilité.

Pendant des années, le scaling de l’IA consistait surtout à :

• augmenter les paramètres

• augmenter le compute

• augmenter les datasets.

Mais le prochain problème ressemble davantage à :

“comment coordonner correctement des systèmes probabilistes.”

Autrement dit :

• orchestration

• runtime

• mémoire

• vérification

• hiérarchie

• contraintes

• auditabilité.

Le modèle devient presque :

un composant parmi d’autres.

Un bon système agentique ressemble moins à :

“une IA omnisciente”

et davantage à :

“une équipe bien encadrée”.

Avec :

• rôles séparés

• limites claires

• validation humaine

• journaux d’actions

• budgets

• règles d’arrêt

• supervision

• retry contrôlé

• sandboxing.

Le problème n’est pas seulement cognitif.

Il est organisationnel.

Le vrai shift est peut-être là.

Les premiers LLM généraient :

• du texte

• du code

• des images.

Les prochains systèmes généreront :

• des workflows

• des plans

• des décisions

• des exécutions

• des pipelines complets.

Et plus ces systèmes deviennent autonomes, plus :

• l’orchestration

• les contraintes

• les garde-fous

• et la traçabilité

deviennent critiques.

Ce week-end, on a construit un moteur Symfony capable de transformer :

• un sujet YAML

• une structure narrative

• une grammaire de style

• des contraintes de rendu

en :

• voix

• images

• scènes

• vidéo finale

• article.

Le plus intéressant n’était pas la génération elle-même.

Le plus intéressant était :

la formalisation de la structure.

On ne cherchait pas à copier un créateur.

On cherchait à comprendre :

• son rythme

• sa densité

• sa structure narrative

• sa compression d’information

• son pacing.

Autrement dit :

transformer une grammaire implicite en système exécutable.

Aujourd’hui, presque tous les outils IA savent générer du contenu.

Le vrai différenciateur devient :

• le format

• le rythme

• l’orchestration

• la cohérence

• la structure.

Pas seulement :

“est-ce que le modèle est intelligent ?”

Mais :

“est-ce que le système sait se coordonner ?”

Et ça vaut autant pour :

• les agents IA

• les pipelines vidéo

• les systèmes autonomes

• que pour les organisations humaines.

Un agent utile n’est pas forcément le plus autonome.

C’est souvent :

• celui qui possède les meilleures limites

• les meilleures validations

• la meilleure orchestration

• et le moins d’onglets ouverts.

L’intelligence brute aide.

Mais sans structure : on ne scale pas l’intelligence.

On scale juste le chaos plus vite.