Harness Engineering: Build Systems Around AI Agents (2026)

TL;DR

Qu'est-ce que le Harness Engineering ?

Le Harness Engineering est la discipline consistant à construire des systèmes, des outils, des contraintes et des boucles de rétroaction autour des agents de codage IA pour les rendre fiables et productifs.

Le terme a été forgé par Mitchell Hashimoto (co-fondateur de HashiCorp) et a attiré l'attention du grand public lorsque OpenAI a publié son article sur Codex sur le sujet au début de l'année 2026.

L'idée centrale est simple :

Agent = Modèle + Harness

Le modèle fournit l'intelligence. Le harness rend cette intelligence utile. Un meilleur harness est souvent plus important qu'un meilleur modèle.

Pourquoi c'est important maintenant

En 2025, toutes les équipes ont adopté des agents de codage IA. En 2026, les équipes gagnantes sont celles qui ont conçu l'environnement de leurs agents (engineered their agent environments) — et pas seulement choisi le meilleur modèle.

Le principe directeur de Mitchell Hashimoto :

"Chaque fois que vous constatez qu'un agent fait une erreur, prenez le temps de concevoir une solution technique pour que l'agent ne refasse plus jamais cette erreur."

Il ne s'agit pas de prompt engineering. C'est de l'ingénierie système pour l'IA.

La preuve : Harness > Modèle

LangChain a mené une expérience contrôlée sur Terminal Bench 2.0. Sans changer le modèle sous-jacent, ils ont amélioré la précision de leur agent de codage de 52,8 % à 66,5 % — une amélioration de 26 % — uniquement en améliorant le harness.

Les changements comprenaient :

• De meilleurs fichiers de contexte (AGENTS.md)


• Des contraintes de sortie structurées


• Des boucles d'auto-vérification


• L'optimisation des outils

Les 7 composants d'un Harness

1. Ingénierie de contexte (Context Engineering)

L'ingénierie de contexte est le socle. C'est là que vous donnez à l'agent une carte de votre base de code, vos conventions et vos contraintes.

• Fichiers CLAUDE.md / AGENTS.md à la racine de votre dépôt
• Cartographies de répertoires et aperçus d'architecture
• Règles de style de code et conventions de nommage

# Exemple CLAUDE.md
## Architecture
- src/app/ — Pages du router Next.js app
- src/lib/ — Utilitaires partagés et clients API
- src/components/ — Composants React (styles colocalisés)

## Règles
- Utiliser des server components par défaut
- Ne jamais importer directement depuis node_modules dans les composants
- Tous les appels API passent par src/lib/api.ts

2. Contraintes architecturales

Au lieu d'espérer que l'agent choisisse la bonne architecture, imposez-la.

• Architectures en couches rigides validées par des linters
• Tests structurels qui échouent si les patterns ne sont pas respectés
• Restrictions d'importation via des règles ESLint ou des scripts personnalisés

3. Outils & serveurs MCP

Les agents ont besoin d'outils pour être efficaces. Les meilleurs harnesses exposent l'outillage interne via :

• Wrappers CLI — préférez les CLI connus (git, docker, npm) aux outils personnalisés
• Serveurs MCP (Model Context Protocol) — laissez les agents appeler vos API internes, bases de données et services
• Accès au système de fichiers — limité à des répertoires spécifiques pour éviter les dommages accidentels

4. Sous-agents & pare-feux de contexte

Les sessions d'agents de longue durée accumulent un contexte qui finit par dégrader les performances — c'est ce qu'on appelle la pourriture de contexte (context rot).

La solution : des sous-agents avec des pare-feux de contexte.

• Décomposer les tâches complexes en sous-tâches distinctes
• Chaque sous-tâche s'exécute dans sa propre session avec un contexte neuf
• Ne passer que des résultats structurés entre les agents, pas la conversation brute

1. Agent Initialisateur — planifie le travail, crée une liste de fonctionnalités
2. Agent de Codage — exécute chaque fonctionnalité de manière isolée

5. Hooks & contre-pression (Back-Pressure)

Des boucles de rétroaction automatisées qui capturent les erreurs avant qu'elles ne s'accumulent :

• Hooks de pré-commit — vérification de type, linting, formatage
• Test runners — les agents doivent exécuter les tests après chaque modification
• Vérification de build — échouer rapidement en cas de build cassé

6. Boucles d'auto-vérification

Forcez les agents à vérifier leur propre travail avant de marquer les tâches comme terminées :

