El nuevo codificador de Google trabaja mientras duermes.

La gravedad tuvo una semana difícil. Wicked 2 llegó a los cines, y Antigravity aterrizó silenciosamente de Google DeepMind junto con Gemini 3 Pro, anunciando no otro asistente de codificación, sino una reevaluación total de lo que realmente es un IDE.

Antigravity llega como una "nueva IDE de Google DeepMind", como dijo el líder de producto Kevin Hou a la multitud de ingenieros de IA, y se siente como una línea en la arena. No es un complemento añadido a VS Code; es la primera IDE completamente desarrollada por un laboratorio de IA fundamental, con los modelos y el editor co-diseñados como un solo sistema.

La procedencia importa. Cuando DeepMind lanza un IDE, indica que los laboratorios de investigación en IA ya no se ven a sí mismos únicamente como proveedores de modelos, sino como creadores de herramientas integrales para desarrolladores, poseyendo todo, desde los pesos del transformador hasta los atajos de teclado.

Antigravity se lanzó la misma semana que Gemini 3 Pro, y esa conexión es el punto, no una coincidencia. Hou enmarcó cada cambio importante en las herramientas de codificación—autocompletar, chat, agentes—como “motivado por algún cambio que ocurre con las capacidades del modelo,” y Antigravity es el primer IDE construido en torno a esas nuevas capacidades desde el día cero.

En lugar de tratar el IDE como una envoltura estática alrededor de una llamada a la API, Antigravity considera a Gemini 3 como el sistema operativo para tu flujo de trabajo de desarrollo. El producto existe porque el modelo ahora puede planificar, ejecutar y verificar tareas de larga duración, no solo autocompletar la siguiente línea.

Hou llama a Antigravity “sin disculpas centrado en el agente”, y esa frase está teniendo un impacto real. En su planteamiento, el IDE ya no es el centro de gravedad; el agente lo es, y el editor, el navegador y las terminales son solo herramientas que el agente elige usar y deja a un lado.

Esa postura centrada en el agente distingue a Antigravity de GitHub Copilot, Cursor, o la creciente lista de editores mejorados por IA. Esas herramientas incrustan la IA dentro del IDE; Antigravity incrusta el IDE dentro de la IA, y esa inversión puede ser la verdadera historia de este lanzamiento.

Antigravity no se envía como un autocompletado más inteligente incorporado en tu editor; se envía como un sistema de tres superficies que trata a los agentes como ciudadanos de primera clase. El editor, el navegador y el Administrador de Agentes funcionan como pares, con agentes potenciados por Gemini 3 saltando entre ellos en menos de 100 ms, actuando más como un proceso de sistema operativo distribuido que como un chatbot.

A nivel del suelo se encuentra el Editor AI, un entorno bifurcado de VS Code que se comporta exactamente como tu memoria muscular espera: pestañas, terminales, puntos de interrupción, hasta que no lo hace. La autocorrección ultrarrápida se encarga del trabajo de "escribir y sugerir", mientras que una barra lateral de agente refleja el contexto del Gestor de Agentes para que puedas delegar o recuperar tareas sin perder el hilo.

Esa barra lateral transforma el editor en una cabina de pilotaje para trabajos detallados. Puedes pedirle a un agente que refactorice un complicado componente de React, genere pruebas para un servicio en Go, o conecte una nueva ruta de API, y luego intervenir en el último 20%: ajustando tipos, solucionando casos límite o reescribiendo textos. Comando-E o Control-E te lleva directamente al Administrador de Agentes, por lo que pasar de un solo archivo a la vista global de la misión se siente instantáneo.

Donde Antigravity se aparta de los IDEs tradicionales es en el navegador controlado por el agente. Detrás de escena, es una instancia de Chrome que el agente puede manejar directamente: hacer clic, desplazarse, llenar formularios, ejecutar JavaScript y recargar tu servidor de desarrollo local, utilizando tu autenticación existente, cookies y acceso a Google Docs, tableros de GitHub o herramientas internas.

