La fin de l'ingénierie des invites est arrivée.

Vous connaissez déjà le schéma. Demandez à un agent IA de renommer des variables, d'écrire un test unitaire ou de résumer une demande de tirage, et ça paraît brillant. Demandez-lui de prendre en charge une implémentation de fonctionnalité complète à travers des dizaines de fichiers, plusieurs services et une semaine d'itération, et il se désintègre discrètement en branches à moitié terminées, tests cassés et APIs hallucinées.

Les développeurs continuent d'essayer de toute façon. Ils mettent en place des agents de codage “autonomes”, intègrent GitHub, Jira et un moteur de test, puis observent le système se bloquer sur des refactorisations circulaires ou oublier des exigences qu'il a vues il y a 20 minutes. Les indicateurs de performance sont impressionnants sur des tâches fictives, mais dans de vrais dépôts, les agents manquent encore de cas limites, régressent en performances ou dépassent les contraintes de sécurité.

C'est pourquoi Vibe Coding est resté surtout un mythe. La fantaisie est la suivante : décrivez une fonctionnalité en quelques phrases, dirigez l'agent vers votre monorepo, et revenez avec une PR propre, un CI vert et des tests d'intégration réussis. En pratique, les modèles dérivent des spécifications, perdent de vue les objectifs à long terme et s'adaptent excessivement à la dernière fenêtre contextuelle que vous leur avez fournie.

Sous le capot, la puissance brute des LLM a cessé de se multiplier à la même vitesse vertigineuse après environ 2023. De plus grands contextes de fenêtre et de meilleures indications ont aidé, mais ils n'ont jamais résolu les problèmes de fiabilité fondamentaux : utilisation des outils fragile, dégradation du contexte, et aucune véritable notion de l'état au niveau du projet. L'ingénierie des incitations et l'ingénierie du contexte ont poussé les limites ; elles n'ont pas changé l'architecture.

Une couche différente émerge discrètement pour remédier à cela. Agent harnesses enveloppe les modèles avec un contrôle explicite sur la mémoire, les outils et les sous-agents, transformant des chatbots débridés en systèmes capables de maintenir un plan pendant des heures ou des jours. Des projets comme le harnais à long terme d’Anthropic, le DeepAgent de LangChain, et le harnais Linear de Cole Medin pointent tous dans la même direction.

Cette série explore ce changement : comment les architectures basées sur des harnais rendent enfin les agents dignes de confiance pour un travail sérieux, où ils continuent à échouer, et ce qu'il faudra pour que le véritable codage d'ambiance cesse d'être une démonstration et commence à devenir la norme.

L'ingénierie des instructions a commencé comme la science populaire de la communication avec GPT‑3. Les développeurs se sont concentrés sur des instructions uniques, ajustant la formulation, les exemples et les formats de sortie pour obtenir de meilleures réponses d'une seule interaction de 2 048 tokens. L'unité de travail était une requête, une réponse, sans mémoire, sans plan.

Avec l'arrivée de GPT‑3.5 et GPT‑4, dotés de fonctionnalités de chat et de fenêtres de contexte plus grandes, cet état d'esprit a changé. L'ingénierie du contexte a pris le relais : le problème n'était plus “quel est le prompt parfait ?” mais “que doit voir le modèle en ce moment parmi plus de 100 messages précédents et des mégaoctets de documents ?” Les équipes ont lutté contre la dégradation du contexte, jonglant avec des prompts système, des résumés et des pipelines de récupération juste pour maintenir la cohérence d'une session.

L'ingénierie contextuelle traite une session d'IA comme une conversation soigneusement organisée. Vous décidez quels spécifications, extraits de code et décisions restent actifs dans la fenêtre contextuelle et lesquels sont déplacés vers un stockage à long terme. Des outils tels que la recherche vectorielle, les résumés hiérarchiques et les messages système basés sur les rôles sont devenus des standards juste pour gérer une seule longue conversation.

L'agent exploite une impulsion qui fait progresser les choses à un niveau supérieur. Au lieu d'optimiser un seul appel ou une seule session, un harness orchestre de nombreuses sessions, souvent réparties sur plusieurs agents, pour accomplir une tâche qui s'étend sur plusieurs heures ou plusieurs jours. Pensez "déployer cette fonctionnalité de bout en bout", et non "refactoriser cette fonction".

