Qu’est-ce qu’un harnais d’agent?

Un modèle de langage, à lui seul, ne peut que lire et écrire du texte. Il ne peut pas ouvrir un fichier, lancer un test ni vérifier une page Web. Quand on parle d’un « agent » qui corrige des bogues ou range un tableur, l’essentiel de ce qui rend cela possible est le programme qui entoure le modèle. Ce programme s’appelle le harnais (harness), par analogie avec l’équipement qui permet à un cheval de tirer une charrette : le cheval fournit la force, le harnais la rend utile et le garde sur le chemin.

Anthropic, par exemple, décrit son Claude Agent SDK comme un harnais d’agent polyvalent, et ses ingénieurs rapportent que la conception du harnais a un grand effet sur la performance des agents qui travaillent longtemps. Deux produits qui utilisent le même modèle peuvent se comporter très différemment parce que leurs harnais diffèrent.

Les quatre parties d’un harnais

La boucle en est le cœur. Le fichier README du Agents SDK d’OpenAI décrit le même cycle : appeler le modèle; s’il a produit une réponse finale, s’arrêter; s’il a demandé un outil, exécuter l’outil, ajouter le résultat à la conversation et recommencer; et s’arrêter de toute façon après un nombre maximal de tours.

Un harnais minimal, étape par étape

Voici un petit harnais en Python qui montre les quatre parties. La fonction call_model remplace l’API de modèle que vous utilisez, quelle qu’elle soit; elle renvoie soit une réponse finale, soit une demande d’utiliser un outil. Le reste est de la vraie logique, prête à exécuter.

import json, subprocess, pathlib

WORKDIR = pathlib.Path("project").resolve()
NOTES = WORKDIR / "PROGRESS.md"           # mémoire qui survit d'une session à l'autre
MAX_TURNS = 30                             # limite de la boucle
ALLOWED_COMMANDS = {"pytest", "ls"}        # autorisation : commandes permises

def read_file(path):
    p = (WORKDIR / path).resolve()
    if WORKDIR not in p.parents:           # autorisation : rester dans le projet
        return "Refusé : hors du dossier du projet."
    return p.read_text()[:20000]

def run(command):
    if command.split()[0] not in ALLOWED_COMMANDS:
        return f"Refusé : '{command}' exige l'approbation d'une personne."
    out = subprocess.run(command.split(), cwd=WORKDIR,
                         capture_output=True, text=True, timeout=120)
    return (out.stdout + out.stderr)[-5000:]

TOOLS = {"read_file": read_file, "run": run}

def agent(task):
    notes = NOTES.read_text() if NOTES.exists() else "Aucune note pour l'instant."
    messages = [{"role": "user",
                 "content": f"{task}\n\nNotes des sessions précédentes :\n{notes}"}]
    for turn in range(MAX_TURNS):
        reply = call_model(messages, tools=list(TOOLS))     # le modèle décide
        if reply["type"] == "final":
            NOTES.write_text(notes + "\n" + reply["summary"])  # mise à jour de la mémoire
            return reply["text"]
        result = TOOLS[reply["tool"]](**reply["args"])        # le harnais agit
        print(f"tour {turn} : {reply['tool']} {json.dumps(reply['args'])}")  # journal
        messages.append({"role": "tool", "content": result})
    return "Arrêt : limite de tours atteinte."

Lisez-le de bas en haut. La boucle for est la boucle, avec un plafond ferme. TOOLS est la liste des choses que le modèle peut demander. PROGRESS.md est la mémoire qu’une nouvelle session lit en premier. Les vérifications à l’intérieur de read_file et de run sont les autorisations : le modèle peut demander de lancer n’importe quelle commande, mais c’est le harnais qui décide si elle s’exécute. La ligne print vous donne un journal de chaque action.

Là où les bons harnais font leurs preuves

La version simple ci-dessus fonctionne pour les travaux courts. Les plus longs révèlent des problèmes plus difficiles, et une bonne partie des efforts d’ingénierie récents y est consacrée.

La mémoire d’une session à l’autre. Un modèle ne peut garder qu’une certaine quantité de texte à la fois, sa fenêtre de contexte. Anthropic a constaté que les agents qui travaillaient sur de nombreuses sessions soit essayaient de tout faire à la fois et manquaient d’espace, soit regardaient du travail partiel et déclaraient la tâche terminée. Dans son harnais, la première session écrivait une liste de fonctions où chaque élément était marqué en échec, un journal de progression et une première version enregistrée du projet; les sessions suivantes lisaient d’abord ces fichiers et travaillaient sur une fonction à la fois.

La vérification du travail. Les agents à qui l’on demande d’évaluer leur propre travail ont tendance à l’approuver. Une expérience ultérieure d’Anthropic a réparti le travail entre un planificateur, un constructeur et un évaluateur distinct, volontairement sceptique, et a constaté que c’était plus facile à régler que de demander à un seul agent de se critiquer lui-même.

La gestion du contexte. Un harnais peut compacter une longue conversation, en résumant sur place les parties plus anciennes, ou la réinitialiser : ouvrir une nouvelle session avec une passation écrite. Chaque option a ses compromis en coût et en continuité, et choisir entre les deux est une décision qui relève du harnais, pas du modèle.

Avez-vous besoin de créer le vôtre?

Habituellement, non. Si vous voulez qu’un agent travaille sur du code ou des fichiers, des harnais existants comme Claude Code, Codex et l’application de bureau de ChatGPT fournissent déjà la boucle, les outils, des fonctions de mémoire et des paramètres d’autorisation, mis à l’épreuve par de nombreux utilisateurs. Vos efforts sont mieux investis dans les consignes, les notes de projet et les choix d’autorisations que vous leur donnez.

Si vous intégrez un agent à votre propre produit, partez d’un cadriciel plutôt que d’un fichier vide. Le Agents SDK d’OpenAI et le Claude Agent SDK font chacun tourner la boucle et les appels d’outils pour vous, et vous laissent définir les outils et les règles.

Écrire vous-même un petit harnais vaut quand même la peine une fois, comme il vaut la peine de changer un pneu une fois même si vous appelez habituellement de l’aide. Vous apprenez exactement où s’arrête le jugement du modèle et où commence la responsabilité de votre code, et cela rend chaque agent tout fait plus facile à configurer de façon sûre.