• Exécuter la suite de tests après les modifications
• Vérifier que le build passe
• Vérifier que la sortie correspond à la spécification
• Prendre une capture d'écran et comparer (pour le travail sur l'UI)

7. Documentation de progression

Pour les tâches de longue durée (plus de 30 minutes) :

• Maintenir un fichier de progression qui suit les étapes terminées
• Commiter le travail fréquemment pour que les sessions suivantes puissent continuer
• Utiliser des listes de tâches structurées plutôt que des notes libres

Résultats concrets

Équipe OpenAI Codex

3 ingénieurs ont produit une base de code d'un million de lignes sans aucun code écrit manuellement sur une période de 5 mois. Ils ont atteint une moyenne de 3,5 PR mergées par ingénieur et par jour — un débit impossible sans un harness mature.

Leur harness comprenait : des conventions de commit strictes, des tests automatisés sur chaque PR et des pipelines CI/CD adaptés aux agents.

Les "Minions" de Stripe

Le système interne de Stripe produit plus de 1 000 PR mergées par semaine à l'aide d'agents IA. Leur harness comprend :

• Des définitions de tâches au périmètre étroit
• Une revue de code obligatoire par des humains
• Des tests de régression automatisés
• L'automatisation des rollbacks

L'architecture à deux agents d'Anthropic

Anthropic a publié son approche des harnesses efficaces pour les agents de longue durée :

• Listes de fonctionnalités structurées comme format de transfert entre les agents
• Suivi de progression basé sur Git pour que les agents puissent reprendre après une interruption
• Critères de sortie explicites pour que les agents sachent quand s'arrêter

Comment commencer à construire votre Harness

Étape 1 : Créez votre fichier de contexte

Ajoutez un CLAUDE.md (ou AGENTS.md) à la racine de votre projet :

# Projet : [Votre Projet]

## Stack
[Framework, langage, base de données, hébergement]

## Architecture
[Structure des répertoires avec descriptions d'une ligne]

## Règles
[5 à 10 règles strictes que l'agent doit suivre]

## Tâches courantes
[Comment lancer les tests, build, déployer]

Étape 2 : Ajoutez des contraintes structurelles

# Exemple : règle ESLint empêchant les imports directs de DB dans les composants
# .eslintrc — règle no-restricted-imports

Configurez des hooks de pré-commit qui appliquent vos règles automatiquement.

Étape 3 : Construisez des boucles de vérification

Assurez-vous que votre agent peut :

1. Lancer les tests (npm test, pytest, etc.)


2. Vérifier les types (tsc --noEmit, mypy)


3. Linter (eslint ., ruff check)

Étape 4 : Limitez la portée des sessions d'agent

Ne donnez pas tout votre backlog à un agent. À la place :

• Une fonctionnalité par session
• Un correctif de bug par session
• Des critères d'acceptation clairs pour chaque tâche

Étape 5 : Itérez sur le Harness

Chaque fois qu'un agent fait une erreur :

1. Identifiez la cause racine
2. Ajoutez une règle, une contrainte ou un hook qui l'empêche
3. Testez le correctif

Harness Engineering vs. Prompt Engineering

Le prompt engineering reste utile, mais ce n'est qu'une petite partie de l'équation. Le harness engineering est le multiplicateur.

À ne pas confondre avec : Harness.io

Si vous avez cherché "Harness Engineering" en quête de la plateforme DevOps — Harness.io est une entité totalement distincte. C'est une plateforme CI/CD propulsée par l'IA, valorisée à 5,5 milliards de dollars (en décembre 2025), qui propose de l'intégration continue, du déploiement, des feature flags, de la gestion des coûts cloud et des tests de sécurité.

Bien que Harness.io et le harness engineering partagent le même nom, ils résolvent des problèmes différents. Il existe toutefois un chevauchement intéressant : le DevOps assisté par IA de Harness.io est sans doute une application des principes de harness engineering au pipeline de déploiement.

L'essentiel

Le modèle est le moteur. Le harness est la voiture. Personne ne gagne une course avec seulement un moteur.

Si vous utilisez des agents de codage IA en 2026 sans investir dans votre harness, vous passez à côté de l'essentiel de la valeur. Commencez par un fichier de contexte, ajoutez des contraintes, construisez des boucles de vérification et itérez chaque fois que quelque chose casse.

Les équipes qui livrent le plus rapidement n'utilisent pas de meilleurs modèles. Elles utilisent de meilleurs harnesses.