Antigravity CLI vs IDE vs SDK: Probé los 4 Productos de Google — Guion v5

Notas de producción

Formato: concepto + narrativa + multi-demo (patrón validado del canal — Harness Engineering, Hermes Agent)
Duración objetivo: 55 minutos
Cambios v4 → v5:
- Re-frame total: NO es solo CLI, es la suite Antigravity completa (2.0 + CLI + IDE + SDK)
- Eje conceptual: “shared agent harness” — conexión directa con el video Harness Engineering del canal
- Aplicar el framework Capa 1 / Capa 2 de Hermes a Antigravity (qué impone, qué no)
- Eliminada sección CI/CD con AGY_TOKEN (no existe en doc oficial — error verificado contra antigravity.google/docs)
- Eliminados flags --no-browser, --max-iterations, --output-format json (no existen — solo agy -p existe)
- Clímax demo: bridge CLI ↔ 2.0 con /resume Tab + caveats técnicos (jugada inversa)
- Demo SDK con 15 líneas Python (verificado oficial)
- Cita literal de la cláusula de los Términos de Servicio sobre herramientas de terceros — drama narrativo verificable
Datos verificados contra antigravity.google/docs (lectura completa de 20 páginas con Playwright + 20 páginas pegadas por usuario)
Cross-promotion con 2 videos publicados:
- Harness Engineering (4 may 2026) — concepto base
- Hermes Agent (30 may 2026) — Capa 1 vs Capa 2 hands-on
Cero argentinismos (verificación con grep al final)
Mezcla ES/EN consensuada: developer, deadline, live, vendor, workflow, tool calling, browser, settings, benchmark, research, framework, build, release, throughput, tokens — se mantienen en inglés
Deadline crítico: publicar antes del 18 jun 2026 (deprecación Gemini CLI)

Fuentes verificadas (cruce con doc oficial)

Claim	Fuente
4 productos + harness compartido	antigravity.google/product + docs/home
`pip install google-antigravity`	blog/introducing-google-antigravity-sdk
9 lifecycle hooks SDK	blog/introducing-google-antigravity-sdk
Configs en `~/.gemini/antigravity-cli/`	docs/cli-* (verificado en 20 páginas)
Modelos en Free: Gemini 3.5 Flash, Gemini 3.1 Pro, Gemini 3 Flash, Claude Sonnet 4.6, Claude Opus 4.6, gpt-oss-120b	antigravity.google/pricing
Benchmarks Gemini 3.5 Flash: Terminal-Bench 76.2%, GDPval-AA 1656 Elo, MCP Atlas 83.6%, CharXiv 84.2%	blog/google-io-2026
Cláusula de los Términos de Servicio: Claude Code/OpenCode prohibido con login Antigravity	docs/faq
`/resume` Tab bridge CLI ↔ 2.0	docs/cli-managing-conversations + blog/introducing-google-antigravity-cli
Antigravity 2.0 NO es IDE	blog/introducing-google-antigravity-2-0 (“there is no IDE”)
`agy plugin import gemini` migration	docs/gcli-migration

[0:00 - 1:00] HOOK

[CÁMARA] google AI OU Mayo de 2026. Google I/O. Google rearmó toda su línea Antigravity y lanzó tres productos nuevos: Antigravity 2.0, el CLI y el SDK. El IDE original ya existía desde noviembre de 2025. Probablemente viste los titulares: “el nuevo IDE de IA”, “el reemplazo de Gemini CLI”, “Google contra Cursor”. Todos hablan de lo mismo. Nadie cuenta lo que de verdad pasó.

Lo que Google lanzó no es un producto. Son cuatro. Y los cuatro corren sobre el mismo motor. Para que te hagas una idea de la escala — en la keynote de I/O Google contó que internamente ya procesan 500 mil millones de tokens al día con sus developers usando esta plataforma. Esto no es PoC. Esto es producción real.

[PANTALLA — diagrama suite Antigravity]

                  ANTIGRAVITY HARNESS (motor compartido)
                              │
   ┌──────────────┬───────────┴───────────┬──────────────┐
   ▼              ▼                       ▼              ▼
Antigravity    Antigravity            Antigravity    Antigravity
2.0            CLI                    IDE            SDK
(desktop)      (terminal)             (editor)       (Python)

[CÁMARA]

Antigravity 2.0, el desktop sin IDE. Antigravity CLI, terminal. Antigravity IDE, el editor original. Y Antigravity SDK, una librería Python que instalas con un pip install. Los cuatro comparten lo que Google llama oficialmente “agent harness”. Y esto es curioso, eh — si viste mi video previo de ingeniería de arneses ya estás pensando lo mismo que yo. Si no lo viste, en los siguientes minutos conectamos los puntos.

Lo probé una semana entera. Y te voy a mostrar tres cosas que no he visto en otros videos en español: cómo pasar una conversación del desktop al terminal sin perder contexto, cómo construir tu propio agente con 15 líneas de Python sobre el mismo motor, y por qué Google escribió en su FAQ oficial que no puedes usar Claude Code con tu login de Antigravity.

[PANTALLA — cita literal del FAQ oficial]

“Using third party software… to access Antigravity is a violation of our Terms of Service. Such actions may be grounds for suspension or termination of your account.”

[CÁMARA — leer en español]

“Usar software de terceros… para acceder a Antigravity es una violación de nuestros Términos de Servicio. Estas acciones pueden ser motivo de suspensión o terminación de tu cuenta.”

[FUENTE: antigravity.google/docs/faq]

[CÁMARA]

Cita textual. La completa, con la solución oficial que Google publica para usarlas juntas, la verás más adelante.

Esto es lo que de verdad pasó.

[1:00 - 1:40] OPEN LOOPS

[CÁMARA]

Esto va a ser largo — porque hay mucho que mostrar. Te voy adelantando cinco cosas:

El CLI y Antigravity 2.0 comparten sesión entre sí — empiezas en el desktop, sigues en el terminal sin perder contexto, y la rematás de vuelta en el desktop. Te muestro en vivo cómo se hace, incluyendo los caveats técnicos que ningún video cubre.
El demo oficial que Google mostró en I/O — 93 subagentes en paralelo construyendo un sistema operativo desde cero en 12 horas. Y por qué eso cambia el modelo mental de cómo trabajamos con agentes.
Quince líneas de Python para armar tu propio agente custom sobre el mismo motor que Google usa internamente con 500 mil millones de tokens al día.
Acceso gratis a cinco modelos en el tier free: Gemini 3.5 Flash, Gemini 3.1 Pro, Claude Sonnet 4.6, Claude Opus 4.6, y GPT-OSS 120B — con varios niveles de razonamiento. Sin API key extra. Sin tarjeta de crédito.
La cita oficial de los Términos de Servicio que dice que Claude Code está prohibido — más la solución oficial que el propio Google publica para usarlos juntos sin que te suspendan la cuenta.

