# O Antigravity roda os agentes. O Maguyva dá a eles o mapa.

Canonical source: https://maguyva.ai/pt-br/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).

O Antigravity é uma IDE centrada em agentes: os agentes planejam e editam entre o editor, o terminal e o navegador. Num monorepo de verdade eles ainda precisam de um mapa de qual arquivo importa. O Maguyva indexa a sua base de código e disponibiliza esse contexto via MCP (semântica, AST, grafo e texto), para que “onde acontece a autenticação” retorne o fluxo de auth de verdade, não sete stubs de teste.

> O Antigravity roda o agente. O Maguyva diz a ele qual arquivo tocar.

## O que cada camada faz

Quatro peças. Cada uma com uma função.

### Antigravity

Onde seus agentes planejam, editam e verificam.

### menções com @ + regras

Contexto manual funciona, até o repositório ficar grande.

### Maguyva

Informações da base de código obtidas automaticamente via MCP.

### Por workspace, não por usuário

Agentes não geram cobranças por usuário. [Ver preços](https://maguyva.ai/pt-br/pricing)

## O Antigravity roda os agentes. Deixe.

A IDE de agentes não é o problema. O Agent Manager, a execução no editor, no terminal e no navegador e os arquivos de regras são excelentes, e você já usa isso para:

- Planejar e rodar agentes entre o editor, o terminal e o navegador.
- Edições multi-arquivo quando a mudança é local.
- Regras de agente para convenções do repositório e regras de estilo.
- Menções com `@` para trazer um arquivo específico para o contexto.

Continue fazendo isso. Nada disso vai embora.

Mas num monorepo de verdade (TypeScript com dependências de workspace, serviços Python, pacotes misturados) o contexto do agente quebra no momento em que o arquivo relevante ainda não está no radar do agente.

## Soluções manuais que você já tentou, e onde elas quebram

Quatro soluções manuais emparelhadas com seus modos de falha. Esquerda = o que você faz hoje. Direita = onde quebra.

### // mencione os arquivos

Você menciona com `@` os três arquivos que acha que importam. O agente edita neles com precisão.

### // mencionar é um chute

Funciona quando você já sabe quais arquivos estão envolvidos. Um agente autônomo precisa dos arquivos que você não sabia que precisava mencionar.

### // cole os trechos

Você cola 200 linhas de outro pacote no agente para dar contexto suficiente.

### // código colado fica desatualizado

O trecho que você colou às 9h não reflete o rebase que seu colega de equipe fez às 11h. O agente está editando com base em uma versão fantasma do pacote.

### // escreva um doc de contexto

Você escreve um arquivo de regras de agente ou um markdown de arquitetura. Está certo hoje.

### // docs desatualizam mais rápido que o código

Tudo que você escreve à mão desatualiza. O código é a fonte da verdade. Um doc explicando a camada de fila está correto por uma semana, e errado para sempre depois.

### // mantenha os arquivos de regras

Você adiciona regras de agente para nomenclatura, lint e comandos de build. Ótimo para comportamento.

### // regras ≠ índice

As regras são o lugar certo para “sempre rode pnpm tsc -b antes de cada commit.” Elas não são um índice consultável de cada símbolo, arquivo e call-site no seu monorepo.

## O Maguyva é a camada por baixo

Não é um substituto do Antigravity. É a camada de contexto de repositório que se conecta ao suporte MCP dele.

- **Semântica + AST + grafo + texto**: busca por significado, estrutura, dependência ou literal. Cada resultado retorna um caminho de arquivo e número de linha.
- **Entre pacotes por padrão**: call-sites e importadores em todos os pacotes do monorepo, não só no que o agente tem aberto.
- **Leva a branch em conta**: O Maguyva enxerga a versão do código que o agente está editando.
- **Feito para autonomia**: um agente que planeja muitas edições precisa do raio de impacto de antemão, não depois que o CI fica vermelho.

> O Antigravity decide o que editar.
> O Maguyva diz ao agente *o que a edição afeta.*

## Três fluxos de trabalho de monorepo

Entre pacotes, entre linguagens. Fundamentado no grafo de chamadas real, não no grep do agente.

### 01. Encontre o fluxo de auth entre pacotes, sem mencionar nada

```text
agent> onde acontece a autenticação nesse monorepo?

graph::query("authentication flow")
  packages/web/src/auth/session.ts:42       middleware
  packages/api/src/auth/jwt.ts:88           verificação do token
  packages/shared/src/auth/types.ts:12      AuthContext
  packages/admin/src/auth/admin-only.ts:31  controle RBAC

→ 4 pontos de entrada em 4 pacotes, ranqueados por densidade de call-sites.
[exit 0]
```

Você não mencionou nenhum arquivo. Você não colou nenhum trecho. O agente tem os quatro arquivos que importam, na ordem certa, e pode fazer uma edição fundamentada.

### 02. Encontre a implementação real, não o stub de teste

```text
agent> como o normalizePhoneNumber trata o 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]
```

Nomes mentem. Mocks fazem sombra no código real. O Maguyva ranqueia a implementação real acima do mock de teste, em todos os pacotes.

### 03. Confira o raio de impacto antes do agente refatorar

```text
agent> o que chama QueueDispatcher.publish em todo o monorepo?

graph::callers(QueueDispatcher.publish)
  3 em packages/billing/*
  1 em packages/audit/*
  1 em packages/notifications/*
  1 em services/python-worker/*  ← entre linguagens via stub gRPC
[exit 0]
```

Entre pacotes, e entre linguagens quando você tem um repositório poliglota, os call-sites aparecem inline. Um agente autônomo recebe o raio de impacto antes de editar, não depois que o CI fica vermelho.

## Configuração com o Antigravity

Três passos. Plano Free: 3 repositórios, Até 50 mil linhas de repositório indexadas, sem cartão.

### 01. Indexe um repositório em maguyva.ai

Escolha o monorepo onde a falta de contexto mais atrapalhou.

### 02. Adicione o Maguyva como servidor MCP no Antigravity

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

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

### 03. Faça uma pergunta cuja resposta você já saiba

Não aponte o agente para a empresa inteira. Comece com um repositório e uma pergunta verificável, tipo “o que chama `formatInvoice` entre pacotes?”

## Indexe um repositório que você já conhece.

Teste uma pergunta cuja resposta você consiga verificar.