Eso convierte al navegador en algo más que un panel de vista previa. Los agentes pueden iniciar tu aplicación, recorrer un flujo de registro, ajustar el CSS y luego entregarte una grabación similar a un video de Chrome con un cursor azul que muestra cada acción en lugar de una pared de diferencias. La verificación se vuelve visual: ¿se mostró el modal, se activó el estado de error, hubo problemas con la animación?

Flotando por encima de todo está el Agente Manager, el centro de control de Antigravity. Trata a los agentes como tareas, no como chats, brindándote una única ventana para iniciar trabajos de larga duración, rastrear el progreso y revisar artefactos: planes, diferencias, grabaciones, capturas de pantalla—sin necesidad de acampar dentro de un solo archivo.

Una vista de bandeja de entrada destaca todo lo que requiere una decisión humana: comandos terminales destructivos, migraciones de esquema, solicitudes de permisos. Las notificaciones a nivel de sistema operativo te regresan solo cuando es necesario, permitiéndote orquestar múltiples agentes que funcionan simultáneamente en el editor y el navegador, mientras tú, irónicamente, te alejas aún más del código.

Los agentes dejan de ser acompañantes en Antigravity; se convierten en tus nuevos gerentes de proyecto. El Gerente de Agentes se sitúa por encima del código, ofreciéndote una vista en tiempo real de todo lo que tus trabajadores autónomos están haciendo en el editor, navegador y terminal. En lugar de desplazarte por diferencias, observas las tareas generarse, ejecutarse y reportar resultados como un panel de operaciones en vivo.

Antigravity impone una relación de uno a muchos aquí: una ventana de Gerente de Agentes, muchos agentes expandiéndose a través de tu pila. Puedes tener un agente refactorizando un monolito de TypeScript, otro conectando una nueva ruta de API y un tercero ejecutando pruebas de integración basadas en el navegador. El Gerente mantiene a todos ellos en un solo flujo de trabajo priorizado, completo con estado, artefactos y próximas acciones.

El control fluye a través de una bandeja de entrada de alto nivel que atrapa cualquier cosa arriesgada, destructiva o ambigua antes de que llegue a tu máquina. Los comandos del terminal, las migraciones de bases de datos y los trabajos de larga duración se detienen en esta cola hasta que los apruebes o deniegues. Ese diseño previene el escenario pesadilla de un agente demasiado entusiasta eliminado un directorio con `rm -rf` mientras duermes.

Los elementos de la bandeja de entrada llegan como tarjetas compactas y legibles para humanos: comando, justificación, archivos o servicios afectados y resultado esperado. Un clic envía al agente hacia adelante; otro cancela la rama de trabajo y la invita a replantearse. Las notificaciones a nivel del sistema operativo significan que no necesitas estar vigilando la ventana: Antigravity te toca el hombro solo cuando algo realmente necesita una decisión humana.

La velocidad es la otra mitad de la historia. Cambiar entre Agent Manager y el editor mediante Command+E o Control+E toma menos de 100 ms, lo suficientemente rápido como para sentirse instantáneo. Puedes escanear una lista de tareas, aprobar una acción en el terminal y luego regresar a un archivo específico para ajustar una función antes de que el agente continúe.

Ese salto de menos de 100 ms es importante cuando estás manejando múltiples hilos: la orquestación en el Administrador, ediciones precisas en el editor, verificación en el navegador controlado por el agente. Todo el sistema te impulsa a dedicar más tiempo a lo estratégico y menos a la gestión minuciosa de los comandos. Para un desglose más detallado de este flujo de trabajo centrado en el agente, Google mantiene documentos y descargas en el Sitio Oficial de Antigravity.

Los agentes no solo leen tu código en Antigravity; manejan una instancia completa de Chrome como un ingeniero de QA que nunca duerme. Google conecta el IDE a un navegador controlado por un agente que funciona con tu perfil normal de Chrome, cookies y autenticación, y luego entrega el control a Gemini 3. El resultado se siente menos como autocompletar y más como un trabajador remoto viviendo dentro de tu pestaña del navegador.

