Fundamentos del arnés de agente: bucles y control · Lección 3 de 6

Lección 3: Condiciones de parada: cuándo debería rendirse un agente

Objetivos de aprendizaje:

Explicar por qué dejar que el modelo regrese end_turn por su cuenta no basta para terminar un bucle, y enunciar la tensión sin rodeos: tienes que confiar en el modelo, y sin embargo puede seguir girando durante muchos turnos

Añadir una compuerta dura de turnos máximos a un bucle esqueleto, y explicar por qué el contador solo funciona si vive fuera del bucle

Distinguir una parada dura (alto forzado en el techo) de una parada suave / suspensión (pausa para una persona, reanudable), y listar las condiciones bajo las cuales un agente dado debe parar

Requisitos: Leíste la Lección 2, puedes escribir un bucle while impulsado por stop_reason, y sabes que el bucle termina por sí solo cuando regresa end_turn | Anterior: Lección 2 << | Siguiente: Lección 4 >>

No cuentes con que el modelo lo dé por terminado

El bucle esqueleto de la Lección 2 se para por exactamente una razón: en alguna ronda el modelo deja de pedir herramientas, stop_reason pasa de tool_use a end_turn, la condición del while se vuelve falsa, y el bucle termina por sí solo.¹ Dicho de otro modo, la decisión de si dar otra vuelta se le ha entregado por entero al modelo: el bucle se para cuando el modelo dice que ya terminó de hablar.

La mayoría de las veces eso funciona, pero ten claro quién toma la decisión. Un agente es, por definición, un sistema donde el modelo dirige dinámicamente su propio proceso y su propio uso de herramientas,² y decidir cuándo rendirse es parte de eso. La autonomía es exactamente lo que hace útil a un agente, pero la otra cara de esa misma moneda es que "The autonomous nature of agents means higher costs, and the potential for compounding errors."² (La naturaleza autónoma de los agentes implica costos más altos y el potencial de errores que se componen.) Y la oración que más importa aquí: "The LLM will potentially operate for many turns, and you must have some level of trust in its decision-making."² (El LLM potencialmente operará durante muchos turnos, y debes tener cierto nivel de confianza en su toma de decisiones.)

La palabra con la que hay que quedarse es confianza. Confianza no es lo mismo que dejar al modelo sin supervisión. Si el modelo se atasca en algún paso, o se desvía por algo que una herramienta le devolvió, y simplemente nunca regresa end_turn, un bucle que solo vigila stop_reason no se impacientará por ti. Le hará compañía al modelo, ronda tras ronda, girando, porque nada en la condición del while que escribiste dice «ya bastó de vueltas». Así que la autoterminación por parte del modelo no basta por sí sola. Necesitas condiciones de parada que el anfitrión decida, unas que no esperen al humor del modelo.

Primero, una compuerta dura sobre el bucle: turnos máximos

La condición de parada más básica de todas está nombrada justo en la guía de ingeniería de Anthropic: "it's also common to include stopping conditions (such as a maximum number of iterations) to maintain control."² (también es común incluir condiciones de parada —como un número máximo de iteraciones— para mantener el control.) Traducido a código, eso es un techo sobre cuántas veces se le permite al bucle dar la vuelta.

Sobre el esqueleto de la Lección 2, el cambio es pequeño:

JAVASCRIPT

// tools es el manifiesto de definiciones de herramientas que envias en cada ronda
const MAX_TURNS = 10;              // la compuerta dura: deja que el bucle de la vuelta 10 veces como maximo
const messages = [{ role: "user", content: userInput }];
let turns = 0;                     // el contador vive fuera del bucle para poder acumular a lo largo de las rondas

let response = await callModel({ tools, messages });

while (response.stop_reason === "tool_use") {
  // revisa la compuerta antes de que empiece esta ronda: en el tope, parada dura y no envies mas solicitudes
  if (turns >= MAX_TURNS) {
    return { stopped: "max_turns", turns, last: response };
  }
  turns += 1;

  messages.push({ role: "assistant", content: response.content });

  const toolUseBlocks = response.content.filter((b) => b.type === "tool_use");
  const toolResults = await Promise.all(
    toolUseBlocks.map(async (block) => ({
      type: "tool_result",
      tool_use_id: block.id,
      content: await executeTool(block.name, block.input),
    }))
  );
  messages.push({ role: "user", content: toolResults });

  response = await callModel({ tools, messages });
}

// dos salidas del bucle: el return temprano de arriba, o stop_reason dejando de ser tool_use
return { stopped: "end_turn", turns, last: response };

