Google Antigravity lanza /swarm: el desarrollo con IA pasa de la ejecución de un solo Agent a la colaboración en equipo multi-Agent, una interpretación de 4 tipos de roles

Nota del autor: este artículo se basa en el blog oficial y la documentación de uso de Google Antigravity, y explica cómo se reparten el trabajo los distintos Agents dentro de /swarm, cómo colaboran, cómo se visualiza y gestiona el proceso y cuáles son sus límites de uso.

El 10 de noviembre de 2026 se abrió oficialmente Gemini 4 Carbon. Ese mismo día, el equipo de Google Antigravity lanzó la función de colaboración multiagente /swarm (Preview). Este comando convierte una sola conversación en un pequeño equipo de ingeniería formado por IA: alguien divide las tareas, alguien escribe el código, alguien revisa y alguien se encarga de detectar cuándo el progreso se queda atascado.

La función tiene respaldo público. El blog oficial de Antigravity y la documentación de uso de Swarm ya están en línea, y Google asegura que sus ingenieros llevan unas 5 semanas usándola internamente. El objetivo de /swarm no es abrir varias ventanas de chat a la vez: intenta construir un sistema de colaboración capaz de descomponer tareas de forma autónoma, ejecutarlas en paralelo, compartir el progreso, verificarse mutuamente y seguir corrigiendo errores.

Valor principal: al terminar el artículo entenderás el mecanismo de ejecución concreto de /swarm, cómo encajan los distintos roles, cómo puede el usuario observar e intervenir, y cuáles son sus límites reales en cuanto a cuota y permisos.

Google Antigravity /swarm: términos clave que conviene conocer

/swarm introduce varios nombres de roles. Si primero dejamos claros estos conceptos, el funcionamiento que viene después se entiende mucho mejor.

Qué es Google Antigravity /swarm: resumen de la información clave

/swarm se lanzó junto con la apertura oficial de Gemini 4 Carbon, pero son dos cosas distintas. La primera es una función de orquestación multiagente dentro de Antigravity; la segunda es un modelo. La tabla siguiente resume lo que Google ha hecho público hasta ahora.

Por qué un solo agente tiene dificultades con las tareas de ingeniería grandes

Un solo agente funciona muy bien cuando se trata de una función o de un bug concreto. Pero cuando la tarea se extiende a decenas de archivos, a dependencias entre varios módulos o exige ejecutar pruebas una y otra vez, ese agente tiene que recordar todos los detalles dentro de un mismo contexto. A medida que el contexto crece, las restricciones iniciales se van quedando enterradas bajo los detalles de ejecución posteriores.

La asignación de tareas es otro punto complicado. Un solo agente solo puede trabajar de forma secuencial: si no ha terminado de modificar el módulo A, la investigación del módulo B tiene que esperar. Muchas tareas de ingeniería se pueden dividir y ejecutar en paralelo, por ejemplo, arreglar las pruebas fallidas de distintos paquetes por separado, y hacerlas en serie es una pérdida de tiempo.

Lo que más se suele pasar por alto es la verificación. Cuando el agente que escribe el código revisa su propio trabajo, es fácil que arrastre las mismas suposiciones de partida y no detecte desvíos en el planteamiento. En un equipo humano se resuelve pidiendo a otra persona que haga un Code Review, y /swarm traslada ese reparto de roles al flujo de programación con IA.

Cómo arranca un equipo de Agents con /swarm en Google Antigravity

Según la documentación oficial, cuando ejecutas /swarm <task> el proceso avanza en este orden:

1. La conversación actual se convierte en Coordinator: el Agent con el que estás hablando pasa a ser el coordinador y se encarga de entender la tarea global.
2. División del trabajo: el Coordinator reparte la tarea en varias subtareas según su estructura.
3. Creación de Workers independientes: cada unidad de trabajo tiene su propio Worker, y cada Worker recibe un contexto independiente y una descripción pública de su tarea.
4. Ejecución y verificación: los Workers modifican código o realizan investigaciones; el Verifier revisa los cambios en el código, ejecuta las pruebas y devuelve los problemas al Worker correspondiente.
5. Ciclo de corrección: el Worker corrige según el feedback y, una vez hechos los cambios, vuelve a pasar la revisión.
6. Informe final: el Coordinator integra los resultados de cada miembro y se lo comunica al usuario.