Debido a que el navegador comparte tu autenticación, el agente puede obtener contexto en tiempo real de los mismos lugares a los que tú accedes. Puede abrir especificaciones de Google Docs, revisar tus solicitudes de extracción en GitHub y navegar por rastreadores de errores internos o tableros que están detrás de SSO. En lugar de que tú pegues URLs y tokens en un aviso, el agente navega silenciosamente por esos sitios, construye un modelo mental operativo de tu sistema y lo incorpora a sus planes.

La segunda mitad del truco es la activación. Antigravity expone primitivas de clic, desplazamiento, teclado y ejecución de JavaScript al modelo, para que pueda: - Hacer clic en botones y menús - Completar formularios y activar flujos - Ejecutar fragmentos de JS en la consola - Capturar pantallas y grabaciones

En la demostración de Kevin Hou, ese poder se manifiesta en una aplicación web de seguimiento de vuelos que parece deceptivamente simple. Él añade una nueva tarjeta modal a un generador de obras de arte al estilo de Thomas Cole y le pide al agente que lo conecte. En lugar de devolver un montón de diferencias, el agente abre el navegador, actualiza la página y mueve un cursor azul a través de la interfaz para demostrar que la función realmente funciona.

Esa grabación no es una animación falsa; es un rastro de eventos reales del DOM y llamadas a la red. El agente hace clic en el modal, verifica el diseño, comprueba que los nuevos vuelos se renderizan correctamente y recarga para asegurar que el estado persista. Obtienes un breve video adjunto a la tarea, al lado de los cambios en el código que lo produjeron.

Esto cierra la brecha de la “última milla” que ha atormentado a las herramientas de codificación de IA durante dos años. Los generadores de código pueden producir componentes de React y manejadores de API, pero normalmente se detienen justo antes de un navegador real, cookies reales y datos reales. El agente de navegador de Antigravity supera esa barrera, convirtiendo “se ve bien en la comparación” en “funciona en la aplicación” por defecto.

Los artefactos están en el centro de cómo Antigravity quiere que juzgues el trabajo de una IA. En lugar de confiar en una serie de resultados del modelo o en una misteriosa insignia de "tarea completada", obtienes objetos concretos y verificables que el agente deja atrás mientras trabaja.

Las herramientas de codificación de IA de la vieja escuela te pedían que revisaras diferencias de código y quizás una transcripción de chat. Antigravity lo cambia: el agente arma planes de implementación, desgloses de tareas paso a paso, capturas de pantalla y grabaciones de navegador que muestran exactamente cómo se ejecutó el cambio.

Aún obtienes diferencias en el editor, pero ya no son la interfaz principal. El Gestor de Agentes te eleva un nivel, donde los artefactos predeterminados son: - Un plan de ataque en lenguaje natural - Cambios de código vinculados - Evidencia visual del navegador controlado por el agente

La grabación del navegador es la pieza central. Cuando el agente termina de implementar una función o corregir un error, puede adjuntar un video de sí mismo utilizando una instancia completa de Chrome: punto azul del cursor moviéndose, clics ejecutándose, desplazamientos, llenado de formularios y JavaScript ejecutándose en tu aplicación real.

En lugar de leer a través de 20 archivos modificados para ver si un modal funciona, presionas play. Observas cómo el agente actualiza tu generador aleatorio de obras de arte, activa la nueva tarjeta modal y verificas que la interfaz se comporte correctamente bajo condiciones reales de DOM y red.

Esas grabaciones se apilan junto a capturas de pantalla estáticas y artefactos de texto. Para una tarea compleja, podrías ver una cadena: documento de diseño inicial, plan de implementación, ediciones de código, registros de terminal y un video final del navegador que prueba que el flujo de extremo a extremo funciona.

