En février 2026, une petite équipe d'OpenAI a livré 1 million de lignes de code en production.
Ils n'ont pas écrit une seule ligne à la main.
Les agents d'IA l'ont écrit.
Les humains ont conçu le système qui a rendu les agents fiables.
Ce système a maintenant un nom.
L'ingénierie du harnais.
Quelques semaines plus tard, Anthropic publiait 3 articles à ce sujet.
ThoughtWorks a formalisé un cadre.
Philipp Schmid, chez Hugging Face, l'a qualifiée de « discipline la plus importante de 2026 ».
Une nouvelle discipline d'ingénierie a émergé en 90 jours.
Et presque personne en dehors des équipes d'infrastructure IA ne la comprend encore.
Cet article explique tout.
Pas de blabla. Pas de jargon académique. Seulement les modèles mentaux dont vous avez besoin pour utiliser cela concrètement.
Gardez ceci. Vous le lirez deux fois.
PARTIE 1 : CE QU'EST RÉELLEMENT UN HARNAIS (Le concept qui change votre façon de penser à l'IA)
1. La définition du harnais
La définition la plus simple vient de ThoughtWorks :
→ Agent = Modèle + Harnais
Le harnais est tout ce qui n'est pas le modèle.
Les contraintes qui maintiennent l'agent sur la bonne voie. Les boucles de rétroaction qui attrapent les erreurs. La documentation qui indique à l'agent où il se trouve. Les outils qu'il a le droit d'utiliser.
Enlevez le harnais → un modèle de langage brut qui tâtonne dans votre base de code.
Ajoutez le bon harnais → un système qui livre du code de production.
Le nom vient du harnachement équestre.
Un harnais est les rênes, la selle et le mors qui canalisent un animal puissant mais imprévisible dans une direction utile.
Vous ne rendez pas le cheval plus intelligent. Vous concevez l'équipement qui rend sa force utile.
2. L'analogie avec le système d'exploitation
Philipp Schmid a donné le meilleur cadre technique :
Pensez-y comme à un ordinateur.
→ Modèle = CPU (puissance de traitement brute)
→ Fenêtre de contexte = RAM (mémoire de travail limitée et volatile)
→ Harnais = Système d'exploitation (gère ce que le CPU voit et quand)
→ Agent = L'application qui s'exécute par-dessus
Votre modèle est puissant.
Mais sans OS pour gérer la mémoire, ordonnancer les tâches et appliquer des règles — ce n'est que du silicium.
La plupart des gens exécutent des applications sans système d'exploitation.
C'est pourquoi leurs agents échouent en production.
3. Ce qui a changé en 2026
LangChain a exécuté le même modèle sur Terminal Bench 2.0 deux fois.
Même modèle. Harnais différent.
→ Ancien harnais : score de 52,8 %
→ Nouveau harnais : score de 66,5 %
Vercel a pris la direction opposée.
Ils ont supprimé 80 % des outils de leur agent.
Résultat ? De meilleures performances.
Pas pire.
La vérité inconfortable de 2026 :
→ L'agent n'a jamais été la partie difficile.
→ Le harnais l'est.
Si 2025 a été l'année où les agents d'IA ont prouvé qu'ils pouvaient écrire du code…
2026 est l'année où nous avons découvert que l'environnement importe plus que le modèle.
PARTIE 2 : LES 5 ARTEFACTS DU HARNAIS (À quoi ressemble un harnais concrètement)
4. Fichiers AGENT.md / CLAUDE.md
L'artefact de harnais le plus universel.
Des fichiers Markdown répartis dans toute votre base de code.
L'agent les lit au début de chaque session — comme des documents d'intégration pour un nouvel ingénieur rejoignant l'équipe.
Ce qu'ils contiennent :
→ Contexte du projet
→ Conventions de codage
→ Décisions architecturales
→ Guide « comment on fait les choses ici »
→ Ce qui est en cours
OpenAI les appelle AGENT.md.
Anthropic les appelle CLAUDE.md.
Cursor utilise .cursorrules.
Noms différents. Même principe.
Un fichier par module principal. Mis à jour au fil de l'évolution du projet.
Sans eux : l'agent commence chaque session à l'aveugle. Avec eux : l'agent commence chaque session informé.
5. Listes de fonctionnalités JSON (Le suivi de progression)
Lorsqu'un agent construit une application complète sur plusieurs sessions, il commence chaque session avec une fenêtre de contexte vierge.
Comment sait-il ce qui est déjà fait ?
Un fichier JSON.
Chaque entrée définit :
→ Une fonctionnalité
→ Comment vérifier qu'elle fonctionne
→ Statut Réussi / Échoué
L'agent lit cela au début de la session. Choisit la fonctionnalité échouée la plus prioritaire. L'implémente. La marque comme réussie. Committe. Répète.
Pourquoi JSON et pas Markdown ?
Anthropic a découvert que les agents sont moins susceptibles de réécrire accidentellement du JSON que du Markdown.
Petit détail. Compte énormément lors d'exécutions autonomes de 6 heures.
6. Routines d'initialisation de session
Chaque session commence de la même façon.
Chaque. Fois.
La séquence de démarrage en 7 étapes d'Anthropic :
- Confirmer le répertoire de travail
- Lire les journaux git et les fichiers de progression
- Vérifier la liste des fonctionnalités pour l'élément incomplet le plus prioritaire
- Démarrer le serveur de développement
- Effectuer une vérification de bout en bout basique
- Implémenter une fonctionnalité
- Committer avec un message descriptif + mise à jour de la progression
Sans cela :
L'agent gaspille ses 20 premières minutes à comprendre ce qui existe déjà.
Chaque session réinvente la roue.
Avec cela :
L'agent commence instantanément informé et passe directement au travail.
7. Contrats de sprint
Avant que l'agent n'écrive une seule ligne de code :
Deux agents négocient.
L'agent générateur propose :
→ Ce qu'il va construire
→ Comment le succès sera vérifié
L'agent évaluateur examine :
→ La proposition est-elle complète ?
→ Les critères de succès sont-ils clairs ?
Ce n'est qu'après l'accord des deux que l'implémentation commence.
C'est une revue de conception.
Sauf que les deux participants sont des IA.
Pourquoi est-ce important ?
Les agents qui planifient et exécutent dans le même passage produisent des résultats peu fiables.
L'étape de planification — même réalisée par l'IA — améliore considérablement la qualité des résultats.
8. Modèles de tâches structurés
Avant tout codage :
Le harnais analyse la base de code réelle.
Il produit une carte d'impact concrète :
→ Chemins de fichiers réels (pas hallucinés)
→ Noms de symboles réels qui existent vraiment
→ Modèles existants à suivre
→ Critères d'acceptation concrets
Ensuite, l'implémentation commence.
Cela semble évident.
Mais la plupart des équipes l'ignorent.
L'agent devine les structures de fichiers. Invente des points d'API qui n'existent pas. Construit quelque chose qui ne correspond pas à la base de code.
Contexte concret avant exécution → résultats considérablement meilleurs.
PARTIE 3 : LES TROIS CAMPS (Trois équipes ont heurté le même mur — et construit trois échelles différentes)
9. OpenAI : L'environnement d'abord
L'équipe Codex d'OpenAI avait un problème absurde.
1 million de lignes de code en production. Zéro écrites à la main.
À cette échelle, vous ne pouvez pas revoir chaque ligne de code.
Alors ils ne l'ont pas fait.
À la place :
Ils ont conçu l'environnement si minutieusement que les agents produisaient d'eux-mêmes un résultat révisable.
Leur approche :
→ Flux de dépendances stricts (Types → Config → Dépôt → Service → Runtime → UI)
→ Fichiers AGENT.md dans toute la base de code
→ Agents branchés directement dans les pipelines CI/CD
La philosophie : Concevez l'environnement. Puis laissez l'agent en liberté.
La preuve : l'application Android Sora. 4 ingénieurs. 28 jours. N°1 sur le Play Store. 99,9 % sans crash.
Codex gérait 70 % des pull requests internes chaque semaine.
10. Anthropic : Séparer l'exécutant du juge
Anthropic avait un problème différent.
Quand ils demandaient à l'agent d'évaluer sa propre production :
Il vantait avec confiance le travail.
Même lorsque, pour un observateur humain, la qualité était manifestement médiocre.
L'auto-évaluation ne fonctionne pas.
L'agent était à la fois l'élève et le professeur.
Et il se donnait des A droits.
Leur correctif : Trois agents spécialisés.
→ Planificateur — transforme une demande de 2 phrases en un cahier des charges complet
→ Générateur — implémente les fonctionnalités un sprint à la fois
→ Évaluateur — utilise l'automatisation du navigateur pour tester l'application en cours d'exécution comme un vrai utilisateur
La leçon : rendre un évaluateur autonome sceptique est bien plus facile que de rendre un générateur critique de son propre travail.
Résultat : Agent seul (sans harnais) : 9 $, 20 min → application cassée. Harnais complet : 200 $, 6 h → logiciel fonctionnel avec UI soignée.
11. ThoughtWorks : Le cadre 2×2
ThoughtWorks est arrivé d'un angle différent.
Ils ne construisaient pas un produit.
Ils regardaient plus de 50 équipes d'ingénierie échouer sur les mêmes problèmes.
Leur leçon : classer chaque contrôle du harnais selon deux axes.
Axe 1 : Quand s'exécute-t-il ?
→ Anticipation = avant que l'agent agisse (guides)
→ Rétroaction = après que l'agent agisse (capteurs)
Axe 2 : Comment fonctionne-t-il ?
→ Computationnel = déterministe, en millisecondes (linters, vérificateurs de types, suites de tests)
→ Inférentiel = utilise un LLM, en secondes (agent de révision de code, analyse sémantique)
Le 2×2 :
→ Anticipation computationnelle : systèmes de types, linters, règles architecturales
→ Rétroaction computationnelle : suites de tests, analyse de couverture, tests de mutation
→ Anticipation inférentielle : documents de spécification, descriptions de contraintes
→ Rétroaction inférentielle : réviseurs de code LLM, validateurs de comportement
Ni l'anticipation seule ni la rétroaction seule ne fonctionnent.
Vous avez besoin des deux.
PARTIE 4 : LES 5 PRINCIPES SUR LESQUELS TOUS LES CAMPS S'ACCORDENT (Trois équipes ne se sont jamais coordonnées. Elles sont arrivées ici indépendamment.)
12. Principe 1 : Le contexte prime sur les instructions
OpenAI : « Donnez une carte, pas un manuel de 1 000 pages. »
Anthropic : Listes de fonctionnalités JSON et fichiers de progression pour que les agents sachent toujours où ils sont.
Red Hat : Analysez la base de code réelle avant de générer des tâches.
ThoughtWorks : « Anticipation. »
Mots différents. Même découverte.
Montrer à l'agent l'état actuel du monde surpasse systématiquement le fait de lui dire abstraitement quoi faire.
→ Concret (chemins réels) : code qui s'adapte à la base de code
→ Vague (description abstraite) : chemins hallucinés et API inventées
La leçon : Avant que l'agent ne tape quoi que ce soit, assurez-vous qu'il sache exactement où il se trouve.
13. Principe 2 : La planification et l'exécution doivent être séparées
OpenAI : les humains conçoivent l'environnement, les agents exécutent.
Anthropic : un agent Planificateur dédié s'exécute avant que le Générateur ne touche au code.
ThoughtWorks : un point de contrôle de révision humaine obligatoire entre la planification et l'implémentation.
Red Hat : Phase 1 (carte d'impact) et Phase 2 (implémentation) avec une barrière stricte entre les deux.
Chaque camp a découvert cela indépendamment :
Laisser un agent planifier et exécuter dans le même passage produit des résultats peu fiables.
L'étape de planification ne doit pas nécessairement être faite par un humain.
Mais elle doit être une étape séparée, dont le résultat est révisé avant que l'implémentation ne commence.
14. Principe 3 : Les boucles de rétroaction sont non-négociables
OpenAI : agents branchés dans les systèmes de CI/CD et d'observabilité.
Anthropic : agent Évaluateur dédié utilisant l'automatisation du navigateur.
ThoughtWorks : formalisé sous le nom de « capteurs ». Averti que les approches d'anticipation seule ne confirment jamais si les guides fonctionnent réellement.
Trois approches du même principe :
→ OpenAI utilise des tests automatisés et CI
→ Anthropic utilise un autre LLM
→ ThoughtWorks dit d'utiliser les deux, en couches
Ils ne sont pas d'accord sur qui fournit la rétroaction.
Ils ne sont pas en désaccord sur le fait que vous en ayez besoin.
Un harnais sans rétroaction n'est qu'une invite avec des étapes supplémentaires.
15. Principe 4 : Une chose à la fois
OpenAI : décompose les objectifs en blocs plus petits, travaille en profondeur d'abord.
Anthropic : impose une fonctionnalité par sprint avec un commit après chaque.
ThoughtWorks : cycle de vie par phases (pré-intégration → post-intégration → surveillance continue).
Les agents qui essaient d'en faire trop à la fois :
→ Épuisent leur contexte
→ Perdent leur cohérence
→ Abandonnent silencieusement des exigences
La routine d'Anthropic :
Lire la progression → Choisir UNE fonctionnalité → Implémenter → Committer → Répéter
L'incrémentalisme forcé est universel dans tous les harnais qui réussissent.
16. Principe 5 : La base de code EST la documentation
OpenAI : intègre les fichiers AGENT.md dans le dépôt.
Anthropic : stocke les listes de fonctionnalités, les fichiers de progression et l'historique Git comme mécanisme de continuité de l'agent.
ThoughtWorks : mesure la « harnaisabilité » — la lisibilité de la base de code pour les agents.
Personne ne maintient une base de connaissances séparée pour l'agent.
Le dépôt est la source unique de vérité.
Si une convention, une contrainte ou une décision architecturale n'est pas dans la base de code — l'agent ne le saura pas.
Implication pratique :
→ Les équipes qui investissent dans l'organisation du code obtiennent de meilleures performances d'agent gratuitement.
→ Dépôts désordonnés + agents IA = chaos, mais à grande échelle.
PARTIE 5 : LE PARADOXE — CONSTRUIRE POUR SUPPRIMER (La vérité la plus contre-intuitive de l'ingénierie du harnais)
17. La dégradation du harnais est réelle
Quand Anthropic est passé d'Opus 4.5 à Opus 4.6 :
La décomposition des sprints — qui avait été essentielle — est devenue du poids mort.
La planification améliorée du modèle l'a rendue redondante.
Un composant du harnais qui était porteur en mars était un surcoût en avril.
Puis Opus 4.7 est arrivé.
Le modèle a commencé à vérifier ses propres résultats.
La description de poste de l'agent Évaluateur a commencé à rétrécir.
C'est la dégradation du harnais.
Chaque composant d'un harnais code une hypothèse sur ce que le modèle ne peut pas faire.
À mesure que les modèles s'améliorent → ces hypothèses expirent → le composant devient un surcoût.
Opus 4.5 : décomposition des sprints + évaluation par sprint
Opus 4.6 : pas de décomposition des sprints + évaluation en un seul passage (économie de 38 % de coûts)
Opus 4.7 : le modèle commence à s'auto-vérifier → le rôle de l'évaluateur se réduit encore
18. Construire pour supprimer
Le conseil de Philipp Schmid :
« Construisez pour supprimer. »
Concevez chaque composant du harnais pour qu'il soit amovible.
Testez chaque composant périodiquement en le désactivant et en mesurant si la qualité des résultats change.
Si elle ne change pas : supprimez-le.
Manus a refactoré son harnais 5 fois en 6 mois. LangChain a restructuré 3 fois en 1 an. Vercel a supprimé 80 % des outils → a obtenu de meilleures performances.
Ces exemples ne sont pas des signes de mauvaise ingénierie.
Ils sont la conséquence naturelle de construire sur des modèles qui s'améliorent rapidement.
Transporter des composants de harnais obsolètes coûte des jetons à chaque exécution. Zéro qualité supplémentaire. Un pur gaspillage.
19. La réalité des coûts
Les chiffres honnêtes du test A/B d'Anthropic :
→ Agent seul (sans harnais) : 9 $, 20 minutes → UI fonctionnelle, fonctionnalité centrale cassée
→ Harnais complet (Opus 4.5) : 200 $, 6 heures → logiciel fonctionnel, UI soignée, physique correcte
C'est une augmentation de coût de 22 fois.
Pour un produit fonctionnel vs une démo qui a l'air correcte seulement sur des captures d'écran.
Que cela soit coûteux ou bon marché dépend entièrement de ce qu'une version défaillante coûte à votre équipe.
Mais voici ce dont personne ne parle :
La combinaison harnais + modèle évolue.
Le harnais à 200 $ est devenu 124 $ avec une seule mise à niveau de modèle.
La tendance :
→ Meilleur modèle = harnais plus simple = exécution moins chère = résultat plus rapide
Les ingénieurs qui gagnent en 2026 n'écrivent pas le meilleur code.
Ils conçoivent les meilleures contraintes.
Et puis ils sont prêts à jeter ces contraintes dès qu'elles cessent de rapporter leur valeur.
CONCLUSION
Tout ce que vous venez d'apprendre :
Ce qu'est un harnais :
→ 1. Agent = Modèle + Harnais
→ 2. Modèle = CPU. Harnais = Système d'exploitation.
→ 3. Même modèle, meilleur harnais = +13 % de performance
Les 5 artefacts du harnais :
→ 4. CLAUDE.md / AGENT.md — documents d'intégration pour agents
→ 5. Listes de fonctionnalités JSON — suivi de progression + suite de tests en un seul fichier
→ 6. Routines d'initialisation de session — même démarrage en 7 étapes à chaque fois
→ 7. Contrats de sprint — les agents négocient avant de coder
→ 8. Modèles de tâches structurés — chemins réels, motifs réels
Les trois camps :
→ 9. OpenAI : concevoir l'environnement, laisser l'agent libre
→ 10. Anthropic : séparer l'exécutant du juge
→ 11. ThoughtWorks : cadre 2×2 anticipation/rétroaction
Les 5 principes universels :
→ 12. Le contexte prime sur les instructions
→ 13. La planification et l'exécution doivent être séparées
→ 14. Les boucles de rétroaction sont non-négociables
→ 15. Une chose à la fois
→ 16. La base de code est la documentation
Le paradoxe :
→ 17. Dégradation du harnais — ce qui fonctionnait le mois dernier nuit ce mois-ci
→ 18. Construire pour supprimer — tester et retirer les composants obsolètes
→ 19. La réalité des coûts — meilleur modèle = harnais plus simple = exécution moins chère
Les ingénieurs qui gagnent en 2026 n'écrivent pas le meilleur code.
Ils conçoivent les meilleures contraintes.
Et ils sont prêts à jeter ces contraintes dès qu'elles cessent de rapporter leur valeur.
Si cela vous a été utile :
→ Repostez pour toucher les développeurs de votre réseau
→ Suivez @sairahul1 pour plus de contenu comme celui-ci chaque semaine
→ Mettez ceci en favori — vous y reviendrez quand vos agents commenceront à mal se comporter
J'écris sur l'IA, la construction de produits, et ce qui fonctionne réellement en 2026.
