Inicio / Artículos

Agente Harness desde cero: seis etapas y un experimento que aísla las mejoras

Un arnés puede mejorar las puntuaciones de referencia más que el modelo. Construya un pequeño arnés para agentes en seis etapas y pruebe un cambio a la vez para ver qué fue lo que realmente ayudó.

Editor: REACTAPP.TOP7 min de lectura1524 palabras

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

Tomemos un modelo de frontera y dos herramientas de evaluación. Con la primera, obtuvo un 62,7 por ciento en una prueba de razonamiento; con la segunda, un 99,9 por ciento, todo en la misma semana. Esa diferencia de 37,2 puntos superó a los 32,5 puntos que hay entre las dos primeras posiciones en la tabla de clasificación. Así, los componentes que rodean al modelo, y que son distintos del propio modelo, pueden influir en los resultados más que el modelo en sí. A continuación se presenta un resumen de lo que contienen esas herramientas, una estructura sencilla en seis etapas, y el paso final que muestra cuáles de los cambios realizados afectaron realmente a la puntuación.

Qué hay dentro de una herramienta

Una herramienta está compuesta por seis elementos, y ninguno de ellos afecta los pesos del modelo.

  • El prompt del sistema, es decir, lo que se le dice al modelo sobre su función y limitaciones antes de recibir la tarea.
  • Acceso a herramientas: ¿puede ejecutar código, leer archivos o acceder a una API? ¿Y qué recibe a cambio al hacerlo?
  • Manejo del contexto, que determina si el razonamiento persiste entre turnos o se reinicia cada vez.
  • Manejo de intentos: la cantidad de intentos permitidos y si el modelo ve cómo resultó el último.
  • Límites de tiempo y tokens.
  • Análisis de la salida, que convierte una respuesta en una respuesta final y decide qué hacer con una respuesta correcta en un formato inesperado.
  • Cada uno de estos aspectos es una decisión tomada por alguien. Al adoptar un marco, heredas sus decisiones sin poder verlas. Eso funciona bien hasta que necesitas explicar por qué tu resultado difiere del de otra persona.

    Por qué es importante

    El efecto se manifiesta a menor escala en el trabajo diario. Imagina dos modelos con una diferencia de 0,7 puntos en una prueba de rendimiento de programación, donde el cambio en los resultados al alterar los parámetros es de aproximadamente 5. La diferencia que se pide que se detecte representa entonces alrededor de una séptima parte del ruido presente en la medición. Un ejemplo público apunta en la misma dirección: se informa que la puntuación en una prueba interactiva de un modelo se triplicó una vez que su proveedor activó dos configuraciones que le permitían conservar su razonamiento de una conversación a otra. Es el mismo modelo, pero ahora se le permite mantener su propio proceso de trabajo.

    La más clara de todas es una historia de segunda mano. Según se cuenta, un ingeniero tomó una tarea de programación y la ejecutó cinco veces con el mismo modelo, añadiendo un componente de arnés cada vez. Un repositorio vacío arrojó una tasa de éxito de aproximadamente el 20 por ciento. Un archivo de instrucciones la elevó a alrededor del 60 por ciento, los comandos de verificación la llevaron al 80 por ciento, y un archivo de progreso casi al 100 por ciento. Nadie ha confirmado estas cifras, así que véanlas únicamente como ilustración. Lo importante es la estructura, ya que permite separar la contribución de cada adición, algo que una comparación entre dos arneses completos no puede hacer.

    Los trabajos publicados indican lo mismo. Una técnica mejora los prompts al analizar ejecuciones anteriores y se dice que supera a un modelo de aprendizaje por refuerzo en un 10 por ciento en promedio, e incluso hasta un 20 por ciento, con hasta 35 veces menos pruebas necesarias. Otra técnica trata el contexto acumulado como una guía que evoluciona, logrando una mejora del 10,6 por ciento en las tareas de los agentes. Un bloc de notas persistente permitió que un modelo pasara del 10 al 99 por ciento en una tarea de rompecabezas. En los tres casos, las ponderaciones no se modificaron en absoluto.

    Un hallazgo contradice al otro. Un artículo de 2026 dividió el arnés en cuatro partes que podrían evolucionar por separado y esperaba que esa estructura diera buenos resultados. Los resultados fueron 0,657 frente a 0,642 al evolucionar una sola cadena plana; los autores consideran esa diferencia insignificante. Según ellos, asignar un presupuesto de optimización fijo entre cuatro partes reduce la señal recibida por cada una. Por defecto, más estructura no ayuda, y este resultado nulo tiene más valor que los éxitos, ya que descarta la interpretación de que se obtendrían beneficios sin esfuerzo.

    Construyéndolo en seis etapas

    Todo el sistema consta de unas cien líneas sin ningún marco predefinido. Se proporciona una única función que envía texto a un modelo y devuelve texto.

    La primera etapa es lo más básico que se ejecuta: tomar una tarea, llamar al modelo con su prompt y medir el tiempo de la llamada.

    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 segunda etapa permite que el modelo actúe y vea. Un asistente ejecuta una orden de shell en un directorio de trabajo con un tiempo límite.

    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"}
    

    Dos decisiones ya están incluidas allí. La salida se corta a los últimos 4,000 caracteres y las órdenes cesan después de 60 segundos. Ambas modifican lo que ve el modelo, por lo que ambas deben formar parte de tus notas como parte del conjunto de instrucciones y no de la tarea en sí.

    La tercera etapa decide qué se transmite entre turnos, al crear la lista de mensajes a partir del prompt del sistema, la tarea y el historial.

    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
    

    Convierta el hecho de llevar a cabo el razonamiento en una opción configurable en lugar de una elección fija, ya que querrá medir ambos ajustes.

    La fase cuatro analiza una acción a partir de la salida del modelo sin fallar en silencio.

    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"
    

    Registre el segundo valor de retorno, ya que contiene la mayor cantidad de información. Cuando una fracción significativa de ejecuciones termina en el modo de fallback, el analizador está midiendo más el formato que la capacidad real, y la puntuación no permite determinar cuál es el factor relevante. Un ejemplo similar de advertencia: un detector diseñado para identificar si un modelo afirmaba haber terminado superó cinco casos de validación, pero pasó por alto dos afirmaciones obvias debido a que un punto dentro de un nombre de archivo interrumpió un patrón basado en oraciones. Los registros indicaban que las pruebas se habían completado con éxito, mientras que el detector no detectó ninguna afirmación en absoluto.

    La fase cinco es el bucle, con un límite de ocho turnos.

    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}
    

    Aquí task[“done”] es una función que usted proporciona y que examina el mundo en lugar de confiar en la afirmación del modelo. Esa única distinción convierte una demostración en una medición.

    La etapa seis es lo que hace que todo esto sea un instrumento: una función de experimentación que ejecuta cada tarea bajo cada variante, repitiéndola un par de veces.

    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}}
    

    Cambie una cosa, mantenga el resto constante, ejecute ambos y compare. Ese método falta en casi todas las comparaciones publicadas. Modifique el modelo, la instrucción y el límite de turnos al mismo tiempo y no aprenderá nada sobre qué factor afectó el resultado.

    Qué medir y qué esperar

    Hay cuatro cifras que vale la pena seguir. Primero, la tasa de resolución para cada variante. Segundo, el número de turnos necesarios para resolver, ya que una variante que alcanza la misma puntuación en menos turnos cuesta menos. Tercero, con qué frecuencia el proceso de análisis recurre a la solución alternativa. Cuarto, cuán diferentes son los resultados de ejecuciones repetidas en una misma tarea, lo cual es lo más revelador. Si las ejecuciones idénticas dan resultados distintos, es posible que el ruido sea mayor que el efecto que busca.

    No se sorprenda si el primer resultado muestra a las dos variantes empatadas. En un ensayo de este diseño, dos modelos de vanguardia abordaron diez tareas pequeñas de corrección de errores dos veces cada uno, y todas las ejecuciones tuvieron éxito, por lo que nada separó a los modelos. Las tareas eran demasiado fáciles como para poder distinguirlos. Ese es el resultado habitual y se debe al conjunto de tareas, no a los modelos. Elija tareas cuya tasa de resolución esté en un rango intermedio, bien por debajo del límite máximo.

    Límites

    Un marco de trabajo no puede dotar a un modelo con capacidades que sus pesos no poseen, por lo que toda mejora tiene como límite máximo lo que esos pesos permiten. Un marco de trabajo ajustado a sus tareas tampoco funcionará bien. Lo que funciona bien para reparar código no es lo mismo que funciona bien para la exploración abierta, ya que los fallos son diferentes.

    Por lo tanto, el punto nunca fue que el modelo no sea importante. Las comparaciones tratan a ambos como si solo uno variara, cuando en realidad ambos lo hacen y solo se informa sobre uno de ellos.

    Lecturas relacionadas

  • ¿Qué es un harness de agente y por qué los agentes de IA fiables lo necesitan? — Una explicación sencilla para principiantes sobre la ingeniería de harness: el contexto, las herramientas, la memoria, las restricciones y los controles de bucle que se aplican a un LLM para convertirlo en un agente confiable.