Un agent moderne coordonne plusieurs éléments en mouvement simultanément : - Plusieurs sessions de LLM avec différents rôles - Stockages de mémoire partagés et par agent - Outils pour l'exécution de code, les tests et les API externes - Points de contrôle, restaurations et étapes de revue humaine

Des projets comme les harnais efficaces pour agents de longue durée d'Anthropic, LangChain DeepAgents et le harnais Linear Agent de Cole Medin suivent tous ce modèle. Un agent planifie, un autre écrit du code, un autre exécute des tests, et le harnais suit l'état à travers des dizaines ou des centaines d'appels. L'unité de travail devient un graphique de flux de travail, et non un journal de chat.

Il est essentiel de comprendre qu'il s'agit d'une évolution, pas d'une amnésie. Les harnais dépendent encore d'une ingénierie de prompt précise à chaque appel et d'une ingénierie de contexte disciplinée à chaque session. Ils considèrent simplement ces compétences comme des primitives de bas niveau dans un programme plus vaste, où le véritable défi réside dans la coordination de nombreux agents imparfaits en un seul système fiable.

La puissance des modèles bruts ne suit plus le graphique de science-fiction que les gens imaginaient en 2020. Le passage de GPT-3 à GPT-4 ressemblait à un saut de « démo sympa » à « je pourrais utiliser ça au travail », mais GPT-4.1, 4.1-mini et Claude 3.5 Sonnet ressemblent davantage à des compromis incrémentiels en termes de latence, de coût et de fiabilité qu'à une nouvelle classe de quotient intellectuel en intelligence machinique.

Les références le confirment. Les classements académiques commencent à se saturer, et les fournisseurs passent discrètement de la vantardise sur les scores MMLU à vanter les « jetons par seconde » et les « requêtes par dollar ». Nous continuons à obtenir de meilleurs modèles, mais la courbe semble plus linéaire qu'exponentielle.

Les chercheurs en IA disent de plus en plus tout haut ce qui était auparavant dit en sous-main : l'ère du scaling laisse place à l'ère de l'architecture. Ajouter 10 fois plus de GPU à un transformateur apporte de moins en moins chaque année, donc l'enjeu réel se déplace vers la manière dont vous structurez les systèmes autour d'un modèle : boucles de planification, couches de mémoire, routeurs d'outils, évaluateurs et points de contrôle avec l'humain dans la boucle.

Ce changement explique pourquoi Anthropic rédige des analyses techniques approfondies comme Effective Harnesses for Long-Running Agents et pourquoi OpenAI, Google et Meta poussent tous les "agents", et pas seulement des LLM plus grands. La pointe de la technologie passe d'un seul appel de modèle opaque à des réseaux d'appels orchestrés avec des états et un contrôle explicites.

Les agents exploités se trouvent au centre de cette nouvelle architecture. Ils gèrent le travail peu glamour mais crucial de décomposer une demande de fonctionnalité en étapes, de coordonner les sous-agents, de gérer la mémoire et de décider quand demander l'aide d'un humain au lieu de créer une voie à suivre de toutes pièces.

Au lieu de prier pour que GPT-5 expédie par magie des demandes de tirage parfaites, les équipes peuvent concevoir des harnais qui :

• 1Faites respecter les normes de codage et les portes de test.
• 2Persistez et récupérez le contexte à l'échelle du projet.
• 3Acheminer les tâches entre les agents planificateur, codeur et réviseur.
• 4Détecter les boucles, les régressions et la dérive des spécifications.

Cette surface de contrôle est là où les développeurs retrouvent soudainement leur pouvoir. Vous ne pouvez pas modifier le cycle de formation d'OpenAI, mais vous pouvez décider combien d'agents vous déployez, comment ils interagissent, quels outils ils utilisent, et quand ils doivent s'arrêter et justifier leurs actions.

Les harnais d'agent, et non les poids de modèle bruts, deviennent la toile principale de l'innovation. Le prochain bond en capacité de "10x" ressemblera moins à une nouvelle carte de modèle et davantage à une architecture d'agent robuste, débogable et prête pour la production.

