L'architecture cachée des agents IA : ce que tout le monde se trompe

Tu bidouilles avec des agents IA ? Alors tu as sûrement remarqué ce comportement bizarre : parfois ils suivent tes instructions complexes à la lettre, parfois ils zappent les règles les plus basiques que tu viens de leur donner.

Tu ne fantasmes pas. Il y a une architecture fondamentale derrière chaque agent IA qui explique exactement pourquoi ça arrive. Et une fois que tu l'as comprise, tout le reste s'aligne.

C'est juste une boucle while True

Voici le secret qui paraît presque trop simple : un agent IA, c'est fondamentalement une boucle qui tourne en continu et qui remplit un tableau.

while True:
    entree_utilisateur = recuperer_entree()
    reponse = llm.generer(entree_utilisateur)
    if reponse.veut_outil:
        resultat = executor_outil(reponse.appel_outil)
        reponse = llm.generer(resultat)
    print(reponse)

C'est tout. C'est l'architecture de base. Tout le reste — les définitions d'outils, les prompts système, la gestion du contexte — c'est juste le harnais autour de cette boucle.

Le "tableau" en question, c'est le context window. Chaque appel API envoie l'intégralité de la conversation accumulée. À chaque tour, ça s'ajoute. Le modèle reste complètement stateless entre les appels.

Ton context window contient : le prompt système, les définitions d'outils, le message utilisateur, les réponses de l'assistant, les résultats d'outils, et tout ce que tu y as mis. Ce tableau grandit à chaque échange.

Le problème de la zone intelligente

Voici où ça devient intéressant. La plupart des développeurs partent du principe que le context window est uniforme — tu mets de l'info, le modèle la traite de façon égale.

Sauf que non.

Les premiers ~40% de ton context window, c'est là où le modèle réfléchit clairement. C'est la "zone intelligente". Au-delà de ce seuil, l'attention se disperse. Les choix d'outils deviennent bâclés. Les instructions tombent à l'eau. L'objectif commence à dériver.

Ça explique pourquoi ajouter du contexte peut en fait dégrader les performances de ton agent. Les modèles frontier suivent de manière fiable environ 150-200 instructions avant que les choses ne commencent à se casser la figure. Au-delà de ce seuil, même les règles explicites tout en haut de ton prompt se font ignorer.

Pense-y : si tu entasses des prompts système, plusieurs définitions d'outils, l'historique de conversation et des documents de référence, tu pousses probablement tes instructions utiles au-delà du point où le modèle peut les suivre correctement.

Le problème d'allocation dont personne ne parle

Les contenus statiques, c'est le tueur silencieux des performances d'agent.

Avant même que ta conversation ne commence, tu remplis probablement ton context window avec des trucs qui semblent nécessaires : des prompts système complets, des définitions d'outils interminables, des memory banks, des configurations MCP, des références документа.

Tout ce contenu statique grignote ta zone intelligente avant même l'arrivée du premier message utilisateur.

Résultat ? Tes instructions les plus importantes — celles qui définissent le comportement de ton agent pour cette tâche précise — se battent pour l'espace dans une zone intelligente qui rétrécit.

C'est pour ça que les meilleurs agents repartent de zéro. Une nouvelle session, c'est un context window vide. Pas de pourriture accumulée. Pas d'instructions concurrentes de tâches précédentes. Juste ce dont tu as besoin pour le job.

Le context rot : le mode d'échec silencieux

Voici ce qui est tricky avec la gestion du contexte : rien ne plante.

Dans un logiciel classique, tu obtiens des erreurs. Des exceptions. Des défaillances que tu peux détecter et gérer. Mais avec les context windows, chaque appel réussit. Le modèle répond. Il devient juste... moins bon.

Même fenêtre. Même modèle. Elle se remplit juste.

C'est le "context rot" — la dégradation progressive des performances de l'agent à mesure que le context window se remplit d'historique de conversation accumulé, de résultats d'outils et de références documentaires. Tu n'auras pas de message d'erreur. Tu vas juste remarquer que ton agent devient moins fiable, moins concentré, moins aligné avec tes instructions.

C'est fondamentalement différent des bugs logiciels habituels. Ce n'est pas une défaillance — c'est un problème de capacité. Et ça te tombe dessus sans que tu t'en rendes compte.

Faire travailler la zone intelligente pour toi

Comprendre ces principes mène à des stratégies concrètes :

Repars de zéro par tâche. Ne réutilise pas une fenêtre fatiguée d'un projet précédent. Les nouvelles tâches méritent de nouvelles sessions. Ardoise propre, zone intelligente à fond.

Inclus uniquement ce dont cette tâche a besoin. Cette intégration MCP qui sert pour d'autres travaux ? Laisse-la de côté. Ces notes d'un autre projet ? Elles prennent juste de la place. Filtre avec brutalité ce qui entre dans ton contexte.

Décharge sur le disque. Les gros fichiers restent sur le disque. Les résumés vont dans la fenêtre. Tu peux toujours lire un fichier quand t'en as besoin — après l'avoir résumé pour le context window.

Utilise des sub-agents pour les missions secondaires. Quand ton agent a besoin d'explorer quelque chose de tangential à la tâche principale, lance un sub-agent. Laisse-le investiguer et revenir avec un paragraphe. Ne laisse pas l'exploration polluer ton contexte principal.

Laisse de la place sous la ligne. Quand ton agent finit le travail principal, tu as encore besoin de finaliser — écrire des tests, commiter du code, lancer des linters. Si ton contexte est plein à craquer, il n'y a plus de place pour cette étape finale cruciale.

Découpe les gros travaux entre les sessions. Quand une tâche ne rentre pas dans une seule fenêtre, planifie d'abord. Écris la spec sur le disque. Laisse plusieurs agents la reprendre là où le précédent s'est arrêté.

La vraie conclusion

Chaque session démarre de zéro. Le contexte ne s'organise pas tout seul.

Quelqu'un doit gérer l'allocation du contexte, la rotation, la compaction, la récupération. Quelqu'un doit décider ce qui vaut la peine de garder dans la zone intelligente et ce qui part sur le disque.

Anthropic livre le harnais de l'agent — la boucle while true, l'exécution d'outils, l'intégration LLM de base. Tu livres la couche autour. La gestion du contexte. Le cadrage de la tâche. Le design du prompt système.

Comprendre cette architecture ne fera pas de toi un expert IA du jour au lendemain. Mais ça te donnera un cadre pour diagnostiquer quand tes agents se comportent mal, et un vocabulaire pour penser systématiquement à la gestion du contexte.

La prochaine fois que ton agent se met à ignorer des instructions, tu sauras exactement quoi vérifier : combien de ta zone intelligente est encore disponible, et qu'est-ce qui la remplit.

C'est l'architecture cachée. Maintenant va construire quelque chose.