Agents de Harnesses : La Fin de la Programmation ?

Quiconque prête attention peut le ressentir : le spectacle de feux d'artifice ralentit. GPT-4, Claude 3 Opus et Gemini 1.5 sont indéniablement puissants, mais ils ne représentent pas le même saut impressionnant qu'a réalisé GPT-3 par rapport à GPT-2. Les benchmarks continuent de grimper—MMLU, HumanEval, GSM8K—mais le véritable facteur "wow" de la puissance brute des LLM ne double plus tous les six mois.

Cette ralentissement n'est pas imaginaire ; c'est de l'économie. Former un modèle de pointe coûte désormais de l'ordre de centaines de millions de dollars en calcul, en curation de données et en ingénierie. Chaque point de pourcentage supplémentaire sur un tableau de classement comme MMLU ou Codeforces exige exponentiellement plus de GPU, plus de jetons et plus de retours humains.

Les rendements décroissants se font sentir partout. Des fenêtres de contexte plus larges—200K, 1M de tokens—existent, mais le raisonnement efficace sur ce contexte échoue toujours de manières fragiles. Les modèles de code maîtrisent les modèles courants et le code standardisé, mais hallucinent des APIs ou interprètent mal des cas particuliers que n'importe quel ingénieur de niveau intermédiaire verrait lors d'une révision de code.

Ainsi, la frontière a bougé. Cole Medin le souligne dans sa vidéo : le « pouvoir brut des LLM ne se développe plus simplement », mais la couche autour d'eux oui. L'orchestration des outils, les systèmes de mémoire et la coordination multi-agents apportent des changements plus significatifs qu'un autre 0,3 sur un benchmark.

Considérez cela comme une transition des processeurs plus rapides vers de meilleurs systèmes d'exploitation. Les agents de harness, les routeurs de contexte et les modèles du monde reposent sur GPT-4 ou Claude 3 et tirent plus de fiabilité d'une intelligence sous-jacente à peu près identique. Le matériel de l'esprit atteint un plateau ; la pile logicielle qui l'entoure commence à devenir plus importante.

Cela redéfinit ce moment non pas comme un plafond, mais comme un point d'inflexion. Au lieu de prier pour que GPT-5 soit 10 fois plus intelligent, les équipes construisent des harnais d'agents qui gèrent les outils, les tentatives et les workflows de longue durée, afin que les modèles d'aujourd'hui se comportent comme des collègues fiables. Le centre de l'innovation passe des poids des modèles à la conception des systèmes.

Appelons cela l'ère post-référentielle. Les gains marginaux du modèle restent importants, mais les véritables percées proviendront de l'architecture de l'échafaudage—mémoire, planification, vérification—autour des LLM. L'action se déplace des séances d'entraînement du laboratoire vers le code d'exploitation de l'ingénieur.

Les appels de modèles bruts commencent à ressembler à du silicium nu : impressionnants sur le papier, fragiles en pratique. L'affirmation centrale de Cole Medin est franche : l'essentiel de l'action s'est déplacé vers la « couche au-dessus des LLM » — la logique d'orchestration qui transforme un moteur de saisie semi-automatique astucieux en quelque chose en qui vous pouvez avoir confiance pour un travail réel.

Cette couche a maintenant un nom : le harnais d'agent. Considérez-le comme un système d'exploitation pour modèles, gérant le flux de contrôle, la mémoire et l'utilisation des outils afin qu'un LLM puisse survivre en dehors d'une démonstration et à l'intérieur d'un SLA de production.

Un appel LLM brut se comporte comme une requête API sans état. Vous envoyez une invite, espérant que le modèle ait compris votre intention, et vous recevez un bloc de texte qui peut ignorer des outils, oublier les étapes précédentes ou halluciner des API qui n'ont jamais existé.

Intégrer le même modèle dans un harnais modifie le comportement. Le harnais suit l'état à travers des dizaines ou des centaines d'étapes, maintient la mémoire de travail et impose des politiques concernant les outils que le modèle peut utiliser, quand et avec quels arguments.

Les harnais modernes combinent plusieurs capacités qui étaient auparavant dispersées dans des scripts variés et des instructions ad hoc : - Stockages de mémoire à long terme et à court terme - Routage d'outils et réessais sensibles aux erreurs - Coordination et planification de sous-agents - Barrières de sécurité, validation et observabilité

