---
title: Forkez le harnais de votre agent, gardez le meilleur
description: Tout ce qu’on peut modifier autour d’un agent de code n’est que du code et du texte. À l’AGNTCon + MCPCon Europe, Fausto Albers a montré comment son équipe l’améliore. L’éval reste hors de la boucle, le coût par changement accepté dit quand une boucle très occupée a calé, et un méta-agent fait tourner plusieurs variantes du harnais sur la même tâche et garde la meilleure.
date: 2026-10-11
tags: agents IA, harness engineering, évaluations, Claude Code, ingénierie agentique
---

Tout ce qu’on peut modifier autour d’un agent de code n’est que du code et du texte : le CLAUDE.md, les sous-agents, les skills, les outils, la politique de mémoire. Alors quand votre boucle d’agent cale, ne pariez pas sur un seul correctif. À l’AGNTCon + MCPCon Europe à Amsterdam, Fausto Albers a montré la méthode de son équipe : un méta-agent écrit plusieurs versions du harnais (harness), les fait toutes tourner sur la même tâche face à une éval placée hors de la boucle, et garde celle qui gagne sur ce que vous comptez comme coût. Les perdantes sont stockées aussi.

Il ouvre sur une ironie. Attention is all you need, et voilà que l’attention est devenue la ressource rare. Depuis 2022, le travail qu’il peut confier à l’IA a énormément grandi, et son attention n’a pas suivi cette courbe. Ses agents prennent des milliers de décisions vers des objectifs qu’il leur fixe, et il n’est pas là pour la plupart d’entre elles. D’où la question du talk : comment construire un système qui sait ce qui compte pour vous, et ce que vous comptez comme un coût ?

## Une poutre en acier, dessinée en 2D

Fausto dirige WonderWhy, qui travaille étroitement avec le laboratoire d’IA appliquée aux jumeaux numériques industriels de l’Amsterdam University of Applied Sciences, et il a cofondé l’AI Builders Club à Amsterdam. Il a une formation de sociologue et a possédé des bars à cocktails et des restaurants. C’est comme ça qu’il est arrivé dans la tech : une startup qui utilisait le machine learning pour prédire les préférences gustatives des clients de l’hôtellerie-restauration.

Son cas vient d’une entreprise du secteur de l’acier. Ses machines CNC savent quoi faire dès qu’elles reçoivent des instructions compilées à partir d’un modèle 3D valide. Mais beaucoup de ses clients ne reçoivent jamais de modèle CAO 3D. Ils reçoivent un plan PDF 2D de la poutre, une copie avec perte du modèle 3D, et un ingénieur formé reconstitue le reste à la main.

Il y a quelques mois encore, transformer ce plan en modèle 3D n’était pas possible, et son équipe s’est retrouvée bloquée. Alors ils ont interrogé les ingénieurs. Chacun avait le PDF à gauche et un logiciel de CAO à droite, et reconstruisait la poutre étape par étape : en se trompant, en se corrigeant, en se construisant une représentation spatiale de la pièce dans la tête. C’est exactement ce qu’ils ont laissé faire aux agents, et ça marche. Ils l’ont livré en septembre. Ça coûte encore un peu d’argent à faire tourner, et ils entraînent un modèle open source sur le supercalculateur néerlandais pour que ça ne coûte presque plus rien.