Les appels bruts des LLM peuvent impressionner lors d'une démo, mais ils se comportent davantage comme un animal puissant et nerveux que comme un collègue fiable. Un harnais d'agent est le système de contrôle qui entoure ce modèle, transformant la prédiction de texte stochastique en quelque chose qui commence à ressembler à un logiciel fiable. Il définit comment l'agent se souvient, quels outils il utilise, comment il collabore avec d'autres agents et comment il reste aligné sur un objectif pendant des heures ou des jours plutôt que sur un unique échange de discussion.

Pensez au LLM comme à un cheval de course : rapide, puissant, et complètement désintéressé par votre backlog de sprint. Le harnais est le mors, les rênes, et la selle qui contraignent cette puissance en un mouvement prévisible. Sans cela, vous obtenez des transcriptions de codage vagues et des APIs halluconnées ; avec, vous obtenez un agent de codage qui peut réellement livrer une fonctionnalité, exécuter des tests, et mettre à jour la documentation sans s'égarer dans la fan fiction.

La première tâche du harnais : gestion de la mémoire. Les LLM fonctionnent toujours dans des fenêtres de contexte finies—128K tokens, peut-être 200K si vous payez pour cela—donc le harnais décide quoi conserver, quoi résumer et quoi oublier. Des systèmes comme Manus et les propres harnais d'Anthropic combattent agressivement le « pourrissement du contexte », élaguant les instructions obsolètes et utilisant la récupération pour n'extraire que les segments de dépôt, les tickets et les décisions antérieures qui comptent à cet instant.

Deuxième emploi : contrôle des outils. Les agents modernes appellent tout, des systèmes de fichiers aux pipelines CI, et un modèle brut ne se privera pas de `rm -rf` votre dépôt si l'invite le pousse à le faire. Les harnais régulent ces capacités : ils décident quand invoquer un outil, valident les résultats et appliquent des politiques telles que « les tests doivent passer avant le commit » ou « ne jamais toucher à la production sans approbation humaine. »

Troisièmement, le système coordonne des sous-agents spécialisés. Au lieu d'un seul prompt géant essayant de « réaliser l'ensemble de la fonctionnalité », vous observez des modèles tels que : - Agent planificateur qui transforme une spécification en tâches - Agent développeur qui modifie des fichiers - Agent testeur qui exécute et interprète des tests - Agent réviseur qui impose le style et l'architecture

Enfin, les harnais maintiennent les tâches de longue durée sur les rails. Ils suivent l'état global, détectent les boucles, établissent des points de contrôle et mettent en lumière des points de décision pour les humains. Un appel brut de LLM est sans état et amnésique ; un agent harnais peut travailler à travers des centaines d'appels, faire une pause pendant la nuit et reprendre le lendemain en sachant exactement quel cas limite a fait échouer la dernière exécution du test.

Les harnais modernes s'ouvrent généralement avec un agent d'initialisation qui se comporte moins comme un chatbot et plus comme un chef de projet. Il lit les spécifications de l'utilisateur, inspecte le dépôt ou l'environnement, et produit un plan concret : jalons, outils à utiliser, fichiers à modifier et critères de réussite explicites. Le propre harnais d'Anthropic décrit cela comme une séparation entre l'« initialiseur » et le « codeur », où l'initialiseur verrouille le périmètre avant que toute modification de code ne soit effectuée.

Une fois que l'initialiseur a terminé, le contrôle passe à un agent de tâche qui réalise réellement le travail. Cet agent fonctionne en boucle, prenant une seule étape, exécutant des outils, puis rejetant la plupart de son contexte. À chaque itération de la boucle, il réhydrate juste assez d'état depuis la mémoire afin que le modèle ne se noie pas dans un journal de chat de 200 messages.

Cette boucle ressemble généralement à un système de contrôle rigide plutôt qu'à une conversation libre. L'agent de tâche : - Récupère le segment de plan actuel et les fichiers pertinents de la mémoire - Propose un changement ou une action - Exécute des outils (tests, analyseurs de code, compilateurs, appels HTTP) - Rédige les résultats et les différences, puis recommence

