Accueil / Articles

Créer son propre agent de renforcement : six étapes et une expérience permettant d’isoler les gains

Un harnais peut améliorer les scores de référence davantage que le modèle lui-même. Construisez un petit harnais d’agent en six étapes et testez un changement à la fois pour déterminer ce qui a réellement été efficace.

Éditeur : REACTAPP.TOP7 min de lecture1524 mots

Sources: Build an Agent Harness, Then Prove Which Change Moved the Score

Prenez un modèle de frontière et deux ensembles d’évaluation. Avec le premier, il a obtenu 62,7 % sur un test de raisonnement, et avec le second, 99,9 %, tout au cours de la même semaine. Cette variation de 37,2 points dépasse de loin les 32,5 points qui séparent les deux meilleurs résultats du classement. Ainsi, le mécanisme qui entoure un modèle, distinct du modèle lui-même, peut influencer les résultats davantage que le modèle lui-même. Ci-dessous est présenté un aperçu de ce que contient ce mécanisme, une petite construction en six étapes, ainsi que l’étape finale qui montre quels changements ont réellement amélioré la note.

Qu’y a-t-il à l’intérieur d’un ensemble d’évaluation ?

Un ensemble d’évaluation est composé de six éléments, et aucun ne touche aux poids du modèle.

  • Le prompt système, c’est-à-dire ce que l’on dit au modèle concernant son rôle et ses limites avant qu’une tâche ne lui soit assignée.
  • L’accès aux outils : le modèle peut-il exécuter du code, lire des fichiers ou interroger une API, et qu’obtient-il en retour ?
  • Gestion du contexte, qui détermine si le raisonnement se poursuit d’une réponse à l’autre ou est réinitialisé à chaque fois.
  • Gestion des tentatives : le nombre de tentatives autorisées et le fait que le modèle prenne en compte le résultat de la dernière tentative.
  • Budgets de temps et de tokens.
  • Analyse des sorties, qui transforme une réponse en une véritable réponse et décide du traitement d’une bonne réponse présentée sous un format inattendu.
  • Chacun de ces éléments correspond à une décision prise par quelqu’un. En adoptant un cadre, vous héritez de ses décisions sans en voir la logique. Cela fonctionne bien tant que vous n’avez pas besoin d’expliquer pourquoi vos résultats diffèrent de ceux des autres.

    Pourquoi c’est important

    Cet effet se manifeste à une échelle plus petite dans le travail quotidien. Imaginez deux modèles séparés de 0,7 point sur un test de codage, où le changement d’outil entraîne une variation d’environ 5. L’écart que l’on vous demande de détecter représente donc environ un septième du bruit présent dans les mesures. Un exemple public confirme ce constat : le score d’un test interactif pour un modèle aurait triplé dès que son fournisseur a activé deux paramètres lui permettant de conserver sa logique d’un tour à l’autre. Même modèle, simplement autorisé à maintenir son propre fonctionnement.

    Le cas le plus clair est celui d’une histoire rapportée par un tiers. Un ingénieur aurait pris une tâche de codage et l’aurait exécutée cinq fois sur le même modèle, en ajoutant à chaque fois un seul composant de harnais. Un répertoire vide donnait un taux de réussite d’environ 20 pour cent. Un fichier d’instructions le portait à environ 60 pour cent, des commandes de vérification à 80 pour cent, et un fichier de progression à près de 100 pour cent. Personne n’a confirmé ces chiffres, il convient donc de les considérer uniquement à titre illustratif. Ce qui compte, c’est la structure, car elle permet de distinguer la contribution de chaque ajout, ce que la comparaison de deux harnais complets ne permet pas.

    Les travaux publiés indiquent la même chose. Une technique améliore les prompts en s’appuyant sur des essais antérieurs et permettrait d’obtenir une performance supérieure de 10 % en moyenne, voire jusqu’à 20 %, avec un nombre de tentatives réduit jusqu’à 35 fois. Une autre méthode considère le contexte accumulé comme un guide qui évolue, affichant une amélioration de 10,6 % sur les tâches assignées aux agents. Un carnet d’essais persistant a permis à un modèle d’atteindre 99 % de performance sur une tâche de puzzle, contre 10 % auparavant. Dans les trois cas, les poids du modèle sont restés inchangés.

    Une étude contredit l’autre. Un article de 2026 a divisé le harnais en quatre parties pouvant évoluer chacune séparément, en s’attendant à ce que cette structure apporte des avantages. Les résultats ont été de 0,657 contre 0,642 pour l’évolution d’une seule chaîne plate, écart que les auteurs qualifient de négligeable. Selon eux, un budget d’optimisation fixe réparti sur quatre parties diminue le signal disponible pour chacune. Une structure supplémentaire n’aide pas par défaut, et ce résultat nul vaut plus que les succès, car il exclut l’interprétation selon laquelle on pourrait obtenir des résultats sans effort.

    Construire en six étapes

    L’ensemble ne compte qu’environ cent lignes et ne repose sur aucun framework. Il suffit de fournir une seule fonction qui envoie du texte à un modèle et en retourne du texte.

    La première étape correspond à l’élément le plus simple qui fonctionne : prendre une tâche, appeler le modèle avec son prompt et mesurer le temps d’exécution de l’appel.

    import time
    def run_task(task, call_model):
        t0 = time.time()
        output = call_model(task["prompt"])
        return {"id": task["id"], "output": output,
                "seconds": round(time.time() - t0, 2)}
    

    La deuxième étape permet au modèle d’agir et de voir. Un outil d’aide exécute une commande shell dans un répertoire de travail avec un délai d’expiration.

    import subprocess
    def run_command(cmd, workdir, timeout=60):
        try:
            r = subprocess.run(cmd, shell=True, cwd=workdir, timeout=timeout,
                               capture_output=True, text=True)
            return {"exit": r.returncode, "stdout": r.stdout[-4000:],
                    "stderr": r.stderr[-4000:]}
        except subprocess.TimeoutExpired:
            return {"exit": None, "stdout": "", "stderr": "timed out"}
    

    Deux décisions y sont déjà intégrées. La sortie est limitée aux 4 000 derniers caractères et les commandes s’arrêtent après 60 secondes. Celles-ci modifient ce que voit le modèle, donc elles doivent toutes deux figurer dans vos notes en tant que partie de l’ensemble nécessaire et non de la tâche elle-même.

    La troisième étape détermine ce qui est transmis d’une passe à l’autre, en construisant la liste de messages à partir du prompt système, de la tâche et de l’historique.

    def build_messages(task, history, carry_reasoning=True):
        msgs = [{"role": "system", "content": SYSTEM},
                {"role": "user", "content": task["prompt"]}]
        for turn in history:
            if carry_reasoning:
                msgs.append({"role": "assistant", "content": turn["output"]})
            msgs.append({"role": "user", "content": format_result(turn["result"])})
        return msgs
    

    Faites en sorte que la prise en compte du raisonnement soit une option configurable plutôt qu’un choix prédéfini, car vous voudrez mesurer les deux paramètres.

    La quatrième étape analyse une action issue de la sortie du modèle sans échouer silencieusement.

    import re
    ACTION = re.compile(r"<action>(.*?)</action>", re.S)
    def parse_action(output):
        m = ACTION.search(output)
        if m:
            return m.group(1).strip(), "matched"
        fence = chr(96) * 3
        alt = re.search(fence + r"(?:bash|sh)?\n(.*?)" + fence, output, re.S)
        if alt:
            return alt.group(1).strip(), "fallback_fenced"
        return None, "no_match"
    

    Enregistrez la deuxième valeur de retour, car elle contient le plus d’informations. Lorsqu’une fraction significative des exécutions se termine par un recours de secours, le analyseur évalue davantage la mise en forme que les capacités réelles du modèle, et le score ne permet pas de distinguer l’un de l’autre. Une histoire d’avertissement similaire : un détecteur conçu pour vérifier si un modèle affirmait avoir terminé a réussi cinq cas de validation, mais a manqué deux affirmations évidentes parce qu’un point à l’intérieur d’un nom de fichier interrompait prématurément un schéma basé sur des phrases. Les transcriptions indiquaient que les tests avaient réussi, tandis que le détecteur signalait aucune affirmation du tout.

    La cinquième étape est la boucle, avec une limite de huit tours.

    MAX_TURNS = 8
    def agent_loop(task, call_model, carry_reasoning=True):
        history, workdir = [], task["dir"]
        for turn in range(MAX_TURNS):
            out = call_model(build_messages(task, history, carry_reasoning))
            action, parse_status = parse_action(out)
            result = run_command(action, workdir) if action else {"note": "no action"}
            history.append({"output": out, "result": result, "parse": parse_status})
            if action and task["done"](workdir):
                return {"solved": True, "turns": turn + 1, "history": history}
        return {"solved": False, "turns": MAX_TURNS, "history": history}
    

    Ici, task["done"] est une fonction que vous fournissez, qui examine le monde réel plutôt que de se fier à l’affirmation du modèle. Cette seule distinction transforme une démonstration en une mesure.

    La sixième étape est ce qui fait de l’ensemble un instrument : une fonction d’expérience qui exécute chaque tâche pour chacune des variantes, en la répétant plusieurs fois.

    def experiment(tasks, call_model, variants, runs_per=2):
        results = []
        for name, config in variants.items():
            for task in tasks:
                for r in range(runs_per):
                    out = agent_loop(task, call_model, **config)
                    results.append({"variant": name, "task": task["id"], "run": r,
                        "solved": out["solved"], "turns": out["turns"],
                        "fallbacks": sum(1 for h in out["history"]
                                         if h["parse"] != "matched")})
        return results
    variants = {"carry_on":  {"carry_reasoning": True},
                "carry_off": {"carry_reasoning": False}}
    

    Modifiez un élément, gardez le reste constant, exécutez les deux versions et comparez-les. Cette méthode fait défaut dans presque toutes les comparaisons publiées. Modifiez en même temps le modèle, la requête et la limite de tours, et vous n’apprendrez rien sur l’élément qui a influencé le résultat.

    Que mesurer et à quoi s’attendre

    Quatre chiffres méritent d’être suivis. Premièrement, le taux de résolution pour chaque variante. Deuxièmement, le nombre de tours nécessaires pour résoudre, car une variante qui atteint le même score en moins de tours coûte moins cher. Troisièmement, la fréquence à laquelle le traitement du texte doit recourir à une solution de secours. Quatrièmement, l’écart entre les résultats obtenus lors de plusieurs exécutions sur une même tâche, ce qui est le plus révélateur. Si les résultats identiques diffèrent, le bruit peut être plus important que l’effet recherché.

    Ne soyez pas surpris si le premier résultat montre les deux variantes à égalité. Lors d’une expérience menée selon ce schéma, deux modèles de pointe ont traité dix petites tâches de correction de bugs, deux fois chacun, et toutes les tentatives ont réussi, ce qui signifie qu’aucun critère ne les distinguait. Les tâches étaient trop simples pour permettre de les différencier. C’est le résultat habituel, et il reflète la nature des tâches plutôt que celle des modèles. Choisissez des tâches dont le taux de résolution se situe dans une fourchette intermédiaire, bien en deçà du plafond maximal.

    Limites

    Un outil d’aide ne peut pas conférer à un modèle des capacités dont ses poids ne disposent pas, donc toute amélioration est limitée par ce que ces poids permettent. Un outil adapté à vos tâches ne sera pas non plus efficace. Ce qui fonctionne bien pour réparer du code n’est pas nécessairement efficace pour une exploration ouverte, car les échecs sont différents.

    Donc, il ne s’agissait jamais du fait que le modèle n’ait pas d’importance. Les comparaisons traitent les deux modèles comme s’un seul variait, alors que c’est en réalité les deux qui changent, mais que seul l’un est pris en compte dans les résultats.