Antigravity y PaellaDoc están en la misma capa del stack, agentes autónomos que planifican, escriben y revisan código, pero parten de apuestas opuestas. La de Antigravity es la de Google: un modelo, una nube, agentes que se corrigen a sí mismos en su propio navegador, a una escala que un fundador en solitario no puede tocar. La otra apuesta es la de PaellaDoc: el modelo que tú quieras, en tu máquina, y un gate que decide “hecho” corriendo tus criterios de aceptación, escritos antes de que el agente empezara. Esta es una comparación entre esas dos apuestas, escrita por quien hace la pequeña.
Qué hace Antigravity
Antigravity es la plataforma de desarrollo agent-first de Google, presentada en Google I/O 2026. Es un producto real y con recorrido: un IDE de escritorio, una CLI, un SDK, una capa de managed agents dentro de la Gemini API y un camino para empresa. Funciona con Gemini, y Gemini 3.5 Flash es el modelo por defecto.
El núcleo es de verdad impresionante. Varios agentes planifican la arquitectura, escriben el código y luego lo prueban en vivo en un Chrome real. Un Browser Subagent pulsa botones, rellena formularios, saca capturas y depura contra lo que ve en pantalla, y después el sistema despliega, todo mientras lo miras. Corre subagentes dinámicos en paralelo, programa tareas en segundo plano y acepta comandos por voz. En la demo del escenario montó un sistema operativo en unas doce horas con 93 subagentes.
Esa autoevaluación en navegador real es un paso de verdad. Un agente que abre lo que ha construido, lo recorre a clics y lee la pantalla hace bastante más que emitir un build en verde. La velocidad, el acabado y los recursos de Google aquí no son algo que vaya a fingir que igualo.
Qué hace PaellaDoc
PaellaDoc es una capa local-first de orquestación y verificación, más una capa de producto, para programar con IA. Corre agentes de código (Claude Code, Codex, Kimi, cualquier agente de CLI) en worktrees de git aislados en tu máquina. Es agnóstica del modelo y usa tu propia suscripción.
Lo que más pesa es el gate de ejecución. En PaellaDoc, “hecho” no es un build en verde ni es el agente diciendo que ha terminado. Tú escribes los criterios de aceptación primero. El gate corre el código producido contra esos criterios, sobre el diff real, y esa ejecución es lo que mueve una tarjeta a hecho.
Alrededor del gate vive la capa de producto: un PRD, épicas, historias de usuario y criterios de aceptación se convierten en artefactos .paella versionados y comparables. Hay un reverse intake que lee un repo existente y reconstruye su contexto de producto, un sala de control multi-repo para los cien repos que ahora viven en tu máquina, control remoto por Telegram para arrancar trabajo o aprobar un paso desde el móvil, y un modo no-coder que construye un producto a partir de una descripción para alguien que no sabe leer un diff.
La diferencia clave: quién revisa el trabajo, y con qué modelo
Hay dos cosas que separan estas herramientas, y están conectadas.
La primera es el modelo cerrado. Antigravity es Gemini. Ese es el motor, y de ahí salen la velocidad y la integración. PaellaDoc no trae modelo. Lo apuntas al agente que ya estés pagando, y puedes correr una tarea difícil en más de uno para ver quién la resuelve de verdad.
La segunda es quién pone la nota. El Browser Subagent de Antigravity prueba el código en el navegador del propio Antigravity. Es el mismo agente (o su hermano) decidiendo si su trabajo está bien. Es una autocomprobación mucho mejor que un compilado que pasa, y las capturas son evidencia real, pero el agente sigue siendo autor y examinador a la vez. PaellaDoc separa esos dos papeles. El gate corre criterios que el agente no escribió y no puede editar. El trabajo pasa porque hace lo que especificaste, no porque lo que lo construyó diga además que tiene buena pinta.
Un build en verde, o el navegador del propio agente, no es lo correcto
No es una preferencia de estilo. Corrimos un benchmark público de 210 ejecuciones, y la salida de un agente en crudo pasaba el build pero estaba genuinamente mal el 40% de las veces. Incluso el modelo frontier más fuerte a máximo esfuerzo falló una tarea difícil dos de cada tres veces, y falló en ejecuciones distintas cada vez, así que no podías predecirlo.
Un build que pasa es una señal débil. Un agente que pasa su propia prueba de navegador es una señal más fuerte, pero sigue siendo la señal del agente. El gate existe porque lo único que lo zanja es correr el código contra una spec que el agente no escribió. El análisis completo está aquí: un build en verde no es una feature correcta.
Código, o producto
Antigravity construye código, rápido y mucho. Noventa y tres subagentes y un sistema operativo en doce horas es una historia de producción de código. PaellaDoc intenta que la capa de encima de eso sea de primera clase. El PRD, las épicas, las historias, los criterios no son notas que tiras después del build. Son artefactos .paella, versionados y con diff, y la comunidad los amplía a través de un SDK abierto con cuatro tipos de packs: method packs (la metodología), stack packs (tu stack técnico), design packs (theming y design tokens) y validator packs (los propios gates). Acabas con producto que puedes revisar y reutilizar, no con una carpeta que compiló.
PaellaDoc no reemplaza a tu agente, ni reemplaza a Gemini
Para que quede claro el solape: PaellaDoc no compite con Antigravity como compiten dos IDEs. Antigravity es un bucle cerrado, lo conduce Gemini, lo revisa el navegador de Gemini, lo corre la nube de Google. PaellaDoc es el bucle exterior alrededor del agente que tú elijas. Si quisieras a Gemini en ese bucle lo traerías como el agente de CLI y PaellaDoc orquestaría el worktree y correría el gate sobre su diff. PaellaDoc es el arnés y la verificación, no el modelo.
Qué compartimos
Bastante. Las dos corren agentes autónomos que planifican, escriben y ejercitan el código en vez de solo autocompletar. Las dos corren subagentes y tareas en segundo plano. Las dos creen que el agente debería probar lo que construyó, no entregarte un diff sin probar. Y en casi todos los ejes que deciden la adopción, Google va por delante: madurez, financiación, acabado, la velocidad de Gemini en crudo, el camino para empresa y una autoevaluación en navegador en vivo que, en sus propios términos, es muy buena. PaellaDoc es temprana y la construye una sola persona. No lo voy a disfrazar.
Comparación
| Capacidad | Antigravity | PaellaDoc |
|---|---|---|
| Agentes autónomos planifican, escriben y prueban código | Sí | Sí |
| Subagentes en paralelo y tareas en segundo plano | Sí | Sí |
| Elección de modelo | Solo Gemini | Cualquier agente (Claude Code, Codex, Kimi, cualquier CLI) |
| Corre en local en tu máquina | Nube / cuenta de Google | Local-first, worktrees de git aislados |
| Quién decide “hecho” | El agente, vía su propia prueba de navegador | Un gate que corre criterios de aceptación que el agente no escribió |
| Benchmark público sobre verificación | No publicado | Sí, 210 ejecuciones, resultados enlazados |
| Artefactos de producto (PRD, épicas, historias, criterios) | Centrado en código | Artefactos .paella versionados y comparables |
| Ampliable con packs abiertos (method, stack, design, validator) | No | Sí, SDK abierto |
| Reverse intake de un repo existente | Limitado | Sí, reconstruye el contexto de producto |
| Modo no-coder (producto a partir de una descripción) | No | Sí |
| Madurez, financiación, escala, acabado | Por delante | Temprana, construida en solitario |
Para quién es cada una
Antigravity es para equipos ya en la nube de Google y en Gemini que quieren la máxima producción autónoma y confían en que un agente planifique, construya y se autoverifique dentro de un único entorno integrado. Si buscas velocidad y escala y estás a gusto en el mundo de Google, es una herramienta seria con una empresa detrás.
PaellaDoc es para quien no quiere quedar atado a un solo modelo, mantiene muchos repos en una máquina, y quiere que lo que decide “hecho” sea una spec que escribió, no la opinión del agente sobre su propia prueba de navegador. También es para el no-coder que necesita un producto real a partir de una descripción, con un gate entre él y un build que solo compiló.
No es que una sea mejor. Son trabajos distintos. Antigravity apuesta a que un modelo rápido, calificándose a sí mismo, desplegado a la escala de Google, basta. PaellaDoc apuesta a que el modelo sea tuyo y el gate sea independiente de él. Tienes el resto de las comparaciones en /es/compare/.