Dans cet article je t'explique ce qu'est un agent, mais plus précisément ce qu'est un harness d'agent, et pourquoi le mettre en oeuvre. Je m'appuierai sur Gemini CLI et son fichier GEMINI.md qui est le point d'entrée de son harness, mais les concepts sont transposables avec des différences minimes dans les écosystèmes concurrents. Chez Anthropic, tu retrouveras un point d'entrée similaire avec le fichier CLAUDE.md.
Je suis développeur en ESN. Je travaille depuis 2 ans sur une application legacy (très legacy) que je m'efforce d'assainir et de moderniser. Et depuis peu, j'ai enfin eu accès à un agent IA pour m'aider. J'ai plongé dedans à fond pour comprendre l'outil et pouvoir exploiter son plein potentiel. Premier constat : les infos sont tellement dispersées que c'est dur de s'y retrouver. Le présent article a vocation à rassembler l'essentiel pour avoir une vision théorique cohérente de ce qu'il y a à savoir. C'était initialement une formation que j'ai construite pour mon équipe. Je me limite ici aux aspects théoriques. En fonction des réactions, je verrai si je crée un deuxième article couvrant la mise en pratique concrète.
Le TL;DR ou la version résumée :
Un agent, c'est un LLM, un contexte (=charge mentale ou charge cognitive) qui doit rester léger, des skills, des MCP, des outils, et des sous-agents.
Le Harness c'est tout ce qui constitue l'agent sans le LLM. Le Harness c'est donc : les skills, les MCP, les outils, et les sous-agents.
Directement autour du LLM, on trouve un "harness interne", établi par le fournisseur (Google dans le cas de Gemini). C'est le guidage fourni par défaut, les sous-agents fournis par défaut. Etc. C'est bien, mais on va faire beaucoup mieux en créant le "harness externe". C'est à dire le guidage qui va spécialiser notre agent pour qu'il devienne expert de notre application.
Cette activité qui consiste à définir/ajuster le harness s'appelle le harness engineering. On a entendu parler de "prompt engineering" en 2023. Puis de "context engineering" en 2024. La version 2026, c'est le harness engineering.
L'agent lui-même est très compétent en harness engineering. Donc quand tu veux configurer le harness, demande à l'agent lui-même comment faire de la meilleure manière possible, et dis-lui de le faire. C'est la leçon la plus essentielle : c'est en échangeant régulièrement avec ton agent que tu auras de nouvelles idées, que tu lui demanderas des suggestions, et que tu lui diras de mettre à jour des éléments de son harness pour devenir toujours plus performant pour ton application en particulier.
Le LLM : une machine à prédire
Le principe du LLM, c'est d'avoir un texte en entrée et de prédire ce qui suit. Pas uniquement à partir du dernier mot. Pas uniquement à partir de la dernière phrase. Mais à partir de la totalité du texte précédent.
Si j'envoie 10 questions à un LLM, j'obtiens 10 réponses. Quand j'écris ma 11ème question, la totalité de l'échange est concaténé dans une string qu'on envoie au LLM pour qu'il fournisse la 11ème réponse. C'est coûteux de trainer tous les échanges précédents, mais c'est nécessaire pour que le LLM ait une vision complète de ce qui se trame. Si on veut que le LLM prédise la suite de "Je traverse la rue", il est préférable qu'il se rappelle si 20 phrases plus tôt on lui a dit qu'on est venus faire du business à New York en hiver, ou un stage de plongée au Mexique en été.
Cette string, c'est ce qu'on appelle le contexte. C'est le concept le plus important dans le harness engineering.
Le contexte c'est une pièce de théâtre
J'ai dit précédemment que le LLM prédit la suite d'un texte. Donc si je dis à mon LLM : "j'aime faire du vélo", on pourrait s'attendre à ce qu'il prédise une suite du genre "sur les routes de campagne". Pourtant ce n'est pas ça qu'il se passe. Le LLM me répond comme une personne différente : "C'est une excellente passion !". Alors qu'est-ce qu'il se passe ?
Tu te rappelles quand on était au collège ou au lycée et qu'on devait lire des pièces de théâtre ? Chaque ligne commence par le nom du personnage qui parle. Pour qu'on attribue les répliques aux bons personnages. Hé bien dans les échanges avec des chatbots ou des agents, c'est la même chose. Il existe des rôles, comme les rôles d'une pièce de théâtre. Je les détaillerai plus loin, mais toi tu t'appelles User, et le LLM s'appelle Model. Et comme dans l'informatique on aime bien les balises ouvrantes et fermantes, la string de contexte ressemble à ça quand Gemini CLI envoie mon contexte au LLM :
[User]J'aime faire du vélo[/User]
[Model]
Le contexte finit par une balise ouvrante [Model] pour montrer au LLM que c'est lui qui doit maintenant fournir une réponse. Et le contexte reviendra ainsi :
[User]J'aime faire du vélo[/User]
[Model]C'est une excellente passion ![/Model]
[User]
Le contexte, c'est le nerf de la guerre
Plus le contexte est précis, plus il permet d'orienter et cadrer l'attention du LLM, et plus la réponse sera pertinente.
Exemple : "Stack technique: .NET Framework 4.8, C# 7.3, Entity Framework 6, XUnit, Moq, Angular 20, Jest, SQL Server 2019. Architecture: 3-couches. Modélisation des données: EDMX"
Cet élément de contexte relativement court va guider les réponses du LLM. Ses réponses futures cibleront le bon langage, dans la bonne version.
Attention cependant : plus le contexte est long, plus le LLM commence à produire des erreurs. Il y a plusieurs raisons à cela. Une liste non-exhaustive inclut:
- Plus un texte est long, plus la probabilité augmente qu'une partie du texte contredise une autre partie
- Plus un texte est long, plus l'attention est diluée : 1 mot parmi 10 peut focaliser 10% de l'attention du modèle. Mais 1 mot parmi 1000 ne peut focaliser que 0,1% de l'attention du modèle
C'est pour cela que j'ai comparé le contexte à de la charge mentale ou de la charge cognitive. Trop peu d'instructions et tu ne fais pas du boulot précis. Trop d'instructions et tu te perds à devoir considérer 1000 aspects à chaque instant. Un petit contexte permet :
- Moins d'erreurs
- Moins de tokens échangés donc une facture moins salée
- Un temps de réponse plus faible
Chaque fabricant de LLM code en dur la longueur maximale de la fenêtre de contexte. Pour Gemini comme pour d'autres modèles d'Anthropic ou OpenAI, la limite est de 1 million de tokens, ce qui équivaut à 4Mo. Il est bon de garder un oeil sur la taille de notre contexte en pourcentage de sa limite, et de "compresser" notre contexte au besoin, ou de démarrer une nouvelle session pour repartir d'un contexte minimaliste.
Un agent, c'est quoi ?
Un agent, c'est un processus qui :
- Alimente un contexte
- Reçoit les entrées d'un utilisateur et lui fournit des sorties
- Exécute des boucles de Raisonnement/Action/Observation (ReAct) via le LLM
- Echange avec d'autres applications via le protocole MCP
- Exécute des commandes sur le poste de l'utilisateur (tool call)
- Invoque des skills
- Délègue des tâches à des sous-agents
Le contexte : on reparle des rôles
On a parlé des rôles en comparant l'échange avec l'agent à une pièce de théâtre.
Les rôles servent à distinguer qui parle, et à quel acteur c'est le tour d'agir. Pour certains rôles (Platform et Developer), il y a également une notion d'autorité : les consignes, contraintes ou limites édictées par Platform (Google par exemple) ou Developer ne peuvent pas être supplantées par un rôle "inférieur". Voici une liste des rôles les plus courants et qui ils représentent :
- Platform : l'entreprise qui crée le LLM ou l'application qui consulte le LLM
- Developer (anciennement System) : prompt technique de niveau supérieur
- User : l'humain qui envoie des demandes
- Model : le LLM qui répond, et qui décide de la prochaine action, et qui observe les résultats des actions
- Tool : l'outil qui est sollicité par l'agent
Le contexte : "lost in the middle"
Une propriété importante des LLM est le concept de "lost in the middle". Quand le contexte s'allonge, le LLM va accorder disproportionnément plus d'attention au début du contexte et à la fin du contexte. Ca présente des avantages et des inconvénients.