<figure class="fd-fig hx-case" aria-labelledby="hx1-cap" data-desc="Le cas de l’acier. Ce que le client envoie : un plan PDF 2D de la poutre, une copie avec perte du modèle 3D qu’il faut un ingénieur formé pour lire. Ce qu’il faut à la machine CNC : des instructions compilées à partir d’un modèle CAO 3D valide. Les ingénieurs travaillent avec le PDF à gauche et la CAO à droite, et reconstruisent la poutre étape par étape : dessiner une partie, repérer l’erreur, la corriger, continuer. L’équipe de Fausto a laissé les agents faire tourner cette même boucle.">
<div class="mp-two-row">
<div class="mp-two-card">
<p class="mp-two-who">Ce que le client envoie</p>
<p class="mp-two-name">PDF 2D</p>
<svg class="mp-two-art" viewBox="0 0 300 120" aria-hidden="true">
<path class="hx-axis" d="M10,54 H250"/>
<rect class="hx-drw" x="20" y="34" width="220" height="40"/>
<path class="hx-fl" d="M20,40 H240 M20,68 H240"/>
<circle class="hx-hole" cx="44" cy="54" r="4"/><circle class="hx-hole" cx="216" cy="54" r="4"/>
<path class="hx-dim" d="M20,92 H240 M20,86 V98 M240,86 V98"/>
<text class="mp-art-t" x="130" y="110" text-anchor="middle">L</text>
<path class="hx-dim" d="M234,34 L256,14 H290"/>
<path class="hx-sym" d="M266,14 L272,23 L278,14 Z"/>
<rect class="hx-sym-ring" x="259" y="5" width="26" height="24"/>
</svg>
<p class="mp-two-line">Une copie avec perte du modèle 3D</p>
<p class="mp-two-line">Il faut un ingénieur formé pour le lire</p>
</div>
<p class="mp-two-vs hx-cycle" aria-hidden="true">⇄</p>
<div class="mp-two-card mp-two-peter">
<p class="mp-two-who">Ce qu’il faut à la machine CNC</p>
<p class="mp-two-name">CAO 3D</p>
<svg class="mp-two-art" viewBox="0 0 300 120" aria-hidden="true">
<polygon class="hx-face hx-top" points="30,52 72,52 252,12 210,12"/>
<polygon class="hx-face-wrong hx-wrong" points="30,52 72,52 226,30 184,30"/>
<polygon class="hx-face hx-side hx-right" points="72,52 72,94 252,54 252,12"/>
<g class="hx-holes"><circle class="hx-hole" cx="99" cy="67" r="3.5"/><circle class="hx-hole" cx="225" cy="39" r="3.5"/></g>
<rect class="hx-face-front" x="30" y="52" width="42" height="42"/>
<text class="mp-art-t hx-t1" x="30" y="114">dessiner le bout</text>
<text class="mp-art-t hx-t2" x="30" y="114">repérer l’erreur</text>
<text class="mp-art-t hx-t3" x="30" y="114">la corriger</text>
<text class="mp-art-t hx-t4" x="30" y="114">continuer</text>
</svg>
<p class="mp-two-line">Instructions compilées d’un modèle 3D valide</p>
<p class="mp-two-line">Reconstruit pas à pas, erreurs comprises</p>
</div>
</div>
<p class="mp-strip"><b>La boucle</b><span>Les ingénieurs : le PDF à gauche, la CAO à droite. Désormais, les agents font tourner la même boucle.</span></p>
<figcaption id="hx1-cap">Le cas de l’acier, dessiné pour cette note et non tiré des fichiers du client. Gardez un œil sur le petit symbole en haut à droite du plan : il reviendra plus tard.</figcaption>
</figure>

Puis la phrase qui prépare tout le reste du talk : son équipe n’a pas écrit une seule ligne de cette application. Elle a conçu le système qui l’a construite.

## Le harnais, c’est la partie que vous pouvez modifier

Sa petite histoire des dernières années : le prompt engineering, puis le context engineering, et maintenant il s’agit de concevoir le harnais et de faire tourner la boucle.

Il est précis sur ce que « harnais » veut dire ici. Deux choses qu’il ne peut pas changer : le modèle de fondation, et le harnais extérieur, c’est-à-dire l’environnement de code, Claude Code, Codex ou ce que vous utilisez. Tout ce qu’il y a à l’intérieur, il peut le changer, et ce n’est que du code et du texte :

- les instructions, CLAUDE.md et AGENTS.md
- les sous-agents, leurs rôles et leur coordination
- le contexte
- la politique de mémoire (« pas d’apprentissage sans mémoire »)
- les skills et les fonctions

Ça fait beaucoup de boutons. Réglez-les autrement et la même tâche donne un autre résultat. Et dans la pratique, dit-il, les agents construisent déjà ces harnais, eux aussi.