Des projets comme l'outil interne d'Anthropic, DeepAgent de LangChain et le Linear Agent Harness de Cole Medin montrent le schéma qui se cristallise. Au lieu d'une simple complétion de chat, vous obtenez des graphiques d'agents, d'outils et d'états pouvant fonctionner pendant des heures sans besoin de supervision humaine.

C'est ici que réside désormais l'ingénierie humaine. Vous ne pouvez pas ajuster les poids de GPT-4.5, mais vous pouvez décider combien de sous-agents créer, comment ils partagent les fenêtres de contexte, comment ils décomposent les tâches et comment ils se remettent des appels d'outils défaillants.

Attendre "GPT-6 mais 10 fois plus performant" rate le point. La prochaine avancée de 10 fois viendra d'une meilleure conception des harnesses : des boucles de planification plus intelligentes, des modèles du monde plus riches, un retour d'informations plus précis des journaux vers les invites et les politiques.

Les équipes de développement qui considèrent le modèle comme une marchandise et le harnais comme le produit saisiront la valeur. Tous les autres se contenteront d'appeler une API en espérant le meilleur.

L'agent peut sembler flou, mais Anthropic et LangChain définissent quelque chose de très concret : une couche de contrôle structurée qui appelle à plusieurs reprises un LLM, suit l'état et orchestre les outils jusqu'à ce qu'une tâche soit réellement terminée. La spécification de l'harnachement d'Anthropic décrit un contrôleur qui possède la boucle, la gestion des erreurs, la mémoire et le routage des outils, tandis que le modèle prédit simplement le prochain token. La documentation de LangChain sur DeepAgent va plus loin, présentant l'harnachement comme une politique programmable qui décide de ce que l'agent fait à chaque étape.

Plus qu'une simple boucle while glorifiée, un harnais moderne fonctionne comme une machine à états. Chaque étape effectue une transition entre les états tels que "planification", "appel_outil_en_attente", "attente_humaine" ou "terminé", avec des règles explicites concernant ce qui est autorisé dans chaque état. Cette structure rend le comportement reproductible et débogable, au lieu de simplement reposer sur des impressions et de l'espoir.

Les responsabilités fondamentales se regroupent en quatre catégories qui apparaissent dans Anthropic, LangChain et le Linear Agent Harness de Cole Medin. Un harness doit gérer la mémoire persistante, réguler les outils, coordonner plusieurs travailleurs et superviser des flux de longue durée. En retirer l'une d'entre elles ferait rapidement régresser les agents à de simples chatbots à usage unique.

La gestion de la mémoire ressemble désormais à un problème de base de données miniature. Les harnais maintiennent des zones de travail à court terme, des magasins vectoriels pour le rappel sémantique et des journaux à long terme, décidant quoi résumer, quoi évincer et quoi réhydrater dans des fenêtres contextuelles limitées à 200k–1M de tokens. Ils contrôlent également les données sensibles, déterminant quels sous-agents peuvent voir quoi, ce qui est une exigence pour tout déploiement en entreprise.

Le contrôle des outils transforme le harnais en moteur de politique. Il décide de : - Quels outils le LLM peut appeler - Comment les arguments sont validés et assainis - Comment réessayer, réduire les appels ou les paralléliser

Cette couche de politique empêche les catastrophes liées aux injections de requêtes telles que "télécharger la base de données de production" et évite que des APIs instables ne perturbent les flux de travail après une erreur 500.

La coordination des sous-agents pousse les harnais dans le domaine de l'orchestration. Un système de codage pourrait générer des agents distincts pour la planification, la mise en œuvre, les tests et le refactoring, chacun avec des outils et une mémoire spécifiques. Le harnais attribue des tâches, fusionne les résultats et résout les conflits lorsque les agents ne sont pas d'accord, similaire à un système de construction qui arbitre les sorties du compilateur et du linter.

Vu de 10 000 pieds, le LLM ressemble à un noyau, tandis que le harnais se comporte comme un shell OS associé à un environnement d'exécution. Il fournit la planification, l'I/O, les autorisations et les journaux autour d'un noyau très intelligent mais très amnésique. L'article d'Anthropic, Harnais efficaces pour des agents de longue durée - Anthropic, se lit en effet comme un document de conception pour ce shell.

