English

Cuenta las llamadas al modelo por turno

Una pregunta. Cinco llamadas al modelo. Estás pagando por cuatro que nunca ves. Cuando un agente recibe una respuesta malformada o inválida, el código que envuelve tu modelo puede volver a preguntar en silencio — una y otra vez — hasta que algo valide. Esos bucles ocultos queman dinero, agregan latencia y esconden el bug real detrás de la factura.

De dónde salen las llamadas extra

La mayoría de los stacks de agentes modernos hacen un reintento que nunca escribiste. Suele ser uno de tres:

• Reintentos de salida estructurada. Las librerías de validación le mandan un esquema al modelo, y si la respuesta no parsea, le devuelven el error y vuelven a preguntar. En Instructor, max_retries controla exactamente cuántos viajes extra cuesta esto — cada reintento es una nueva llamada a la API del modelo.
• Reintentos de transporte a nivel de framework. LangChain reintenta las llamadas al modelo hasta 6 veces por defecto con backoff exponencial antes de rendirse. Una llamada con rate limit o inestable se convierte en varias, sin avisar.
• Bucles de herramientas del agente. Cada llamada a una herramienta que hace un agente es otra llamada al modelo para decidir el siguiente paso. Un plan de cinco pasos son al menos cinco llamadas, antes de cualquier reintento.

Combina dos de estos — un reintento de salida estructurada dentro de un framework que también reintenta — y un solo "turno" se multiplica en silencio.

Cuenta el número real

No adivines. Instrumenta el punto donde tu código llama al modelo y registra una línea por llamada con un ID de turno. Después cuenta.

calls_this_turn = 0

def call_model(**kwargs):
    global calls_this_turn
    calls_this_turn += 1
    resp = client.chat.completions.create(**kwargs)
    log.info("model_call", turn=turn_id, n=calls_this_turn,
             tokens=resp.usage.total_tokens)
    return resp

Cada proveedor devuelve un objeto usage por respuesta, así que también obtienes los tokens por llamada gratis. Si usas un SDK de agentes, aprovecha su contabilidad integrada: el OpenAI Agents SDK expone request_usage_entries, un desglose por solicitud dentro de un mismo turno — una ejecución con entradas [100K, 150K, 80K] hizo tres llamadas al modelo, no una.

Arréglalo: acótalo, regístralo, exponlo

Un reintento silencioso no es resiliencia — es un detector de bugs que silenciaste. Reemplázalo por un reintento que sea:

1. Acotado. Fija un tope explícito. En Instructor eso es max_retries=2; en LangChain, baja el max_retries externo a un número que elijas tú en lugar del 6 por defecto. Nunca lo dejes sin límite.
2. Registrado. Emite el motivo de la falla en cada reintento, no solo en el éxito final. El dato interesante es por qué falló el primer intento.
3. Expuesto. Cuando se alcanza el tope, lanza un error — no devuelvas una respuesta degradada como si estuviera bien. Una falla que puedes ver es más barata que una falla que pagas en silencio.

Nivel avanzado: pon un presupuesto al turno

Fija un presupuesto duro de llamadas por turno (digamos, 3) y dispara una alerta cuando un turno lo exceda. Combina el conteo de llamadas con el uso de tokens para atrapar el caso caro: un turno dentro de su presupuesto de llamadas pero con 10x el costo en tokens es un contexto desbocado, no un bucle. Envía ambos números a tus dashboards desde el día uno — reconstruir la visibilidad de costos después de que llega la factura es como los equipos descubren que estaban pagando 5x todo el tiempo.

Recursos

• Instructor — Retrying — cómo max_retries convierte fallas de validación en llamadas extra al modelo
• LangChain — Structured output — los viajes de tool-calling detrás de with_structured_output
• LangChain — model_retry middleware — reintento configurable ante excepciones con backoff
• OpenAI Agents SDK — Usage — request_usage_entries cuenta las llamadas reales por turno