La validación se convierte en visual y temporal en lugar de ser puramente textual. Confirmas que se ejecuta una prueba de regresión, que la autenticación tiene éxito con tus cookies reales, que un clic en un botón realmente actualiza el estado, todo sin reconstruir la lógica solo a partir de las diferencias.

La confianza crece porque los artefactos coinciden con la forma en que los humanos ya depuran y revisan el trabajo. Los ingenieros naturalmente recurren a compartir pantallas, videos en Loom y URL de staging; Antigravity incorpora ese instinto en el producto y permite que el agente produzca esos activos automáticamente.

A medida que modelos como Gemini 3 Pro mejoran en tareas a largo plazo, estos artefactos se convierten en los rieles de seguridad. Dejas que el agente funcione toda la noche y luego regresas a una bandeja de entrada curada de planes, parches y grabaciones que puedes auditar en minutos en lugar de horas.

La antigravedad existe porque los modelos subyacentes finalmente cruzaron un umbral. Gemini 3 Pro no es una actualización marginal sobre Gemini 1.5 o Gemini 2; dentro de DeepMind, los equipos lo describen como un cambio radical en el poder de razonamiento y la fiabilidad. El mantra de Kevin Hou—“el producto solo es tan bueno como los modelos que lo sustentan”—se refleja en casi cada decisión de diseño.

Los copilotos de codificación anteriores se basaban en mejoras estrechas: primero la autocompletación de forma corta, luego el chat con aprendizaje por refuerzo con retroalimentación humana (RLHF), y después "agentes" frágiles que se desmoronaban en tareas largas. Gemini 3 Pro supera eso al mantener planes más grandes en su mente, coordinando herramientas durante horas en lugar de minutos, y recuperándose de sus propios errores. Ese cambio hace que un IDE centrado en agentes como Antigravity no solo sea posible, sino necesario.

Cuatro mejoras de modelo son las más importantes. Primero, inteligencia avanzada: Gemini 3 Pro puede descomponer una solicitud de función en docenas de subtareas, rastrear dependencias y actualizar el plan a medida que las pruebas fallan o cambian las API. Segundo, uso matizado de herramientas: el modelo puede decidir cuándo acceder al sistema de archivos, cuándo abrir un navegador, cuándo ejecutar un comando en la terminal y cuándo preguntarte antes de hacer cualquiera de estas acciones.

En tercer lugar, Gemini 3 Pro maneja tareas de mayor duración sin perder el hilo. En lugar de agotarse después de unas pocas llamadas a herramientas, puede orquestar refactorizaciones de varias horas, ejecuciones de CI y pasos de pruebas de extremo a extremo, destacando solo los pasos que necesitan revisión humana. En cuarto lugar, la multimodalidad nativa significa que puede leer capturas de pantalla de la interfaz de usuario, maquetas de diseño, registros y documentación directamente, e integrar todo eso en código y pruebas.

Esas capacidades rompen la metáfora de la ventana de chat. Una sola conversación desplazable no puede representar a 15 agentes operando en un editor, un navegador y un terminal, cada uno con sus propios estados y artefactos. Necesitas un plano de control asincrónico que trate el chat como solo una de las muchas vistas de un sistema en vivo.

Por eso, Antigravity envía un Gestor de Agentes con bandejas de entrada, notificaciones y artefactos en lugar de un cuadro de texto glorificado. La interfaz de usuario se adapta a lo que realmente puede hacer Gemini 3 Pro: gestionar el trabajo mientras duermes y luego presentar resultados verificables—diferencias, grabaciones, planes—cuando regreses. Para un análisis más profundo de esa arquitectura, Google detalla la pila en Construye con Antigravity - Blog de Desarrolladores de Google.

Gemini multimodal convierte Antigravity de un autocompletado inteligente en un colaborador de diseño completo. Debido a que Gemini 3 Pro comprende de manera nativa texto, código, imágenes y diseños de interfaz en una única ventana de contexto, el agente puede razonar sobre tus componentes de React, tu exportación de Figma y tus variables CSS como un artefacto coherente en lugar de archivos separados.

