# Antigravity ejecuta los agentes. Maguyva les da el mapa.

Canonical source: https://maguyva.ai/es/for-antigravity

License: text under [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/); code samples under [MIT-0](https://opensource.org/license/mit-0); the Maguyva name, logos, brand assets and other code are not covered. Details: [maguyva.ai/license](https://maguyva.ai/license).

Antigravity es un IDE pensado primero para agentes: los agentes planifican y editan en el editor, la terminal y el navegador. En un monorepo real igual necesitan un mapa de qué archivo importa. Maguyva indexa tu base de código y la pone a disposición vía MCP (semántico, AST, grafo y texto), así que “dónde pasa la autenticación” devuelve el flujo de auth real, no siete stubs de prueba.

> Antigravity ejecuta al agente. Maguyva le dice qué archivo tocar.

## Qué hace cada capa

Cuatro piezas. Cada una tiene su trabajo.

### Antigravity

Donde tus agentes planifican, editan y verifican.

### menciones con @ + reglas

El contexto manual funciona, hasta que el repo se hace grande.

### Maguyva

Información sobre la base de código obtenida automáticamente vía MCP.

### Por espacio de trabajo, no por usuario

Los agentes no generan cargos por usuario. [Ver precios](https://maguyva.ai/es/pricing)

## Antigravity ejecuta los agentes. Déjalo.

El IDE de agentes no es el problema. El Agent Manager, la ejecución en varias interfaces y los archivos de reglas son excelentes, y ya los usas para:

- Planificar y ejecutar agentes en el editor, la terminal y el navegador.
- Ediciones multiarchivo cuando el cambio es local.
- Reglas de agente para convenciones del repo y estilo.
- Menciones con `@` para traer un archivo específico al contexto.

Sigue haciendo eso. Nada de eso desaparece.

Pero en un monorepo real (TypeScript con dependencias de workspace, servicios en Python, paquetes mixtos) el contexto del agente se rompe en el momento en que el archivo relevante todavía no está en el radar del agente.

## Arreglos manuales que ya probaste, y dónde fallan

Cuatro arreglos manuales junto con su modo de falla. Izquierda = lo que haces hoy. Derecha = dónde se rompe.

### // menciona los archivos

Mencionas con `@` los tres archivos que crees que importan. El agente edita limpiamente dentro de ellos.

### // mencionar es adivinar

Funciona cuando ya sabes cuáles archivos están involucrados. Un agente autónomo necesita los archivos que no sabías que había que mencionar.

### // pega los snippets

Pegas 200 líneas de otro paquete en el agente para darle suficiente contexto.

### // el código pegado se vuelve viejo

El snippet que pegaste a las 9 a. m. no refleja el rebase que tu compañero hizo a las 11 a. m. El agente está editando a partir de una versión fantasma del paquete.

### // escribe un doc de contexto

Escribes un archivo de reglas de agente o un markdown de arquitectura. Hoy está correcto.

### // los docs se desactualizan más rápido que el código

Todo lo que escribes a mano se desactualiza. El código es la fuente de verdad. Un doc que explica la capa de colas es correcto durante una semana, y después está mal para siempre.

### // mantén los archivos de reglas

Agregas reglas de agente para nomenclatura, lint y comandos de build. Genial para el comportamiento.

### // reglas ≠ índice

Las reglas son el lugar correcto para “siempre ejecuta pnpm tsc -b antes de los commits”. No son un índice consultable de cada símbolo, archivo y punto de llamada en tu monorepo.

## Maguyva es la capa que está debajo

No es un reemplazo de Antigravity. Es la capa de contexto de repo que se conecta a su soporte MCP.

- **Semántica + AST + grafo + texto**: busca por significado, estructura, dependencia o texto literal. Cada resultado devuelve una ruta de archivo y un número de línea.
- **Entre paquetes por defecto**: puntos de llamada e importadores en todos los paquetes del monorepo, no solo en el que el agente tiene abierto.
- **Tiene en cuenta la rama**: Maguyva ve la versión del código que el agente está editando.
- **Hecho para la autonomía**: un agente que planifica muchas ediciones necesita el radio de impacto por adelantado, no después de que el CI se ponga en rojo.

> Antigravity decide qué editar.
> Maguyva le dice al agente *qué toca esa edición.*

## Tres flujos de trabajo de monorepo

Entre paquetes, entre lenguajes. Fundamentado en el grafo de llamadas real, no en el grep del agente.

### 01. Encuentra el flujo de auth entre paquetes, sin mencionar nada

```text
agent> ¿dónde pasa la autenticación en este monorepo?

graph::query("authentication flow")
  packages/web/src/auth/session.ts:42       middleware
  packages/api/src/auth/jwt.ts:88           verificación del token
  packages/shared/src/auth/types.ts:12      AuthContext
  packages/admin/src/auth/admin-only.ts:31  control RBAC

→ 4 puntos de entrada en 4 paquetes, ordenados por densidad de puntos de llamada.
[exit 0]
```

No mencionaste ningún archivo. No pegaste ningún snippet. El agente tiene los cuatro archivos que importan, en el orden correcto, y puede hacer una edición fundamentada.

### 02. Encuentra la implementación real, no el stub de prueba

```text
agent> ¿cómo maneja normalizePhoneNumber el formato E.164?

semantic::query("normalize phone E.164")
  packages/shared/util/phone.ts:88     normalizePhoneNumber()  ← impl real
  packages/api/test/phone.spec.ts:14   jest.mock(...)          ← stub
[exit 0]
```

Los nombres mienten. Los mocks tapan el código real. Maguyva ubica la implementación real por encima del mock de prueba, en todos los paquetes.

### 03. Revisa el radio de impacto antes de que el agente refactorice

```text
agent> ¿qué llama a QueueDispatcher.publish en todo el monorepo?

graph::callers(QueueDispatcher.publish)
  3 en packages/billing/*
  1 en packages/audit/*
  1 en packages/notifications/*
  1 en services/python-worker/*  ← entre lenguajes vía stub de gRPC
[exit 0]
```

Entre paquetes, y entre lenguajes cuando tienes un repo políglota, los puntos de llamada aparecen inline. Un agente autónomo obtiene el radio de impacto antes de editar, no después de que el CI se ponga en rojo.

## Configuración con Antigravity

Tres pasos. Nivel Free: 3 repositorios, Hasta 50 mil líneas de repo indexadas, sin tarjeta.

### 01. Indexa un repo en maguyva.ai

Elige el monorepo donde más problemas te ha causado la falta de contexto.

### 02. Agrega Maguyva como servidor MCP en Antigravity

`~/.gemini/config/mcp_config.json`

```json
{
  "mcpServers": {
    "maguyva": {
      "serverUrl": "https://maguyva.tools/mcp",
      "headers": {
        "Authorization": "Bearer mgv_xxxx"
      }
    }
  }
}
```

### 03. Haz una pregunta cuya respuesta ya conozcas

No apuntes al agente hacia toda tu empresa. Empieza con un repo y una pregunta verificable, como “¿qué llama a `formatInvoice` entre paquetes?”

## Indexa un repo que ya conozcas.

Prueba una pregunta cuya respuesta puedas verificar.