Agentes de IA auto-mejorables: Convierte razonamiento repetido en herramientas que el agente escribe solo

#ai #programming #tutorial #spanish

💻 Todo el código de esta serie está en un solo repo: resilient-agent-harness-sample-for-aws. Este post es la demo de Self-Improving Skills (04-self-improving-skills). Clona el repo y sigue el paso a paso.

Un ingeniero senior que sigue resolviendo el mismo problema a mano eventualmente para, escribe una función, la prueba, y nunca más resuelve ese problema a mano. El razonamiento pasó una vez; cada llamada después de esa es una invocación barata y exacta. Ese instinto, convertir trabajo repetido en una herramienta, es lo que la mayoría de agentes de IA no tienen.

Un agente estático re-razona el mismo tipo de tarea desde cero cada vez. Pídele que sume una lista de números hoy y derivará una respuesta; pregunta de nuevo mañana y la derivará de nuevo, quemando tokens, y a veces equivocándose diferente en cada ejecución, sin forma de saber que estaba mal. Nada de lo que aprendió la primera vez persiste.

Un agente auto-mejorable hace lo que hace el ingeniero: resuelve la tarea una vez, escribe una pequeña herramienta para esa capacidad, confirma que la herramienta corre, y la reutiliza exactamente desde entonces. El razonamiento repetido se convierte en una llamada de función determinista.

El detalle que vale decir en voz alta primero: escribir la herramienta cuesta más tokens que razonar una sola vez, no menos. Escribir código en runtime es intensivo en tokens. La ganancia es correctitud y reutilización (construir una vez, luego llamarla exactamente para siempre), no una factura más pequeña en la primera pasada. Construí una demo ejecutable que mide exactamente ese trade-off, sin mano-wavear. El código completo está en el repo resilient-agent-harness.

¿Cuál es la demo?

Un solo agente, construido con Strands Agents, trabaja a través de cuatro tareas de matemáticas de tarifas sobre tarifas reales del sandbox de Duffel: totalizar estas tarifas, contar las que superan un umbral, sumar las dos más baratas. La cuarta tarea repite la capacidad de la primera tarea a propósito, para que veas la reutilización en acción. Cada tarea se ejecuta de dos formas (un agente estático y uno auto-mejorable), y la demo mide tokens reales más si cada respuesta es exacta contra un ground truth calculado en Python.

¿Qué es un agente de IA auto-mejorable?

Un agente de IA auto-mejorable extiende su propio toolkit en runtime: resuelve una tarea, escribe una pequeña herramienta para esa capacidad, la carga en sí mismo, y la reutiliza en tareas posteriores en vez de re-razonar desde cero. Lo que mejora es el toolkit del agente (el conjunto de funciones que puede llamar), no los pesos del modelo. No hay fine-tuning ni paso de entrenamiento. El mismo modelo corre todo el tiempo; simplemente acumula herramientas que él escribió, de la misma forma que un desarrollador acumula una biblioteca personal de helpers.

Esa distinción importa. "Auto-mejora" suena como que el modelo se está volviendo más inteligente. No lo está. El arnés determinista alrededor del modelo se está enriqueciendo, y ahí es donde vive la ganancia duradera.

Cómo funciona el meta-tooling, y por qué Strands lo hace posible

La parte de "escribe sus propias herramientas" no es un truco casero; es una capacidad documentada de Strands llamada meta-tooling. Strands incluye tres herramientas que permiten a un agente escribir y cargar código en caliente en sí mismo:

editor escribe el archivo .py de la herramienta.
load_tool carga en caliente ese archivo en el agente para que se convierta en una de sus propias herramientas.
shell lo ejecuta o depura si la carga falla.

El diagrama muestra el loop que el agente sigue para cada tarea: si ya tiene una herramienta para esta capacidad simplemente la reutiliza (el camino verde); si no, usa editor para escribir un archivo tools/<name>.py, load_tool para cargarlo en su propio toolkit, shell para depurar si es necesario, y luego llama a la nueva herramienta para un resultado exacto y determinista.

from strands import Agent
from strands_tools import editor, load_tool, shell

agent = Agent(tools=[editor, load_tool, shell], system_prompt=BUILDER_PROMPT)

# El agente escribe ./tools/total_fares.py con una función @tool, la carga, luego la llama.
agent("Add a tool named total_fares that sums a list of fares, then use it on [229.92, 360.67, 395.14].")

print(agent.tool_names)   # -> [..., 'total_fares']  el agente extendió su propio toolkit

Para cada nueva tarea, si el agente ya tiene una herramienta para esa capacidad simplemente la llama (una llamada de herramienta normal, sin re-escribir); si no, escribe y carga una nueva. Aquí está la herramienta real que el agente escribió para la capacidad de "totalizar todas las tarifas" en una ejecución: pequeña, tipada, determinista.

@tool
def total_fares(fares: list[float]) -> float:
    return round(sum(fares), 2)

Esa es toda la idea. El agente vio que iba a seguir necesitando esto, lo escribió una vez, y desde entonces la suma se computa con Python, no se aproxima con un modelo de lenguaje.

¿Cómo se comparan estático y auto-mejorable?

Una ejecución medida en OpenAI gpt-4o-mini me dio esta forma (el agente estático lee respuestas con structured_output_model=NumberAnswer, así que la correctitud es una comparación numérica contra ground truth, no un regex de texto libre):

	Agente estático	Agente auto-mejorable
Cómo responde	Re-razona cada tarea a mano	Escribe una herramienta una vez, la carga, la reutiliza
Tareas resueltas exactamente	~2/4	4/4
Respuestas verificables	0/4 (no puede auto-verificarse)	4/4 (una herramienta que corre es determinista)
Tokens del modelo (pasada única)	~814	~129,000
Herramientas construidas / reutilizadas	0 / 0	3 construidas / 1 reutilizada