[1:40 - 2:00] SUSCRIPCIÓN

[CÁMARA]

Como siempre, todo el código y los configs van en la descripción. Los invito a suscribirse — venimos de un mes muy bueno con Harness Engineering y Hermes Agent, y este video conecta directo con esos dos. Si todavía no los viste, te los dejo arriba. Vamos a Antigravity.

[2:00 - 5:00] QUÉ ES ANTIGRAVITY — la suite completa

[CÁMARA]

Antes de entrar en demos, vamos al concepto. Porque casi todos los videos que vi sobre Antigravity hablan del IDE, otros solo del CLI, pero nadie cubre la suite completa. Y son cuatro productos, no uno.

[PANTALLA — cita literal /product]

“Google Antigravity is our agentic development platform, allowing anyone to build in the agent-first era.”

[CÁMARA — leer en español]

“Google Antigravity es nuestra plataforma agentic de desarrollo, que permite a cualquiera construir en la era agent-first.”

[FUENTE: antigravity.google/product]

[CÁMARA]

Son cuatro productos. Te los presento uno a uno con la descripción oficial de Google. Después vemos cómo se conectan.

Antigravity 2.0

[PANTALLA — cita oficial blog 2.0]

“Antigravity 2.0 is a new, standalone desktop application that fully delivers on a truly agent-optimized experience… there is no IDE.”

[CÁMARA — leer en español]

“Antigravity 2.0 es una nueva aplicación de escritorio standalone que ofrece por completo una experiencia optimizada para agentes… no es un IDE.”

[FUENTE: antigravity.google/blog/introducing-google-antigravity-2-0]

[CÁMARA]

Antigravity 2.0 no es un editor. Es un command center. Una aplicación de escritorio donde tu trabajo es hablar con agentes — pedirles tareas, revisar el resultado, dar feedback en los artefactos que generan. No vas a escribir código línea por línea ahí. Lo que vas a hacer es dirigir agentes. Google lo llama “agent-first surface” — superficie centrada en el agente, no en el código.

Tiene Projects, que agrupan tus repos. Tiene Scheduled Tasks — cron jobs que disparan agentes mientras tú duermes. Tiene transcripción de voz para que dictes prompts en vez de escribirlos. Tiene worktrees de Git nativos para que cada agente trabaje en una branch aislada sin pisarse con el resto.

Antigravity CLI

[PANTALLA — cita oficial blog CLI]

“The most lightweight way to invoke, monitor, and interact with Antigravity agents, directly from your terminal.”

[CÁMARA — leer en español]

“La forma más liviana de invocar, monitorear e interactuar con agentes de Antigravity, directo desde tu terminal.”

[FUENTE: antigravity.google/blog/introducing-google-antigravity-cli]

[CÁMARA]

El CLI es la versión terminal del mismo motor. El binary se llama agy — no antigravity. Es el detalle que confunde a varios al instalar.

CLI keyboard-first, ideal para sesiones SSH, tmux, máquinas remotas. Y comparte configuración, permisos y MCP servers con Antigravity 2.0. Cambias un permiso en 2.0, se aplica en CLI. Sin sincronización manual.

Antigravity IDE

[PANTALLA — cita oficial blog inicial]

“Google Antigravity is our new agentic development platform… a familiar AI-powered IDE experience with the best of Google’s models.”

[CÁMARA — leer en español]

“Google Antigravity es nuestra nueva plataforma agentic de desarrollo… una experiencia de IDE familiar potenciada por IA con lo mejor de los modelos de Google.”

[FUENTE: antigravity.google/blog/introducing-google-antigravity]

[CÁMARA]

El Antigravity IDE es lo que Google lanzó primero, en noviembre 2025. Sí es un editor de código completo — fork de Open VSX, parecido a VS Code, con autocompletado, comandos inline, y un agente que vive en el side panel. Si vienes del mundo Cursor o Windsurf, este es el equivalente.

Y acá viene un dato importante que casi nadie está cubriendo: Antigravity 2.0 NO reemplazó al IDE. Conviven los dos. El blog oficial recomienda usarlos juntos:

[PANTALLA — cita oficial]

“We recommend dual-wielding Antigravity 2.0 with your IDE of choice.”

[CÁMARA — leer en español]

“Recomendamos usar Antigravity 2.0 en paralelo con el IDE que prefieras.”

[FUENTE: antigravity.google/blog/introducing-google-antigravity-2-0]

[CÁMARA]

El IDE para editar código. El 2.0 para orquestar agentes. Dos interfaces, mismo agente debajo.

Antigravity SDK

[PANTALLA — cita oficial blog SDK]

“A Python library that gives you programmatic access to Google’s premier Antigravity coding agent.”

[CÁMARA — leer en español]

“Una librería de Python para usar el agente principal de Antigravity desde tu código.”

[FUENTE: antigravity.google/blog/introducing-google-antigravity-sdk]

[CÁMARA]

Y el cuarto producto — el que casi nadie está mostrando en español — es el SDK. Una librería Python. Te la instalas con pip install google-antigravity, escribes 15 líneas de código, y tienes un agente funcional construido sobre el mismo motor que usan los otros tres productos.

Esto es enorme. Porque significa que el agente de Google ya no es algo que solo corre dentro del IDE o del CLI. Lo puedes embeber en tu propia aplicación. Tu propio script. Tu propio servicio en producción.

[5:00 - 9:00] EL “HARNESS” — el motor compartido

[CÁMARA]

Y acá llega el concepto central del video. La palabra que Google está usando — y que toda la industria está usando ahora — es harness.

[PANTALLA — cita literal docs/home]

“Every Antigravity surface runs on a shared, highly-optimized agent harness co-trained with Gemini models.”

[CÁMARA — leer en español]

“Cada superficie de Antigravity corre sobre un agent harness compartido y altamente optimizado, co-entrenado con los modelos Gemini.”

[FUENTE: antigravity.google/docs/home]

[CÁMARA]

Y en la keynote de Google I/O, Sundar y el equipo lo definieron así:

[PANTALLA — cita keynote Google I/O 2026]

“The Anti-Gravity agent harness, the invisible framework for Gemini to perform real-world tasks.”

[CÁMARA — leer en español]

“El agent harness de Antigravity — el framework invisible que permite a Gemini ejecutar tareas en el mundo real.”

[FUENTE: antigravity.google/blog/google-io-2026]

[CÁMARA]

Y este término no es invento de Google. Es un término que la industria de IA está adoptando desde noviembre de 2025.

[PANTALLA — timeline harness engineering]