<figure class="fd-fig hx-anat" aria-labelledby="hx2-cap" data-desc="Ce que vous pouvez changer, et ce que vous ne pouvez pas changer. Impossible à changer : le modèle de fondation, et l’environnement de code comme Claude Code ou Codex. Modifiable, parce que ce n’est que du code et du texte : les instructions dans CLAUDE.md et AGENTS.md, les sous-agents et leurs rôles, leur coordination, le contexte, la politique de mémoire, puisqu’il n’y a pas d’apprentissage sans mémoire, les skills et les fonctions. Réglez ces boutons autrement et la même tâche donne un autre résultat.">
<div class="hx-anat-in">
<div class="hx-fixed">
<p class="hx-k">Non modifiable</p>
<p class="hx-fixed-row"><b>Modèle de fondation</b></p>
<p class="hx-fixed-row"><b>Environnement de code</b><span>Claude Code, Codex…</span></p>
</div>
<div class="hx-edit">
<p class="hx-k">Modifiable · du code et du texte</p>
<ul class="hx-knobs">
<li><i aria-hidden="true"></i>Instructions<span>CLAUDE.md, AGENTS.md</span></li>
<li><i aria-hidden="true"></i>Sous-agents<span>leurs rôles</span></li>
<li><i aria-hidden="true"></i>Coordination<span>comment ils collaborent</span></li>
<li><i aria-hidden="true"></i>Contexte<span>ce que chacun voit</span></li>
<li class="hx-knob-mem"><i aria-hidden="true"></i>Politique de mémoire<span>pas d’apprentissage sans mémoire</span></li>
<li><i aria-hidden="true"></i>Skills et fonctions<span>ce qu’ils savent faire</span></li>
</ul>
</div>
</div>
<p class="mp-strip"><b>Même tâche</b><span>Réglez les boutons autrement, et le résultat change.</span></p>
<figcaption id="hx2-cap">Son découpage du harnais, à 6:29 dans le talk. La politique de mémoire est mise en avant à cause de sa phrase à son sujet.</figcaption>
</figure>

## Gardez le juge hors de la boucle

Autour du harnais tourne la boucle : agir, vérifier le résultat, recommencer. La vérification ne peut pas vivre dans le harnais. Plus les modèles deviennent capables, plus ils excellent au reward hacking, donc l’éval doit se trouver hors du système. Ce peut être un agent ou du simple code déterministe. Ce qui compte, c’est qu’elle ne fasse pas partie de ce qui est noté.

Le retour atterrit dans des fichiers sur disque, et ces fichiers servent d’entrée à l’itération suivante. Chaque tour de boucle peut donc repartir d’une fenêtre de contexte vierge au lieu d’une conversation toujours plus longue. Ça compte aussi pour le coût : ma [note TokenOps](/fr/notes/tokenops-agent-cost-curve.html) explique comment le coût en entrée d’une longue conversation d’agent croît avec le carré du nombre de tours.

<figure class="fd-fig hxl" aria-labelledby="hx3-cap" data-desc="La boucle autour du harnais, avec le juge à l’extérieur. Une limite en pointillés marque le système qu’on améliore. À l’intérieur : le harnais, la partie modifiable, qui exécute la tâche, et les fichiers sur disque où le retour est enregistré. À l’extérieur : l’éval, un agent ou du simple code déterministe, jamais ce qui est noté. Elle doit rester dehors parce que plus le modèle est capable, plus il sait tricher avec une vérification qu’il peut atteindre. La boucle : le résultat du harnais franchit la limite vers l’éval ; la note de l’éval revient et est enregistrée sous forme de fichiers ; l’itération suivante lit ces fichiers et démarre avec une fenêtre de contexte vierge, et la boucle repart.">
<div class="hxl-in">
<div class="hxl-grid" role="group" aria-label="Le harnais agit, son résultat part vers une éval hors du système, la note revient sous forme de fichiers sur disque, et le tour suivant repart de ces fichiers dans une fenêtre de contexte vierge">
  <p class="hxl-sys">Le système qu’on améliore</p>
  <p class="hxl-out">En dehors</p>
  <div class="hxl-node hxl-act">
    <p class="hxl-step"><b>1</b> Agir</p>
    <h3>Harnais</h3>
    <p>Exécute la tâche. La partie modifiable.</p>
  </div>
  <div class="hxl-link hxl-l1" aria-hidden="true"><span>résultat</span><i></i></div>
  <div class="hxl-node hxl-eval">
    <p class="hxl-step"><b>2</b> Vérifier</p>
    <h3>Éval</h3>
    <p>Un agent ou du code déterministe. Jamais ce qui est noté.</p>
  </div>
  <div class="hxl-link hxl-l2" aria-hidden="true"><span>note</span><i></i></div>
  <div class="hxl-node hxl-mem">
    <p class="hxl-step"><b>3</b> Retenir</p>
    <h3>Fichiers sur disque</h3>
    <p>Le retour, enregistré en fichiers.</p>
  </div>
  <div class="hxl-link hxl-l3" aria-hidden="true"><span>tour suivant, contexte vierge</span><i></i></div>