Des garde-fous encadrent chaque itération. Les vérifications pré-exécution valident que la prochaine action de l'agent correspond au plan et aux outils autorisés ; les vérifications post-exécution vérifient les résultats en fonction de contraintes telles que « les tests doivent réussir » ou « pas de secrets dans les journaux ». Des systèmes comme LangChain DeepAgent et OutSystems Agent Workbench intègrent ces vérifications comme des politiques qui peuvent échouer de manière rigoureuse ou demander un examen humain.

Les points de contrôle donnent une colonne vertébrale au harnais. Après des progrès significatifs—comme un ensemble de tests réussi ou une intégration d'API terminée—le harnais prend un instantané de l'état : position du plan, hachages de fichiers, sorties des outils et décisions clés. Si l'agent hallucine ou corrompt un fichier par la suite, le harnais peut revenir au dernier point de contrôle valide au lieu de deviner ce qui a mal tourné.

Les transferts de contextes se font entre des agents spécialisés. Un agent planificateur peut transmettre un graphe de tâches structuré à un agent de codage ; un agent de codage peut transmettre un correctif accompagné d'un plan de test à un agent de relecture. Chaque transfert utilise des schémas stricts afin que les agents ne se transmettent pas des textes vagues mais des états vérifiables par machine.

Rien de tout cela ne fonctionne sans une couche de mémoire sérieuse. Les harnais modernes s'appuient sur RAG pour le code et la documentation, des stocks à long terme pour les décisions, et la compression de la mémoire via la résumé ou les embeddings pour lutter contre la dégradation du contexte. Des points de rupture impliquant l'humain se trouvent au sommet de cette pile, interrompant la boucle pour obtenir des approbations sur des actions risquées—migrations de schéma, flux de paiement, ou refactorisations sensibles à la sécurité—afin que le codage dynamique ne déclenche pas discrètement un désastre.

Anthropic a discrètement publié l'un des plans les plus clairs pour de véritables agents de code : un harnais qui transforme Claude en quelque chose de plus proche d'un ingénieur junior que d'un autocomplete bavard. Leur harnais d'agent à long terme ne recherche pas la nouveauté ; il systématise la planification, l'exécution et la vérification, permettant au modèle de s'attaquer à des tâches de codage pouvant durer plusieurs heures sans perdre le fil.

Au cœur se trouve un agent d'initialisation qui se comporte comme un leader technique. Il ingère un large cahier des charges, inspecte le dépôt, énumère les contraintes et émet un plan structuré : des tâches concrètes, des listes de fichiers à toucher, des notes de dépendance et des critères d'acceptation. Ce plan devient le contrat pour un agent codeur séparé qui effectue le travail de fond consistant à modifier des fichiers, à appeler des outils et à exécuter des tests.

Le système d'Anthropic considère l'état comme un problème de première classe, et non comme une simple réflexion ultérieure. Au lieu de tout entasser dans une immense fenêtre contextuelle, il maintient : - Un graphique de tâches canonique et une liste de contrôle - Des historiques et des différences au niveau des fichiers - Des résumés des appels d'outils précédents et des tests effectués

L'initiateur écrits cet état ; le codeur lit des parts de celui-ci, puis ajoute de nouveaux artefacts que des appels futurs peuvent récupérer. Ce schéma permet au système de sauter à travers de nombreux petits fenêtres de contexte ciblées tout en se comportant comme une session continue unique.

Les outils assemblent le tout. L'agent codeur ne fait pas d'hallucinations sur les modifications de fichiers ; il appelle des outils explicites pour : - Lire et écrire des fichiers - Exécuter des tests unitaires et d'intégration - Exécuter des linters et des formatters

Chaque appel d'outil renvoie une sortie structurée que le harnais enregistre, résume et renvoie sélectivement dans le contexte. Les tests échoués, par exemple, deviennent des rapports de bogues précis que le développeur doit traiter avant que le harnais ne considère une tâche comme terminée.

La validation autonome est omniprésente. L'initiateur critique son propre plan par rapport au cahier des charges original, le programmeur analyse les différences par rapport au plan, et le dispositif impose des boucles de contrôle qui bloquent l'avancement lorsque des tests échouent ou que des lacunes de couverture apparaissent. Des points de contrôle humains peuvent s'intégrer dans la même boucle pour les changements à haut risque.