26 Nov 2025  → Anthropic: "Effective Harnesses for Long-Running Agents"
 5 Feb 2026  → Mitchell Hashimoto: "engineer the harness"
11 Feb 2026  → OpenAI: "Harness Engineering: Leveraging Codex"
 2 Abr 2026  → Martin Fowler: taxonomía formal Guides + Sensors
29 Abr 2026  → Karpathy: vibe coding muerto → agentic engineering
19 May 2026  → Google: "shared agent harness"

[CLIP: Harness Engineering — 03:38 a 03:59 — definición canónica]

“El harness es todo lo que rodea al modelo: restricciones, permisos, infraestructuras, protocolos, observabilidad. Todo excepto el modelo mismo. Y la fórmula que ahora todos están repitiendo es: agente igual a modelo más harness.”

[CÁMARA]

Si quieres el concepto completo — las cinco fuentes primarias, los patrones de Fowler, el detalle de las eras — te dejo el video arriba.

Acá voy directo al grano: cuando Google dice “Antigravity agent harness” se refiere a su runtime específico. Pero la disciplina general — Harness Engineering — es más amplia. Cosas que el harness de Google no incluye por default.

Y esto es importante porque mucha gente se confunde — habla del “harness de Antigravity” pensando que es lo mismo que la disciplina. No lo es. El runtime de Google es una implementación de la disciplina. Una buena, técnicamente potente. Pero una sola.

[9:00 - 13:00] CAPA 1 vs CAPA 2 — qué Antigravity SÍ impone, qué NO

[CÁMARA]

En mi video previo de Hermes Agent toqué la diferencia entre Capa 1 y Capa 2 de seguridad. Acá la voy a desarrollar como framework completo y aplicarla a Antigravity.

CAPA 1 — Seguridad por convención
  El agente PUEDE hacer la acción peligrosa
  pero te pregunta antes (approval gate, permissions, sandbox)
  → Confía en que TÚ apruebes correctamente

CAPA 2 — Seguridad por diseño
  La capacidad peligrosa NO EXISTE en el código
  El agente no puede borrar registros DNS porque la función no está
  → No depende de tu juicio

[CÁMARA]

¿Dónde encaja Antigravity? Te respondo con la doc oficial en la mano.

Lo que Antigravity SÍ impone — Capa 1 brutal

Sandbox terminal nativo:

[PANTALLA — cita doc oficial]

“Lightweight security isolation… leverages native operating system features: nsjail on Linux, sandbox-exec on macOS, AppContainer on Windows.”

[CÁMARA — leer en español]

“Aislamiento de seguridad liviano… aprovecha funciones nativas del sistema operativo: nsjail en Linux, sandbox-exec en macOS, AppContainer en Windows.”

[FUENTE: antigravity.google/docs/cli/sandbox]

Sin máquinas virtuales pesadas. Usa el kernel del sistema. Cero overhead.

Fine-grained permissions con regex:

[PANTALLA — settings.json ejemplo]

"permissions": {
  "allow": [
    "command(git)",
    "command(npm run (build|lint|test))",
    "read_file(/var/log/app)"
  ],
  "deny": [
    "command(rm -rf)",
    "command(sudo)",
    "write_file(.git/)"
  ]
}

Precedencia Deny > Ask > Allow. Puedes denegar comandos por regex. Esto es Capa 1 sofisticada, nivel empresa.

Hooks de ciclo de vida:

En el SDK son nueve hooks distintos — session start, session end, pre-turn, post-turn, pre-tool-call, post-tool-call, tool error recovery, user interaction, context compaction. Te dejan interceptar cada acción del agente para validar, transformar o registrar.

Lo que Antigravity NO impone — Capa 2

Y acá está la diferencia clave.

[CÁMARA]

El built-in toolset de Antigravity 2.0, del CLI y del IDE incluye file I/O completo, ejecución de shell, browser control, búsqueda en directorios. El agente sí tiene la capacidad de ejecutar rm -rf /. La protección es Capa 1 — te lo va a preguntar primero, te lo va a meter en el sandbox. Pero si activas el preset always-proceed o lanzas con --dangerously-skip-permissions, esa barrera desaparece.

El único producto de la suite que permite Capa 2 real es el SDK. Cuando construyes un agente con LocalAgentConfig, tú decides qué tools registras. Si no registras run_command, el agente no puede correr comandos. Punto. La capacidad no existe.

Y esto es exactamente lo que demostré en mi video de 3 Agentes A2A: la función delete_dns_record no existe en el código del agente DNS. No hay forma de que la llame, porque no está registrada.

[CÁMARA]

Veredicto técnico, neutro y honesto: Antigravity tiene un harness brutal en sentido producto. Su Capa 1 es de las mejores del mercado. Pero si quieres Capa 2 — restricción arquitectónica real — tienes que construirla tú con el SDK. Google no la impone por default.

Esto no es una crítica. Es un plano del producto. Y es lo que define cuándo usar Antigravity tal cual viene, y cuándo necesitas armar tu propio agente sobre el SDK.

[13:00 - 13:30] MANIFIESTO DE DIFERENCIACIÓN

[CÁMARA]

Antes de la primera demo, te aclaro qué tipo de video vas a ver. No es un tutorial de cinco minutos. No es un video de hype celebrando que Google lanzó algo nuevo. Es un análisis técnico desde la perspectiva del ingeniero que construye agentes en producción.

Vas a ver código real. Configs reales. Trade-offs honestos. Y cuándo un producto NO te conviene, te lo voy a decir.

Si te interesa esto, dale like al video y suscríbete — venimos construyendo serie con Harness Engineering, Hermes y ahora Antigravity. Vamos a las demos.

[13:30 - 14:00] CTA SKOOL #1

[CÁMARA]

Antes de la primera demo, dos cosas. Lo que vas a ver de aquí en adelante son configs, comandos, código real. Todo va a estar también en mi comunidad de Skool — skool.com/agentic-engineers — donde hay un curso completo de Antigravity en preparación. El link en la descripción. Vamos.

[14:00 - 19:00] DEMO 1 — Instalación + primer agente

[CÁMARA]

Empezamos por la base. Setup completo de las 4 superficies.

[PANTALLA — antigravity.google/download]

Antigravity 2.0 y el IDE son aplicaciones de escritorio. Descargas el instalador desde antigravity.google/download — hay versiones para macOS Apple Silicon y Intel, Windows x64 y ARM64, y Linux x64 y ARM64. Lo instalas como cualquier app de escritorio.

El CLI y el SDK los instalamos por terminal. El SDK lo veremos en el demo del minuto 32. Acá vamos con el CLI.

[PANTALLA — terminal]

# macOS / Linux
curl -fsSL https://antigravity.google/cli/install.sh | bash

# Windows PowerShell
irm https://antigravity.google/cli/install.ps1 | iex

