Los agentes pagan caro por esperar: comparación de encuestas, bloqueos y tareas
Un punto de referencia de tres formas en que un agente puede esperar a que se complete una operación en la nube lenta: sondeo, bloqueo y tareas MCP, el costo en tokens de cada uno, y reglas para los diseñadores de herramientas.
Fuentes: Your Agent Doesn’t Know How to Wait
Casi todas las API de infraestructura en la nube contienen la misma funcionalidad de pausa. Una llamada de creación no devuelve un recurso ya completado, sino un comprobante:
{
"name": "operations/abc-123",
"status": "RUNNING",
"done": false
}
La base de datos necesita varios minutos para cargarse, y mientras tanto lo único que tiene el llamante es un ID de seguimiento. Este es el patrón de operación de larga duración, o LRO, y se aplica tanto en la provisión de infraestructura, el entrenamiento de modelos, las migraciones de bases de datos como en la transcodificación de video. Para una persona frente a una terminal es algo rutinario: ejecutar la orden, esperar y tomarse un café.
Para un agente de IA, sin embargo, representa un problema grave en el diseño. Las pruebas de rendimiento que compararon los diferentes métodos para manejar la espera mostraron una diferencia de 5 veces en los costos, una penalización de 11 veces en los tokens de salida generados y graves cuellos de botella de concurrencia. La mayoría de los creadores de herramientas no se dan cuenta de que están eligiendo un enfoque al redactar las definiciones de sus herramientas. La comparación abarcó tres métodos con cargas de trabajo idénticas y el mismo modelo: hacer consultas dentro del bucle del agente, bloquearse en el servidor y dejar que una tarea gestionada por el sistema se encargue de la espera.
Por qué esperar es costoso
Un agente es un modelo de lenguaje que funciona en un bucle. Recibe un objetivo y algunas herramientas, razona, llama a una herramienta, examina el resultado y decide qué hacer. Cada ciclo es un paso, y un paso no es una solicitud HTTP aislada. En cada paso, toda la conversación se vuelve a introducir en la ventana de contexto: el prompt del sistema, cada definición de herramienta, el objetivo y todas las llamadas y respuestas anteriores. Por lo tanto, el costo total de la tarea es aproximadamente el número de pasos multiplicado por el tamaño del contexto en cada paso.
Imagínese ahora al agente consultando el estado de una operación. Llama a get_operation y ve que está EN EJECUCIÓN; para decidir qué hacer a continuación necesita realizar un proceso completo de inferencia sobre todo lo acumulado. Vuelve a llamar, ve nuevamente que está EN EJECUCIÓN, y debe pagar por otro proceso completo. Se utiliza un modelo de tipo frontier, cuyo precio se calcula en dólares por millón de tokens, para implementar la función de espera.
A continuación aparecen cuatro términos repetidos:
- Pasos: cantidad de llamadas a herramientas que realizó el agente. Cuantos menos, mejor.
- Tokens facturados: la métrica de costo, que valora el contexto en caché de forma más económica, aproximadamente a una décima del precio de una entrada nueva. Esa es la cifra que refleja la factura en la nube.
- Superficie de herramientas: todo aquello a lo que el agente tiene permiso para acceder, ya sea a través de un servidor MCP o ingresando comandos CLI en una shell.
- Tareas: trabajos en segundo plano que se transfieren al harness o al entorno de ejecución MCP, lo que mantiene el hilo principal del agente sin bloqueos.
Cómo se ejecutó la prueba de rendimiento
La prueba utilizó Evalbench contra el mismo plano de control de base de datos en la nube en tres configuraciones:
- MCP Toolbox, un servidor con una configuración de base de datos preconstruida.
- Un servidor MCP básico que expone herramientas simples de creación, lectura, actualización y eliminación, además del estado de las operaciones.
Había 12 tareas por nivel de dificultad, ejecutadas con Claude Opus en una versión CLI fija, con un juez automatizado que realizaba la puntuación. Entre las tareas difíciles, dos duraron mucho tiempo: clonar una instancia y provisionar una de alta disponibilidad. Las tres configuraciones manejan la espera de tres maneras diferentes.
Los tres patrones de espera
Consultas dentro del bucle
El servidor devuelve un ID de operación y el agente sigue haciendo consultas dentro de su bucle de razonamiento:
create_instance() → operations/abc-123
get_operation(abc-123) → RUNNING
get_operation(abc-123) → RUNNING
... ×10 ...
get_operation(abc-123) → DONE
Se realizan viajes completos a través del contexto del modelo solo para darse cuenta de que un clon sigue en proceso.
Bloqueo en el servidor
El servidor ofrece una herramienta que mantiene la conexión abierta hasta que la operación alcanza un estado final:
create_instance() → operations/abc-123
wait_for_operation(abc-123) → DONE (one call, eleven minutes later)
Ese es un paso. El tiempo de inactividad se procesa en un servidor cuyo costo es una fracción minúscula de un centavo por hora, y no dentro de un contexto de modelo cuyo costo se calcula en dólares por millón de tokens. El problema es que el bloqueo es estrictamente secuencial, y mientras la llamada permanece abierta, el hilo del agente se congela.
Tareas entregadas al sistema
En lugar de bloquear al agente o gastar tokens en consultas, el agente transfiere la operación a un ejecutor de tareas en segundo plano:
Bash(cmd, run_in_background: true) → task_id: task-8921
... agent configures network rules, audits schemas, writes migration scripts ...
TaskOutput(task-8921, block: true) → done
Gracias a la extensión MCP Tasks, iniciar un trabajo y obtener su resultado se convierten en eventos separados. El agente inicia la tarea, recibe un identificador de tarea y pasa a realizar otras tareas útiles. Cuando finalmente necesita acceder a la base de datos, verifica dicho identificador o espera una señal de finalización. Solo este patrón permite que un agente espere varias operaciones al mismo tiempo o combine una espera prolongada con cálculos productivos.
Costo de la prueba de clonación
En la evaluación de clonación (clonar una instancia, esperar a que esté lista, confirmar su estado), la operación subyacente tarda aproximadamente 13 minutos en tiempo real en cada entorno. Las diferencias en el tiempo real fueron pequeñas, pero la economía de tokens varió significativamente:
- MCP Toolbox, con su espera bloqueante, obtuvo los mejores resultados en todas las métricas: 4 pasos, 211,854 tokens facturados, 765 segundos.
- El método básico de consulta del servidor MCP, que realiza diez intentos, tardó más tiempo, con 864 segundos en un total de 23 pasos.
- La CLI de respaldo generó la mayor carga adicional: 328,316 tokens facturados y 14,108 tokens de salida en 19 pasos.
La espera bloqueante única redujo los pasos en un 80%, los tokens facturados en un 26% en comparación con el polling básico, y los costos en un 35% en comparación con la CLI de respaldo. Además, terminó primero, ya que los agentes de polling se despertaban constantemente para realizar pasos adicionales de razonamiento.
La cifra más llamativa son los tokens de salida, que fueron 11 veces mayores en la CLI. Al no contar con herramientas MCP, el agente tuvo que escribir su propio script de reintentos en bash:
while true; do
st=$(cloud-cli operations list --project=production-db \
--instance=staging-replica --format='value(status)' | head -1)
[ "$st" = "DONE" ] && break
sleep 20
done
Escribió que ese bucle se ejecutó tres veces en formas ligeramente diferentes, ya que cada intento falló al no poder monitorear de manera adecuada. Al final, desistió y configuró un temporizador de despertar para cinco minutos después. Un modelo autónomo gastó 14,000 tokens de salida reinventando la función wait_for_operation desde cero, y lo hizo mal. Un agente al que se le niega la posibilidad de esperar creará su propia forma de hacerlo, a un alto costo, y el resultado es peor que la herramienta que no se envió.
Guía para diseñadores de API y herramientas
Diseñar para agentes implica repensar las convenciones de REST y gRPC teniendo en cuenta una limitación con la que nunca se han enfrentado: cada byte expuesto se vuelve a leer en cada paso. Cada práctica que se describe a continuación se basa en algo medible.
Ofrezca un modelo de espera por niveles
Diferentes situaciones requieren diferentes tiempos de espera, por lo que debe proporcionar los tres niveles y permitir que el agente elija:
create_instance() → { "operation": "operations/abc-123", "done": false }
get_operation(id) → Tier 1: inspect status, resume after interruption
wait_for_operation(id, timeout_seconds) → Tier 2: the 90% single-instance case
create_instance(async) → Tier 3: durable handle for parallel, fleet-wide work
Ofrecer los tres elementos no añade casi ningún costo adicional, pero la diferencia entre ellos representó el 55% del costo total en una tarea de clonación. Limitar la funcionalidad a la primera capa obligó al agente CLI a crear su propio mecanismo de intentos, con un costo de 14,108 tokens de salida.
Incluir el ID de la operación en el cuerpo JSON
REST clásico coloca los enlaces de las operaciones en encabezados como Location u Operation-Location. Las capas modernas de llamada a herramientas, como MCP, OpenAI Tools y LangChain, suelen omitir los encabezados HTTP y pasar únicamente la carga útil JSON al modelo.
Cuando el ID falta en el cuerpo de la solicitud, el modelo no falla de manera evidente. En su lugar, recurre a consultar directamente el recurso objetivo en lugar de verificar la operación. Esto es más costoso y menos claro, ya que los puntos finales de los recursos suelen devolver errores 404 o datos obsoletos durante la inicialización, lo que hace que el procesamiento activo sea indistinguible de un fallo. En una ejecución, esto generó 221 llamadas repetidas a get_instance.
Añadir tiempos de espera explícitos con resultados parciales estructurados
El bloqueo indefinido conlleva riesgos reales: conexiones interrumpidas, límites de 300 segundos impuestos por los balanceadores de carga y tareas congeladas de forma permanente. La herramienta de espera con el costo total más bajo no tenía tiempo de espera y, en un caso, bloqueó durante dieciséis minutos, dejando al agente sin ninguna medida de contingencia en caso de que la llamada se estancara.
La solución es un parámetro timeout_seconds, cuyo valor por defecto es de aproximadamente 300. Al alcanzar ese límite, se debe devolver un estado estructurado que no sea un error, en lugar de lanzar una excepción:
{
"done": false,
"operation": "operations/abc-123",
"elapsed_seconds": 300,
"status": "RUNNING",
"metadata": { "percent_complete": 65 }
}
Ahora el modelo puede observar el progreso y decidir si esperar de nuevo, poner el trabajo en segundo plano o informar al usuario, sin activar las rutinas de manejo de errores. Ese campo distingue entre una espera bloqueante y una apuesta.
Diseño para tareas y mecanismos asíncronos
El desarrollador de servidores que implementa MCP obtiene la forma estandarizada del tercer patrón a través de la extensión Tasks. Hay varios puntos importantes:
- Deje que el servidor decida la ruta de ejecución. Las tareas están dirigidas por el servidor. Anuncie io.modelcontextprotocol/tasks y devuelva un CreateTaskResult en lugar de un resultado normal siempre que una solicitud vaya a tardar mucho en ejecutarse. No exija que los llamantes pasen una bandera asíncrona, ya que el cliente elige activarla durante la negociación de capacidades.
- Devolver metadatos estructurados del identificador: un taskId, un estado inicial, ttlMs y pollIntervalMs, y asegurarse de que la tarea se cree de forma duradera antes de enviar la respuesta. De este modo, los mecanismos de monitoreo pueden seguir el progreso sin activar el modelo, y los clientes pueden recuperarse tras una caída.
- Soportar notificaciones de finalización. Cuando el transporte lo permite, utilizar notificaciones push/tareas en lugar de depender de la consulta periódica por parte del cliente. La consulta periódica sigue siendo la opción de respaldo, pero las notificaciones eliminan los viajes innecesarios.
- Mantener el estado de las tareas y operaciones completadas durante al menos 24 a 48 horas. Si el contexto de un agente se comprime durante una espera y posteriormente consulta un trabajo completado, debería recibir el resultado y no un 404.
Contar los esquemas
Cada herramienta impone un costo en cada paso de cada tarea, incluso en aquellas que nunca la utilizan. El costo es aproximadamente el producto de los pasos por el tamaño del contexto. Una espera de tipo bloqueante mejora el primer factor, mientras que el sobredimensionamiento del esquema puede anular las ventajas obtenidas mediante el segundo factor. Un servidor con la menor cantidad de pasos aún puede gastar la mayor cantidad de tokens si los esquemas de herramientas grandes se encuentran en el contexto en cada uno de ellos. Al contar con una superficie de herramientas reducida, cargar las definiciones bajo demanda, utilizar habilidades o agregar búsquedas de herramientas ayuda a mantener el esquema siempre presente de tamaño pequeño.
Conclusión
La espera es una decisión arquitectónica que determina la eficiencia económica de un agente, y no una simple optimización. Sustituir las consultas que consumen muchos tokens por esperas escalonadas, de tipo bloqueante o basadas en tareas reduce la carga adicional, y unas superficies de herramientas más simples ayudan a que los agentes escalen sin tener que recurrir a modelos especializados para contar los segundos.