Le développement précoce de l'IA semblait trompeusement puissant : rédigez une invite astucieuse, ajoutez peut-être un pipeline RAG basique, et regardez le modèle cracher du code ou de la documentation. Cela fonctionnait pour des tâches ponctuelles : rédiger une fonction, résumer un PDF, répondre à une question provenant d'un petit magasin de vecteurs. Dès que vous alliez au-delà, tout s'effondrait.

Les systèmes uniquement basés sur des demandes se comportent comme des stagiaires amnésiques. Demandez à un LLM de refactoriser un monolithe de 200 000 lignes avec une seule demande et vous obtenez des modifications partielles, des fichiers halluciné et des imports cassés. Même avec la récupération, une RAG naïve se contente de placer des morceaux « pertinents » dans le contexte ; elle ne suit pas l'état, ne vérifie pas les résultats et ne se souvient pas de ce qui a déjà été exécuté.

Un travail complexe et en plusieurs étapes expose rapidement ces failles. Les tâches de longue durée—migrations, refontes de services multiples, procédures d'incidents—nécessitent une logique ramifiée, un retour en arrière et une prise en compte des contraintes externes telles que les échecs de tests ou les limites de taux d'API. Les invites statiques ne peuvent pas s'adapter lorsqu'un ensemble de tests expire, qu'une dépendance est en conflit ou qu'un outil renvoie un JSON malformé.

L'agent moderne exploite directement cette fragilité. Au lieu d'un seul prompt, vous obtenez une boucle de contrôle capable de planifier, d'agir, d'observer et de réviser sur des dizaines ou des centaines d'étapes. Le harnais possède le graphique d'exécution, pas le modèle : il décide quand utiliser des outils, quand replanifier et quand abandonner.

Les tentatives de réessai ne sont plus une pensée secondaire. Des outils tels que le harnais de codage d'Anthropic ou DeepAgent de LangChain encapsulent chaque appel d'outil avec une gestion des erreurs structurée : des réessais automatiques en cas de défaillance réseau, une validation de schéma sur les résultats des outils et des relances ciblées lorsque le modèle dévie de ses spécifications. Ils enregistrent chaque étape afin que l'agent puisse inspecter son propre historique et corriger son parcours.

La planification dynamique devient une fonctionnalité de premier plan. Au lieu d'une séquence codée en dur, le système met à jour la liste des tâches en fonction des retours de l'outil : - Générer un plan - Exécuter un outil - Comparer les résultats attendus et réels - Insérer, supprimer ou réorganiser des étapes

Considérez à nouveau cette refonte de code basée sur une grande base de code. Une seule demande pourrait tenter de tout réécrire d'un coup, dépasser les limites de contexte et expédier un code non compilable. Un agent piloté par un cadre peut analyser le dépôt, diviser les fichiers, refactoriser module par module, exécuter des tests après chaque lot, détecter les échecs, revenir sur des modifications spécifiques et réparer de manière itérative jusqu'à ce que l'ensemble passe.

L'agent de production utilise des harnais qui ressemblent moins à des invites astucieuses et plus à de mini systèmes d'exploitation. Le harnais DeepAgent de LangChain, les frameworks internes d'Anthropic et le harnais Linéaire de Cole Medin convergent tous vers la même architecture : une boucle étroite entourée de quatre composants clés qui maintiennent un grand modèle de langage orienté vers un objectif au lieu de se laisser distraire par des ressentis.

À la base se trouve le Gestionnaire d'État. Ce module suit l'objectif actuel de l'agent, les sous-objectifs intermédiaires, l'historique des étapes et les métadonnées d'exécution : quels outils ont été utilisés, ce qu'ils ont retourné et s'ils ont échoué. Dans DeepAgent, cela existe souvent sous la forme d'un objet d'état structuré qui circule à travers chaque appel, offrant au modèle une vue canonique de « où nous en sommes » et « ce qui vient de se passer ».

Une bonne gestion d'état va au-delà de la simple journalisation. Elle impose des schémas pour chaque interaction, sauvegarde des points de contrôle afin que les tâches de longue durée puissent reprendre après un crash, et enregistre des contraintes telles que les délais ou les budgets de tokens. Au lieu d'une conversation libre, l'agent fonctionne à l'intérieur d'un flux de travail typé qui peut être audité, rejoué et testé.