# Windows CMD
curl -fsSL https://antigravity.google/cli/install.cmd -o install.cmd && install.cmd && del install.cmd

[CÁMARA]

El binary va a ~/.local/bin/agy en Unix. Verificas con agy --version.

[PANTALLA — terminal — primera ejecución]

mkdir agy-demo && cd agy-demo
agy

[CÁMARA]

Primera ejecución te pide tres cosas en pantalla interactiva: tema de colores, modo de renderizado (Alt-screen o Inline), y trust del workspace. Apruebas y ya estás dentro del TUI.

[PANTALLA — TUI con prompt]

[CÁMARA]

Acá hay un detalle que NO se cuenta en otros videos. Antigravity en el tier free te da acceso a cinco modelos distintos, con varios niveles de razonamiento cada uno.

[PANTALLA — /model con la lista real en el TUI]

Switch Model

  Gemini 3.5 Flash (Medium)   (current)
  Gemini 3.5 Flash (High)
  Gemini 3.5 Flash (Low)
  Gemini 3.1 Pro (Low)
  Gemini 3.1 Pro (High)
  Claude Sonnet 4.6 (Thinking)
  Claude Opus 4.6 (Thinking)
  GPT-OSS 120B (Medium)

[CÁMARA]

Sí, Claude Sonnet 4.6 y Claude Opus 4.6. Y GPT-OSS 120B. En el tier gratuito. Sin API key extra. Lo cambias con /model en vivo.

[PANTALLA — comando /model]

Selecciono Gemini 3.5 Flash, que es el default y el que Google optimizó. Según el blog oficial de I/O 2026:

[PANTALLA — cita oficial]

“Terminal-Bench 2.1: 76.2%, GDPval-AA: 1656 Elo, MCP Atlas: 83.6%, CharXiv Reasoning: 84.2%. 12x faster on Antigravity thanks to some further optimizations.”

[CÁMARA — leer en español]

“Terminal-Bench 2.1: 76.2%. GDPval-AA: 1656 Elo. MCP Atlas: 83.6%. CharXiv Reasoning: 84.2%. Doce veces más rápido en Antigravity gracias a optimizaciones adicionales.”

[FUENTE: antigravity.google/blog/google-io-2026]

[CÁMARA]

Y le pido la primera tarea — un script Python que descargue el texto de una página web.

[PANTALLA — prompt y respuesta del agente]

> Write a simple python script to fetch web page text

El agente lee el workspace, ve que no hay archivos, planea el script, lo crea. Cuando termina, presiono Ctrl+R para abrir el Artifact Picker — y reviso el archivo línea por línea antes de aprobarlo.

[PANTALLA — Artifact Review screen]

Apruebo con y. Salgo con Esc. Le pido al agente que ejecute el script para verificar.

> Run the python script and show me the output

El agente propone python3 main.py. Apruebo. Corre. Output en pantalla.

[CÁMARA]

Tres conceptos clave acá:

Uno — workspace trust. El agente solo opera dentro del directorio que apruebas. Por defecto, acceso limitado: Capa 2 parcial sobre el filesystem

Dos — artifacts. El agente no aplica cambios silenciosamente. Crea artefactos – archivos, planos, grabaciones del navegador – y tú los apruebas o rechazas con y/n. Esto es Capa 1 funcionando bien.

Tres — el @ autocompleta paths. Si escribes @src/ te abre el path picker. Si necesitas referenciar un archivo específico en tu prompt, lo usas con @. Ahorra mucho tiempo.

[19:00 - 24:00] DEMO 2 — Migración desde Gemini CLI

[CÁMARA]

Si vienes de Gemini CLI, te interesa esto. Porque el 18 de junio Gemini CLI deja de servir requests. Migración obligatoria. Pero Google hizo el upgrade path bien.

[PANTALLA — terminal]

agy plugin import gemini

[CÁMARA]

Un solo comando. El CLI busca tu configuración legacy de Gemini, parsea los manifests, convierte las skills, los MCP servers, los comandos custom.

[PANTALLA — output del import]

[ok]   conductor-tools
       - skills     : skipped (none detected)
       - agents     : skipped (none detected)
       ✔ commands   : 4 legacy commands converted to skills
       - mcpServers : skipped (none detected)
[ok]   google-workspace
       ✔ skills     : 5 skills processed
       - agents     : skipped (none detected)
       ✔ commands   : 2 legacy commands converted to skills
       ✔ mcpServers : 1 server definition migrated to mcp_config.json

[CÁMARA]

Tres cambios importantes que tienes que entender:

Uno — el directorio cambió, pero el nombre raíz NO.

[PANTALLA — paths comparados]

Gemini CLI            → ~/.gemini/settings.json
Antigravity CLI       → ~/.gemini/antigravity-cli/settings.json

[CÁMARA]

Mira esto. El nombre del producto cambió a Antigravity, pero la configuración sigue colgando del directorio .gemini. Google no rompió retro-compat. Si abres tu home y haces ls -la, vas a ver el directorio .gemini sigue ahí con la sub-carpeta antigravity-cli adentro. Detalle de ingeniería interesante — no tuvieron que tocar la jerarquía.

Dos — las skills cambiaron de path.

[PANTALLA — paths skills]

Gemini CLI            → .gemini/skills/
Antigravity CLI       → .agents/skills/

[CÁMARA]

Antigravity se suma al estándar abierto AGENTS.md que ya usan otras herramientas como Codex — el archivo en raíz para reglas del repo, las skills en .agents/. Si tienes skills custom en tu repo, las mueves con mv y actualizas tu repo.

mv .gemini/skills .agents/skills

Tres — el schema MCP cambió.

[PANTALLA — comparativa schemas]

// Gemini CLI (legacy)
{
  "mcpServers": {
    "remote-indexer": {
      "url": "https://mcp.internal.com/sse"
    }
  }
}

// Antigravity CLI (nuevo)
{
  "mcpServers": {
    "remote-indexer": {
      "serverUrl": "https://mcp.internal.com/sse"
    }
  }
}

[CÁMARA]

La key url o httpUrl se reemplaza por serverUrl. Si tienes servers MCP remotos, los actualizas manualmente. Los servers locales (stdio) no cambian.

Mi recomendación: si todavía usas Gemini CLI, migra cuanto antes. La transición es trivial — diez minutos máximo. El 18 de junio de 2026 es la fecha límite de Gemini CLI — pasada esa fecha tu CI se rompe.

[24:00 - 24:30] CTA SKOOL #2

[CÁMARA]

Voy a la sección más jugosa del video — el bridge CLI ↔ 2.0. Antes de eso, recordatorio: en skool.com/agentic-engineers el curso completo de Antigravity incluye la migración paso a paso de Gemini con un repo real para que practiques. Link en la descripción. Vamos al clímax.