La demostración del prototipo de Antigravity muestra cómo se siente eso en realidad. Le pides al agente que “diseñe una página de destino para una startup de autenticación sin contraseña,” y no solo genera HTML, sino que crea un artefacto de imagen de alta fidelidad de la página directamente dentro del IDE, junto al código que podría renderizarla.

La parte salvaje viene a continuación: anotas ese prototipo como si fuera un Google Doc. Puedes dejar comentarios pegajosos directamente sobre la imagen principal, rodear el botón de llamada a la acción, o resaltar la tabla de precios y escribir: "Haz que esto se sienta más empresarial, menos de startup", y el agente potenciado por Gemini interpreta esas pistas espaciales y notas en lenguaje natural juntas.

En lugar de tratar esos comentarios como sugerencias vagas, Antigravity los considera como entradas estructuradas. El agente lee la imagen, entiende dónde se sitúa cada comentario en el lienzo, mapea esas áreas de vuelta al código de diseño y a los tokens de diseño, y luego genera un nuevo artefacto de maquetación además de un dif correspondiente en tu base de código.

Ese bucle — imagen → comentarios → nueva imagen más código — se ejecuta completamente dentro del IDE. Nunca cambias a Figma, nunca exportas PNGs, nunca copias CSS a mano. El Agente de Gestión rastrea cada iteración como un artefacto separado, por lo que puedes regresar a "Versión 2 con CTA azul" o comparar diseños como compararías commits.

El desarrollo de software se volvió multimodal en silencio hace años. Los equipos modernos ya manejan: - Código y archivos de configuración - Diagramas de arquitectura y gráficos de secuencia - Mocks de interfaz de usuario, sistemas de diseño y capturas de pantalla - Registros de log, tableros y grabaciones del navegador

La mayoría de las herramientas aún segregan estos elementos en aplicaciones separadas; Antigravity es el primer IDE convencional que los trata como un único espacio de trabajo continuo. Al construirse en torno a Gemini multimodal desde el primer día, permite que el mismo agente razone a través de diagramas, interfaces de usuario y rutas de código, lo que hace que "diseñar con IA" se sienta menos como chatear con un bot y más como colaborar con un diseñador de producto de pila completa que nunca duerme.

El diseño centrado en agentes significa que Antigravity considera a la IA como el operador principal de tu entorno de desarrollo, no como un asistente secundario en una barra lateral. El producto asume que los agentes leerán, escribirán, harán clic y probarán en tu pila mientras tú no estás, y luego solo mostrarán las decisiones y puntos de control que requieren tu juicio. Los humanos se convierten en revisores, no en ejecutores manuales de cada paso.

La mayoría de las herramientas "asistidas por IA" aún giran en torno a un flujo de trabajo centrado en el ser humano. Escribes código, luego presionas una tecla de acceso rápido para autocompletar, obtener una respuesta de chat o una sugerencia de refactorización; el modelo solo reacciona a tu cursor. Incluso cuando catalogan características como "agentes", esos sistemas generalmente permanecen atrapados en una única pestaña de IDE, limitados por tu siguiente solicitud.

Los giros antigravitatorios que invierten esa jerarquía. El Gerente de Agentes se sitúa por encima del editor y del navegador como una especie de centro de control, diseñado para rastrear objetivos, ramas de trabajo y tareas de varias horas en lugar de diferencias individuales. En cualquier momento, hay exactamente una ventana de Gerente de Agentes coordinando a muchos agentes y muchas superficies.

Las decisiones de UI y UX siguen esa suposición de autonomía. El editor, la instancia de Chrome controlada por el agente y la terminal se enmarcan como herramientas para el agente, no herramientas para ti. Un atajo de teclado (Command-E o Control-E) te lleva entre el Manager y el editor en menos de 100 ms, reforzando que tu vista principal es el progreso del agente, no tus propias pulsaciones de teclas.

