Run Antigravity Workflows With Parallel Agents Safely

Un solo agente que recorre cincuenta archivos cambiados en una sola conversación va a perder el hilo. Lee, busca, ejecuta pruebas, y todo ese detalle se acumula en una sola ventana de contexto hasta que el trabajo del inicio se desvanece. Google Antigravity tomó otra ruta el 13 de noviembre con Dynamic Workflows, y vale la pena entender ese cambio antes de confiarle código real.

Con Dynamic Workflows, la coordinación sale de la conversación y entra en el código. Escribes /run-workflow y una tarea. El agente lee su habilidad de flujo de trabajo integrada y escribe un guion corto en Python para esa tarea. Antigravity te muestra el guion y te pide que lo apruebes. El guion luego se ejecuta en segundo plano mientras sigues trabajando, y el agente principal lee los registros al final y resume los resultados.

Este tutorial sigue la documentación oficial de Antigravity para Dynamic Workflows y para los comandos de barra, revisada el 14 de noviembre de 2026. No afirma haber hecho una prueba propia. El orden de seguridad importa más que la velocidad. Una tarea de revisión va primero porque no cambia nada. La edición viene después, y solo dentro de espacios de trabajo aislados.

Lo que vas a construir o aprender

Vas a ejecutar una revisión en paralelo de los archivos Python cambiados desde main, con un agente por archivo y un veredicto de una línea de cada agente. En el camino vas a aprender a leer un guion generado, a elegir un modelo para cada agente, y a detectar los ajustes que mantienen seguro el trabajo en paralelo.

También vas a aprender cuándo no usar un flujo de trabajo. Si los agentes necesitan hablar entre sí mientras trabajan, Antigravity te dirige a /swarm, donde los agentes comparten un tablero de mensajes. Si la tarea es un solo trabajo que puedes entregar completo, un solo subagente tiene menos carga. Un flujo de trabajo gana su lugar cuando el mismo control se repite en una lista, o cuando las etapas deben ejecutarse en un orden fijo.

Un agente por archivo, cada uno trabajando al mismo tiempo y ninguno compartiendo una conversación. Ilustración: Dirty Static

Antes de empezar

Cada agente que inicia un flujo de trabajo recibe su propia conversación. Ese agente no puede ver el guion y no puede ver a los otros agentes. Ese aislamiento es el diseño, y tiene una consecuencia simple. El guion debe dar a cada agente todo el contexto que necesita, la tarea exacta, y la forma del resultado que quieres recibir. Una instrucción vaga no produce una respuesta vaga de un solo agente. Produce respuestas vagas de veinte agentes a la vez.

Conoce los cinco bloques base antes de leer un guion. phase(name) inicia una fase con nombre y agrupa los registros y las tarjetas de agentes bajo esa fase. log(*args) agrega una línea a la fase. agent(prompt, schema, role, type_name, workspace, model) define un agente. parallel(items, fn) ejecuta una función para cada elemento al mismo tiempo y devuelve los resultados en el orden de los elementos, y si un elemento falla, los demás se cancelan. pipeline(items, fn) ejecuta los elementos uno a la vez en orden. await trajectory(...) trae al guion pasos anteriores de tu conversación.

Paso 1: Elige una tarea que se divida bien

Acción: elige una tarea que se divida en elementos que no dependan unos de otros, o en etapas con un orden claro. Buenas primeras tareas incluyen una revisión de cada archivo cambiado, una auditoría de cada paquete, o un ciclo de prueba y corrección para un error a la vez. Escribe el resultado que quieres en una frase antes de escribir el comando.

Resultado esperado: puedes nombrar la lista de elementos, el trabajo hecho en cada elemento, y el resultado que quieres para cada uno. Si no puedes nombrar esas tres cosas, la tarea aún no está lista para un flujo de trabajo.

Paso 2: Escribe la instrucción con los controles nombrados

Acción: en cualquier conversación en la App o el CLI, escribe /run-workflow y luego la tarea. Nombra el nivel de modelo, la forma del resultado, y el espacio de trabajo en la instrucción cuando esas elecciones importen. Para la primera tarea, usa esta instrucción tal cual, ajustando solo el nombre de la rama si tu rama principal tiene otro nombre.

/run-workflow List the Python files changed since main, then review each file in parallel for unhandled exceptions using the flash model, and log a one-line verdict per file.

Resultado esperado: el agente escribe un guion en Python para la tarea y te lo muestra en un aviso que pregunta, en las palabras de los documentos, Allow running this workflow script? Nada se ejecuta aún. Si tu ajuste de permisos ya permite los guiones, como el ajuste Turbo nombrado en los documentos, el guion puede ejecutarse sin ese aviso, lo que es una razón más para configurar tu ajuste con cuidado antes de empezar.

