Cómo ejecutar tools en paralelo en un agente

Cómo ejecutar tools en paralelo en un agente

Empieza varias consultas juntas

Imagina que el agente necesita consultar alimentos, ejercicios y rutinas para preparar una recomendación. Ya sabe qué buscar en cada caso y ninguna consulta necesita el resultado de las otras. Tu programa puede empezar las tres juntas.

Si cada consulta tarda 300 milisegundos, ejecutarlas una tras otra requiere unos 900 milisegundos. Si las tres pasan la mayor parte de ese tiempo esperando una descarga, empezarlas juntas puede acercar el tiempo total a 300 milisegundos. La idea es aprovechar el tiempo de espera de una consulta para avanzar con las demás.

Una tras otra

Alimentos
300 ms
Ejercicios
300 ms
Rutinas
300 ms
0300600900 ms

Tiempo total: unos 900 ms

Las tres juntas

Alimentos
300 ms
Ejercicios
300 ms
Rutinas
300 ms
0300600900 ms

Tiempo total: unos 300 ms

Ejemplo ilustrativo: cada barra representa una consulta. Los tiempos reales dependen de las operaciones y de los recursos que compartan.

El modelo puede pedir varias tools en una misma respuesta, pero es tu programa el que las ejecuta. Recibir tres peticiones no basta: el código tiene que empezar las consultas antes de ponerse a esperar sus resultados.

Decide qué puede ejecutarse junto

La primera decisión es distinguir las tools que consultan datos de las que cambian datos. Después comprueba sus dependencias: una consulta puede empezar junto a otra si ya tiene todos sus argumentos y no necesita un resultado ni un cambio pendiente. Define estas reglas en el código; no dependas de que el modelo adivine cuáles son seguras.

Por ejemplo, el agente pide buscar alimentos, buscar ejercicios, guardar un peso y consultar el peso guardado. Podemos organizar esas cuatro operaciones así:

  1. Buscar alimentos y buscar ejercicios.

    Son dos consultas independientes. Empiezan juntas y esperamos a que ambas terminen.

  2. Guardar un peso de 75 kg.

    Ahora cambiamos un dato. Esta operación se ejecuta sola y esperamos a que termine de guardarlo.

  3. Consultar el peso guardado.

    Esta consulta empieza después del guardado, para leer los 75 kg. Adelantarla podría devolver el peso anterior.

También hay que evitar que dos cambios se pisen. Imagina un almacén que guarda la lista completa de alimentos: dos operaciones leen la misma lista vacía; una prepara una lista con una manzana y la otra una lista con un yogur. Si guardan esas listas por separado, el segundo guardado puede borrar lo que añadió el primero. Al ejecutarlas una tras otra, la segunda puede leer la lista que ya contiene la manzana y añadir el yogur.

Gymnasia toma una decisión sencilla: ejecuta todos los cambios uno tras otro, aunque afecten a datos distintos. Una tool que el programa no conoce también espera su turno. Si una acción necesita confirmación del usuario, espera esa decisión y la finalización de la acción antes de continuar. Y una consulta posterior debe leer el dato actualizado, en lugar de reutilizar una copia anterior al guardado.

Cómo implementarlo, paso a paso

Necesitas un componente que reciba las peticiones del modelo y decida cuándo empezar cada una. Puedes construirlo con estas reglas:

  1. Declara qué hace cada tool.

    Indica si consulta o modifica datos y qué condiciones permiten ejecutarla junto a otras.

  2. Prepara cada petición.

    Comprueba los datos de entrada de la tool, por ejemplo que una búsqueda incluya el texto que debe buscar. Conserva también el identificador que viene con la petición del LLM. Cuando la tool termine, enviarás su resultado de nuevo al LLM junto a ese identificador, para que el modelo sepa a qué petición corresponde.

  3. Pon un límite a las consultas activas.

    Gymnasia permite hasta cuatro. Si llega una quinta, espera a que termine alguna. Es un punto de partida que debes ajustar con mediciones, no una cifra óptima para todas las apps.

  4. Respeta los cambios de datos.

    Recorre las peticiones en su orden original. Antes de modificar un dato, espera todas las consultas anteriores. Termina ese cambio antes de empezar las siguientes peticiones.

  5. Recoge los resultados.

    Cuando terminen las tools, reúne sus resultados y envíaselos al LLM para que continúe la conversación y prepare la respuesta al usuario. En esta implementación los enviamos en el orden de las peticiones originales y cada uno conserva su identificador. Así el modelo distingue el resultado de buscar alimentos del resultado de buscar ejercicios.

Este pseudocódigo muestra la decisión central. Un «hueco» es simplemente permiso para iniciar otra consulta sin superar el límite:

for each call in the order requested:
    if the call can run independently:
        wait until a read slot is free
        start the call; save its result or error with its label
    else:
        wait for all running calls
        run this call on its own and wait for it to finish
        save its result or error with its label