La supervisión reemplaza la microgestión. La bandeja de entrada del Gerente de Agentes agrega eventos que requieren atención—ejecutar un comando terminal arriesgado, fusionar una gran reestructuración, actualizar la configuración de producción—para que puedas aprobar o rechazar con un solo clic. Las notificaciones a nivel de sistema te devuelven solo cuando algo cruza un límite de seguridad que el equipo no desea que el agente cruce solo.

Los artefactos hacen que esta confianza sea auditable. En lugar de exponer llamadas de herramientas en bruto, los agentes producen artefactos como planes de implementación, recorridos de código, capturas de pantalla y grabaciones completas de Chrome con un cursor visible. Revisas lo que el agente hizo en el editor y el navegador como si estuvieras viendo a un colega compartir su pantalla.

Esa arquitectura centrada en agentes separa a Antigravity de los competidores que aún añaden IA a IDEs centrados en humanos. A medida que modelos como Gemini 3 Pro escalan en longitud de contexto, fiabilidad y uso de herramientas, la jerarquía de Antigravity ya asume que los agentes llevarán a cabo la mayor parte del flujo de trabajo mientras los humanos supervisan las partes que realmente importan.

Cursor, Replit y GitHub Copilot Workspace prometieron un programador asistido por IA que vive dentro de tu editor. Antigravity da la vuelta a ese concepto, proponiendo un espacio de trabajo agentivo donde el IDE es solo una superficie y el agente es el sistema operativo de tu trabajo. En lugar de autocompletar más chat, Google está vendiendo un entorno de automatización de pila completa que abarca editor, navegador y capa de orquestación.

Los competidores tienen partes de esto. Cursor se enfoca fuertemente en las refactorizaciones dentro del editor y el contexto a nivel de repositorio; los prototipos de Copilot Workspace convierten "especificaciones en PRs" que se ejecutan en la nube. Antigravity fusiona esas ideas en un plano de control local y multi-superficie que puede abrir Chrome, navegar por tableros y enviar artefactos mientras duermes.

La verdadera ventaja de Google se encuentra antes de la interfaz de usuario. Al integrar al equipo del producto Antigravity dentro de DeepMind, el grupo de Kevin Hou probó Gemini 3 meses antes de su lanzamiento, moldeando tanto las API de llamada a herramientas del modelo como los comportamientos del agente del producto. Ese ciclo cerrado significa que la investigación puede corregir modos de fallo—como la planificación a largo plazo poco fiable—directamente en el modelo en lugar de cubrirlos con trucos de producto.

El stack de DeepMind también permite a Google ajustar específicamente las cargas de trabajo de los agentes, no solo los puntos de referencia de chat. El contexto largo, el uso más potente de herramientas y el razonamiento multimodal de Gemini 3 Pro llegaron calibrados para la arquitectura de tres superficies de Antigravity, no añadidos posteriormente. Los competidores que dependen de APIs públicas no obtienen ese tipo de privilegio de co-diseño.

Luego vino el error de la “escasez global de chips”. Cuando Antigravity lanzó las listas de espera esta semana, un muro de capacidad activó un banner de fallo en tono humorístico que se difundió en X y Hacker News en cuestión de horas. El mensaje también sirvió como un gráfico de crecimiento: la demanda de agentes siempre activos que compilan, navegan y prueban en segundo plano ya está golpeando los aceleradores de Google.

Ese momento viral también expuso el consumo de recursos detrás de este paradigma. Un agente que ejecuta pruebas en el navegador, gestiona terminales y mantiene artefactos durante horas se comporta más como un pequeño servicio backend que como una finalización puntual. La disposición de Google a asumir ese costo señala cuán central considera a los agentes en su estrategia de nube.

La antigravedad, vista de esta manera, es menos un IDE y más la plantilla de Google para el escritorio del desarrollador de próxima generación. Introducción a Antigravity - Google Codelabs se lee menos como una incorporación para un complemento y más como capacitación para un nuevo modelo operativo: tu código, tu navegador y tus agentes compartiendo el mismo espacio de trabajo.

