Ejecutar varios agentes en Antigravity: patrones que de verdad funcionan

Ejecutar varios agentes en Antigravity parece sencillo hasta que el tercer agente se cae en silencio y pasas cuarenta minutos preguntándote por qué el resultado está a medio hacer. La ejecución en paralelo es una de las funciones más potentes de Antigravity, pero exige un modelo mental concreto. Este artículo explica qué funciona de verdad en producción, cómo estructuran sus pipelines de agentes los equipos reales y cómo evitar las trampas que, a primera vista, parecen inofensivas.

Qué hace Antigravity de forma diferente

La mayoría de los frameworks de agentes serializan por defecto. Defines una tarea, un agente la recoge, la termina y solo entonces empieza la siguiente. Antigravity invierte esta lógica. Su planificador central se basa en un bucle de eventos concurrente que trata las tareas de los agentes como elementos de primera clase, no como añadidos improvisados sobre un pool de hilos.

El bucle que lo gestiona todo

En su núcleo, Antigravity ejecuta un bucle reactivo. Cuando registras un agente, no estás lanzando un proceso nuevo. Estás registrando una corrutina que gestiona el planificador. Esto significa que la latencia se acumula de otra manera que en los sistemas con hilos. Diez agentes ejecutándose a la vez en Antigravity suelen superar a diez llamadas secuenciales, porque el tiempo de espera de E/S, que es donde la mayoría de las llamadas a LLM pasan el 80% de su tiempo, se comparte entre todo el pool.

La idea clave aquí: concurrente no significa descontrolado. Antigravity te da los bloques de construcción, pero la lógica de coordinación es enteramente tuya.

Por qué importan los límites de un solo agente

Antes de añadir más agentes, conviene entender por qué existe el valor por defecto de un solo agente. Un agente solo es predecible. Lee un contexto, actúa sobre él y devuelve un resultado. En el momento en que introduces un segundo agente que lee el mismo contexto, aparece la posibilidad de resultados divergentes. Antigravity no concilia esas diferencias por arte de magia. Esa tarea es tuya.

💡 Empieza con un solo agente, mide dónde pasa el tiempo esperando y solo entonces decide qué tiempos de espera compensa paralelizar.

Configurar varios agentes

Configurar varios agentes en Antigravity exige tres decisiones previas: cómo se crean los agentes, si comparten estado y cómo devuelven los resultados al orquestador.

Crear agentes en paralelo

El enfoque más directo es la creación explícita a nivel de definición de tareas. En lugar de llamar a los agentes uno tras otro, defines un lote de tareas y dejas que el planificador las despache a la vez.

tasks = [
    agent.create_task("summarize", doc_a),
    agent.create_task("summarize", doc_b),
    agent.create_task("summarize", doc_c),
]
results = await asyncio.gather(*tasks)

Copiar prompt

El detalle crítico: asyncio.gather en Antigravity respeta el tamaño del pool de agentes. Si fijas max_concurrent=3 y despachas 10 tareas, las tres primeras se ejecutan de inmediato. Las siete restantes esperan en cola. Es un control de frecuencia intencionado, no un error.

Estado compartido frente a tareas aisladas

Esta es la decisión que rompe la mayoría de las configuraciones con varios agentes. Hay tres patrones válidos:

Las tareas aisladas son casi siempre la opción predeterminada correcta. Si dos agentes necesitan el mismo dato, pasa una copia a cada uno. El costo de memoria merece la pena por la previsibilidad.

El estado de escritura compartida debe tratarse como último recurso, no como comodidad. Si lo necesitas sin remedio, usa el StateManager integrado de Antigravity con bloqueos explícitos, en lugar de un dict plano de Python.

Pasar contexto entre agentes

Cuando la salida del Agente A alimenta al Agente B, existe una dependencia. En Antigravity, las dependencias rompen el paralelismo por definición. Dos agentes que dependen el uno del otro no pueden ejecutarse al mismo tiempo.

El patrón más limpio es el traspaso explícito:

summary = await agent_a.run(document)
analysis = await agent_b.run(summary)

Copiar prompt

Para pipelines grandes con dependencias mixtas, usa un enfoque de grafo de dependencias. Define qué tareas son independientes (se ejecutan en paralelo) y cuáles son secuenciales (se ejecutan en orden), y deja que el planificador de Antigravity se encargue del resto.

Patrones que funcionan a escala

Tres patrones cubren aproximadamente el 90% de los casos de uso con varios agentes en Antigravity. No son exóticos. Son aburridos, y eso, en el mejor sentido posible.

El patrón de abanico (fan-out)

El patrón de abanico es el más habitual para el trabajo por lotes con IA. Una entrada, muchos agentes en paralelo y un único punto de recogida.

Cómo funciona:

1. El orquestador recibe un lote de elementos, por ejemplo 20 documentos
2. El orquestador crea un agente por elemento (o por fragmento)
3. Todos los agentes se ejecutan de forma concurrente
4. El orquestador recoge todos los resultados cuando terminan

Este patrón brilla cuando las tareas son fácilmente paralelizables: ningún agente necesita saber qué hace otro. La generación de imágenes, el resumen de documentos, las tareas de clasificación y la traducción encajan a la perfección en esta forma.

💡 Para lotes muy grandes, añade un semáforo que controle la concurrencia máxima: asyncio.Semaphore(10) garantiza que nunca crees más de 10 agentes a la vez, protegiendo los límites de frecuencia de las API posteriores.

La cadena de pipeline

La cadena de pipeline es el complemento del abanico: un flujo estrictamente secuencial en el que cada agente se basa en la salida del anterior.

Agent 1 (Research) → Agent 2 (Draft) → Agent 3 (Edit) → Agent 4 (Format)

Copiar prompt

Ideal para: tareas en las que la calidad depende del refinamiento progresivo. La redacción, la generación de código y el razonamiento en varios pasos se benefician de las cadenas de pipeline, porque los agentes posteriores pueden corregir los errores de los anteriores.

El riesgo de las cadenas de pipeline es la propagación de errores. Si el Agente 1 devuelve una salida defectuosa, los agentes 2 a 4 seguirán construyendo sobre ese fallo con total confianza. Añade validación entre etapas, aunque sea una comprobación simple de longitud o de esquema.

El modelo supervisor

El modelo supervisor es el más sofisticado de los tres. Un agente, el supervisor, orquesta un grupo de agentes trabajadores. El supervisor no hace el trabajo en sí. Planifica, delega, revisa y decide si hay que reintentar.

Las responsabilidades del supervisor:

• Descomponer la tarea original en subtareas
• Asignar las subtareas a los agentes trabajadores adecuados
• Validar cada resultado antes de pasarlo a la siguiente etapa
• Gestionar los fallos reintentando, reasignando o escalando

Para este patrón, Kimi K2.6 y GPT 5.1 son excelentes modelos supervisores. Ambos están pensados para tareas de orquestación de agentes, y GPT 5.1 está diseñado específicamente para crear agentes de IA. Como trabajadores, modelos más ligeros como Claude 4.5 Haiku o GPT 4.1 Mini reducen los costos de forma notable sin sacrificar calidad en tareas bien acotadas.

Dónde se rompe todo

La mayoría de los fallos con varios agentes en Antigravity caen en dos categorías. Ambas se pueden evitar una vez sabes qué vigilar.

Condiciones de carrera en recursos compartidos

Una condición de carrera se produce cuando dos agentes escriben en el mismo recurso al mismo tiempo y ninguno sabe que el otro existe. En Antigravity, normalmente aparece así:

• Dos agentes actualizan el mismo archivo: la segunda escritura sobrescribe la primera sin avisar
• Dos agentes llaman al mismo endpoint de API: los límites de frecuencia se activan sin aviso
• Dos agentes actualizan un dict compartido: una de las actualizaciones desaparece

La solución es no escribir nunca en un recurso compartido sin un bloqueo. En la práctica, esto significa:

lock = asyncio.Lock()

async def safe_write(lock, data, destination):
    async with lock:
        destination.append(data)

Copiar prompt

Para recursos externos como archivos o API, serializa las escrituras a través de un único agente escritor dedicado. Los demás agentes pasan sus salidas al escritor; el escritor es el único que toca el recurso.

Colisiones en el presupuesto de tokens

Este caso es menos evidente. Cuando ejecutas varios agentes a la vez, cada uno solicita tokens al mismo endpoint del modelo. Si no gestionas el gasto total de tokens concurrentes, alcanzarás los límites de frecuencia en momentos impredecibles.

El patrón aquí es el presupuesto de tokens a nivel de orquestador. Antes de crear los agentes, estima el total de tokens que necesita el lote. Si la estimación supera la ventana de límite de frecuencia, introduce una pausa o reduce el tamaño del lote.

💡 Para cargas de trabajo paralelas intensas, Llama 4 Maverick Instruct y Deepseek v3.1 ofrecen opciones de alto rendimiento con límites de frecuencia generosos, lo que los convierte en opciones prácticas para pipelines de agentes con mucho volumen.

Síntomas habituales de las colisiones en el presupuesto de tokens:

• Los agentes terminan, pero algunos resultados aparecen truncados
• Errores 429 intermitentes sin un patrón claro
• La calidad total de la salida baja a medida que aumenta el tamaño del lote
• Algunos agentes devuelven respuestas vacías o incompletas

Si ves alguno de estos síntomas, revisa tu consumo concurrente de tokens antes de dar por hecho que hay un error en la lógica de tus agentes.

Combinar agentes con la generación de imágenes con IA

Las configuraciones con varios agentes resultan especialmente interesantes cuando combinas tareas de generación de texto y de imagen. Un caso de uso real y habitual: generar un lote de artículos y producir automáticamente las imágenes de cada uno en paralelo.

Un agente por tipo de medio

El enfoque más limpio asigna agentes separados a tipos de medio distintos. Un agente gestiona toda la generación de texto. Un pool de agentes aparte atiende todas las solicitudes de generación de imágenes. Los dos pools se ejecutan en paralelo, pero nunca interactúan directamente.

Estructura típica:

1. El pool de agentes de texto procesa los artículos en paralelo
2. Cada artículo terminado pasa a la cola de imágenes
3. Los agentes de imagen recogen tareas de la cola y generan las ilustraciones
4. Un agente recolector agrupa los pares de texto e imagen para el resultado final

Esta separación importa por una razón práctica: la generación de texto y la de imagen tienen perfiles de latencia muy distintos. El texto de un artículo de 1000 palabras puede tardar 8 segundos. La generación de una imagen puede tardar entre 15 y 25 segundos. Si los mezclas en el mismo pool de agentes, las tareas de texto rápidas harán cola detrás de las tareas de imagen lentas. Mantenerlas separadas maximiza el rendimiento de ambas.

Usar LLM como coordinadores en PicassoIA

En los flujos de trabajo que combinan redacción y producción visual, usar un LLM como coordinador y modelos de imagen especializados como trabajadores es una arquitectura muy eficaz. El LLM se encarga de descomponer las tareas, refinar los prompts y revisar la calidad. Los modelos de imagen se encargan de la generación en sí.

En PicassoIA, esto se traduce en una división natural:

• Coordinador: Claude Opus 4.7 o GPT 5 para la orquestación, la planificación y la revisión
• Trabajadores de imagen: modelos de texto a imagen para la generación en paralelo
• Control de calidad: Kimi K2 Instruct o Gemini 3 Pro para validar las salidas según criterios definidos

💡 Al construir pipelines de agentes multimodales, trata la ingeniería de prompts como una tarea de primer nivel. Asigna un agente LLM exclusivamente a refinar los prompts de imagen a partir del contenido bruto del artículo antes de pasarlos a los modelos de imagen. La calidad de la salida mejora de forma notable con este paso.