Degré d'attention porté aux éléments de contexte en fonction de leur position
L'inconvénient majeur, c'est le relatif oubli des instructions qu'on a donné au milieu d'une conversation longue et qui nous force, une fois de plus, à surveiller que notre contexte reste assez court.
Parmi les avantages on va trouver :
- une attention soutenue portée aux instructions initiales d'une conversation : stack technique, les interdits à ne pas franchir, les conventions de code, etc.
- une attention élevée accordée à l'instruction la plus récente
Justement, lorsque Gemini CLI est lancé, il cherche un fichier GEMINI.md dans le répertoire depuis lequel il a été lancé. Ce fichier au format markdown est le point de départ de la création de notre harness. Puisqu'il est systématiquement chargé au début de notre contexte, son contenu recevra une attention durable pendant toute la session d'utilisation de l'agent. J'expliquerai plus loin, dans la partie pratique, comment l'utiliser.
Les skills : définition et utilisation
Un skill, c'est un prompt pré-enregistré.
L'intérêt d'un skill, c'est donc d'avoir un prompt réutilisable pour des actions que tu réalises de façon récurrente. Si tu veux que l'agent fasse toutes les vérifications habituelles avant de créer une Pull Request (Definition of Done, respect des conventions de codage, couverture par des tests), ça peut avoir du sens de créer un skill qui sera appelé après le développement, pour effectuer ces vérifications.
Un skill possède 3 caractéristiques :
- un nom: c'est la base
- une description : plus importante qu'il n'y parait au premier abord, la description précise les conditions dans lesquelles l'agent doit utiliser le skill. C'est pourquoi les descriptions s'écrivent toujours "à utiliser quand [décrire la condition]"
- une procédure : ce que l'agent doit faire
Puisqu'un skill c'est un prompt, sa présence allonge le contexte. Au démarrage de Gemini CLI, seuls le nom et la description du skill sont ajoutés au contexte pour que l'agent sache qu'il dispose d'un skill utilisable et dans quelles circonstances ce skill doit être utilisé. Lorsque le skill est effectivement utilisé, et à chaque fois qu'il est utilisé, c'est toute sa procédure qui vient s'ajouter au contexte. Il est donc souhaitable d'avoir des skills courts, et d'avoir des skills en nombre limité. J'ai vu passer la recommandation de 20-30 skills idéalement. Et évidemment cette recommandation évoluera quand les limites de fenêtre de contexte s'allongeront au-delà du million de tokens.
Il est possible de définir des skills qui peuvent être invoqués par l'utilisateur mais pas spontanément par l'agent. Dans Gemini CLI, ça s'appelle des "Custom Commands". Dans Claude, ce sont des skills possédant une métadonnée supplémentaire précisant que ce "skill" ne peut pas être invoqué par l'agent. C'est un sujet que je vais laisser de côté parce que cet article sera bien assez long sans cela.
Si tu souhaites créer des skills de qualité, je te recommande l'excellente vidéo de Matt Pocock (auteur d'un repository de skills hautement populaire sur Github), qui est intitulée "Building Great Agent Skills: The Missing Manual".
Les MCP
Les MCP sont des API standardisées pour être consommées par des agents IA. Ce qui est standardisé, c'est essentiellement le fait que ces API présentent 3 propriétés :
- Tools : ce que l'IA a le droit de FAIRE (actions, écritures, appels d'API)
- Resources : ce que l'IA a le droit de LIRE (fichiers, bases de données, logs)
- Prompts : COMMENT l'IA doit procéder (recettes et workflows préconfigurés)
De plus, le MCP peut communiquer en local (stdio) en plus de http. Cela permet des échanges plus rapides sans avoir à ouvrir de port réseau. Ce qui évite des conflits de port déjà utilisé, des blocages de firewall, etc.
Comme je disais juste avant, un MCP est juste une API standardisée. Il n'y a pas forcément une IA qui réfléchit derrière ce MCP. Si mon Outlook met un serveur MCP à disposition, mon agent peut utiliser cette interface standardisée pour manipuler mes emails. Mais il n'y a pas forcément d'intelligence artificielle dans Outlook.
Les Tool Calls / Appels d'outils
Un tool call, c'est un message technique structuré qui est émis par le LLM pour dire à l'application d'agent (Gemini CLI) d'exécuter un script ou une commande locale.
{
"candidates": [
{
"content": {
"role": "model",
"parts": [
{
"functionCall": {
"name": "run_local_command",
"args": {
"command": "npm run jest some-component.spec.ts"
}
}
}
]
},
"finishReason": "STOP"
}
]
}
Le résultat de cette commande sera capturé par Gemini CLI et renvoyée au LLM pour que le LLM raisonne à partir du résultat et décide de quoi faire ensuite.
Les tool calls recouvrent l'ensemble des commandes que tu pourrais exécuter toi-même sur ton poste. Et bien évidemment les capacités de l'agent sont limitées par les outils installés sur ton poste. Pour exécuter du python, il faut évidemment que python soit installé avant.
Cas d'usage classiques de tool call pour un développeur web :
- exécuter les tests unitaires ciblés d'un composant Angular
- auditer l'accessibilité ou les performances avec un navigateur headless
- introspection d'une base de données
Les sous-agents
Un sous-agent c'est un agent secondaire auquel notre agent principal délègue des tâches.
Cela a 3 intérêts majeurs :
- Epargner le contexte de notre agent principal
- Paralléliser le travail pour gagner en vitesse
- Etre plus efficace pour des tâches spécifiques
Au moment de son invocation, le sous-agent démarre avec un prompt minimal. Le GEMINI.md qui est chargé au démarrage de Gemini CLI n'est pas chargé dans le sous-agent. A moins d'y avoir inscrit que ce fichier de contexte devait obligatoirement être chargé aussi dans le sous-agent. On peut confier au sous-agent un prompt spécialisé qui en fait un expert dans un certain type de tâches. Cela peut être redoutablement efficace combiné à des skills. Et au lieu de produire des sorties verbeuses qui vont polluer le contexte de notre agent principal, le sous-agent renverra uniquement son résultat final.
La création d'un harness
Comme évoqué au début, le point d'entrée du harness est le fichier GEMINI.md présent dans le répertoire depuis lequel tu vas lancer Gemini CLI. Le harness sera une multitude de fichiers, principalement au format markdown. Chacun des fichiers vise un aspect différent de notre application. En référençant certains de ces fichiers depuis GEMINI.md, on crée une sorte de "réseau" interconnecté de notions que notre agent prend en compte, afin de considérer tous les aspects qui importent pour notre projet. Entre autres :
- stack technique
- terminologie
- conventions de codage
- carte d'architecture du code
- éléments de sécurité
- règles métier
- pratiques TDD
- feuille de route
- boussole d'architecture
Le mot de la fin
C'est la fin de ce tour d'horizon théorique. Si la demande est forte pour que j'aborde la partie pratique, je ferai un deuxième article. Dis-moi ce que tu en as pensé. Si tu as aimé, si tu as des questions, des observations, des retours d'expérience, on en discute dans les commentaires. Et si tu veux partager avec ton équipe via LinkedIn, ça permettra de diffuser plus rapidement l'adoption du harness engineering et les bonnes pratiques.




Top comments (0)