Le design d'Anthropic correspond presque un à un au schéma général de harnais : mémoire durable, outils explicites, sous-agents spécialisés et boucles de contrôle étroites. Des projets comme Linear-Coding-Agent-Harness reflètent le même schéma, qui devient rapidement l'architecture de facto pour quiconque essaye de rendre le "vibe coding" plus qu'un simple tour de magie.

Le codage par ambiance a toujours semblé appartenir à la science-fiction : décrivez une fonctionnalité « ambiance », allez prendre un café, et revenez avec une demande de tirage terminée. Avec les harnais d'agent, cette fantasie se rapproche de la réalité, mais seulement « en quelque sorte ». Vous pouvez maintenant pointer un agent vers un dépôt Git et lui faire planifier, éditer, exécuter des tests et itérer pendant des heures sans avoir à surveiller chaque frappe de clavier.

Les harnais rendent cela possible en enveloppant le modèle brut dans un système de contrôle. Un harnais bien conçu gère les outils (git, runners de tests, linters), suit l'état à travers des dizaines ou des centaines d'appels, et applique des points de contrôle. Par exemple, le harnais de codage à long terme d'Anthropic utilise un agent d'initialisation pour établir un plan, puis une boucle de codage et de test pour travailler sur l'implémentation et la vérification.

Les arcs-en-ciel et les marguerites s'arrêtent là. Le codage de vibe entièrement autonome s'effondre toujours au moment où il rencontre un monolithe désordonné, des tests manquants ou des exigences de produit ambiguës. Les harnais amplifient la discipline d'ingénierie que vous possédez déjà ; ils ne la remplacent pas.

Le succès est fortement corrélé à une base de code bien structurée et des outils riches. Les équipes qui parviennent réellement à déployer des fonctionnalités de manière fiable ont tendance à évoluer dans des environnements avec : - Une couverture de tests élevée et un retour d'information rapide (secondes, pas minutes) - Des linters et des formatteurs stricts (ESLint, Prettier, Ruff) - Des frontières de modules claires et des API typées (TypeScript, mypy)

L'humain dans le processus reste non négociable pour tout ce qui a de l'importance. Les configurations de codage de vibe les plus efficaces intègrent des humains à des points de contrôle critiques : validation du plan initial, approbation des modifications architecturales, examen des migrations risquées et fusion des demandes de tirage. Les exemples de harnais de Cole Medin s'appuient sur des étapes de révision explicites plutôt que sur des pipelines de fusion automatique aveugles.

Alors, le codage par ambiance est "de retour", mais en tant que flux de travail, pas en tant que tour de magie. Vous déchargez la corvée - modifications de fichiers, modèles, refactorisations - tout en restant informé sur l'intention, l'architecture et les compromis. La fantaisie des agents prêts à l’emploi peut attendre ; la version pratique est disponible aujourd'hui, tant que vous concevez le harnais et la base de code pour le mériter.

Les agents enveloppés dans des harnais se heurtent toujours à un problème difficile : l'alignement dans le temps. Des prompts courts peuvent respecter les spécifications ; des marathons de codage de 500 étapes ne le peuvent pas. Même avec la boucle initialiseurs-codes d’Anthropic ou le DeepAgent de LangChain, les modèles réinterprètent discrètement les exigences, réinventent les modèles de données ou “optimisent” des contraintes qui étaient non négociables dans le cahier des charges initial.

Le dérive d'alignement se manifeste de manière subtile. Un agent de codage pourrait échanger REST contre GraphQL en cours de refonte, ou ignorer un budget de performance une fois que les tests sont réussis. Les harnais ajoutent des barrières de protection : points de contrôle, auto-critique, tests de régression, mais personne n'a de méthode infaillible pour maintenir un grand modèle stochastique fidèle à une architecture et à un cahier des charges produit sur des heures ou des jours d'utilisation des outils.