Gestionar bien el estado de los agentes

El estado es el enemigo silencioso de los sistemas con varios agentes. Los agentes que cargan demasiado estado se vuelven impredecibles. Los que no cargan ninguno no sirven para nada. El punto ideal son los agentes sin estado con inyección explícita de contexto.

Qué significa esto en la práctica:

• Cada agente recibe todo lo que necesita en un único objeto de entrada
• Los agentes no mantienen memoria interna entre llamadas
• Todo el estado vive en el orquestador, no en los agentes individuales

Este patrón, al que a veces se llama estilo de paso de mensajes, hace que los agentes sean mucho más fáciles de probar, depurar y escalar. Puedes sustituir cualquier agente sin actualizar los demás, porque ningún agente guarda un estado del que dependan los otros.

Antipatrones que conviene evitar:

En el momento en que te encuentres depurando por qué cambió la salida de un agente sin haber cambiado su código, la deriva del estado es casi siempre la culpable.

Lógica de reintentos y tolerancia a fallos

Los sistemas de producción con varios agentes fallan. Las llamadas de red caducan, las API de los modelos devuelven errores y, de vez en cuando, un agente produce una salida que no supera tus reglas de validación. Incorporar la lógica de reintentos en el orquestador desde el primer día, en lugar de añadirla después, es la diferencia entre un pipeline fiable y uno frágil.

Una estrategia de reintentos práctica:

1. Clasifica los fallos: transitorios (reintenta de inmediato), por límite de frecuencia (espera y reintenta) o fatales (escala a una persona)
2. Fija un máximo de reintentos por tarea: 3 es un valor razonable para la mayoría de las cargas de trabajo
3. Implementa una espera exponencial: espera 1 s, luego 2 s, luego 4 s entre reintentos
4. Registra cada fallo con su contexto: incluye el ID de la tarea, el ID del agente, el tipo de error y el hash de la entrada

En las tareas con mucho razonamiento, en las que un agente produce una respuesta lógicamente incorrecta en lugar de un error técnico, Deepseek R1 merece la pena como validador de respaldo. Su razonamiento paso a paso lo hace muy adecuado para detectar errores lógicos que otros modelos pasan por alto.

Reintento frente a respaldo:

No todos los fallos justifican un reintento con el mismo modelo. Considera un pool de respaldo en el que las tareas fallidas se reasignan a un modelo distinto. Una tarea que agota el tiempo en GPT 5 Pro podría terminar con éxito en Claude 4.5 Sonnet, sobre todo si el tiempo de espera se debió a la profundidad del razonamiento y no a un problema de conexión.

Construye tu primer flujo de trabajo con varios agentes

Ejecutar varios agentes en Antigravity no consiste en añadir más modelos a un script. Consiste en pensar en pipelines en los que cada etapa tiene una entrada clara, una salida clara y un modo de fallo claro.

Los equipos que más partido sacan a las configuraciones de Antigravity con varios agentes siguen una progresión sencilla:

1. Haz que un agente funcione a la perfección con una sola tarea
2. Identifica el cuello de botella (casi siempre la espera de E/S)
3. Paraleliza exactamente las tareas que están esperando
4. Añade un supervisor si la complejidad de la coordinación crece
5. Supervisa, reintenta y valida en cada etapa

La colección de modelos de lenguaje (LLM) de PicassoIA te ofrece la gama completa de modelos que necesitas para cada rol en esta arquitectura: trabajadores rápidos, supervisores capaces y razonadores profundos. Tanto si estás creando un pipeline de producción de contenidos, una herramienta de investigación automatizada o un flujo creativo multimodal, todos los bloques de construcción están disponibles.

Prueba hoy mismo a componer tu primer pipeline en abanico en PicassoIA. Elige una tarea por lotes que hagas a mano en este momento, asígnala a tres agentes en paralelo con Kimi K2.6 o GPT 5.1 y mide la diferencia. El primer resultado suele cambiar para siempre la forma en que piensas sobre la automatización.