Agent Harness : Architecture des agents IA pour la production | Guide

# # Harnais d'agent : Architecture pour des agents IA prêts pour la production

Le problème n'est pas le réseau de neurones. Quand les agents basés sur LLM échouent en production, c'est l'infrastructure autour du modèle qui est en cause. LangChain est passé de la 30e à la 5e place au TerminalBench 2.0 sans changer le modèle — uniquement en optimisant son environnement. Cet environnement s'appelle un harnais d'agent, et il transforme un LLM sans état en un agent autonome.

Qu'est-ce qu'un harnais d'agent ? Architecture de Von Neumann pour l'IA

Le terme a été formalisé en 2026, mais le concept est aussi ancien que l'idée d'un système informatique. Un harnais est l'infrastructure complète qui entoure le LLM : boucle d'orchestration, outils, mémoire, gestion du contexte et gestion des erreurs. Anthropic qualifie explicitement son SDK de « harnais d'agent » dans la documentation de Claude Code. L'analogie clé : un LLM nu est comme un CPU sans RAM ni disque. La fenêtre de contexte fait office de mémoire de travail, les bases de données externes de stockage à long terme, et les outils de pilotes de périphériques. Le harnais devient le système d'exploitation, implémentant l'architecture de Von Neumann pour l'IA.

Beaucoup de gens confondent « agent » et « harnais ». Un agent est le comportement : une entité orientée vers un objectif, capable de s'auto-corriger. Un harnais est le mécanisme qui génère ce comportement. Comme l'a précisément formulé Vivek Trivedy de LangChain : « If you're not the model—you're the harness. »

Trois niveaux d'ingénierie autour des LLM

L'environnement du modèle est construit en couches concentriques :

• Ingénierie de prompts — façonne les instructions pour le modèle.
• Ingénierie de contexte — gère ce que le modèle voit et quand.
• Ingénierie de harnais — englobe les deux couches précédentes plus l'orchestration d'outils, la persistance d'état, la gestion des erreurs et la sécurité.

Un harnais n'est pas juste un wrapper autour d'un prompt. C'est le système qui rend possible le comportement d'un agent autonome en production. Sans lui, même les modèles avancés se comportent comme des démos fragiles.

Douze composants critiques d'un harnais de production

L'analyse des solutions d'Anthropic, OpenAI et LangChain a révélé 12 composants essentiels :

• Boucle d'orchestration — le battement de cœur du système (Thought-Action-Observation).
• Outils — schémas pour interagir avec le monde extérieur.
• Mémoire — gestion des données sur différentes échelles de temps.
• Gestion du contexte — lutte contre la dégradation du contexte.
• Construction de prompts — assemblage de l'entrée du modèle.
• Analyse de sortie — gestion des réponses structurées.
• Gestion d'état — persistance et points de contrôle.
• Gestion des erreurs — stratégies de récupération.
• Limites de sécurité — garde-fous à trois niveaux.
• Boucles de vérification — contrôle des sorties de l'agent.
• Orchestration de sous-agents — délégation de tâches.
• Cycle de vie — déploiement et surveillance.

La gestion du contexte mérite une attention particulière. Les recherches de Chroma et Stanford (« Lost in the Middle ») ont montré des baisses de performance de plus de 30 % quand le contenu clé est au milieu de la fenêtre. Les stratégies de production incluent :

• Compaction : résumé de l'historique (Claude Code conserve les décisions architecturales, en discardant les détails techniques).
• Masquage des observations : cacher les anciennes sorties d'outils (comme dans Junie de JetBrains).
• Récupération juste-à-temps : chargement dynamique de données via des requêtes légères (grep, glob).
• Délégation à des sous-agents : renvoyer des résumés compressés (1000–2000 tokens) au lieu de données brutes.

Anthropic définit l'objectif : trouver l'ensemble minimal de tokens à fort signal qui maximise la probabilité de succès.

Comment fonctionne la boucle d'orchestration

Décomposons la boucle TAO dans un système de production :

• Assemblage du prompt : le harnais forme l'entrée, en positionnant le contexte critique au début et à la fin (selon les résultats de « Lost in the Middle »). Inclut le prompt système, les schémas d'outils, la mémoire et la requête courante.
• Inférence LLM : le modèle traite la requête, renvoyant du texte ou des tool_calls structurés.
• Classification de sortie : s'il y a des appels d'outils — les exécuter ; s'il y a un handoff — changer d'agent ; sinon, terminer la boucle.
• Exécution d'outils : valider les arguments, vérifier les permissions, exécuter en isolation. Les erreurs reviennent sous forme de ToolMessage pour correction par le modèle.
• Vérification : contrôles basés sur des règles (linters, tests), vérification visuelle (Playwright), ou LLM-as-judge.
• Mise à jour d'état : points de contrôle via des commits git (Claude Code) ou des dictionnaires typés (LangGraph).

Un détail critique : le harnais sépare le raisonnement de l'exécution. Le modèle décide « quoi faire », le système d'outils décide « est-ce autorisé ». Claude Code contrôle plus de 40 permissions discrètes via des vérifications en trois étapes.

Enseignements clés

• Le problème n'est pas le modèle : 90 % des échecs d'agents en production proviennent de lacunes du harnais, pas du LLM.
• La dégradation du contexte est fatale : même les fenêtres de 1 M de tokens nécessitent une gestion active du contexte.
• La vérification est obligatoire : les agents sans boucles de contrôle produisent 2 à 3 fois plus d'erreurs.
• La sécurité est architecturale : l'exécution doit être séparée du raisonnement.
• Les erreurs s'accumulent : un processus en 10 étapes avec 99 % de succès par étape n'a que 90,4 % de succès de bout en bout.

— Editorial Team