Paso 3: Lee el guion generado línea por línea

Acción: lee el guion antes de aprobarlo, y revisa cinco cosas en orden. Las fases coinciden con las etapas que pediste. Cada llamada agent() da al agente su contexto completo y su tarea en el texto de la instrucción. Cada schema coincide con el resultado que quieres, como un arreglo de cadenas para una lista de rutas o una cadena simple para un veredicto. El modelo nombrado para cada agente encaja con el trabajo, con flash_lite o flash para controles rápidos en muchos archivos y pro para trabajo que necesita un razonamiento más profundo, según los documentos. El ajuste de espacio de trabajo encaja con el riesgo, lo que para una tarea de revisión significa el ajuste por defecto que usa tu espacio actual y no escribe nada.

El guion para la instrucción del Paso 2 debería parecerse a este ejemplo de la documentación oficial. El código en un guion de flujo de trabajo es un dato de los documentos, mostrado aquí para que puedas compararlo con lo que tu agente genera.

phase("Discover")

files = await agent(
    "List the Python files changed since main. Paths only.",
    schema={"type": "array", "items": {"type": "string"}},
)

phase("Review")

# parallel() runs one agent per file at the same time.
# role titles each agent's card.

reviews = await parallel(
    files,
    lambda f: agent(
        f"Review {f} for unhandled exceptions. Reply with a one-line verdict.",
        schema={"type": "string"},
        role=f"Review {f}",
        model="flash",
    ),
)

for r in reviews:
    log(r)

Resultado esperado: cada línea hace lo que esperas, y nada en el guion sale de la tarea. Si una línea te sorprende, elige No en el aviso de aprobación y dile al agente qué cambiar. Los documentos dan ese camino exacto. Niega, describe el cambio, y lee el nuevo guion otra vez.

Paso 4: Aprueba el guion y sigue las fases

Acción: en el aviso de aprobación, elige la opción que permite el guion solo esta vez. Mientras el flujo de trabajo se ejecuta, expande el paso del flujo de trabajo en tu conversación. Deberías ver una sección por fase, las líneas de registro de esa fase, y una tarjeta por agente con su rol y su estado, como en ejecución, en espera de tu aprobación, o terminado. Haz clic en una tarjeta de agente para abrir la conversación de ese agente en el panel lateral, donde puedes leer su instrucción, ver sus llamadas a herramientas, aprobar una solicitud pendiente, o enviarle un mensaje.

Resultado esperado: el título del paso muestra la fase actual y cuántos agentes han terminado, en la forma que los documentos dan como flujo de trabajo, el nombre de la fase, y un conteo como 3 de 4 agentes. La conversación muestra que una tarea se está ejecutando, y el flujo de trabajo aparece bajo Background Tasks en la vista Overview del panel lateral. Para detener un flujo de trabajo antes, detén la conversación principal. Los documentos dicen que detener la conversación principal también detiene cada agente de flujo de trabajo en ejecución.

Paso 5: Lee los resultados frente al esquema

Acción: cuando el guion termine, lee el resumen que te da el agente principal, y luego lee los veredictos registrados en sí. Cada agente envió su resultado por una herramienta llamada finish, y esa herramienta revisa el resultado frente al esquema en el guion antes de que el guion reciba el valor analizado. Las lecturas de archivos, las búsquedas, y la salida de las pruebas quedan dentro de las conversaciones de los agentes, así que tu conversación principal se mantiene limpia incluso en una tarea grande.

Resultado esperado: tienes un veredicto por archivo cambiado, en el orden de los archivos, porque parallel() devuelve los resultados en el orden de los elementos. Un archivo con un veredicto limpio no necesita ninguna acción. Un archivo con un veredicto de problema ahora tiene un asunto nombrado sobre el que puedes actuar en el Paso 6 o en una conversación normal. Si un agente falló, espera que el resto de esa llamada en paralelo haya sido cancelado, según los documentos, y ejecuta el flujo de trabajo otra vez para los archivos que faltan en lugar de adivinar sus veredictos.

Paso 6: Deja que los agentes editen solo en espacios de rama

Acción: solo después de que una tarea de revisión se haya ejecutado sin problemas, pasa a la edición. En tu instrucción, pide un espacio de trabajo de rama para cada agente en paralelo. Los documentos nombran este ajuste workspace="branch", y le da a cada agente su propio árbol de trabajo Git aislado, así que los agentes pueden cambiar archivos y ejecutar pruebas al mismo tiempo sin sobrescribir el trabajo de los demás. Una instrucción en el estilo del ejemplo de los documentos se lee así.

/run-workflow For each package under packages/, start one agent in an isolated branch workspace to replace the deprecated request() helper with fetchJson(), run npm test in that package, and log a diff summary and the test result.