</div>
</div>
<figcaption id="hx3-cap">La boucle qu’il a décrite. Le harnais et ses fichiers sont à l’intérieur des pointillés ; l’éval est à l’extérieur, parce que plus le modèle est capable, plus il sait tricher avec une vérification qu’il peut atteindre.</figcaption>
</figure>

## Surveillez le coût par changement accepté

Le chiffre qu’il trouve le plus utile, c’est le coût par changement accepté. Chaque itération coûte quelque chose, et l’éval est votre indicateur de progression vers l’objectif. Quand le coût continue de monter et que la progression stagne, vous avez atteint les rendements décroissants. La boucle a toujours l’air très occupée. Votre carte bancaire, elle, brûle.

C’est le moment de s’arrêter et de se demander ce qui manque au harnais, puisque ce n’est que du code et du texte que vous pouvez changer.

Et le coût ne veut pas seulement dire des euros. Si un client a un budget à six chiffres et que le problème, c’est le temps, dépenser beaucoup de tokens peut être le choix raisonnable.

<figure class="fd-fig hx-cost-fig" aria-labelledby="hx4-cap" data-desc="Un schéma du coût par changement accepté, sans données réelles. Au fil des itérations de la boucle, la progression telle que l’éval la note monte vite, puis s’aplatit. Le coût par changement accepté reste bas au début, puis grimpe. Au-delà du point où la progression stagne commence la zone des rendements décroissants : la boucle a toujours l’air occupée, et la carte bancaire brûle. C’est le signal pour se demander ce qui manque au harnais.">
<div class="fd-canvas">
<svg viewBox="0 0 440 228" role="img" aria-labelledby="hx4-title hx4-desc">
<title id="hx4-title">Coût par changement accepté, schéma</title>
<desc id="hx4-desc">Au fil des itérations de la boucle, la progression monte vite puis s’aplatit, tandis que le coût par changement accepté reste bas puis grimpe. Au-delà du plateau commence la zone des rendements décroissants : la boucle a l’air occupée et la carte brûle.</desc>
<rect class="hx-band" x="262" y="20" width="162" height="200"/>
<path class="hx-axis-l" d="M40,20 V220 H424"/>
<path id="hx4-cost" class="hx-cost" d="M40,212 C140,210 220,200 262,180 S370,128 424,104"/>
<path class="hx-prog" d="M40,216 C100,130 170,84 262,72 S380,66 424,64"/>
<rect class="hx-stall" x="256" y="66" width="12" height="12"/>
<g class="fd-token fd-token-ui"><rect x="-5" y="-5" width="10" height="10"><animateMotion dur="6s" repeatCount="indefinite"><mpath href="#hx4-cost"/></animateMotion></rect></g>
</svg>
</div>
<p class="hx-axis-x" aria-hidden="true">itérations de la boucle →</p>
<ul class="hx-key" aria-hidden="true">
<li><i></i>la progression, notée par l’éval</li>
<li><i class="hx-key-cost"></i>coût par changement accepté</li>
<li><i class="hx-key-band"></i>rendements décroissants : la boucle a l’air occupée, la carte brûle</li>
</ul>
<p class="mp-strip"><b>Quand la courbe tourne</b><span>Arrêtez-vous et demandez-vous ce qui manque au harnais.</span></p>
<figcaption id="hx4-cap">La forme qu’il a décrite à 8:47, dessinée en schéma sans données : les courbes illustrent, elles ne mesurent rien. Le carré marque l’endroit où la progression stagne.</figcaption>
</figure>

## Trois harnais, une tâche

Voici la partie que je volerais. Quand une boucle cale, le réflexe habituel, c’est de réfléchir à ce qui pourrait être différent, d’écrire une nouvelle version du harnais et de l’essayer. L’équipe de Fausto confie plutôt ça à un méta-agent : un agent, ou un système plus gros, qui lit tous les signaux que produit le harnais de code.

Le méta-agent n’écrit pas un nouveau harnais. Il en écrit trois, ou beaucoup plus. L’un reçoit d’autres instructions, un autre change l’ordre du travail, un troisième ajoute ou retire un outil. Chaque version exécute la même tâche, l’éval la note, et vous comparez le résultat et le coût avec l’original.