[24:30 - 32:00] DEMO 3 — Bridge CLI ↔ 2.0 (CLÍMAX)

[CÁMARA]

Lo voy a hacer entre las dos superficies del mismo harness — Antigravity 2.0 y el CLI. Te lo muestro en vivo.

Empiezo en Antigravity 2.0 — el command center desktop sin IDE. Project nuevo. Le doy una tarea simple para mostrar el flujo:

[PANTALLA — Antigravity 2.0 con conversación activa]

hola, crea un script bash llamado promo.sh que imprima con echo:
"Suscríbete en youtube.com/@nicolasneiragarcia"

El agente lee el workspace, genera el archivo promo.sh, lo presenta como artifact. Reviso el contenido, apruebo con y.

[CÁMARA]

Bien. Ahora quiero seguir esta misma tarea desde el terminal, sin perder nada de contexto. Abro el terminal local — donde quiero trabajar sin la interfaz visual del 2.0.

[PANTALLA — terminal local]

cd ~/test02
agy

Lanzo el CLI. Dentro escribo:

/resume

[PANTALLA — Conversation Picker]

Se abre el Conversation Picker. Por default me muestra solo las conversaciones del CLI local. Presiono Tab.

[PANTALLA — Tab switching a Antigravity tab]

Ahora me muestra las conversaciones de Antigravity 2.0 — todas las que abrí en el desktop. Selecciono la del promo.sh que acabo de empezar. Confirmo con Enter.

[PANTALLA — conversación importada en CLI]

[CÁMARA]

Y acá está. La conversación entera del 2.0 — el script, el artifact, el historial — aparece en el terminal. Sigo desde donde estaba. Sin re-explicar nada al agente. Sin perder estado.

Ahora le pido que agregue otra línea:

[PANTALLA — escribo siguiente prompt en CLI]

> agrega otro echo al script invitando a la comunidad de Skool:
> "Únete a la comunidad en skool.com/agentic-engineers"

El agente entiende perfectamente el contexto. Edita el mismo promo.sh, agrega la segunda línea. Apruebo. Y ejecuto el script para verificar:

bash promo.sh

[PANTALLA — output del script con los 2 echos]

Suscríbete en youtube.com/@nicolasneiragarcia
Únete a la comunidad en skool.com/agentic-engineers

[CÁMARA]

Esto es lo que Google llama “shared agent harness” en acción. El mismo motor, dos superficies, contexto importable.

La jugada inversa — CLI → 2.0

[CÁMARA]

Ahora la jugada inversa. Quiero volver al 2.0 y ver el script con las dos líneas que agregué desde el CLI. Acá viene un detalle que la doc oficial no te cuenta — para que funcione, hay que hacer tres cosas en orden.

[PANTALLA — terminal]

Uno: cerrar la sesión del CLI con /exit o Ctrl+D. El CLI usa SQLite con Write-Ahead Log — los últimos turnos quedan en buffer hasta que cerrás. Si no haces esto, la conversación se ve incompleta en el 2.0.

/exit

[PANTALLA — Antigravity 2.0]

Dos: el Project del 2.0 tiene que incluir el mismo folder donde lanzaste el CLI. Si tu CLI corría en ~/test02, el Project del 2.0 debe tener ese path en sus folders. Sin workspace alignment, no aparece nada.

Tres: refrescá el @conversation dropdown del 2.0 — a veces hay que cerrar y reabrir el Project para que recargue.

[PANTALLA — Antigravity 2.0 con @conversation: dropdown]

Ahora sí. Escribo @conversation: en el prompt del 2.0, y aparece la sesión del CLI. La selecciono. Y acá está — el promo.sh con las dos líneas que agregué desde el CLI, disponible para seguir editando con feedback visual.

[CÁMARA]

Honestidad técnica: este bridge inverso es inestable hoy. Hay reportes en el forum oficial de Google AI Devs de conversaciones que aparecen incompletas o no aparecen. La comunidad armó tools para arreglar conversaciones rotas. El changelog oficial menciona bugs fixed en el import SQLite, lo que indica que hubo problemas históricos. Funciona si seguís los tres pasos — pero no es plug-and-play.

La dirección que funciona limpio es 2.0 → CLI. Esa es la que recomiendo usar como flujo principal en producción.

Esto, igual, cambia el modelo mental. Un agente, múltiples superficies. Tú decides cuál usar según el momento.

Y el último bonus de esta sección — /fork.

[PANTALLA — comando /fork]

/fork

[CÁMARA]

Fork clona la conversación entera. Mismo estado, mismo contexto, sesión nueva. Sirve para experimentar approaches alternativos sin perder la branch principal. Si fallas, /resume te vuelve a la sesión estable.

[32:00 - 39:00] DEMO 4 — Antigravity SDK + tu propia Capa 2

[CÁMARA]

Hasta acá vimos los productos cerrados — IDE, CLI, 2.0. Ahora viene la pieza que te da control real. El SDK.

[PANTALLA — terminal]

python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt

[CÁMARA]

Tres líneas: venv limpio, lo activo, e instalo deps. El requirements.txt tiene dos paquetes: google-antigravity (el SDK oficial, versión 0.1.2) y python-dotenv (para cargar la API key desde .env sin exponerla en código). Abrimos el archivo Python.

[PANTALLA — editor con código]

import asyncio
from google.antigravity import Agent, LocalAgentConfig

async def main():
    config = LocalAgentConfig()
    async with Agent(config) as agent:
        response = await agent.chat(
            "What files are in the current directory?"
        )
        print(await response.text())

if __name__ == "__main__":
    asyncio.run(main())

[CÁMARA]

Quince líneas. Un agente funcional que abre tu filesystem, lee directorios, te responde. Sobre el mismo motor que usan Antigravity 2.0 y el CLI. Mismo runtime, misma calidad, mismo Gemini 3.5 Flash debajo.

Ejecuto:

[PANTALLA — output del agente]

$ python agent.py
Looking at the current directory, I see the following files:
- agent.py (this script)
- requirements.txt
- README.md

[CÁMARA]

Bueno. Pero esto es el “hello world”. El valor real del SDK está en lo que viene ahora — tu propia Capa 2.

Construir Capa 2 con el SDK

[PANTALLA — código safety policies]

from google.antigravity.hooks.policy import deny, allow, ask_user

policies = [
    deny("*"),                           # Bloquea todo por defecto
    allow("view_file"),                  # Permite leer archivos
    ask_user("run_command", handler=my_handler),  # Pregunta antes de shell
]

[CÁMARA]

Esto es Capa 1 sofisticada — el agente todavía tiene las tools, pero las políticas controlan cuándo se invocan.