El contexto de cada Worker es independiente y solo contiene la información de su parte de la tarea, así que se reduce el problema de la contaminación mutua en contextos largos. Además, la descripción de la tarea es pública: el resto de los miembros puede saber quién está haciendo qué, y el reparto del trabajo tiene límites claros.

/swarm: reparto de roles entre Coordinator, Worker, Verifier y Monitor

Según la documentación oficial, un equipo Swarm suele incluir cuatro tipos de roles. Conviene aclarar que esta es la organización típica que describe la documentación, no una arquitectura fija que se aplique a todas las tareas. Cuántos Workers se crean y si hacen falta miembros adicionales lo decide el Coordinator según la tarea.

Mecanismos de Verifier y Monitor en /swarm

El blog oficial llama al Verifier «agente de verificación adversarial». Su trabajo es encontrar problemas: revisa las modificaciones de los demás agentes, ejecuta pruebas y cuestiona los cambios poco razonables. El Worker recibe el feedback, lo corrige y vuelve a enviarlo para su revisión. Así, ejecución y verificación forman un ciclo cerrado.

El Monitor se ocupa de otro tipo de riesgo. Cuando varios agentes colaboran, puede darse una situación en la que todos esperan y nadie avanza. El Monitor permanece inactivo la mayor parte del tiempo, pero si detecta que todo el equipo se ha detenido y la tarea no está terminada, despierta a los miembros relacionados. Gracias a esto, cuando el equipo se atasca no hay que depender por completo de que el usuario intervenga a mano.

Cada rol de /swarm puede usar un modelo distinto

En su blog oficial, Google recomienda asignar los modelos según las características de cada rol, en lugar de usar el modelo más caro para todos los agentes:

• Usar Gemini 4 Carbon: diseño de la arquitectura general, coordinación de tareas, revisión de seguridad y auditorías de código complejas
• Usar un modelo más rápido y ligero: implementación de código rutinaria y modificación de archivos en paralelo
• Usar un agente de verificación especializado: pruebas y validación automáticas

En los ejemplos de la documentación oficial también aparece el uso de modelos distintos para la implementación del código y para la verificación independiente. Es un enfoque que equilibra costo y capacidad: las decisiones complejas se dejan al modelo potente, y el trabajo de ejecución en grandes volúmenes, al modelo rápido.

💡 Recomendación: si en tu propio pipeline multiagente también quieres combinar modelos según el rol, puedes empezar probando con la misma clave API en APIYI (apiyi.com) cómo rinde cada modelo en las fases de planificación, implementación y revisión. Una vez que tengas claro quién encaja mejor en cada rol, fija la configuración; para cambiar de modelo solo tendrás que modificar el parámetro model.

/swarm Cómo coordinan varios agentes sin interferir entre sí

Tablero de mensajes compartido: la comunicación pública entre agentes

Todos los agentes usan un mismo tablero de mensajes (Shared Message Board) de tipo solo-añadir, donde se registran tanto el proceso de colaboración como el avance de las tareas. Los mensajes se añaden y nunca se sobrescriben, así que el historial de comunicación del equipo queda completo y se puede rastrear. Mientras espera a los demás miembros, un agente puede dormir y despertarse cuando necesita un dato; según Google, esperar inactivo no consume tokens.

Este diseño es más transparente que dejar que los agentes se llamen entre sí por su cuenta. Los comentarios que el Verifier da al Worker y las decisiones de coordinación del Coordinator están a la vista, de modo que al revisar lo ocurrido después se ve con claridad en qué eslabón se torció algo.

Espacio de trabajo compartido frente a copia de trabajo independiente

Aquí el blog oficial y la documentación de uso no lo plantean exactamente igual, y es fácil equivocarse al escribirlo. El blog insiste en que los Worker en paralelo pueden trabajar en Git Worktree aislados para no modificar el mismo directorio directamente. La documentación de uso, en cambio, detalla reglas más finas:

• Por defecto: los Worker comparten el espacio de trabajo actual.
• Aislamiento bajo demanda: cuando varios Worker tienen que modificar o compilar el proyecto a la vez, el Coordinator puede asignarles copias de trabajo independientes del código.
• Quitar es borrar: al eliminar un Worker, su copia de trabajo se borra, así que primero hay que fusionar o hacer commit de los resultados.