Parallèlement à l'état, le Contrôleur d'Outils médie chaque effet secondaire. Les harnais ne permettent jamais au modèle d'appeler des API brutes ou de toucher directement au système de fichiers ; ils exposent une boîte à outils soigneusement sélectionnée avec des contrats d'entrée et de sortie stricts. Dans LangChain, les outils déclarent des schémas JSON et des garde-fous, permettant ainsi au contrôleur de valider les arguments, de limiter les requêtes et de bloquer les actions manifestement dangereuses.

Un contrôleur robuste gère également : - L'authentification et l'isolation des secrets - La limitation de débit et le backoff entre plusieurs fournisseurs - L'exécution en bac à sable pour les fichiers, les shells ou les outils de code

La mémoire se trouve dans son propre module, reliant les limites de contexte de 200K à 1M de tokens du LLM avec des charges de travail réelles qui s'étendent sur plusieurs jours. La mémoire à court terme ressemble généralement à un carnet de notes : un résumé en cours des N dernières étapes, compressé par le modèle lui-même pour rester dans les limites budgétaires. La mémoire à long terme réside dans des bases de données vectorielles comme Pinecone, Weaviate ou pgvector, indexées par des embeddings provenant de modèles tels que text-embedding-3-large.

Les harnais intelligents distinguent la mémoire des tâches éphémères, la mémoire des projets durables et la connaissance organisationnelle globale. Ils décident quoi résumer, quoi intégrer et quoi éliminer, au lieu de tout remettre dans l'invite.

En maintenant tout cela ensemble, le Dispatching/Coordonnateur gère la boucle centrale. Il fournit à l'LLM l'état actuel et la mémoire, analyse l'« intention » du modèle (appeler un outil, créer une sous-tâche ou finaliser la sortie), et dirige le contrôle vers le bon composant. Chaque itération met à jour l'état, ajoute des éléments à la mémoire et resserre les contraintes, transformant un modèle stochastique en un système prévisible.

Le vibe coding peut sembler une blague jusqu'à ce que vous réalisiez qu'il décrit ce que chaque développeur veut vraiment : énoncer un résultat, éviter le code répétitif et livrer. Dans ce contexte, le vibe coding signifie décrire l'intention au niveau de « créer un bot Slack qui gère les incidents » et laisser le système découvrir les API, concevoir des modèles de données et écrire des tests sans que vous ayez à surveiller chaque fonction.

Pendant des années, c'était un fantasme car les LLM bruts se comportent comme des stagiaires doués mais peu fiables. Ils hallucinent des API, ignorent les cas particuliers et perdent le fil de plans en plusieurs étapes après une douzaine d'interactions. Même avec GPT-4 ou Claude 3.5, demander un système non trivial—par exemple, un SaaS complet CRUD avec authentification, facturation et analyses—donne toujours du code qui compile mais qui se brise silencieusement sous un trafic réel et des données concrètes.

L'agent de harnessing change modifie la nature de ce risque. Il transforme la "vibe" en un objectif de haut niveau, puis oblige le modèle à fonctionner à l'intérieur d'une structure d'outils, de mémoire et de contraintes explicites. Au lieu de dire "écrire un backend", vous demandez au harness de "fournir un backend prêt pour la production", et il orchestre les sous-tâches : conception de schéma, migrations, tests d'intégration, configurations de déploiement.

Les harnais modernes comme le cadre interne d'Anthropic ou le DeepAgent de LangChain ne font pas confiance à un seul appel de LLM. Ils imposent des boucles de planification → action → vérification, enregistrent chaque étape et renvoient les échecs à des débogueurs ou à une révision humaine. LangChain documente cela de manière explicite dans ses capacités de harnais d'agent - Docs par LangChain, où les agents reçoivent des objectifs structurés, choisissent des outils et maintiennent un état multi-étapes.

Ainsi, le codage par ambiance devient "en quelque sorte" viable, exactement comme Cole Medin le soutient. Vous vibrez à la frontière du système : "migrer notre monolithe vers une architecture orientée services d'ici le troisième trimestre, maintenir la latence en dessous de 150 ms, réutiliser l'authentification existante" - et le harnais décompose cela en centaines d'actions concrètes. Le LLM ne fait plus d'associations libres ; il fonctionne dans un flux de travail régulé et testable.