Los desarrolladores ahora enfrentan una pregunta directa: si un agente puede refactorizar una base de código, conectar OAuth, acceder a tu API de staging y navegar por la interfaz mientras duermes, ¿cuál es exactamente tu trabajo? Antigravity responde redefiniéndolo silenciosamente. Dejas de actuar como un implementador línea por línea y comienzas a actuar como la persona que decide qué se construye, por qué y con qué estándares.

En lugar de temer a ser reemplazados, los desarrolladores que se adaptan se convierten en arquitectos y orquestadores. El Manager de Agentes transforma el trabajo en un portafolio de misiones delegadas: “Implementar un sistema de control de características”, “Migrar este servicio a gRPC”, “Diseñar una matriz de pruebas para móvil”. Tu valor se centra en elegir las misiones adecuadas, secuenciarlas y juzgar si los artefactos resultantes son realmente lo suficientemente buenos para ser enviados.

Ese cambio exige nuevas habilidades. La descomposición de problemas a alto nivel se convierte en algo innegociable: necesitas desglosar una solicitud de producto vaga en tareas concretas y del tamaño adecuado para el agente, con criterios de éxito claros, dependencias y parámetros de seguridad. Si no puedes describir el sistema en un inglés claro y con diagramas, no te gustará lo que el agente produzca en código.

La generación de indicaciones deja de ser un meme y se convierte en ingeniería de requisitos. Las buenas indicaciones en Antigravity parecen mini documentos de diseño: entradas y salidas explícitas, casos límite, no objetivos, restricciones de rendimiento y cómo verificar el resultado. Escribirás menos bucles for y más especificaciones que se lean como: “Dadas estas SLOs de latencia y este esquema, diseña un plan de implementación con canarios y retroceso automático.”

La validación se convierte en la otra mitad del trabajo. Los artefactos de Antigravity—grabaciones del navegador, planes, diferencias, ejecuciones de pruebas—se transforman en tu superficie de revisión. Aprenderás a: - Leer el plan de un agente y detectar modos de fallo que falten - Usar el navegador controlado por el agente para investigar estados extraños de la interfaz de usuario - Anotar artefactos con comentarios específicos en los que el agente pueda iterar de manera autónoma

Herramientas como Antigravity no reducirán la cantidad de desarrolladores; harán que sean más ambiciosos. Cuando un solo ingeniero puede coordinar agentes para implementar servicios, realizar pruebas de extremo a extremo e iterar en la experiencia del usuario durante la noche, el cuello de botella deja de ser "¿Qué tan rápido puedo programar?" y se convierte en "¿Qué tan audaz puedo ser sobre lo que construimos a continuación?"

¿Qué es la antigravedad de Google?

Google Antigravity es un nuevo Entorno de Desarrollo Integrado (IDE) 'primero en agentes' de Google DeepMind. Utiliza agentes de IA autónomos para gestionar, escribir y verificar código en múltiples superficies, incluyendo un editor, un navegador y un gestor central de agentes.

¿Cómo difiere Antigravity de GitHub Copilot o Cursor?

Mientras que herramientas como Copilot se centran en la finalización de código asistida por IA y en el chat dentro del editor, Antigravity está diseñada para agentes autónomos que ejecutan tareas complejas y de larga duración. Eleva al desarrollador a un papel de orquestación, gestionando agentes que pueden trabajar simultáneamente en un editor de código y en un navegador web.

¿Es Google Antigravity gratuito?

Sí, según los detalles iniciales de lanzamiento, Google Antigravity se ofrece de forma gratuita a desarrolladores individuales en macOS, Linux y Windows.

¿Qué modelos de IA utiliza Antigravity?

Antigravedad se lanzó en conjunto con Gemini 3 Pro y está profundamente integrado con sus capacidades. La plataforma también admite la opción de modelos, lo que permite a los desarrolladores utilizar otros modelos como Claude Sonnet 4.5 y GPT-4.