Pero ahora viene Capa 2 real. Donde la tool no existe.

[CÁMARA]

El blog oficial del SDK lo dice textual: del built-in toolset puedes — cito — “layer in system instructions to set identity, add domain-specific guidance, or replace the defaults entirely.”

Replace the defaults entirely. Esa es la frase clave. El SDK te permite reemplazar el toolset por el tuyo propio. Si en tu config no incluyes run_command, el agente literalmente no tiene esa herramienta. No es approval gate — es ausencia de capacidad.

[CÁMARA]

El ejemplo concreto lo viste en mi video de 3 Agentes A2A: la función delete_dns_record no existe en el código del agente DNS. No hay forma de que la ejecute, porque la herramienta no está registrada. Eso es Capa 2 real.

Mi recomendación: para cualquier agente que vaya a producción con datos sensibles, no uses el built-in toolset completo. Construye tu propio config con SDK, registra solo lo que necesitas. Capa 2 real.

Los 9 lifecycle hooks

[PANTALLA — diagrama hooks]

session_start
    │
    ├── pre_turn
    │       ├── pre_tool_call
    │       │       ├── (TOOL EXECUTION)
    │       └── post_tool_call
    │
    ├── post_turn
    │       └── tool_error_recovery
    │
    ├── user_interaction_handler
    │
    └── context_compaction
session_end

[CÁMARA]

Nueve puntos donde puedes interceptar. Cada uno con tres modos: inspect (solo lee, para logging), decide (aprueba o bloquea), transform (modifica los datos en tránsito).

Ejemplo concreto — un hook que registra cada tool call para audit trail:

from google.antigravity.hooks import post_tool_call

@post_tool_call
async def audit_log(result):
    print(f"Tool {result.name} ran with result: {result.summary}")

[CÁMARA]

Esto es observability nativa. Para enterprise. Para compliance. Para debugging real cuando un agente hace algo raro en producción.

Roadmap oficial del SDK

[PANTALLA — cita blog SDK]

“Remote harness: Deploy SDK agents to Google Cloud. TypeScript and Go: Same runtime, additional language support. Gemma integration: bringing the full agent runtime to open models you can run and fine-tune yourself. Plugins. Deeper observability.”

[CÁMARA — leer en español]

“Remote harness: desplegar agentes del SDK en Google Cloud. TypeScript y Go: mismo runtime, soporte para más lenguajes. Integración con Gemma: llevar el runtime completo a modelos open que tú mismo puedes correr y fine-tunear. Plugins. Observabilidad más profunda.”

[FUENTE: antigravity.google/blog/introducing-google-antigravity-sdk]

[CÁMARA]

Lo más fuerte de esta roadmap: Gemma integration. O sea, el harness completo de Antigravity corriendo sobre modelos open que tú controlas. Eso cambia el juego para empresas que necesitan no enviar datos a Google.

[CÁMARA]

Honestidad técnica antes de cerrar este bloque: Antigravity SDK no es el único SDK agentic del mercado. Anthropic publicó claude-agent-sdk con hooks, MCP servers y permission modes. Cursor también lanzó su SDK con sandboxed VMs y subagentes. La diferencia de Antigravity SDK no es “ser el primero” — es que conecta nativamente con los otros tres productos de la suite Google.

[39:00 - 44:00] DEMO 5 — Subagentes paralelos y Scheduled Tasks

[CÁMARA]

Última demo antes del cierre. Dos features que diferencian Antigravity de la mayoría de su competencia.

Subagentes asíncronos

[CÁMARA]

Le doy al agente principal una tarea grande sobre un módulo auth.py deliberadamente imperfecto: refactor con type hints y manejo de errores, ampliación de tests, y generación de documentación. Y le pido explícitamente que divida el trabajo en tres subagentes paralelos.

[PANTALLA — prompt completo en el CLI]

Tengo un módulo auth.py en este proyecto que necesita atención completa.
Lee primero AGENTS.md para entender las reglas del proyecto.

Después divide el trabajo en tres tareas paralelas usando subagentes,
una por cada tarea:

1. Refactor de auth.py: aplicar type hints, docstrings estilo Google,
   reemplazar comparación de contraseñas en texto plano por bcrypt,
   manejo de errores con excepciones.
2. Ampliar tests/test_auth.py: cubrir los nuevos casos del refactor y
   asegurar que los 5 tests baseline siguen pasando.
3. Generar docs/auth.md con propósito del módulo, API pública,
   y ejemplos de uso.

Lanza los tres subagentes en paralelo y muéstrame el progreso en /agents.

[CÁMARA]

El agente principal arma un plan y dispara los tres subagentes:

[PANTALLA — spawn de subagentes]

[subagent_1] Refactoring auth.py
[subagent_2] Writing tests/test_auth.py
[subagent_3] Updating docs/auth.md

[PANTALLA — /agents panel]

Abro el panel con /agents. Veo los tres subagentes corriendo, su estado, qué tool están ejecutando ahora mismo. Puedo entrar al detalle de cualquiera con Enter.

[CÁMARA]

Y acá vienen dos atajos brutales para no quedarse pegado micro-aprobando.

Alt+J — teleport. Si un subagente necesita aprobación para un comando, este atajo te lleva instantáneo al detalle del subagente. Apruebas, presionas Esc, y vuelves al prompt principal.

Ctrl+K — fast-path approve. Sin moverte de la conversación principal, ves la notificación arriba del prompt, y apruebas con un solo atajo. Sin perder foco.

Esto en agentes que hacen muchas tool calls — refactors grandes, scrapings — te ahorra literalmente minutos por sesión.

[CÁMARA]

¿Hasta dónde escala esto? Mira lo que Google mostró en la keynote de I/O.

[PANTALLA — cita keynote Google I/O 2026]

“Over 12 hours, 93 sub-agents working in parallel made over 15,000 model requests and processed 2.6 billion tokens to take an initially empty project to the core of a functioning operating system.”

[CÁMARA — leer en español]

“En 12 horas, 93 subagentes trabajando en paralelo hicieron más de 15,000 requests al modelo y procesaron 2.6 billones de tokens para llevar un proyecto inicialmente vacío al núcleo de un sistema operativo funcional.”

[FUENTE: antigravity.google/blog/google-io-2026]

[CÁMARA]

93 subagentes en paralelo. 15,000 requests. Un sistema operativo desde cero. En 12 horas. Y agregaron — cito otra vez:

[PANTALLA — cita keynote]

“This was not possible on Gemini 3.1 Pro.”

[FUENTE: antigravity.google/blog/google-io-2026]

[CÁMARA]

Lo que estamos viendo es un cambio de escala. Lo que antes era “un agente que escribe código” ahora es “93 agentes que construyen un OS mientras tú duermes”. El harness está hecho para eso — no para una tarea, para coordinar decenas de tareas en paralelo.