wait for all running calls
send every result or error to the LLM in request order, with its label

Así, varias consultas consecutivas pueden empezar juntas, pero ninguna se adelanta a un cambio anterior. Decide también cómo representar los errores: si una consulta falla, conserva ese error junto a su petición sin perder las respuestas de las demás. Si el fallo obliga a detener el turno, deja de iniciar operaciones y espera las que ya empezaron. Evita repetir automáticamente un cambio cuando no sabes si llegó a guardarse.

Relaciona cada respuesta con su petición

Supongamos que el LLM pide estas consultas: A busca alimentos, B busca ejercicios y C consulta rutinas. Puede que C termine primero. Su resultado sigue correspondiendo a la consulta de rutinas, aunque sea el primero que recibe tu programa.

Orden de las peticiones del LLMA: alimentos → B: ejercicios → C: rutinas
Orden en que terminan las toolsC: rutinas → A: alimentos → B: ejercicios
Orden de envío de resultados al LLMA: alimentos → B: ejercicios → C: rutinas

Tu programa guarda cada resultado con el identificador de su petición en cuanto llega. Cuando todas las consultas han terminado, prepara el siguiente mensaje al LLM con A y sus alimentos, B y sus ejercicios, y C y sus rutinas. El modelo puede usar esos datos para continuar la conversación y redactar la respuesta que verá el usuario.

La etiqueta conecta la petición del LLM con el resultado de la tool; no es un número que deba ver el usuario. Conserva el identificador que viene con cada petición. El nombre de la tool no basta: el LLM podría pedir dos búsquedas de alimentos distintas en el mismo turno.

Tests para comprobar que el patrón funciona

Primero prueba el componente que decide cuándo ejecutar las tools usando funciones de prueba: tú controlas cuándo empiezan, cuándo terminan y qué devuelven. Así compruebas las reglas sin depender de una conexión ni de un modelo real. Incluye estos casos:

  1. Las consultas independientes empiezan juntas.

    Deja dos consultas esperando y comprueba que ambas han empezado antes de permitir que termine ninguna. Esto demuestra que la segunda no espera a la primera.

  2. El límite de operaciones se respeta.

    Con un límite de cuatro, prepara cinco consultas. Comprueba que empiezan cuatro, que la quinta espera y que puede empezar cuando termina una de las anteriores.

  3. Guardar termina antes de consultar el dato nuevo.

    Usa el ejemplo de las dos búsquedas, el guardado de 75 kg y la lectura del peso. El guardado espera a las búsquedas; la lectura espera al guardado y devuelve 75 kg.

  4. Los resultados vuelven a la petición correcta del LLM.

    Haz que las consultas terminen C, A y B. Comprueba que el mensaje enviado al LLM contiene A con alimentos, B con ejercicios y C con rutinas, en ese orden y con sus identificadores originales.

  5. Un error no hace desaparecer los demás resultados.

    Haz que una consulta falle y que otras dos terminen bien. Si ese error permite continuar, el LLM debe recibir los dos resultados y el error asociado a la petición que falló. Prueba aparte que un fallo que obliga a detener el turno impide iniciar más operaciones.

  6. Dos cambios conservan lo que guardó el anterior.

    Añade una manzana y después un yogur. Vuelve a leer la lista guardada y comprueba que contiene ambos. El test verifica los datos que quedaron guardados, además del orden de las operaciones.

Después prueba el recorrido completo con un LLM simulado: entrega las peticiones A, B y C, ejecuta las tools y comprueba el siguiente mensaje que tu programa enviaría al modelo. Debe contener los resultados correctos, sus identificadores y el orden elegido. Esta prueba comprueba que la planificación y el envío al LLM encajan; medir solo la velocidad no detectaría un resultado asociado a la petición equivocada.

También funciona en un móvil

Un móvil puede iniciar varias descargas mientras espera sus respuestas. Esta técnica aprovecha esas esperas; no distribuye por sí sola los cálculos locales entre varios núcleos. Si las tools hacen mucho cálculo, iniciarlas juntas no garantiza una mejora. Mide en el dispositivo y con la conexión que usará tu app.

Comprueba la mejora y los resultados

Compara las mismas consultas antes y después del cambio. Para saber qué aporta esta implementación, mide desde que empiezan las tools hasta que están disponibles sus resultados. Mide aparte el tiempo que tarda el modelo en generar la respuesta final.

Repite la comparación cuando la app necesita descargar los datos y cuando ya los tiene guardados. La mejora puede ser grande en el primer caso y pequeña en el segundo. Usa varias ejecuciones, no una sola, y compara el tiempo típico y los casos más lentos.