Dicho con precisión: el sistema organiza copias de trabajo aisladas según lo que exijan las tareas en paralelo, y no que todos los agentes tengan por naturaleza su propio Git Worktree totalmente independiente. Para tareas que solo investigan y no tocan archivos, el espacio de trabajo compartido basta; cuando varios Worker editan código y lanzan compilaciones al mismo tiempo, las copias separadas reducen los conflictos entre archivos.

Cómo observar y controlar un equipo /swarm en Antigravity

Cuando varios agentes trabajan en paralelo, lo que más preocupa al usuario es no saber qué está pasando por dentro. Para resolverlo, Antigravity ofrece tres vistas principales, y la CLI incluye atajos equivalentes.

Tu control no se limita a mirar los resultados. Desde estas vistas puedes revisar el recorrido de trabajo de cada agente, entrar directamente en un Worker para intervenir e incluso ajustar las instrucciones que le diste al Coordinator. Además, Alt + J y Ctrl + K dejan claro que la aprobación de las llamadas a herramientas sigue estando en manos de una persona: cuando un agente necesita ejecutar una operación sensible, se detiene y espera tu confirmación.

Qué tareas de ingeniería complejas puede resolver /swarm

Google ha revelado que sus casos de uso internos se agrupan básicamente en tres categorías: migración de múltiples paquetes de software, investigación de la causa raíz entre subsistemas y rediseño de arquitecturas de software complejas. Todas comparten lo mismo: mucho volumen de trabajo, divisible en partes y con necesidad de verificación.

Los ejemplos de la documentación oficial de uso están más cerca del día a día del desarrollo:

• Modificar varios API Handler por separado y configurar pruebas para cada uno;
• Investigar en paralelo la causa raíz de un arranque lento de la CLI;
• Agrupar las pruebas fallidas de un proyecto grande por paquete y repartirlas entre distintos agentes para que las corrijan;
• Encargar a modelos diferentes la implementación del código y su verificación independiente.

Google también enseñó una demo oficial: con la colaboración multiagente de Antigravity, Carbon procesó 7 PDF públicos de planificación urbana, extrajo 206 vistas de planos de ingeniería y terminó generando un modelo interactivo de edificios en Three.js de unos 906.000 triángulos; todo el proceso pasó por 10 rondas de iteración nocturna. Es un caso oficial de Google, no una validación independiente de terceros, pero deja ver cómo se reparte el trabajo entre varios agentes cuando la tarea se alarga.

Coste, permisos y limitaciones de Preview en /swarm

Consumo de cuota con varios agentes

Un agente parado esperando no gasta tokens, pero eso no significa que /swarm salga barato. Cada Worker es un agente independiente, así que cuando varios miembros trabajan a la vez el consumo global de cuota avanza bastante más rápido que en una sola conversación. El propio Google lo advierte.

Y hay otra trampa fácil de pisar: cuando un Worker agota su cuota se pausa, y aunque la cuota se restablezca después, no reanuda la ejecución por su cuenta; hay que intervenir manualmente. Antes de lanzar una tarea larga conviene calcular primero si la cuota dará para tanto.

Los permisos de Swarm no son los permisos del modelo Carbon

Este es el punto que más se confunde. Poder usar /swarm no implica poder usar Carbon dentro de Swarm.

Dicho de otro modo: quien tiene Pro puede probar el mecanismo de colaboración de Swarm, pero los modelos que cada agente puede usar siguen dependiendo de los permisos de modelo de su propia suscripción.

Análisis del impacto: /swarm lleva la programación con IA del asistente al equipo

Impacto para los desarrolladores

• Cambio de rol: el desarrollador deja de ser quien «le hace preguntas al modelo» y pasa a ser quien «organiza un equipo de IA». La calidad con la que se dividen las tareas y los criterios de aceptación influyen directamente en el resultado.
• Verificación desde el principio: el mecanismo Verifier convierte las pruebas y las revisiones en una parte habitual del flujo, en lugar de un parche que se aplica después de generar el código.
• La gestión de costes gana peso: con varios Workers en paralelo hay que vigilar la cuota, la combinación de modelos y el tamaño de las tareas, y ya no basta con fijarse en la experiencia de una sola conversación.

Impacto para la industria

• La colaboración entre varios modelos se perfila como el modelo de despliegue: un modelo potente se encarga de planificar y revisar, y uno más rápido ejecuta el trabajo en lote. Cada vez más frameworks de Agentes adoptarán este reparto de funciones.
• La competencia se centra en la entrega de tareas: la rivalidad entre modelos pasa de las puntuaciones en preguntas y respuestas de un solo turno a la capacidad de planificar, ejecutar, verificar y entregar tareas de larga duración.