Il est crucial de ne pas se contenter d'une simple interface de chat LLM nue. Vous émettez des directives de haut niveau à un système robuste que vous avez conçu : schémas d'outils, garde-fous, points d'observation, stratégies de retour en arrière. La créativité se hisse à un niveau supérieur : passer de l'écriture de boucles à la conception du harnais qui permet de transformer le codage d'ambiance en quelque chose sur lequel vous pouvez réellement parier une feuille de route.

Les programmeurs sont discrètement promus au rang d'architectes de systèmes d'IA. Au lieu de s'acharner sur des contrôleurs, des services et des mappers de bases de données, ils orchestrent des réseaux de modèles, d'outils et de flux de travail qui se comportent davantage comme des équipes que des scripts. Le poste passe de « écrire une fonctionnalité » à « concevoir comment un système intelligent pense et agit ».

Cole Medin résume le tournant de manière franche : « nous concevons le système, nous concevons le harnais, mais nous n'allons pas écrire la plupart du code dans un avenir proche. » Cette phrase semble hyperbolique jusqu'à ce que vous voyiez un agent de type DeepSeek, Claude ou GPT connecter des appels REST, des migrations et des tests à partir d'un paragraphe d'intention. L'humain fixe toujours la direction ; l'agent gère l'échafaudage.

Les développeurs de New-day définissent les objectifs des agents avec la précision des spécifications produits. Au lieu de dire « créer une page de facturation », ils formulent des objectifs tels que « maintenir les factures Stripe synchronisées avec notre registre interne, concilier les échecs chaque heure et signaler les anomalies dépassant 5 000 $. » Le système traduit cela en outils, sous-agents et garde-fous.

L'outillage devient un artisanat de premier plan. Les architectes choisissent ou créent des fonctions pour : - Interagir avec des API et des services internes - Interroger des magasins de vecteurs et des entrepôts SQL - Déclencher des changements CI/CD et d'infrastructure

Chaque outil nécessite des schémas stricts, des limites d'authentification et des budgets de latence. La qualité de ces outils détermine à quel point l'agent se sent compétent.

Harness Logic remplace le code d'orchestration écrit à la main. Les développeurs conçoivent des boucles de planification, des politiques de réessai en cas d'erreur, des stratégies de gestion de la mémoire et des portes d'approbation. Un « fichier de workflow » pourrait déclarer comment un agent décompose des tâches, quand il peut générer des sous-agents, et ce qui doit être enregistré pour l'audit. Cela ressemble moins à du Java et plus à du Terraform pour la cognition.

Le débogage se transforme en analyse judiciaire des traces de raisonnement. Au lieu de parcourir les frames de la pile, vous inspectez les chaînes de pensée, les appels d'outils et les fenêtres de contexte. Vous ajustez les invites, modifiez les contrats des outils ou reconfigurez le planificateur, puis vous relancez le scénario.

Loin d'effacer les programmeurs, cette transformation les élève de maçons à architectes. Les problèmes complexes prennent un niveau supérieur : passer de l'écriture de boucles à la conception de systèmes capables d'écrire les leurs—de manière fiable, sûre et à grande échelle.

Les agents cessent d'être abstraits au moment où vous les orienterez vers un problème ennuyeux et coûteux. L'équipe d'ingénierie d'Anthropic a utilisé un harnachement pour effectuer des analyses de données s'étalant sur plusieurs heures sur un vaste ensemble de données internes, avec des agents orchestrant des requêtes SQL, résumant les résultats et itérant sur des hypothèses sans qu'un humain ne soit en charge. Leur compte rendu décrit des flux de travail prolongés qui surmontent les erreurs d'outils, les problèmes d'API et les instructions changeantes tout en convergeant vers un rapport utilisable.

Cet exemple d'Anthropic ressemble moins à une « discussion avec un bot » et plus à un analyste de données autonome. Le système suit l'état à travers des dizaines d'appels d'outils, enregistre les résultats intermédiaires et décide quand s'arrêter, pas seulement quoi dire ensuite. Vous obtenez quelque chose de plus proche d'un service persistant que d'une réponse ponctuelle.

