Qué es un bucle agéntico (agentic loop): definición y ejemplo

Un bucle agéntico es el ciclo que un agente de IA repite (percibir el estado, actuar, observar el resultado y decidir si continuar o parar) hasta cumplir un objetivo o alcanzar una condición de parada. Si lo has visto escrito como “agentic loop”, es lo mismo: el término viaja en inglés, el concepto es idéntico en español.

La mayoría de la gente que usa ChatGPT cree que un agente responde una vez y ya está. No es así. Un agente da vueltas, y cada vuelta corrige la anterior. Esa diferencia es la que separa a quien escribe un prompt de quien construye algo que trabaja solo.

La idea: aparcar un coche a base de correcciones

Piensa en cómo aparcas un coche en un hueco justo. No calculas el ángulo perfecto y giras el volante una sola vez. Miras el retrovisor, giras un poco, avanzas, vuelves a mirar, corriges. Cada movimiento depende de lo que viste después del anterior. Paras cuando el coche está dentro de las líneas.

Un agente de IA hace lo mismo con una tarea. No resuelve el problema de un tirón: ejecuta una acción pequeña, mira qué pasó, y decide el siguiente paso con esa información nueva. La palabra “bucle” no es decorativa. El agente vuelve al principio del ciclo una y otra vez, con más contexto en cada vuelta, hasta que la tarea está hecha.

Un modelo de lenguaje suelto no hace esto. Le preguntas, te contesta, se acabó. El bucle es justo lo que le añades alrededor para convertir un modelo que solo habla en un agente que actúa.

Las piezas del bucle

Un bucle agéntico tiene cuatro piezas, y todas hacen falta para que gire. Quítale una y deja de ser un bucle.

Percibir el estado. Antes de decidir nada, el agente lee en qué punto está. En la primera vuelta eso es la tarea y su situación de partida; en las siguientes, todo lo que ha ido observando hasta ahora. Esa foto del momento es la materia prima con la que razona el paso siguiente.

La acción. En cada vuelta, el agente elige una acción y la ejecuta. Casi siempre eso significa llamar a una herramienta: leer un archivo, ejecutar un comando, consultar una API o buscar en una base de datos. Aquí entra el tool calling, y conviene entenderlo bien: el modelo no ejecuta nada por sí mismo, sino que pide “ejecuta este comando con estos argumentos”, y es tu código quien lo ejecuta de verdad. Muchas de esas herramientas se conectan al agente a través de MCP, el protocolo estándar para darle a un agente acceso a herramientas externas.

La observación. Después de actuar, el agente lee el resultado. El comando devolvió un error, o el test falló en la línea 42. Esa observación entra de nuevo en el contexto del modelo, y es lo que hace que la siguiente decisión sea distinta a la anterior.

La decisión de seguir o parar. Con la observación fresca, el agente decide: ¿ya está el objetivo cumplido, o hay que dar otra vuelta? El objetivo (“haz que los tests pasen” o “encuentra el pedido del cliente y reembólsalo”) es el criterio contra el que mide si ha terminado. Sin un objetivo claro, el bucle no sabe cuándo parar, y eso da para media discusión, así que vuelvo a ello al final. Si falta, vuelve a elegir acción y el ciclo sigue. Si está, para y entrega el resultado.

Bucle ≠ cadena: en qué se diferencia del prompt chaining

La confusión más común es mezclar el bucle agéntico con el prompt chaining, y son cosas distintas. Una cadena de prompts es lineal: el paso 1 alimenta al paso 2, que alimenta al paso 3, y cuando llegas al final, terminaste. Los pasos los decides tú de antemano. La cadena no vuelve atrás ni repite; recorre un camino fijo y sale por el otro lado.

Un bucle no tiene ese camino fijo. Repite el mismo paso (percibir, actuar, observar, decidir) tantas veces como haga falta, y es el propio agente quien decide en cada vuelta si sigue o para. Una cadena de tres pasos siempre hace tres pasos. Un bucle puede dar dos vueltas o quince, según lo que vaya observando.

La forma rápida de distinguirlos: en una cadena, tú diseñas la secuencia; en un bucle, el agente la descubre sobre la marcha. Si quieres ver cadenas montadas de verdad, con y sin librería, tienes ejemplos de encadenamiento de prompts que lo enseñan paso a paso.

Un ejemplo: el agente que arregla un test que falla

El caso más claro para ver el bucle en acción es un agente que arregla un test roto. El objetivo es simple: que el test pase. Mira las vueltas:

1. Actúa: ejecuta el test.
2. Observa: el test falla, y el output dice TypeError: cannot read property 'id' of undefined en la línea 12.
3. Decide: el objetivo no está cumplido. El agente lee el archivo y entiende que falta una comprobación de null.
4. Actúa: edita el código para añadir esa comprobación.
5. Observa: vuelve a ejecutar el test. Ahora pasa.
6. Decide: objetivo cumplido. Para.

El esqueleto en TypeScript, sin los detalles de cada herramienta, queda así:

// El bucle agéntico reducido a su esqueleto:
// actuar, observar, y decidir si repetir o parar.
async function agentLoop(objetivo: string) {
  let contexto = objetivo;
  const MAX_VUELTAS = 20; // ajústalo a tu caso
  for (let vuelta = 0; vuelta < MAX_VUELTAS; vuelta++) {
    const accion = await modelo.decidir(contexto);   // el modelo elige la acción
    if (accion.tipo === "terminar") return accion.resultado;

    const observacion = await ejecutar(accion);       // tu código ejecuta la herramienta
    contexto += `\n${observacion}`;                    // el resultado vuelve al contexto
  }
  throw new Error("Se acabaron las vueltas sin cumplir el objetivo"); // parada dura
}