Reproducir la idea de /swarm con la API: un ejemplo mínimo

Si quieres probar en tu propio proyecto el enfoque de «coordinador que divide + trabajadores que ejecutan», puedes armar un prototipo mínimo con una interfaz compatible con OpenAI. El código de abajo solo muestra la estructura de colaboración y no es la implementación de Antigravity /swarm. Cambia los nombres de los modelos por los que tengas disponibles en tu cuenta.

from openai import OpenAI

client = OpenAI(api_key="YOUR_API_KEY", base_url="https://api.apiyi.com/v1")

def ask(model, prompt):
    resp = client.chat.completions.create(
        model=model, messages=[{"role": "user", "content": prompt}]
    )
    return resp.choices[0].message.content

plan = ask("STRONG_MODEL", "把“修复 3 个 API Handler 的失败测试”拆成独立子任务，每行一个")
for task in [t for t in plan.splitlines() if t.strip()]:
    print(ask("FAST_MODEL", f"完成这个子任务并给出补丁：{task}"))

import concurrent.futures as cf
from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.apiyi.com/v1"  # Interfaz compatible con OpenAI de APIYI
)

COORDINATOR_MODEL = "STRONG_MODEL"   # Planificación y resumen; cámbialo por un modelo con buena capacidad de razonamiento
WORKER_MODEL = "FAST_MODEL"          # Ejecución por lotes; cámbialo por un modelo rápido y ligero
VERIFIER_MODEL = "REVIEW_MODEL"      # Revisión independiente; conviene que sea distinto al del Worker
board = []                           # Tablero de mensajes compartido, solo de adición

def ask(model, system, prompt):
    resp = client.chat.completions.create(
        model=model,
        messages=[{"role": "system", "content": system},
                  {"role": "user", "content": prompt}],
    )
    return resp.choices[0].message.content

def worker(task, max_rounds=3):
    patch = ask(WORKER_MODEL, "你是 Worker，只负责分配给你的子任务。", task)
    for i in range(max_rounds):
        review = ask(VERIFIER_MODEL,
                     "你是 Verifier，检查补丁问题。没有问题只回复 PASS。",
                     f"任务：{task}\n补丁：\n{patch}")
        board.append(f"[Verifier] {task[:20]}... 第{i+1}轮：{review[:60]}")
        if review.strip().startswith("PASS"):
            return patch
        patch = ask(WORKER_MODEL, "根据审查意见修复补丁。",
                    f"任务：{task}\n原补丁：{patch}\n意见：{review}")
    return patch + "\n# 未通过验证，需人工检查"

goal = "为 users、orders、payments 三个 API Handler 补充输入校验并修复失败测试"
plan = ask(COORDINATOR_MODEL, "你是 Coordinator，把目标拆成互不重叠的子任务，每行一个。", goal)
tasks = [t.strip() for t in plan.splitlines() if t.strip()]
board.append(f"[Coordinator] 拆分为 {len(tasks)} 个子任务")

with cf.ThreadPoolExecutor(max_workers=4) as pool:
    results = list(pool.map(worker, tasks))

summary = ask(COORDINATOR_MODEL, "汇总各 Worker 结果，列出完成情况与风险。",
              "\n\n".join(results))
print("\n".join(board))
print(summary)

🚀 Para empezar rápido: si vas a montar un prototipo con varios roles como este, te recomendamos obtener tu clave API y un crédito de prueba gratuito para nuevos usuarios en APIYI (apiyi.com). La plataforma ofrece una interfaz compatible con OpenAI, así que con un único código puedes invocar modelos de OpenAI, Claude, Gemini y más, y comprobar fácilmente si la combinación «modelo potente que planifica, modelo rápido que ejecuta y modelo heterogéneo que revisa» encaja en tu proyecto.

Preguntas frecuentes

Google Antigravity /swarm: puntos clave (Key Takeaways)

