Loop Engineering

Resumen

Loop engineering es la práctica de diseñar intencionalmente el ciclo observar → razonar → actuar → observar que ejecuta un agente IA. No es el código que llama al LLM una vez. Es la arquitectura del bucle completo: qué estado se mantiene entre pasos, cómo se registran observaciones, qué herramientas están disponibles, cómo se manejan errores, cuántas iteraciones se permiten y bajo qué condiciones el agente se detiene.

Importa porque la diferencia entre un agente útil y uno peligroso o costoso está en el loop. Un agente sin límite de pasos puede iterar para siempre. Uno sin registro de estado puede repetir las mismas acciones. Uno sin manejo de errores puede fallar silenciosamente. Loop engineering aplica disciplina de ingeniería a ese ciclo: cada iteración tiene costo, cada tool call tiene riesgo, y cada paso debe ser observable y recuperable.

Alcance y supuestos

Este paquete cubre loop engineering a nivel de práctica y diseño: estado del agente, ejecución de herramientas, manejo de errores, límites de pasos, tracking de costos, condiciones de término y patrones como human-in-the-loop.

No cubre implementación completa de frameworks de agentes, coordinación multi-agente, ni reinforcement learning para optimización del loop. Asume que entiendes agentes IA, tool calling, ensamblaje de contexto y el ciclo de inferencia de LLMs.

Modelo mental

Piensa en un piloto automático de avión. El loop es: leer instrumentos (observar), decidir ajuste (razonar), mover superficies de control (actuar), volver a leer instrumentos (observar). Cada ciclo es rápido, cada acción es pequeña, y hay límites duros: si algo falla, el sistema alerta y pasa a control humano.

Loop engineering aplica esa misma disciplina a agentes de software. El agente no debe operar en un vacío sin retroalimentación. Cada paso produce una observación que alimenta el siguiente. Si una herramienta falla, el loop debe decidir si reintentar, usar otra herramienta o detenerse. Si el costo acumulado excede un umbral, el loop debe terminar. Si el modelo produce una acción inválida, el loop debe detectarlo y corregir.

La práctica se resume en diseñar cinco cosas para cada loop:

1. Estado: qué recuerda el agente entre pasos (observaciones, resultados, contador de pasos, costo).
2. Ejecución: cómo se invocan herramientas, con qué timeouts, y qué pasa si fallan.
3. Observación: cómo se registra y formatea el resultado para el siguiente paso de razonamiento.
4. Término: bajo qué condiciones el loop se detiene — éxito, error, presupuesto agotado, handoff humano.
5. Recuperación: qué hace el agente cuando algo sale mal — reintento, fallback, escalación.

Uso práctico

Aplica loop engineering cuando diseñas agentes que ejecutan múltiples pasos:

• ✅ Agentes de soporte que investigan tickets llamando herramientas y consultando políticas.
• ✅ Asistentes de código que leen archivos, ejecutan tests y aplican fixes en ciclos.
• ✅ Flujos de automatización donde cada paso depende del resultado del anterior.
• ❌ No necesitas un loop complejo para un solo tool call; una llamada directa al modelo con function calling puede bastar.
• ❌ No diseñes loops sin límites; cada loop debe tener max steps, max cost, o max time.

Ejemplo trabajado: loop de agente con estado, errores y término

Supón que un agente debe procesar un ticket de soporte: buscar el pedido, revisar la política de devolución y proponer una acción. Sin loop engineering, el código llama herramientas secuencialmente y reza. Con loop engineering, el ciclo es explícito:

type AgentState = {
  task: string;
  observations: string[];
  stepsTaken: number;
  maxSteps: number;
  totalCostCents: number;
  maxCostCents: number;
  status: "running" | "success" | "error" | "max_steps" | "budget_exceeded";
  finalResponse?: string;
};

type ToolResult = {
  toolName: string;
  output: unknown;
  error?: string;
  costCents: number;
};

async function agentLoop(state: AgentState, tools: Tool[]): Promise<AgentState> {
  while (state.status === "running") {
    // 1. Verificar límites antes de iterar
    if (state.stepsTaken >= state.maxSteps) {
      state.status = "max_steps";
      state.observations.push("Límite de pasos alcanzado");
      break;
    }
    if (state.totalCostCents >= state.maxCostCents) {
      state.status = "budget_exceeded";
      break;
    }

    // 2. Construir contexto y decidir acción
    const context = buildLoopContext(state);
    const decision = await callModel(context, tools);

    // 3. Si el modelo decide terminar
    if (decision.action === "finish") {
      state.status = "success";
      state.finalResponse = decision.response;
      break;
    }

    // 4. Ejecutar herramienta y registrar observación
    const result = await executeTool(decision.toolName, decision.args);
    state.stepsTaken++;
    state.totalCostCents += result.costCents;
    state.observations.push(
      `[Paso ${state.stepsTaken}] ${decision.toolName}: ${
        result.error ?? JSON.stringify(result.output).slice(0, 200)
      }`
    );

    // 5. Si la herramienta falló, decidir si reintentar o abortar
    if (result.error && decision.shouldRetry !== true) {
      state.status = "error";
      state.observations.push(`Error irrecuperable en ${decision.toolName}`);
      break;
    }
  }

  return state;
}

Lo que hace robusto este loop:

1. Límites explícitos: maxSteps y maxCostCents evitan loops infinitos y facturas sorpresa.
2. Estado observable: observations registra cada paso para debugging y auditoría.
3. Decisión del modelo: el LLM decide la acción, pero el loop impone las reglas.
4. Manejo de errores: si una herramienta falla y no es reintentable, el loop termina con error.
5. Condición de término clara: finish, max_steps, budget_exceeded, error — cada estado final es distinto.

Antes de implementar un agent loop, cinco preguntas:

1. ¿Cuántos pasos como máximo debería ejecutar este agente?
2. ¿Qué pasa si una herramienta falla? ¿Reintento, fallback, escalación?
3. ¿Cómo sabes que el agente terminó con éxito vs. se rindió?
4. ¿Cada paso es visible? Si algo sale mal en producción, ¿puedes ver qué pasó?
5. ¿Cuánto cuesta cada iteración y cuál es el presupuesto máximo aceptable?

Evidencia

• Anthropic Engineering, Building Effective AI Agents distingue workflows predefinidos de agentes que dirigen su propio proceso y usan herramientas bajo orquestación, destacando la importancia del diseño del loop.
• LangGraph documentation, Overview presenta LangGraph como un framework para construir aplicaciones stateful con agentes multi-actor, modelando el loop del agente como un grafo de estados con checkpoints.