Encore plus difficile : l'alignement doit survivre à un contexte changeant. Les exigences évoluent en cours d'exécution, les humains interviennent avec des retours partiels, et les systèmes externes échouent. Les harnais d'aujourd'hui rapprochent l'intention avec des heuristiques—« ne touchez pas à l'authentification », « ne modifiez jamais ce répertoire », « exécutez des tests tous les N pas »—pourtant ils manquent toujours d'objectifs de niveau supérieur comme « préserver la parité de l'expérience utilisateur » ou « garder cette base de code idiomatique ».

Il y a ensuite le coût de la construction d'un harnais sérieux. Un système de production nécessite : - Des états persistants et des stores de mémoire - L'orchestration des outils (éditeurs, exécuteurs de tests, CI, systèmes de billetterie, observabilité) - Des contrôles de sécurité, des chemins de retour en arrière et un examen par un humain dans la boucle - Des évaluateurs et des métriques spécifiques au domaine

Cette pile ressemble moins à une invite et plus à un nouveau produit. Le cadre à long terme d'Anthropic s'étend sur plusieurs agents, étapes de planification et couches de validation ; le cadre d'agent Linéaire de Cole Medin relie Git, les gestionnaires de problèmes et l'exécution de code. Rien de tout cela ne vient « gratuitement » d'un SDK.

Il n'existe pas encore de norme universelle de harnais « à taille unique ». Un backend fintech, un système de design React et un pipeline de notebooks en data science ont tous besoin de différents outils, de différentes vérifications de sécurité, et de différentes définitions de « terminé ». Des frameworks comme LangChain DeepAgent et des plateformes comme OutSystems Agent Workbench laissent présager une convergence, mais nécessitent encore une personnalisation lourde par équipe et domaine.

Plutôt que d'être des éléments rédhibitoires, ces deux obstacles marquent la prochaine frontière. La course porte désormais moins sur un modèle légèrement plus intelligent et davantage sur des harnais réutilisables et sensibles à l'alignement, qui rendent le codage d'ambiance ennuyeusement fiable plutôt que parfois magique.

Commencez par esquisser votre agent en tant que flux de travail avec état, et non comme une invite magique. Notez les étapes concrètes : ingestion des spécifications, Planification, Mise en œuvre, Tests, Refactoring, Déploiement et Revue. Votre cadre devient la couche qui fait circuler l'état entre ces étapes, décide quand appeler le LLM et quand impliquer un humain.

Pour des exemples pratiques, les DeepAgents de LangChain sont l'endroit le plus accessible à explorer. Les DeepAgents montrent comment connecter planificateurs, exécutants et critiques, avec l'utilisation d'outils et la mémoire intégrées dans une boucle plutôt que dans un appel unique. Vous pouvez suivre comment ils gèrent des tâches multi-étapes telles que les refactorisations à l’échelle du dépôt ou les intégrations d'API multi-services.

Le propre agent de codage linéaire de Cole Medin sur GitHub est un modèle encore plus affirmé. Il encapsule un agent de codage autour des problèmes Linéaires, vous offrant des flux concrets pour lire les tickets, planifier des changements, éditer des fichiers et poster des mises à jour vers Linear. Vous obtenez des modèles du monde réel pour les points de contrôle, la gestion des erreurs et la façon de récupérer lorsque le modèle s'écarte des spécifications.

Si vous travaillez dans une architecture d'entreprise, OutSystems Agent Workbench vous propulse encore plus haut dans l'échelle d'abstraction. Il intègre des garde-fous, de l'observabilité et des validations humaines afin que vous puissiez définir des politiques telles que « ne jamais toucher à la production sans examen » ou « exiger que les tests réussissent avant la fusion ». L'équipe Outshift de Cisco cartographie des modèles similaires pour les systèmes de production dans Comment les entreprises peuvent tirer parti des agents IA pour une automatisation plus intelligente.

Traitez la conception du harnais comme un problème d'architecture logicielle, et non comme un bricolage de prompts. Identifiez l'état prolongé de votre agent (graphique de tâches, fichiers, billets), vos outils (accès au dépôt, CI, recherche de documentation) et vos garde-fous (tests, linters, revue humaine). Ensuite, codifiez-les en tant qu'états et transitions explicites au lieu d'espérer que le modèle « se souvienne ».