Le Linear-Copilot-Harness en open source de Cole Medin montre à quoi cela ressemble dans un véritable flux de travail SaaS. Il connecte un LLM à l'API de Linear pour créer, trier et mettre à jour des tickets tout en jonglant avec le contexte provenant de l'historique des problèmes, des conventions d'équipe et des jalons de projet. Au lieu d'un prompt fragile "écrire un ticket", le harnais gère les outils, la mémoire et les garde-fous afin que l'agent se comporte comme un responsable de projet junior intégré à Linear.

Le harnais de Medin s'appuie sur des modèles tels que : - Routage des outils en fonction du type de tâche - Mémoire persistante liée aux problèmes linéaires et aux utilisateurs - Plans multi-étapes pouvant être réajustés en cas de défaillance des outils

Ces mêmes schémas se traduisent parfaitement dans d'autres agents générateurs de revenus. Des systèmes de recherche financière autonomes peuvent analyser les dépôts, les appels de résultats et les données du marché, puis maintenir une thèse en cours sur une entreprise ou un secteur. Un harnais coordonne la récupération de documents, la modélisation par tableurs et les résumés de risques tout en imposant des limites strictes aux outils pour tout ce qui touche au capital réel.

Les agents de test QA automatisés peuvent gérer des suites de régression de bout en bout. Ils génèrent des tests, appellent des pipelines CI, interprètent les échecs, déposent des tickets et relancent des vérifications ciblées après la correction des problèmes. Le système maintient une cartographie à long terme de la couverture des tests, des instabilités historiques et de la propriété des composants, de sorte que l'agent s'améliore au fil des semaines au lieu de se réinitialiser à chaque exécution.

Les équipes marketing expérimentent déjà des agents de campagne auto-gérés. Un harness peut orchestrer la génération de textes, des tests créatifs A/B, la réallocation de budget et des requêtes d'analyse sur Google Ads, Meta et les plateformes d'email. Des plateformes de niveau entreprise comme OutSystems Agent Workbench se précipitent pour industrialiser cela, en emballant des modèles de harness en "recettes d'agents" à glisser-déposer qui s'intègrent directement dans les systèmes existants.

Pavel Panchekha propose le modèle mental le plus clair pour tout cela : les LLM sont des noyaux, les interfaces d'agent sont des coquilles. Pensez à Linux plus bash, pas à un « agent magique ». Le noyau expose la puissance brute ; la coquille décide comment les humains et les programmes l'utilisent réellement.

Un noyau de système d'exploitation planifie les processus, gère la mémoire et expose des appels système. Un shell comme bash ou zsh transforme cela en `ls`, en pipes, en scripts et en automatisation. Remplacez Claude ou GPT par le noyau, et votre interface devient le shell : elle interprète l'intention de l'utilisateur, séquence les appels d'outils et maintient en vie les tâches de longue durée.

Lisez Les Harnais d'Agent ne sont que des Coquilles - Pavel Panchekha et l'analogie prend forme. Le « noyau » LLM peut : - Générer et transformer du texte - Appeler des outils via des appels de fonction structurés - Maintenir l'état conversationnel à court terme

Le « revêtement » du harnais enveloppe cela avec : - Contrôle de processus pour des tâches qui s’exécutent pendant des minutes, des heures ou des jours - Orchestration des outils à travers des API, des bases de données et des codes - Persistance, journalisation et récupération en cas de crash

Vu de cette manière, le DeepAgent de LangChain, les exemples de harnais d'Anthropic et le harnais Linear de Cole Medin ressemblent moins à de l'IA exotique et plus à de l'ingénierie OS familière. Ils mettent en œuvre des boucles de planification, des réessais, des délais exponentiels et des machines à états—simplement orientés vers les appels LLM au lieu des appels système. La magie passe de l'« ingénierie des invites » à la conception d'un environnement d'exécution robuste.

Ce modèle clarifie également pourquoi les gains des LLM bruts semblent incrémentaux tandis que les gains de l'exploitation semblent multiplicatifs. Un meilleur noyau est important, mais une meilleure interface change la manière dont chaque utilisateur et chaque processus interagit avec ce noyau. Bash a fait plus pour l'utilisation d'Unix que n'importe quelle mise à niveau de processeur unique.