Scheduled Tasks

[CÁMARA]

Y la feature más diferenciada del paquete — solo en Antigravity 2.0. Scheduled Tasks.

[PANTALLA — comando /schedule en Antigravity 2.0]

/schedule "Every weekday at 9am, review the GitHub PRs assigned to me and write a summary of which ones are ready to merge"

[CÁMARA]

El agente toma esta instrucción como un cron job. Cada día laboral a las 9 de la mañana se dispara, revisa los PRs, genera un summary. Mientras tú duermes o estás en una reunión.

[PANTALLA — Scheduled Tasks panel]

Esto cambia el modelo mental de cómo trabajas con agentes. Ya no es “humano dispara cada query”. El agente puede tener su propia agenda. Tareas recurrentes. Triggers temporales.

Honesto: esta feature todavía es nueva y tiene limitaciones — solo tasks en Antigravity 2.0, no CLI, no SDK. Pero el concepto está implementado en producción y funciona.

[44:00 - 49:00] EL DRAMA — Términos de Servicio + interoperabilidad

[CÁMARA]

Y llegamos a la parte que casi nadie está cubriendo, y que es importante que sepas.

[PANTALLA — cita literal del FAQ oficial de Antigravity]

“Why can’t I use third party software (e.g. Claude Code, OpenClaw, OpenCode) with my Antigravity login? Using third party software, tools, or services to access Antigravity is a violation of our Terms of Service, and severely degrades the experience for legitimate product users. Such actions may be grounds for suspension or termination of your account.”

[CÁMARA — leer en español]

“¿Por qué no puedo usar software de terceros — por ejemplo Claude Code, OpenClaw, OpenCode — con mi login de Antigravity? Usar software, herramientas o servicios de terceros para acceder a Antigravity es una violación de nuestros Términos de Servicio, y degrada severamente la experiencia para los usuarios legítimos del producto. Estas acciones pueden ser motivo de suspensión o terminación de tu cuenta.”

[FUENTE: antigravity.google/docs/faq]

[CÁMARA]

Eso lo escribió Google. Está en antigravity.google/docs/faq. Cita literal — no es interpretación mía.

¿Qué significa? Si tienes una cuenta de Antigravity y usas Claude Code o cualquier herramienta de terceros haciéndola pasar por sesión legítima de Antigravity — por ejemplo proxeando requests al endpoint de Antigravity desde Claude Code — Google puede terminarte la cuenta.

Y mira lo que Google recomienda hacer en su lugar, en el mismo FAQ:

[PANTALLA — siguiente línea del FAQ]

“If you would like to use a third party coding agent with Gemini, we recommend using a Vertex or AI Studio API key.”

[CÁMARA — leer en español]

“Si quieres usar un agente de codificación de terceros con Gemini, recomendamos usar una API key de Vertex o AI Studio.”

[FUENTE: antigravity.google/docs/faq]

[CÁMARA]

O sea — la solución oficial para mezclar herramientas es usar Vertex AI o AI Studio con API key. NO con tu login de Antigravity. Dos sistemas separados. Mismo modelo Gemini debajo, pero accedido por canales distintos.

Esto te lo digo neutral — no estoy criticando a Google. Es válido que protejan sus tiers de uso. Pero como ingeniero que va a montar esto en producción, necesitas saberlo antes de armar un stack mixto. Te lo digo porque muchos están experimentando con Claude Code + Antigravity y no se enteraron del clause.

La forma legal y técnicamente correcta de combinar herramientas:

[PANTALLA — esquema]

Tu setup mixto (legal según Google):
─────────────────────────────────
[Antigravity 2.0]  ──► login Google ──► Antigravity harness
[Antigravity CLI]  ──► login Google ──► Antigravity harness
[Claude Code]      ──► Vertex API key ──► Gemini directo (NO Antigravity)
[Codex local]      ──► Vertex API key ──► Gemini directo (NO Antigravity)

[CÁMARA]

Si quieres usar Claude Code apuntando a Gemini, sacas un API key en Vertex AI o AI Studio, y conectas Claude Code a ese endpoint. No tocas tu login de Antigravity. Sin riesgo de suspensión.

Esto también explica una decisión técnica: Google está construyendo Antigravity como ecosistema cerrado por arriba (tu login + sus 4 productos) y API abierta por abajo (Vertex/AI Studio para todo lo demás). Dos planos. Dos contratos. Sabes cuál usar según tu caso.

[49:00 - 53:00] CUÁNDO USAR Y CUÁNDO NO

[CÁMARA]

Ya te mostré toda la suite. Ahora — cuándo conviene cada uno, cuándo no, y para qué tipo de developer.

Cuándo SÍ — Antigravity 2.0

Quieres orquestar varios agentes en paralelo desde una interfaz visual
Necesitas Scheduled Tasks para agentes que corren sin ti
Te gusta el modelo “command center” más que el modelo editor

Cuándo SÍ — Antigravity CLI

Trabajas mucho por SSH, tmux, sesiones remotas
Quieres terminal-first, keyboard-only
Migras desde Gemini CLI antes del 18 de junio

Cuándo SÍ — Antigravity IDE

Vienes de Cursor o Windsurf y quieres equivalente Google
Editas mucho código manual con autocompletado fuerte
Quieres dual-wield con 2.0 para algunas tareas

Cuándo SÍ — Antigravity SDK

Construyes agentes custom para producción
Necesitas Capa 2 arquitectónica de verdad
Tu equipo va a hostear el agente en su propia infraestructura
Vas a embeber el harness en tu propio producto

Cuándo NO

Si solo necesitas autocompletado simple, GitHub Copilot te basta y es más barato
Si tu stack es 100% Anthropic-first y ya tienes Claude Code productivo, cambiar todo a Antigravity es overhead
Si tu compliance no permite enviar código a Google, espera la integración Gemma del SDK (en roadmap)
Si estás en una región sin acceso (verificar docs/faq — disponibilidad geográfica restringida)
Si vas a hacer uso diario intensivo en el tier Free — los rate limits son ajustados y los modelos Claude y GPT-OSS tienen quota separada de los Gemini. Para uso serio necesitas Pro

[53:00 - 55:00] CTA SKOOL #3 + CIERRE + PREGUNTA

[CÁMARA]

Resumen de lo que viste hoy.

Antigravity no es un CLI. No es un IDE. Es una plataforma agentic con cuatro productos que comparten el mismo motor. Cada uno optimizado para un workflow distinto — desktop, terminal, editor, código.

Conecté tres conceptos del canal — el harness compartido (Harness Engineering), la diferencia entre Capa 1 y Capa 2 (Hermes Agent), y los ejemplos concretos de producción (3 Agentes A2A, Workspace Profiling, Agent Teams, IDP).

