Cómo funciona el bucle de un agente

"Agente" es la palabra más gastada del año. Pero debajo del ruido hay una mecánica concreta y bastante simple, y entenderla es la diferencia entre usar un agente con criterio y rezar para que funcione. La definición que mejor ha aguantado es la de Anthropic, que Simon Willison resume en una frase: un agente es un modelo usando herramientas en un bucle (simonwillison.net). Sin bucle no hay agente; hay una llamada suelta a un modelo.

Agente no es lo mismo que workflow

Antes del bucle conviene una distinción que ahorra muchos disgustos. Anthropic separa dos cosas que la jerga mezcla: un workflow es un sistema donde el modelo y las herramientas se orquestan por rutas de código que tú escribes de antemano; un agente es un sistema donde el propio modelo decide su trayectoria y qué herramienta usar a partir del feedback del entorno, en bucle (Building Effective AI Agents). El workflow es predecible y barato; el agente es flexible y caro. La mayoría de problemas se resuelven con lo primero — el agente se reserva para cuando no puedes cablear el camino de antemano pero sí verificar el resultado.

El ladrillo: el "augmented LLM"

La pieza básica no es el modelo pelado, sino lo que Anthropic llama el augmented LLM: un modelo con acceso a recuperación (buscar datos), herramientas (ejecutar acciones) y memoria. Lilian Weng lo describe con el modelo como "cerebro" y tres pilares alrededor — planificación (descomponer en subobjetivos, corregirse), memoria (corto y largo plazo) y uso de herramientas (LLM Powered Autonomous Agents). El bucle es lo que pone todo eso en movimiento.

Pensar, actuar, observar

El patrón que ordena el bucle viene de un paper de 2022: ReAct (Reason + Act). La idea es intercalar razonamiento y acción en vez de separarlos: el modelo razona un paso ("necesito el precio actual, no lo sé de memoria"), ejecuta una acción (llama a una herramienta de búsqueda), observa el resultado, y ese resultado alimenta el siguiente razonamiento (Yao et al., 2022). El razonamiento planifica y gestiona las excepciones; la acción trae información del mundo exterior que el modelo no tenía.

El round trip, en concreto

En la práctica, ese "actuar" tiene una forma muy precisa en las APIs actuales. Cuando el modelo quiere usar una herramienta, no la ejecuta: para su turno con una señal —en la API de Claude, stop_reason: "tool_use"— y devuelve un bloque describiendo qué herramienta quiere y con qué argumentos. Tu código ejecuta esa operación y le devuelve el resultado en un bloque tool_result, que reentra en el contexto en la siguiente iteración (Tool use with Claude). OpenAI documenta el mismo baile en cinco pasos: petición con herramientas → el modelo pide una llamada → tu app la ejecuta → segunda petición con la salida → respuesta final o más llamadas (Function calling).

Quitado el detalle de cada proveedor, el bucle entero cabe en unas líneas:

# El bucle de un agente, en esencia
mensajes = [prompt_del_usuario]

while True:
    respuesta = modelo.generar(mensajes, herramientas)
    mensajes.append(respuesta)

    if respuesta.motivo_parada == "fin":
        break                       # el modelo decidió que terminó

    # el modelo pidió una o más herramientas: las ejecuta TU código
    resultados = [ejecutar(ll) for ll in respuesta.llamadas]
    mensajes.append(resultados)     # las observaciones vuelven al contexto

Eso es todo. No hay más magia en el núcleo: un while que alterna generación del modelo y ejecución de herramientas, acumulando la conversación entera en mensajes hasta que el modelo señala que terminó. Lo que cambia entre un juguete y un agente serio no es el bucle — es lo que rodea a esas dos líneas.

Por qué el contexto crece en cada vuelta

Fíjate en que mensajes solo hace una cosa: crecer. Cada vuelta añade la respuesta del modelo y el resultado de cada herramienta. En tareas largas esto se acumula rápido, y ahí aparece el primer problema real. Anthropic lo dice sin rodeos: "un agente corriendo en bucle genera cada vez más datos… que hay que refinar cíclicamente" (Effective context engineering). La ventana de contexto es un presupuesto de atención finito, y pasado cierto punto aparece el context rot: a más tokens metidos, peor recupera el modelo lo que importaba. Por eso los agentes serios compactan, resumen o toman notas — no por elegancia, sino porque el bucle, sin gestión, se ahoga en su propio historial.

Dónde se rompe

El bucle es simple, y por eso mismo tiene fallos predecibles. Vale la pena conocerlos antes de soltar un agente a producción:

• El coste crece en cada iteración. Cada vuelta reenvía todo el historial acumulado y añade más. Un agente que da veinte vueltas no cuesta veinte llamadas pequeñas: cuesta veinte llamadas cada vez más grandes.
• Los errores se propagan. Un razonamiento equivocado en la vuelta 3 entra en el contexto y contamina las vueltas 4, 5, 6… El modelo arrastra su propio error como si fuera un hecho. Anthropic recomienda por esto el patrón más simple que pase la evaluación, no el más agéntico (Building Effective AI Agents).
• La parada no es gratis. El while True del ejemplo depende de que el modelo emita "fin". Un agente puede quedarse dando vueltas, repetir acciones o no reconocer que terminó. En serio hace falta un límite de iteraciones, detección de bucles y una condición de parada explícita — el objetivo es alcanzar una meta, no iterar sin fin.

Lo que hay que llevarse

Un agente es un while alrededor de un modelo que llama herramientas y va acumulando lo que observa. Entender esa mecánica no lo hace menos útil — lo hace usable con criterio: sabes que el coste escala con las vueltas, que el contexto se degrada si no lo gestionas, que un error temprano envenena el resto, y que tú controlas el punto exacto donde una herramienta se ejecuta o no. Nada de eso se ve desde fuera, donde solo hay "un agente que hace cosas". Se ve desde dentro del bucle. Y mirar dentro, antes de confiar, es justo el punto medio que este sitio persigue: ni rechazar los agentes por reflejo, ni ejecutarlos a ciegas.