Ainsi, la prochaine étape logique pour les développeurs est évidente : ne plus traiter les agents comme des applications monolithiques et commencer à considérer les harnais comme des environnements d'exploitation. Nous ne nous contentons plus d'appeler des noyaux ; nous construisons des coques pour une toute nouvelle classe de logiciels.

Les systèmes de contrôle des agents passent des blogs de recherche aux CV. D'ici 2026, être "à l'aise avec l'IA" signifiera que vous pouvez concevoir, déboguer et déployer des systèmes de contrôle qui maintiennent les LLM en tâche pendant des heures, et non que vous pouvez rédiger une invite astucieuse. Considérez la construction de systèmes de contrôle comme l'apprentissage de React en 2015 ou de Kubernetes en 2018 : optionnel au début, puis essentiel pour un travail sérieux.

Commencez par un système concret : un assistant de codage capable de gérer un dépôt pendant 30 à 60 minutes. Connectez des appels d’outils pour git, l'entrée/sortie de fichiers et les tests, puis ajoutez des garde-fous : suivi de l'état, politiques de réessai et critères de réussite explicites. Mesurez le succès à l'aide de chiffres précis : taux de correction de bogues, temps jusqu'à la demande de tirage (PR), et fréquence à laquelle les humains doivent secourir l'agent.

Votre manuel principal est la documentation LangChain DeepAgent. Étudiez comment elle modélise l'état de l'agent, le routage des outils et les plans en plusieurs étapes, puis décomposez ce modèle dans votre propre pile, même si vous n'importez jamais LangChain. Traitez son design comme vous traiteriez la lecture du code source d'un bon planificateur d'OS : une mise en œuvre de référence de ce à quoi ressemble un système “robuste”.

Le blog d'ingénierie d'Anthropic est un autre incontournable. Leur méthode pour l'analyse de données à long terme montre comment gérer la mémoire, la journalisation et les modes de défaillance lorsque les tâches s'exécutent pendant des heures. Faites attention à la façon dont ils divisent le travail, enregistrent les progrès et limitent l'étendue des impacts d'un appel de modèle défaillant.

GitHub regorge déjà de modèles. Étudiez des harnais open-source comme le harnais Linéaire de Cole Medin et les exemples d'Anthropic, puis : - Forkez-en un et remplacez-le par vos propres outils - Ajoutez de la télémétrie et du suivi des coûts - Renforcez-le pour une charge de travail réelle dans votre emploi ou votre projet parallèle

Le travail futur à fort impact en IA appartiendra aux personnes capables d'envelopper les modèles bruts dans des systèmes fiables. Si Cole Medin a raison et que nous déléguons 99 % du codage à des agents, le pouvoir sera entre les mains de ceux qui conçoivent les harnais dans lesquels ces agents évoluent. Vous pouvez être la personne qui construit les coquilles autour des noyaux de demain.

Qu'est-ce qu'un harnais d'agent IA ?

Un harnais d'agent est un cadre structuré qui gère la mémoire, les outils et l'état d'un agent IA afin de garantir qu'il peut exécuter de manière fiable des tâches complexes et de longue durée, tout comme un shell gère un noyau dans un système d'exploitation.

Comment un harnais est-il différent de l'ingénierie des invites ?

Alors que l'ingénierie des invites se concentre sur la création de l'entrée initiale parfaite, un harnais construit un système opérationnel complet autour du LLM pour contrôler son flux d'exécution, gérer les outils et gérer les erreurs au fil du temps.

Les agents d'exploitation remplaceront-ils les développeurs de logiciels ?

Ils sont sur le point de transformer le rôle des développeurs, passant de l'écriture de code ligne par ligne à la conception et à l'ingénierie des systèmes (harnais) qui guident les agents IA dans l'écriture du code, les élevant au rang d'architectes de systèmes.

Le 'vibe coding' et les harnais d'agent sont-ils liés ?

Oui. Le « codage de vibe »—décrire un résultat souhaité en langage naturel—devient plus viable avec des harnais, car ils offrent la fiabilité nécessaire pour traduire des « vibes » de haut niveau en exécution de code fonctionnelle et en plusieurs étapes.