Si te interesa profundizar en cualquiera de estos cuatro productos con repos reales y ejemplos hands-on, en mi comunidad de Skool — skool.com/agentic-engineers — tienes acceso gratuito a la comunidad y a los cursos introductorios. El curso completo de Antigravity con repos privados y ejercicios hands-on se va en el tier Premium. Link en la descripción.

Y antes de cerrar, una pregunta para los comentarios — ¿qué producto de la suite te interesa más cubrir en profundidad como un video aparte? El SDK con Capa 2 propia, las Scheduled Tasks para automatización 24/7, o el bridge entre el desktop 2.0 y el CLI para flujos híbridos? Te leo en los comments y el más votado se va a video propio.

Gracias por quedarte hasta el final. Nos vemos en el próximo.

RESUMEN DE PRODUCCIÓN

Cámara nueva (Nicolás directo a cámara)

Hook (1:00)
Open loops (0:40)
Suscripción (0:20)
Concepto suite (3:00)
Harness concept (4:00)
Capa 1 vs Capa 2 (4:00)
Manifiesto (0:30)
CTA Skool 1 (0:30)
Demo 1 narración (5:00)
Demo 2 narración (5:00)
CTA Skool 2 (0:30)
Demo 3 narración (7:30)
Demo 4 narración (7:00)
Demo 5 narración (5:00)
Drama Términos de Servicio (5:00)
Cuándo SÍ / NO (4:00)
Cierre + CTA 3 + pregunta (2:00)
Total cámara: ~55 min

Pantallas / capturas necesarias

#	Qué capturar	Sección
1	Diagrama suite 4 productos	Concepto
2	Cita `/product` overlay	Concepto
3	Cita blog 2.0 “there is no IDE”	Concepto
4	Cita blog inicial sobre IDE	Concepto
5	Cita blog SDK pip install	Concepto
6	Cita `docs/home` shared harness	Harness
7	Timeline harness engineering	Harness
8	Diagrama capas 1 vs 2	Capa 1/2
9	Cita sandbox doc	Capa 1/2
10	Ejemplo settings.json permissions	Capa 1/2
11	Curl install commands	Demo 1
12	TUI first launch interactivo	Demo 1
13	Cita pricing modelos disponibles	Demo 1
14	`/model` con lista	Demo 1
15	Cita benchmarks I/O 2026	Demo 1
16	Prompt + respuesta agente Python script	Demo 1
17	Artifact Review screen	Demo 1
18	Comando `agy plugin import gemini`	Demo 2
19	Output import (skills + commands + mcp)	Demo 2
20	Paths comparados Gemini vs Antigravity	Demo 2
21	Paths skills `.gemini/` vs `.agents/`	Demo 2
22	Schema MCP url vs serverUrl	Demo 2
23	Antigravity 2.0 con conversación activa	Demo 3
24	Terminal local lanzando agy	Demo 3
25	`/resume` Conversation Picker	Demo 3
26	Tab switch a Antigravity tab	Demo 3
27	Conversación importada en CLI	Demo 3
28	Antigravity 2.0 con @conversation dropdown	Demo 3
29	Comando `/fork`	Demo 3
30	`pip install google-antigravity`	Demo 4
31	Código Python 15 líneas	Demo 4
32	Output agente filesystem	Demo 4
33	Código safety policies	Demo 4
34	Código tool registration limitada (Capa 2)	Demo 4
35	Diagrama 9 lifecycle hooks	Demo 4
36	Código hook ejemplo post_tool_call	Demo 4
37	Cita roadmap SDK Gemma	Demo 4
38	Subagentes paralelos spawn	Demo 5
39	`/agents` panel	Demo 5
40	`/schedule` comando	Demo 5
41	Scheduled Tasks panel	Demo 5
42	Cita literal FAQ — cláusula de Términos de Servicio	Drama
43	Cita siguiente línea FAQ Vertex/AI Studio	Drama
44	Esquema setup mixto legal	Drama

Setup técnico previo a grabar

Slides a generar (Keynote o ChatGPT)

Diagrama suite 4 productos + harness compartido
Timeline Harness Engineering (Nov 2025 - May 2026)
Diagrama Capa 1 vs Capa 2
Paths Gemini vs Antigravity (settings + skills + mcp)
Schema MCP url vs serverUrl
Diagrama 9 lifecycle hooks SDK
Esquema setup mixto legal (Antigravity ↔ Vertex API)

Datos verificados — fuentes primarias

Todas las citas son verbatim de antigravity.google/*. Verificado con scraping Playwright contra:

antigravity.google/ (landing)
antigravity.google/product
antigravity.google/pricing
antigravity.google/docs/home
antigravity.google/docs/faq
antigravity.google/docs/sdk-overview
antigravity.google/docs/features
antigravity.google/blog/introducing-google-antigravity
antigravity.google/blog/introducing-google-antigravity-2-0
antigravity.google/blog/introducing-google-antigravity-cli
antigravity.google/blog/introducing-google-antigravity-sdk
antigravity.google/blog/google-io-2026
antigravity.google/blog/changes-to-antigravity-plans
Más 20 páginas de doc CLI completa (overview, getting-started, install, tutorial, using, features, migration, prompting, artifacts, conversations, subagents, permissions, sandbox, settings, plugins-skills, status-line, terminal-title, best-practices, troubleshooting, reference)

Cross-promotion con videos del canal

Video referenciado	Cuándo se menciona	Cómo
Harness Engineering (4 may)	Min 6:00, 9:00	Concepto base, fórmula `Agent = Model + Harness`
Hermes Agent (30 may)	Min 9:00, 35:00	Framework Capa 1 vs Capa 2
Workspace Profiling	Min 36:00	Ejemplo de Capa 2 con `delete_dns_record` ausente
Agent Teams	(en cierre)	Continuidad serie

KPIs esperados (basados en patrón canal)

Duración: 55 min
Target retention: 35-40% (formato concepto + multi-demo, como Harness Engineering)
CTR thumbnail: 5-8% (con miniatura siguiendo patrón)
Click a Skool: 3-5%
Comments con respuesta a la pregunta final: 50+ en primera semana

Pendiente post-guion

Validar guion con grep argentinismos (vos/tenés/podés/querés)
Confirmar Antigravity 2.0 + IDE instalados con cuenta activa
Definir miniatura (concepto separado)
Definir descripción YouTube con 3 hashtags strategy (#AntigravityCLI #AgentSDK #GoogleAI)
Definir tags VidIQ optimizados
Generar SBV ES + EN + PT-BR durante edición (PT-BR mercado abierto según VidIQ)
Comentario fijado con links a Harness Engineering y Hermes