Dos cosas llevan el peso aquí. Primero, let turns = 0 se declara fuera del bucle. Tiene que seguir viva a lo largo de las rondas y sumar cada una, o la compuerta no tiene idea de cuántas vueltas han pasado; muévela al cuerpo del bucle y obtienes exactamente la trampa que el ejercicio de Nivel 2 desarma. Segundo, a la compuerta no le importa por qué el modelo sigue pidiendo herramientas: atascado, dando vueltas en círculo, desviado por la salida de una herramienta, nunca lo pregunta. Una vez que la cuenta de vueltas toca el techo, el anfitrión se para, no envía más solicitudes, y recupera el control para su propio lado.

Eso es una parada dura: en la frontera se detiene sin condiciones y el bucle se acabó. Es algo distinto del final suave de end_turn, donde el modelo decide que ya terminó: una es un techo que tú fijas, la otra es el propio juicio del modelo. Fíjate que no hay una respuesta estándar para qué tan grande debería ser MAX_TURNS; depende de más o menos cuántas rondas la tarea debería necesitar. El 10 de aquí es un valor de relleno. Lo que importa es que la compuerta exista y de veras pueda parar un bucle que se ha desbocado.

Juzgar si la autoterminación del modelo por sí sola basta, sin otra condición de parada

Estás diseñando un agente de operaciones que llamará herramientas ronda tras ronda. Un colega argumenta: los modelos ya son lo bastante listos como para regresar end_turn por su cuenta una vez que la tarea está hecha, así que el bucle no necesita ninguna condición de parada externa; deja la decisión de rendirse al modelo. ¿Deberías seguirle la corriente?

Más allá de la parada dura, otra clase: pararse a esperar a una persona

Compuertas como los turnos máximos comparten una propiedad: topar con una es el fin del camino —el bucle se acabó y no continuará por sí solo. Pero esa no es la única clase de condición de parada. El mismo artículo nombra otra: "Agents can then pause for human feedback at checkpoints or when encountering blockers."² (Los agentes pueden entonces pausar para recibir retroalimentación humana en puntos de control o al encontrar obstáculos.) Ese es un animal distinto de una parada dura, y vale la pena desglosarlo:

Parada dura: en el techo se detiene, el bucle queda terminado para siempre, nada continúa automáticamente. Los turnos máximos y el presupuesto agotado pertenecen ambos aquí. Es un estado terminal.
Parada suave / suspensión: el bucle se detiene deliberadamente en un punto de control, entrega el control a una persona, y puede retomar desde ese punto exacto una vez que ella haya respondido. No es un final; es una pausa reanudable.

En código la diferencia aterriza en lo que regresas. Una parada dura regresa un resultado final: aquí es donde terminó. Una parada suave tiene que preservar el estado: regresa una instantánea de la escena desde la que se puede reanudar, entregando los messages actuales junto con la acción pendiente en la que se estancó, de modo que una vez que una persona la haya atendido, esa instantánea baste para seguir:

JAVASCRIPT

while (response.stop_reason === "tool_use") {
  if (turns >= MAX_TURNS) {
    return { stopped: "max_turns", turns, last: response };   // parada dura: terminal
  }

  const block = response.content.find((b) => b.type === "tool_use");
  if (needsHumanApproval(block)) {
    // parada suave / suspension: no es un final, una pausa. Entrega toda la escena para que pueda reanudar aqui
    return { paused: "awaiting_human", pending: block, messages, turns };
  }

  // ...de lo contrario ejecuta la herramienta, anexa al historial, y envía la siguiente solicitud como de costumbre
}

El caso clásico de parada suave es que el siguiente paso del modelo sea algo irreversible —dejar caer una base de datos, disparar un correo, enviar un pedido— y quieres que una persona mire antes de que pase; o que el modelo reporte por su cuenta que está atascado y necesita más información. Trazar la línea entre parada dura y parada suave basta por ahora. Cómo decide de veras needsHumanApproval, y cómo el bucle reanuda desde esa instantánea una vez que una persona responde, es el tema principal de la Lección 5 sobre mantener a una persona en el bucle.

Un marco: empieza preguntando «¿bajo qué condiciones debe parar?»

Con las paradas duras y las paradas suaves en mano, diseñar un agente gana una jugada de apertura útil. Antes de escribir cualquier bucle, deja respondida una pregunta: ¿bajo qué condiciones debe parar esta cosa? Lista las respuestas y por lo general se reducen a estas cuatro:

La tarea está hecha — el modelo regresa end_turn. Esta es la más suave de las cuatro, juzgada por el modelo, y aun así tienes que confirmar que de veras terminó en vez de haberse rendido a medias.
El techo de turnos — una parada dura. Esa es la compuerta MAX_TURNS de arriba, atrapando el peor caso donde el bucle arranca y no puede refrenarse.
Un obstáculo que necesita una decisión humana — una parada suave / suspensión, pausando para recibir retroalimentación humana.² Disparada por operaciones irreversibles, o por el modelo reportando explícitamente que está bloqueado.
Presupuesto agotado — una parada dura. Tokens, gasto o tiempo transcurrido: el que primero toque su techo para el bucle. Los detalles (cómo contar, dónde instrumentar) esperan a la Lección 4.

Alinea esas cuatro y algo se vuelve visible: la decisión de parar no se asienta toda en el modelo. La número 1 pertenece al modelo, las números 2 y 4 pertenecen al anfitrión (paran en la marca sin importar lo que el modelo piense), y la número 3 es compartida. Ese bucle esqueleto de la Lección 2 implementaba solo la número 1 y dejaba caer las otras tres; esta lección añade la número 2, la compuerta dura más básica, mientras que las números 3 y 4 llegan en la Lección 5 y la Lección 4 respectivamente.

El valor del marco no es memorizar cuatro elementos. Es construir un hábito: antes de escribir el bucle, cuenta las condiciones de «debe parar» explícitamente, en vez de dejarlas enterradas bajo la suposición por defecto de que el modelo va a parar de todos modos.

Las condiciones de parada son un seguro barato, no sobreingeniería

Alguien puede refunfuñar que estas compuertas convierten un bucle simple en uno complicado. Lo cual saca a relucir un principio al que Anthropic vuelve una y otra vez: "you should consider adding complexity only when it demonstrably improves outcomes."² (habría que considerar añadir complejidad solo cuando mejora los resultados de forma demostrable.) Esa línea suele citarse para disuadir a la gente de amontonar maquinaria elaborada, pero para las condiciones de parada apunta al otro lado: las deja pasar.

Haz la aritmética y es obvio. Un contador de turnos máximos es una declaración fuera del bucle y una comparación dentro de él, unas pocas líneas de código. Lo que frena —un bucle que no para de girar, costos que trepan fuera de control, una acción irreversible tomada sobre una salida manipulada o malformada— cuesta muchísimo más. La autonomía del agente ya carga costos más altos y el potencial de errores que se componen,² y una condición de parada es el freno más barato apuntado de lleno a ese riesgo.

Así que una condición de parada no es la clase de complejidad que habría que añadir solo cuando mejora los resultados de forma demostrable²; supera esa vara de sobra. Comprime la frontera del peor caso de «sin límite» a «con límite», lo cual es en sí una mejora verificable en los resultados. Es el control más básico que hace de un bucle autónomo algo que te atreves a dejar en marcha, no un extra decorativo.

Resumen

El bucle termina naturalmente con end_turn, pero ese es el propio juicio del modelo; solo puedes depositar cierto nivel de confianza en su toma de decisiones, y puede operar durante muchos turnos, así que fiarse solo de la autoterminación del modelo no basta²
La compuerta dura más básica es un tope de turnos: incluir una condición de parada explícita como un número máximo de iteraciones para mantener el control es una práctica común²; el contador tiene que asentarse fuera del bucle para acumular a lo largo de las rondas, y moverlo al cuerpo lo convierte en código muerto que no para nada
Más allá de las paradas duras hay paradas suaves / suspensiones: pausar para recibir retroalimentación humana en puntos de control o al encontrar obstáculos² —no un estado terminal sino una pausa reanudable que retoma desde una instantánea de la escena
Al diseñar un agente, pregunta primero bajo qué condiciones debe parar: tarea hecha (end_turn, decisión del modelo), techo de turnos (parada dura, decisión del anfitrión), un obstáculo que necesita una decisión humana (parada suave, compartida), presupuesto agotado (parada dura, cubierto en la Lección 4)
Las condiciones de parada son un control barato con un gran rédito: la autonomía ya trae costos más altos y errores que se componen,² y una compuerta de turnos máximos atrapa exactamente el peor caso; frente al principio de añadir complejidad solo cuando mejora los resultados de forma demostrable,² supera la vara de sobra —comprimir lo sin límite en lo con límite es una mejora verificable

