Comment fonctionne un agent IA : les couches qui enveloppent le LLM et où chercher l'origine d'un bug

Un développeur au bagage ML a publié sur Habr en juillet 2026 une analyse de l'architecture interne des agents IA : au centre de tout schéma agentique reste un seul LLM, autour duquel s'accumule un « oignon » de couches d'enveloppes, et la plupart des pannes surviennent précisément dans ces couches, et non dans le modèle lui-même.

Que recouvre le mot « agent » ?

Un agent IA n'est pas le réseau de neurones lui-même, mais plusieurs couches de code qui l'entourent. Les frameworks changent, les serveurs MCP se multiplient, les plateformes cloud promettent des « agents clés en main », mais le noyau reste partout le même : un grand modèle de langage (LLM) qui lit le contexte et propose l'étape suivante. Tout ce qui se trouve à l'extérieur n'est que de la plomberie, qui prépare l'entrée du modèle et traite sa sortie.

L'auteur énumère les niveaux types à partir desquels on construit un agent autour d'un modèle :

• LLM — le noyau, qui prédit les probabilités du token suivant
• Couche de prompt et de contexte — ce qui est exactement envoyé au modèle en entrée
• Orchestration et appel d'outils — la façon dont la réponse du modèle se transforme en action
• Serveurs MCP — un accès standardisé de l'agent aux données et fonctions externes
• Frameworks et enveloppes cloud — l'« agent clé en main » posé par-dessus l'ensemble

Chaque niveau ajoute sa propre logique : l'un assemble le contexte, un autre décide quel outil appeler, un troisième branche les données externes. Le modèle lui-même n'exécute aucune de ces étapes : il se contente de prédire du texte.

Pourquoi le bug n'est le plus souvent pas dans le modèle

L'origine d'une panne dans un agent se situe généralement non pas dans le LLM, mais dans l'une des couches externes : dans la façon dont le prompt est construit, dont le contexte est transmis, dont l'appel d'outil est traité. Selon la formule de l'auteur, le modèle ne fait qu'une seule chose : prédire le token suivant ; tout le reste est ajouté par les enveloppes qui l'entourent.

«

Le modèle lui-même ne fait que prédire les probabilités du token suivant ; un oignon d'enveloppes s'accumule à l'extérieur », écrit l'auteur de l'article sur Habr.

C'est précisément pour cela, note l'auteur, qu'il est important de comprendre toute la construction au moment du débogage : si l'agent n'est pas assemblé à partir d'un kit prêt à l'emploi, connaître les couches aide à localiser plus vite le problème. Vérifier le modèle en premier est une erreur fréquente : si la réponse de l'agent semble fausse, c'est plus souvent parce que le mauvais contexte est parvenu au modèle, ou que sa réponse a été mal interprétée par un niveau voisin. Le modèle, lui, a fonctionné normalement.

Pourquoi partir du modèle vers l'extérieur

L'analyse est construite du noyau vers la périphérie, du LLM vers les enveloppes externes, parce que l'auteur est venu aux agents depuis le ML, où chaque nouvelle couche se pose sur une base déjà familière. Cet ordre, selon lui, rend le tableau plus clair : d'abord ce que fait le modèle, puis ce que fait chaque enveloppe au-dessus. Le chemin inverse, de l'« agent clé en main » vers l'intérieur, masque où passe précisément la frontière de responsabilité de chaque couche.

Le point de départ de l'article est prosaïque : ces notes sont nées après une énième séance de recherche de bug menée avec l'équipe technique. L'auteur les a réunies en une seule synthèse afin de pouvoir, la prochaine fois, expliquer plus facilement à ses collègues où se trouve chaque élément dans un schéma agentique et où regarder en cas de panne. Il s'agit en somme d'une carte des niveaux, à laquelle il est pratique de se référer pendant le débogage.

Ce que cela signifie

Derrière le mot à la mode « agent » se cache une pile de plusieurs couches, et comprendre cette structure est une compétence pratique de débogage : quand l'agent se comporte de façon inattendue, il ne faut pas commencer l'analyse par le LLM, mais par les enveloppes qui l'entourent, là où se cache la plupart des erreurs.