Resultado esperado: cada agente trabaja en su propio árbol de trabajo, ejecuta las pruebas de su propio paquete, y registra un resumen de diferencias más un resultado de prueba. Revisa cada diferencia tú mismo antes de que ese trabajo se una a tu rama. Un espacio de trabajo de rama aísla los archivos. No juzga si un cambio es bueno, y ese juicio sigue siendo tuyo. Nuestra guía sobre sesiones de agentes en un entorno aislado cubre el patrón más amplio de dar a los agentes un lugar acotado donde trabajar.

Paso 7: Guarda un guion que funciona y ejecútalo otra vez

Acción: cuando un flujo de trabajo haga bien una tarea, pide al agente que guarde el guion en un archivo .py en tu espacio de trabajo. Después, ejecútalo otra vez con una instrucción que nombre el archivo, en la forma que dan los documentos.

/run-workflow Run scripts/review-changes.py

Resultado esperado: Antigravity te pide que apruebes el guion cada vez que se ejecuta, a menos que hayas elegido permitirlo siempre. Mantén los guiones guardados bajo revisión con el resto de tu código. Un guion guardado que un equipo puede leer y volver a ejecutar es la ganancia real aquí. La misma auditoría se ejecuta de la misma forma el mes que viene, y un miembro nuevo del equipo puede leer el guion para aprender cómo funciona la auditoría. El flujo de trabajo se ejecuta en un proceso separado con el entorno Python que viene con Antigravity, así que no se requiere una instalación local de Python, y puedes configurar la variable de entorno ANTIGRAVITY_PYTHON si necesitas otro intérprete.

Verificación

Haz estas revisiones después de tu primer flujo de trabajo y anota los resultados. El aviso de aprobación mostró el guion completo antes de que nada se ejecutara, o tu ajuste de permisos es uno que elegiste a propósito. El paso del flujo de trabajo mostró fases con nombre, y el conteo de agentes llegó al conteo completo de la tarea. Los resultados volvieron en el orden de los elementos y cada resultado cumplió el esquema que configuraste. Ningún archivo en tu espacio de trabajo cambió durante la tarea de revisión, lo que puedes confirmar con git status en tu repositorio.

Termina con la revisión de créditos. Cuenta los agentes que inició el flujo de trabajo y anota el modelo que cada uno usó. Ese conteo, por las llamadas que cada agente hizo, es lo que la tarea costó en créditos del plan. Si el conteo es mayor que la lista de archivos que esperabas, tu fase de descubrimiento encontró más elementos de los que pensabas, y los registros del guion mostrarán la lista sobre la que trabajó.

Solución de problemas

Pasos siguientes

Toma una tarea que se repita en tu propio trabajo y dale la forma de un flujo de trabajo. Una revisión semanal de archivos cambiados es un buen inicio, y una auditoría de cada paquete antes de un lanzamiento es otro. Guarda el guion, mantén las primeras ejecuciones de solo lectura en los hechos, y amplía lo que los agentes pueden hacer solo después de que los resultados hayan ganado confianza en varias ejecuciones.

Si tu próxima tarea necesita que los agentes debatan una interfaz o revisen el trabajo de los demás a medida que llega, lee los documentos de Antigravity sobre /swarm antes de forzar esa tarea en un guion de flujo de trabajo. Los guiones sirven para un control de flujo que puedes enunciar por adelantado. Ese límite no es un defecto de la herramienta. Es la razón por la que se puede confiar en la herramienta para trabajo en paralelo.

Fuentes

• Documentación de Google Antigravity, Dynamic Workflows (/run-workflow), antigravity.google/docs/dynamic-workflows, revisada el 14 de noviembre de 2026. La fuente para el flujo del flujo de trabajo, los bloques base, el guion de ejemplo, las opciones de modelo y espacio de trabajo, los permisos, y la captura de pantalla del aviso de aprobación usada en este artículo.
• Documentación de Google Antigravity, Slash commands, antigravity.google/docs/slash-commands, revisada el 14 de noviembre de 2026. La fuente para la disponibilidad de Google AI Pro y Ultra para /run-workflow.
• Registro de cambios de Google Antigravity, entrada del 13 de noviembre de 2026, antigravity.google/docs/changelog. La fuente para la fecha de lanzamiento de Dynamic Workflows.
• AlphaSignal, Google Antigravity Ships Dynamic Workflows to Run Parallel AI Coding Agents, 13 de noviembre de 2026. Cobertura del lanzamiento usada para la nota de que los flujos de trabajo no tienen un precio aparte y usan los créditos de modelo del plan.
• Crédito de imagen: la captura de pantalla del aviso de aprobación en este artículo viene de la documentación de Google Antigravity. Las demás imágenes son ilustraciones de Dirty Static.