>> Lección 4: Desbocamiento y repliegue: bucles muertos, giros en vacío, agotamiento del presupuesto

How tool use works — Claude API — https://platform.claude.com/docs/en/agents-and-tools/tool-use/how-tool-use-works ↩
Building Effective AI Agents — Anthropic Engineering — https://www.anthropic.com/engineering/building-effective-agents ↩ ↩² ↩³ ↩⁴ ↩⁵ ↩⁶ ↩⁷ ↩⁸ ↩⁹ ↩¹⁰ ↩¹¹ ↩¹² ↩¹³ ↩¹⁴

Ejercicios

Estás diseñando un agente de «arregla CI automáticamente». Recoge un pipeline que falla y tiene estas herramientas: read_logs (leer los logs), edit_file (cambiar código), run_tests (ejecutar las pruebas) y push (empujar al remoto, disparando una corrida fresca de CI). La meta es dejar las pruebas en verde. Responde esto para él:

Nivel 1: Cuenta las condiciones de parada de un agente

Lista al menos cuatro condiciones bajo las cuales este agente debe parar.
Para cada una, márcala como una parada dura o una parada suave / suspensión, y di si la decisión de parar pertenece al modelo, al anfitrión, o a ambos.
¿Diseñarías push (que empuja al remoto y dispara una corrida de CI que otras personas pueden ver) como una parada suave a la espera de que una persona apruebe? Da una línea de razonamiento.

Criterios de finalización · marcado local

Al menos cuatro condiciones de parada dadas, cubriendo la mayoría de las cuatro categorías: tarea hecha / techo de turnos / obstáculo que necesita una decisión humana / presupuesto agotadoCada condición clasificada correctamente como dura o suave, con una decisión razonable sobre quién decide (tarea hecha → el modelo, turnos y presupuesto → el anfitrión, tipo obstáculo → compartida)Una postura clara sobre `push` con una razón: la reconoce como una acción visible por fuera y relativamente costosa, bien adecuada a una parada suave a la espera de aprobación

Un colega quería una salvaguarda de turnos máximos sobre el bucle y escribió la versión de abajo. La probó en tareas que necesitaban una o dos llamadas a herramienta y «se veía bien». Pero en cuanto el modelo cayó en llamar a la misma herramienta una y otra vez sin regresar end_turn, esta compuerta no atrapó nada en absoluto y el bucle siguió desbocado. Encuentra la causa raíz y arréglala.

Nivel 2: Por qué esta compuerta de turnos máximos no atrapó nada

JAVASCRIPT

async function runAgent(userInput, tools) {
  const MAX_TURNS = 10;
  const messages = [{ role: "user", content: userInput }];
  let response = await callModel({ tools, messages });

  while (response.stop_reason === "tool_use") {
    let turns = 0;                       // pretende atrapar un bucle desbocado
    if (turns >= MAX_TURNS) {
      return { stopped: "max_turns", response };
    }
    turns += 1;

    const block = response.content.find((b) => b.type === "tool_use");
    const result = await executeTool(block.name, block.input);
    messages.push({ role: "assistant", content: response.content });
    messages.push({
      role: "user",
      content: [{ type: "tool_result", tool_use_id: block.id, content: result }],
    });

    response = await callModel({ tools, messages });
  }
  return response;
}

Criterios de finalización · marcado local

Nombra la causa raíz exacta: `let turns = 0` se declara dentro del cuerpo del bucle, se reinicia a 0 en cada ronda, `turns >= MAX_TURNS` nunca es verdadero, y la compuerta es código muertoExplica en qué difiere esto del bucle infinito de la Lección 2: aquí `response` sí se reasigna y el bucle todavía puede pararse con el propio `end_turn` del modelo, que es por lo que «las tareas cortas se ven bien»pero el respaldo de turnos máximos que debería haber atrapado el desbocamiento nunca se activóDa el arreglo: mueve `let turns = 0` arriba del `while` (el estado del contador tiene que acumular a lo largo de las rondas), manteniendo `turns += 1` dentro del cuerpo del bucle

Lección 3: Condiciones de parada: cuándo debería rendirse un agente

No cuentes con que el modelo lo dé por terminado

Primero, una compuerta dura sobre el bucle: turnos máximos

Más allá de la parada dura, otra clase: pararse a esperar a una persona

Un marco: empieza preguntando «¿bajo qué condiciones debe parar?»

Las condiciones de parada son un seguro barato, no sobreingeniería

Resumen

Footnotes

Ejercicios