Fíjate en dos cosas. El modelo nunca ejecuta el test él mismo; solo dice qué hacer, y tu código (ejecutar) lo corre de verdad. Y el bucle tiene una salida de emergencia: MAX_VUELTAS. Sin ese límite, un agente que no consigue arreglar el test seguiría intentándolo para siempre.

La condición de parada: la pieza que casi todo el mundo olvida

La condición de parada es lo que decide cuándo el bucle deja de girar, y es la pieza que más veces he visto que falta en un primer agente. Un bucle sin condición de parada clara es un bucle infinito con nombre bonito.

Hay varias formas de parar, y un agente serio combina más de una:

• Objetivo cumplido. La razón por la que quieres parar: el test pasa o el pedido queda reembolsado. Es la parada “buena”, la que buscas.
• Límite de vueltas. Un tope duro de iteraciones. Si el agente no ha terminado en, digamos, veinte vueltas, algo va mal y es mejor cortar que seguir quemando tokens.
• Presupuesto o contexto agotados. Aquí se juntan dos límites distintos, y los dos piden una salida limpia. El primero es el coste: cada vuelta consume tokens y los tokens cuestan dinero, así que un tope de gasto corta el bucle antes de que se te vaya de las manos. El segundo es la ventana de contexto: como cada observación se va acumulando en el contexto, llega un punto en que la petición supera el máximo del modelo y la API la rechaza con context_length_exceeded. Si no vigilas ninguno de los dos, el bucle no se detiene bien: se cae.
• Bucle detectado. Si el agente repite exactamente la misma acción con los mismos argumentos varias veces, está atascado. Detectarlo y parar evita que dé vueltas sobre sí mismo sin avanzar.

En un agente de verdad, la parada buena es la que quieres y las demás son redes de seguridad. Pero si solo implementas la primera y el objetivo nunca se cumple, no tienes un agente: tienes un proceso que no termina nunca. Ese caso concreto —por qué un agente se queda dando vueltas y cómo cerrarle la salida— lo desgrano en cómo evitar que un agente entre en bucle infinito.

Errores comunes

Creer que el agente responde una vez

Este es el error de modelo mental, y viene de usar solo la interfaz de chat. Escribes, el modelo contesta, y parece que ahí acaba todo. Pero cuando ese mismo modelo trabaja dentro de un agente, la “respuesta” que ves es el final de un bucle que quizá dio diez vueltas por debajo: leyó archivos, ejecutó comandos, corrigió sus propios errores y volvió a intentarlo. Si diseñas pensando en una sola respuesta, no diseñas un agente.

Montar el bucle y olvidar cómo se para

Un agente sin condición de parada explícita funciona en la demo y explota en producción. Lo he visto las veces suficientes como para desconfiar por defecto de cualquier agente que solo haya brillado sobre un caso de juguete. En la demo el objetivo se cumple en dos vueltas y todo parece mágico. El día que el agente se topa con un problema que no sabe resolver, gira sin fin, consume tokens y no devuelve nada. La condición de parada es parte del diseño del bucle desde la primera línea, no un parche que añades cuando algo ya se ha roto.

Definir un bucle agéntico es fácil: percibir, actuar, observar y decidir si repetir. Diseñarlo para que converja, que no se atasque, que sepa cuándo parar y que no se gaste el presupuesto dando vueltas, es otra cosa. Cuando programas con agentes, el trabajo de fondo ya no es escribir el código, sino diseñar bien ese ciclo: eso es el loop engineering, y es la disciplina que cubre cómo se diseña un bucle que llega a buen puerto. Ponerle además los frenos que lo detienen cuando algo se tuerce tiene su propia técnica: cómo montarlos bien es de lo que van los guardarrailes en agentes de IA.

Preguntas frecuentes

¿Un bucle agéntico y el prompt chaining son lo mismo?

No. Una cadena de prompts es una secuencia lineal que diseñas de antemano y que termina en el último paso. Un bucle agéntico repite el mismo ciclo tantas veces como haga falta, y es el agente quien decide en cada vuelta si sigue o para. Puedes usar una cadena dentro de una sola vuelta del bucle, pero no son el mismo mecanismo.

¿Un chatbot es un bucle agéntico?

Un chatbot normal no lo es. Le escribes, genera una respuesta con lo que tiene en el contexto y se detiene hasta tu siguiente mensaje: no ejecuta acciones ni observa resultados por su cuenta. Se convierte en un bucle agéntico cuando le das herramientas y le dejas actuar, observar el resultado y volver a decidir sin que tú intervengas en cada paso. Lo que lo convierte en agente es el bucle que le pones alrededor, no el modelo en sí.

¿Qué hace que un bucle agéntico se pare?

Se para por una de varias razones. La buena es que el objetivo se cumple: el agente comprueba que ya logró lo que buscaba y entrega el resultado. Las otras son redes de seguridad para cuando eso no ocurre: un límite de vueltas o la detección de que el agente repite la misma acción sin avanzar. Un bucle agéntico bien hecho tiene siempre al menos una de estas paradas de emergencia, porque confiar solo en que el objetivo se cumpla es la forma más rápida de acabar con un agente girando sin fin.

¿Un bucle agéntico y un sistema multi-agente son la misma cosa?

No, son dos ejes distintos. El bucle agéntico es cómo trabaja un agente por dentro: percibe, actúa, observa y decide si repetir. Un sistema multi-agente es cuántos agentes hay y cómo se reparten el trabajo, por ejemplo un orquestador que reparte tareas a varios workers. Y cada uno de esos agentes tiene su propio bucle girando dentro. Puedes tener un solo agente con un bucle muy bien diseñado, o diez agentes coordinados donde cada uno corre el suyo. Multi-agente responde a “cuántos y cómo se coordinan”; el bucle responde a “cómo razona y actúa cada uno”.