Chaque version entre dans une base de données comme instantané de l’environnement de code. Celle qui s’en sort le mieux, selon ce qui compte pour vous, devient le nouveau harnais. Les autres restent dans la base avec leurs évals et leurs traces, parce qu’elles pourraient servir : ce qui a réglé un problème dans un projet pourrait en régler un dans le suivant.

<figure class="fd-fig hx-var" aria-labelledby="hx5-cap" data-desc="Trois harnais, une tâche. Un méta-agent lit tous les signaux que produit le harnais de code et écrit des variantes : une avec d’autres instructions, une avec un autre ordre de travail, une avec un outil ajouté ou retiré. L’original et les variantes exécutent tous la même tâche, et une éval externe note chacun sur le résultat et le coût, le coût étant ce qui compte pour vous en ce moment. Le meilleur est gardé comme nouveau harnais. Chaque version entre dans une base d’instantanés avec son éval et ses traces, les perdantes aussi, pour qu’on retrouve ce qui a marché dans le projet suivant.">
<div class="hx-var-in">
<p class="hx-meta"><b>Méta-agent</b><span>lit les signaux, écrit les variantes</span></p>
<ol class="hx-lanes">
<li class="hx-lane"><p class="hx-lane-name">Original<span>le harnais tel quel</span></p><p class="hx-run" aria-hidden="true"><i></i></p><p class="hx-score">stocké</p></li>
<li class="hx-lane"><p class="hx-lane-name">Variante A<span>autres instructions</span></p><p class="hx-run" aria-hidden="true"><i></i></p><p class="hx-score">stockée</p></li>
<li class="hx-lane hx-lane-win"><p class="hx-lane-name">Variante B<span>autre ordre de travail</span></p><p class="hx-run" aria-hidden="true"><i></i></p><p class="hx-score">gardée</p></li>
<li class="hx-lane"><p class="hx-lane-name">Variante C<span>un outil en plus ou en moins</span></p><p class="hx-run" aria-hidden="true"><i></i></p><p class="hx-score">stockée</p></li>
</ol>
<div class="hx-db">
<p class="hx-db-h">Base d’instantanés</p>
<p class="hx-db-row">Chaque version, son éval et ses traces. Les perdantes aussi.</p>
<p class="hx-cells" aria-hidden="true"><i></i><i></i><i></i><i></i><i></i><i></i><i></i><i></i><i></i><i></i><i class="new"></i><i class="new"></i><i class="new on"></i><i class="new"></i></p>
</div>
</div>
<p class="mp-strip"><b>Même tâche</b><span>Résultat et coût, le coût étant ce qui compte pour vous en ce moment.</span></p>
<figcaption id="hx5-cap">Un schéma de l’étape des variantes, à 10:01 dans le talk. La variante gagnante est ici arbitraire ; dans son récit, c’est celle que l’éval note le mieux sur ce qui compte pour vous.</figcaption>
</figure>