• Mecanismo de ejecución: /swarm <task> convierte la conversación actual en un Coordinator, que divide la tarea y crea Workers independientes.
• Reparto típico de roles: Coordinator, Worker, Verifier y Monitor. Lo habitual es asignar un Verifier por cada 2-4 Workers.
• Forma de colaboración: un tablero de mensajes compartido, de solo adición, permite la comunicación abierta, y los agentes que están inactivos o en espera no consumen Tokens.
• Reglas del espacio de trabajo: por defecto se comparte el espacio de trabajo, y cuando hay modificaciones en paralelo se asignan copias de trabajo independientes según haga falta.
• Control visual: tres vistas (Board, Members y Graph), además de operaciones de CLI como /swarm board y /agents.
• Límites reales: sigue en Preview, el consumo de cuota con varios Workers es rápido y los permisos de Swarm no equivalen a los permisos de Carbon.
• Práctica por cuenta propia: con APIYI (apiyi.com) puedes combinar varios modelos a través de una interfaz unificada y montar tu propio prototipo con múltiples roles.

Resumen

Los puntos clave de Google Antigravity /swarm:

1. Del paralelismo a la colaboración: el valor de /swarm está en el ciclo completo que forman la división de tareas, los contextos independientes, la verificación adversarial y el seguimiento del progreso. La ejecución en paralelo es solo una parte.
2. Aislamiento bajo demanda: el espacio de trabajo compartido y las copias de trabajo independientes se alternan según lo que necesite la tarea, así que conviene vigilar cuándo se hacen los merges.
3. Capacidad y coste, juntos: los sistemas multiagente mejoran el manejo de tareas de ingeniería complejas, pero también implican un mayor consumo de cuota y una gestión de recursos más complicada. Por ahora sigue en Preview.

Para quienes desarrollan, /swarm supone un cambio en la forma de trabajar: ya no se trata solo de hacerle preguntas a un modelo, sino de organizar un equipo de IA capaz de repartirse el trabajo, ejecutarlo, verificarlo y entregarlo. Aunque de momento no puedas usar Antigravity, la idea de «asignar modelos por rol y hacer que la verificación sea independiente de la ejecución» también sirve para tus propios sistemas de agentes. Te recomendamos validar rápidamente el efecto de distintas combinaciones de modelos con APIYI (apiyi.com), una plataforma que ofrece cuota de prueba gratuita y una interfaz unificada para múltiples modelos.

📚 Referencias

1. Documentación oficial de Google Antigravity Swarm: mecanismo de ejecución de /swarm, configuración de roles, copias de trabajo y operaciones por CLI
2. Enlace: antigravity.google/docs/swarm

3. Descripción: fuente de primera mano sobre los detalles de Coordinator, Verifier y Monitor, y sobre las vistas Board / Members / Graph

4. Blog oficial de Google Antigravity: Gemini 4 Carbon in Google Antigravity

5. Enlace: antigravity.google/blog/gemini-4-carbon-in-google-antigravity

6. Descripción: información del lanzamiento de /swarm, arquitectura multiagente y recomendaciones para asignar modelos a cada rol

7. Anuncio oficial de Google: Gemini 4 Carbon is now available

8. Enlace: blog.google/innovation-and-ai/models-and-research/gemini-models/gemini-4-carbon-now-available

9. Descripción: alcance de la apertura oficial de Carbon y contexto del lanzamiento en vista previa de /swarm

10. Página de beneficios de las suscripciones de Google AI: permisos de modelos en AI Pro y Ultra

11. Enlace: one.google.com/about/google-ai-plans

12. Descripción: diferencias entre niveles de suscripción y acceso a los modelos Carbon

13. Cobertura de The Verge sobre el lanzamiento: Google releases Gemini 4 Carbon with agent swarm feature

14. Enlace: theverge.com/ai-artificial-intelligence/1030787/google-gemini-4-carbon-public-rollout
15. Descripción: contexto del lanzamiento y restricciones de acceso desde la perspectiva de un medio independiente

Autor: Equipo técnico de APIYI
Intercambio técnico: te invitamos a contactarnos en la página principal de APIYI (apiyi.com) para compartir experiencias con sistemas multiagente. Encontrarás más información de integración en el centro de documentación docs.apiyi.com

Artículos relacionados

• Análisis del lanzamiento de Gemini 4 Carbon: supera a Opus 5.5 con 59 puntos y gana en 15 de 17 pruebas, pero no se puede invocar: Gemini 4 Carbon lideró el índice de inteligencia de Artificial Analysis con 59 puntos y ganó 15 de 17 comparativas oficiales, pero no tiene ID de modelo API ni fecha de acceso; analizamos la puntuación, por qué aún no se puede invocar y cómo los desarrolladores chinos pueden usar gemini-4-argon por ahora.