Comprueba además que cada respuesta conserva su petición, que una lectura posterior al guardado devuelve el dato nuevo, que nunca se supera el límite de operaciones activas y que los errores no hacen desaparecer otros resultados. La velocidad solo es útil si la app sigue dando respuestas correctas.

Un ejemplo medido en Gymnasia

Comparamos tres búsquedas de ejercicios en la versión web de Gymnasia. Un modelo simulado entregaba siempre las mismas peticiones y cada descarga de datos de búsqueda tenía una espera controlada. Cuando esos datos aún debían descargarse, el tiempo mediano bajó de unos 696 a 264 milisegundos.

La medición incluía recibir las peticiones, ejecutar las búsquedas y preparar sus resultados para continuar la conversación. No incluía la generación de una respuesta por un modelo real. Es una comparación controlada en web; la mejora en un móvil todavía requiere medirla en el dispositivo. Método y resultados completos.

Una pieza del agente que estamos construyendo

En la serie usamos una app de gimnasio para explicar cómo construir un agente que consulta y modifica datos. Ejecutar tools en paralelo añade una decisión al programa que lo controla: qué puede empezar junto y qué debe esperar. Puedes aplicar el mismo patrón a otros agentes, conservando el límite de operaciones y la relación entre cada petición y su respuesta.

Sigue la serie sobre cómo construir un agente con Gymnasia. Si quieres ver la implementación concreta de este ejemplo, consulta el cambio de código y sus pruebas.

Seguir leyendo

Últimos posts -->

¿Has visto estos proyectos?

Gymnasia

Gymnasia Gymnasia
Expo
React Native
TypeScript
OpenAI
Anthropic

App de fitness con dos agentes que se ejecutan íntegramente en el dispositivo, sin backend, de forma que los datos del usuario nunca salen del móvil. Un coach conversacional BYOK con tools locales y system prompt remoto con fallback offline, y un estimador de comidas que saca los macronutrientes de una foto del plato, con lectura de códigos de barras contra OpenFoodFacts.

LangGraph Deep Researcher

LangGraph Deep Researcher LangGraph Deep Researcher
Python
LangGraph
FastAPI
React
TypeScript
Docker

Sistema multiagente de investigación construido con LangGraph. Un supervisor descompone tu pregunta en temas y lanza subagentes de búsqueda en paralelo; cada uno comprime sus hallazgos antes de pasarlos a un agente redactor que escribe el informe final en markdown con sus fuentes. Streaming en vivo por WebSockets, modelo configurable por rol y claves de API propias que nunca se guardan en el servidor.

Tau

Tau Tau
Python
LangChain

Sistema multiagente de tutoría para estudiantes de secundaria, con un agente por asignatura y material de curso elaborado y validado por un equipo de profesores. Llegó a usarse con alumnos reales en un colegio privado en España y en un instituto en Colombia.

Ver todos los proyectos -->
>_ Disponible para proyectos

¿Tienes un proyecto con IA?

Hablemos.

maximofn@gmail.com

Especialista en Machine Learning e Inteligencia Artificial. Desarrollo soluciones con IA generativa, agentes inteligentes y modelos personalizados.

¿Quieres ver alguna charla?

Últimas charlas -->

¿Quieres mejorar con estos tips?

Últimos tips -->

Usa esto en local

Los espacios de Hugging Face nos permite ejecutar modelos con demos muy sencillas, pero ¿qué pasa si la demo se rompe? O si el usuario la elimina? Por ello he creado contenedores docker con algunos espacios interesantes, para poder usarlos de manera local, pase lo que pase. De hecho, es posible que si pinchas en alún botón de ver proyecto te lleve a un espacio que no funciona.

Flow edit

Flow edit Flow edit

Edita imágenes con este modelo de Flow. Basándose en SD3 o FLUX puedes editar cualquier imagen y generar nuevas

FLUX.1-RealismLora

FLUX.1-RealismLora FLUX.1-RealismLora
Ver todos los contenedores -->
>_ Disponible para proyectos

¿Tienes un proyecto con IA?

Hablemos.

maximofn@gmail.com

Especialista en Machine Learning e Inteligencia Artificial. Desarrollo soluciones con IA generativa, agentes inteligentes y modelos personalizados.

¿Quieres entrenar tu modelo con estos datasets?

short-jokes-dataset

HuggingFace

Dataset de chistes en inglés

Uso: Fine-tuning de modelos de generación de texto humorístico

231K filas 2 columnas 45 MB
Ver en HuggingFace →

opus100

HuggingFace

Dataset con traducciones de inglés a español

Uso: Entrenamiento de modelos de traducción inglés-español

1M filas 2 columnas 210 MB
Ver en HuggingFace →

netflix_titles

HuggingFace

Dataset con películas y series de Netflix

Uso: Análisis de catálogo de Netflix y sistemas de recomendación

8.8K filas 12 columnas 3.5 MB
Ver en HuggingFace →
Ver más datasets -->