Pendant les questions, quelqu’un l’a interrogé sur les optimiseurs de prompts comme GEPA. Il en a utilisé dans MLflow sur un autre projet, ainsi que DSPy, et voit tout ça comme une forme d’apprentissage par renforcement, d’algorithmes évolutionnaires. Pour aller plus loin, il a cité l’article [Hyperagents](https://arxiv.org/abs/2603.19461) de Meta, qui s’appuie sur la [Darwin Gödel Machine](https://arxiv.org/abs/2505.22954), et [JIT-Agent](https://arxiv.org/abs/2608.25593), qui entraîne un modèle open source à générer des harnais. Il utilise aussi celui-là.

## Le symbole que personne n’avait mis dans le harnais

L’exemple qui a rendu tout ça concret vient du projet acier. Un harnais donnait au pipeline, la version A, un moyen de recadrer les plans techniques et de zoomer sur les détails. Ce qu’il ignorait, c’est que certains tout petits symboles sur ces plans sont très importants. Cette connaissance n’était pas dans le harnais.

Les évals ont calé. C’est un signal, mais il ne dit pas ce qui ne va pas ni quoi changer. Ils ont exploré beaucoup de pistes et ont abouti à une base de données de ces symboles. Le harnais suivant a donné au pipeline un moyen de les consulter, et c’est devenu la règle à partir de là.

<figure class="fd-fig hx-sym-fig" aria-labelledby="hx6-cap" data-desc="L’histoire du symbole en trois étapes. Un : la version A du harnais permet au pipeline de recadrer le plan et de zoomer sur les détails, mais elle ne sait pas que les petits symboles comptent. Deux : les évals calent, ce qui est un signal mais pas un diagnostic, puisque ça ne dit pas ce qui manque. Trois : le harnais suivant donne au pipeline un moyen de consulter les symboles dans une base de données. Cette consultation est devenue la règle pour les harnais suivants.">
<ol class="mp-trio">
<li class="mp-trio-step">
<svg class="mp-grow-art" viewBox="0 0 120 110" aria-hidden="true">
<rect class="hx-drw" x="8" y="10" width="104" height="30"/>
<circle class="hx-hole" cx="24" cy="25" r="3"/><circle class="hx-hole" cx="96" cy="25" r="3"/>
<path class="hx-sym" d="M100,3 L104,9 L108,3 Z"/>
<rect class="hx-crop" x="14" y="15" width="20" height="20"/>
<path class="hx-dim" d="M14,35 L20,56 M34,35 L100,56"/>
<rect class="hx-zoom" x="20" y="56" width="80" height="46"/>
<circle class="hx-hole" cx="60" cy="79" r="12"/>
</svg>
<p class="mp-trio-n"><b>1</b>Version A</p>
<p class="mp-trio-what">Recadre le plan et zoome dedans. Ignore que les petits symboles comptent</p>
</li>
<li class="mp-trio-step">
<svg class="mp-grow-art" viewBox="0 0 120 110" aria-hidden="true">
<path class="hx-axis-l" d="M10,10 V96 H112"/>
<path class="hx-prog" d="M10,90 C28,62 48,46 68,44 L112,44"/>
<rect class="hx-stall" x="64" y="40" width="8" height="8"/>
<text class="hx-q" x="92" y="30" text-anchor="middle">?</text>
</svg>
<p class="mp-trio-n"><b>2</b>Les évals calent</p>
<p class="mp-trio-what">Un signal, pas un diagnostic : rien ne dit ce qui manque</p>
</li>
<li class="mp-trio-step">
<svg class="mp-grow-art" viewBox="0 0 120 110" aria-hidden="true">
<rect class="hx-drw" x="4" y="44" width="28" height="28"/>
<path class="hx-sym" d="M11,52 L18,64 L25,52 Z"/>
<path class="hx-dim" d="M34,58 H44"/><path class="hx-sym" d="M44,54 L50,58 L44,62 Z"/>
<rect class="hx-drw" x="54" y="14" width="60" height="80"/>
<path class="hx-fl" d="M54,30 H114 M54,46 H114 M54,62 H114 M54,78 H114"/>
<circle class="hx-mini" cx="62" cy="22" r="3"/><rect class="mp-ln" x="70" y="21" width="36" height="3"/>
<rect class="hx-mini" x="59" y="35" width="6" height="6"/><rect class="mp-ln" x="70" y="37" width="30" height="3"/>
<path class="hx-sym" d="M58,51 L62,58 L66,51 Z"/><rect class="mp-ln" x="70" y="53" width="38" height="3"/>
<path class="hx-mini" d="M58,70 H66 M62,66 V74"/><rect class="mp-ln" x="70" y="69" width="26" height="3"/>
<circle class="hx-mini" cx="62" cy="86" r="3"/><rect class="mp-ln" x="70" y="85" width="34" height="3"/>
<rect class="hx-scan" x="55" y="15" width="58" height="14"/>
</svg>
<p class="mp-trio-n"><b>3</b>Consulter</p>
<p class="mp-trio-what">Le harnais suivant consulte les symboles dans une base</p>
</li>
</ol>
<p class="mp-strip"><b>Ensuite</b><span>La consultation est devenue la règle pour les harnais suivants.</span></p>
<figcaption id="hx6-cap">L’histoire du symbole, à 11:59 dans le talk, dessinée pour cette note : la petite marque en haut du premier plan est le genre de détail que la version A ne regardait jamais.</figcaption>
</figure>

## Le coût est un état d’esprit

Tout garder pose le problème suivant. Avec mille harnais dans la base, comment trouver celui qui convient à une nouvelle situation ? Sa réponse s’appuie sur la façon dont les gens se souviennent. Nous ne nous rappelons pas en empilant les détails, et les systèmes que nous construisons fonctionnent très différemment de la mémoire humaine. Il pense qu’on peut en tirer des leçons.

Son exemple : la même situation, confiée à deux agents, humains ou IA. L’un sait que l’argent n’est pas un problème et qu’il y a assez de temps. Il peut se permettre d’être curieux. La curiosité coûte cher, apprendre coûte cher, et ça peut rapporter gros. L’autre sait que le projet doit être livré. Il n’y a plus de place pour explorer : il faut juste vérifier.

Il est prudent sur ce point. Il ne dit pas qu’une IA a des émotions. Il dit que des états d’esprit comme la curiosité, l’inquiétude ou l’urgence peuvent représenter ce que nous comptons comme coût. Aujourd’hui, un agent de code avec un objectif a à peine conscience de ce qui compte pour vous. Il essaie juste d’atteindre l’objectif face à une éval quelconque.

<figure class="fd-fig hx-mind" aria-labelledby="hx7-cap" data-desc="La même situation, deux façons de compter le coût. Curieux : l’argent n’est pas un problème et il y a assez de temps, donc l’agent peut explorer plusieurs chemins et essayer des choses ; apprendre coûte cher, et ça peut rapporter gros. Pressé : le projet doit être livré, donc pas de place pour explorer, il faut juste vérifier, une chose après l’autre. Ces états d’esprit ne sont pas des émotions de l’IA. Ils représentent ce que vous comptez comme coût, ce que les agents de code d’aujourd’hui savent rarement.">
<div class="mp-two-row">
<div class="mp-two-card">
<p class="mp-two-who">Pas de souci d’argent, on a le temps</p>
<p class="mp-two-name">Curieux</p>
<svg class="mp-two-art" viewBox="0 0 300 96" aria-hidden="true">
<path id="hx7-p1" class="mp-thin" d="M24,48 L110,16 L200,6"/>
<path id="hx7-p2" class="mp-thin" d="M24,48 L110,48 L200,58 L262,48"/>
<path id="hx7-p3" class="mp-thin" d="M24,48 L110,80 L200,90"/>
<path class="mp-thin" d="M110,16 L200,26 M110,48 L200,38 M110,80 L200,70"/>
<g class="hx-nodes"><rect x="18" y="42" width="12" height="12"/><rect x="107" y="13" width="6" height="6"/><rect x="107" y="45" width="6" height="6"/><rect x="107" y="77" width="6" height="6"/><rect x="197" y="3" width="6" height="6"/><rect x="197" y="23" width="6" height="6"/><rect x="197" y="35" width="6" height="6"/><rect x="197" y="55" width="6" height="6"/><rect x="197" y="67" width="6" height="6"/><rect x="197" y="87" width="6" height="6"/></g>
<path class="mp-pole" d="M268,62 V30"/><path class="mp-flag" d="M268,30 H286 L281,36 L286,42 H268 Z"/>
<g class="fd-token fd-token-ui"><rect x="-4" y="-4" width="8" height="8"><animateMotion dur="4.5s" repeatCount="indefinite"><mpath href="#hx7-p1"/></animateMotion></rect>
<rect x="-4" y="-4" width="8" height="8"><animateMotion dur="4.5s" begin="-1.5s" repeatCount="indefinite"><mpath href="#hx7-p2"/></animateMotion></rect>
<rect x="-4" y="-4" width="8" height="8"><animateMotion dur="4.5s" begin="-3s" repeatCount="indefinite"><mpath href="#hx7-p3"/></animateMotion></rect></g>
</svg>
<p class="mp-two-line">Il peut explorer et essayer</p>
<p class="mp-two-line">Apprendre coûte cher, et ça peut rapporter gros</p>
</div>
<p class="mp-two-vs" aria-hidden="true">même tâche</p>
<div class="mp-two-card">
<p class="mp-two-who">Le projet doit être livré</p>
<p class="mp-two-name">Pressé</p>
<svg class="mp-two-art" viewBox="0 0 300 96" aria-hidden="true">
<path class="mp-track" d="M14,48 H268"/>
<g class="hx-boxes"><rect x="52" y="40" width="16" height="16"/><rect x="112" y="40" width="16" height="16"/><rect x="172" y="40" width="16" height="16"/><rect x="232" y="40" width="16" height="16"/></g>
<path class="hx-tick hx-tick-0" d="M55,48 L59,52 L66,43"/><path class="hx-tick hx-tick-1" d="M115,48 L119,52 L126,43"/><path class="hx-tick hx-tick-2" d="M175,48 L179,52 L186,43"/><path class="hx-tick hx-tick-3" d="M235,48 L239,52 L246,43"/>
<path class="mp-pole" d="M274,62 V30"/><path class="mp-flag" d="M274,30 H292 L287,36 L292,42 H274 Z"/>
<g class="fd-token"><rect x="-4" y="-4" width="8" height="8"><animateMotion dur="4s" repeatCount="indefinite" path="M14,48 H268"/></rect></g>
</svg>
<p class="mp-two-line">Plus de place pour explorer</p>
<p class="mp-two-line">Il faut juste vérifier</p>
</div>
</div>
<p class="mp-strip"><b>Pas des émotions</b><span>Une façon de représenter ce que vous comptez comme coût. Les agents de code d’aujourd’hui le savent rarement.</span></p>
<figcaption id="hx7-cap">Ses deux agents dans la même situation, à 14:00 dans le talk. Même tâche, autre idée de ce qui coûte cher.</figcaption>
</figure>

## Où en est mon propre harnais

Il a conclu sur quatre choses à retenir : laisser les méthodes utiles survivre à la tâche, bien réfléchir à ce que veut dire le coût, parce que c’est bien plus que des tokens, laisser des points de vue concurrents orienter la suite, et apprendre.

Ma propre configuration, c’est l’intérieur de son schéma. Un CLAUDE.md par dossier, 26 skills à moi, un hook qui refuse d’ouvrir une pull request sans numéro d’issue, et un dossier de mémoire d’environ 200 fichiers d’un fait chacun. Quand je corrige un agent, il enregistre la leçon avec un pourquoi, et la session suivante la lit. Une partie de mon harnais est donc déjà écrite par des agents.

Mais chaque changement est une seule variante, gardée parce que je l’ai décidé. Pas d’instantanés, pas de course entre deux versions sur la même tâche. Les revues jugent chaque changement de code ; rien ne juge le harnais lui-même. C’est cette habitude du pari unique que l’équipe de Fausto a dépassée.

<div class="levels" role="group" aria-label="Trois façons de changer un harnais. Un, là où j’en suis aujourd’hui : un correctif à la fois, à la main, une règle écrite après une erreur. Avec une éval hors de la boucle, on passe à deux, une boucle jugée où chaque exécution est notée de l’extérieur et où le coût par changement accepté est visible. Avec un méta-agent, on passe à trois, la configuration de Fausto : plusieurs variantes du harnais sur la même tâche, la meilleure gardée et chaque instantané stocké">
  <div class="level level--focus">
    <p class="level-num">1 · moi, aujourd’hui</p>
    <h3>Un correctif, à la main</h3>
    <p>Une règle écrite après une erreur, gardée parce que je l’ai décidé.</p>
  </div>
  <div class="level-step"><span>Une éval externe</span></div>
  <div class="level">
    <p class="level-num">2</p>
    <h3>Une boucle jugée</h3>
    <p>Chaque exécution notée de l’extérieur, le coût par changement accepté en vue.</p>
  </div>
  <div class="level-step"><span>Un méta-agent</span></div>
  <div class="level">
    <p class="level-num">3 · l’équipe de Fausto</p>
    <h3>Des variantes, on garde la meilleure</h3>
    <p>Plusieurs harnais sur la même tâche, chaque instantané stocké.</p>
  </div>
</div>

Le chiffre qui me manque, c’est son coût par changement accepté. [Meterlex](/fr/projets/meterlex.html) chiffre déjà chaque session que je lance, mais rien ne relie ça aux changements qui ont été mergés.

Le [talk](https://www.youtube.com/watch?v=kic8ijrzxLI) dure 18 minutes. Le découpage du harnais est à [6:29](https://www.youtube.com/watch?v=kic8ijrzxLI&t=389s), les variantes à [10:01](https://www.youtube.com/watch?v=kic8ijrzxLI&t=601s) et l’histoire du symbole à [11:59](https://www.youtube.com/watch?v=kic8ijrzxLI&t=719s). Si vous avez déjà mis en course deux versions d’un CLAUDE.md sur la même tâche, j’aimerais beaucoup savoir laquelle a gagné, et pourquoi.