Une recette de démarrage pratique ressemble à ceci : - Un agent planificateur qui convertit les spécifications en une liste de tâches - Un agent exécuteur qui édite le code et utilise des outils - Un agent réviseur qui critique les différences et les résultats des tests - Une boucle de contrôle qui décide quand replanifier ou escalader

Une fois que vous pensez de cette manière, l'ingénierie des prompts devient un détail d'implémentation à l'intérieur d'un carnet qui possède réellement la fiabilité.

L'ingénierie des requêtes a eu son heure de gloire, mais le centre de gravité a changé. Le pouvoir réside désormais dans l'orchestration : des agents qui gèrent la mémoire, les outils, les sous-agents et les points de contrôle humains, de sorte qu'un seul appel LLM devienne un système cohérent et en cours d’exécution plutôt qu'un simple tour de passe-passe d'autocomplétion.

Nous observons l'IA suivre la même trajectoire que le logiciel lui-même. Les premiers "scripts" de commandes ajustées à la main laissent place à une véritable ingénierie système : planificateurs, vérificateurs, tests de régression, télémétrie et restauration, le tout entourant un modèle qui pourrait n'être que 10 à 20 % meilleur par génération au lieu de 10x.

Résolvez les deux grands obstacles—l'alignement à long terme et la fidélité de l'architecture—et les agents cessent d'être des jouets pour devenir les maîtres de workflows entiers. Un harnais bien conçu peut, en principe, exécuter une boucle de croissance complète, un entonnoir d'intégration de bout en bout, ou un refactorisation sur plusieurs mois d'une base de code de 500 000 lignes tout en respectant les spécifications.

C'est à ce moment-là que "l'assistant de codage IA" devient "membre de l'équipe d'ingénierie IA". Le même schéma s'étend au travail scientifique : balayages de littérature, campagnes de simulation et planification d'expériences enchaînées sur des milliers d'appels LLM, avec le harnais appliquant des contraintes, consignant les décisions et mettant en avant uniquement les branches critiques pour les humains.

Les développeurs qui s'épanouissent dans cette ère agentique ne seront pas ceux qui mémorisent des astuces de prompt ; ce seront ceux qui conçoivent des systèmes de contrôle. Votre travail passe de discuter avec un modèle à l'architecture de planificateurs, de critiques, de routeurs d'outils et de portails de révision capables de survivre à des jours ou des semaines de fonctionnement autonome.

Alors commencez petit, mais commencez maintenant. Saisissez le harnais de longue date d'Anthropic, le harnais d'agent Linéaire de Cole Medin, le DeepAgent de LangChain ou les modèles d'ingénierie contextuelle de Manus et connectez un harnais pour un seul flux de travail douloureux que vous contrôlez aujourd'hui.

Puis équipez-le, cassez-le et renforcez-le. La prochaine vague de levier en IA appartient à ceux qui orchestrent les modèles, et non à ceux qui se contentent de les inciter.

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

Un harnais d'agent est un système construit autour d'un agent AI pour gérer la mémoire, contrôler les outils, coordonner les sous-agents et maintenir l'état, lui permettant d'exécuter de manière fiable des tâches complexes et de longue durée.

Comment un agent de harness diffère-t-il de l'ingénierie de prompt ?

L'ingénierie des prompts optimise des interactions individuelles avec un LLM. Un agent de mise en réseau est une architecture complète qui orchestre de nombreuses interactions et fenêtres de contexte pour réaliser un projet plus vaste, intégrant des techniques d'ingénierie de prompts et de contextes au sein de son cadre.

Le 'vibe coding' est-il possible avec des harnais d'agent ?

Les harnais d'agents nous rapprochent du 'codage d'ambiance' (implémentation de fonctionnalités sans intervention) en rendant les agents plus fiables. Cependant, ce n'est pas entièrement résolu ; les tâches complexes nécessitent encore une validation impliquant un humain et des garde-fous bien conçus.

Pourquoi les harnais pour agents deviennent-ils importants maintenant ?

Alors que la puissance brute des LLMs commence à se stabiliser, l'innovation se concentre sur les systèmes qui les entourent. Les harnesses offrent la structure nécessaire pour débloquer le prochain niveau de capacité pour les agents autonomes de niveau entreprise.