Lee la fila de tokens con cuidado: el agente auto-mejorable usa mucho más tokens en esta pasada única, aproximadamente 158x más (dividiendo las dos cifras de arriba). Eso no es un error tipográfico ni algo que se deba pasar por alto. Escribir herramientas con editor, load_tool, y shell significa escribir un archivo, cargarlo, y a veces depurarlo, lo cual es genuinamente costoso.

¿Usa menos tokens?

No. En una pasada única usa más, mucho más. Si ejecutaras cada tarea exactamente una vez y nunca más, el agente estático es más barato en tokens crudos.

La ganancia no es la factura de tokens; es lo que pasa en la repetición y en los casos difíciles:

Reutilización. Una vez que la herramienta existe, cada llamada posterior es una llamada exacta sin re-razonamiento. El agente estático re-paga su costo completo de razonamiento en cada repetición, y producción envía el mismo tipo de trabajo una y otra vez.
Correctitud. Sumar varias tarifas reales con decimales es una debilidad genuina para un modelo pequeño: aproxima y no puede saber que está mal. Ese es trabajo determinista que pertenece en código. El agente auto-mejorable escribe ese código una vez y es exacto desde entonces, y una herramienta que corre es verificable de una forma que el razonamiento en texto libre nunca es.

Así que el encuadre honesto es "construir una vez, luego ejecutarlo exacta y permanentemente", no "menos tokens." Cualquiera que prometa que la auto-mejora reduce la factura en la primera pasada está vendiendo la historia equivocada.

¿Es seguro ejecutar código escrito por el agente?

El agente escribe archivos y ejecuta código, así que la demo establece BYPASS_TOOL_CONSENT=true; de otro modo editor, shell, y load_tool se bloquearían en un prompt de confirmación interactiva y colgarían el notebook. Ese flag se establece a sabiendas, porque esta demo ejecuta los helpers de matemáticas generados por el agente sobre datos locales.

Para código no confiable en producción, no lo ejecutes en el host. Strands incluye Sandbox y PosixShellSandbox para aislar código generado, y un runtime de producción como Amazon Bedrock AgentCore le da a cada sesión un runtime aislado más un registro de herramientas versionado, para que las herramientas que un agente gana persistan entre sesiones en vez de ser re-adivinadas cada vez. La tesis se mantiene a cualquier escala: el trabajo determinista pertenece en una herramienta que el agente escribe una vez y reutiliza, no re-derivado y re-pagado en cada llamada.

Preguntas frecuentes

¿Es esto un sistema multi-agente?
No. Es un solo agente mejorando su propio toolkit. No hay swarm ni graph de agentes; la "auto-mejora" es un agente escribiendo y cargando en caliente sus propias herramientas vía meta-tooling.

¿El modelo se fine-tunea o re-entrena?
No. El modelo no se toca. Lo que crece es el conjunto de herramientas llamables del agente. Los mismos pesos de principio a fin; el agente simplemente acumula funciones que él escribió.

¿Por qué el agente estático se equivoca en las respuestas?
Sumar varias tarifas reales con decimales es una tarea determinista que un modelo pequeño aproxima y no puede auto-verificar. El agente auto-mejorable mueve ese trabajo a una pequeña función Python, así que se computa exactamente en vez de adivinarse.

¿Necesito OpenAI para esto?
No. Strands es agnóstico al modelo: sus proveedores son intercambiables, así que el mismo código corre en Amazon Bedrock (el default), Anthropic, OpenAI, o un modelo local vía Ollama. La demo usa OpenAI gpt-4o-mini por defecto porque solo necesita una API key para probar, aunque eso sigue siendo una llamada a la nube, no un modelo en tu máquina.

Ejecútalo tú mismo

El antes/después completo (cuatro tareas de tarifas sobre tarifas reales de Duffel, un agente estático que re-razona versus un agente que escribe, carga y reutiliza sus propias herramientas, con números reales de tokens y correctitud) corre de principio a fin en un solo notebook. Clona el repo y ejecútalo:

git clone https://github.com/elizabethfuentes12/resilient-agent-harness-sample-for-aws.git
cd resilient-agent-harness-sample-for-aws/04-self-improving-skills

uv venv && source .venv/bin/activate
uv pip install -r requirements.txt

# Default: OpenAI gpt-4o-mini (solo necesitas una API key para probar)
echo "OPENAI_API_KEY=sk-..." > .env
echo "DUFFEL_API_KEY=duffel_test_..." >> .env   # token sandbox gratuito de app.duffel.com
uv run test_self_improving_skills.py

¿Prefieres notebooks? Abre test_self_improving_skills.ipynb y ejecútalo de arriba a abajo.

El patrón sigue a Memento-Skills (Zhou et al., Mar 2026) y SAGE (Peng et al., Mar 2026), ambos sobre agentes que mejoran en tiempo de inferencia sin fine-tuning. Las cifras de benchmark y la lectura completa están en el README del repo. Lo que esta demo produce es el contraste real y medido de tokens-y-correctitud en tu modelo elegido.

¿Qué razonamiento repetido está tu agente re-pagando en cada llamada, trabajo que podría escribir en una herramienta una vez y nunca re-derivar? Cuéntame en los comentarios.

📬 ¿Construyes agentes de IA confiables? Escribo sobre memoria de agentes, guardrails, evaluación y patrones multi-agente. Suscríbete a mi newsletter para recibir el siguiente.

¡Gracias!

🇻🇪 Dev.to Linkedin GitHub Twitter Instagram Youtube