Based on Google’s official docs, checked October 20, 2026

How to add an MCP server to Google Antigravity

Google Antigravity reads MCP servers from an mcp_config.json file with a top-level "mcpServers" object, and every surface (the Antigravity app, the IDE and the CLI) can manage them. You can install from the built-in MCP Store or add any server by hand. Remote servers use a serverUrl field; the url and httpUrl fields from Gemini CLI are not supported. This guide follows Google’s Antigravity docs as checked on October 20, 2026, and ends with the permission settings that control whether the agent asks before running commands and MCP tools.

1. Install from the MCP Store (IDE)
In the Antigravity IDE, click … at the top of the agent side panel and select MCP Servers. Hover over a supported server, click Install and follow the prompts. The Store lists servers for databases, cloud, developer tools and productivity apps.
2. Or use the app or the CLI
In the Antigravity app, go to Settings > Customizations > Installed MCP Servers and choose Add MCP. In Antigravity CLI, type /mcp in the prompt and press Enter to open the MCP Manager, which shows each server’s status and connection logs and can reload the configuration.

3. Edit mcp_config.json for a custom server

Global servers live in ~/.gemini/config/mcp_config.json. Project servers live in .agents/mcp_config.json in your workspace. In the IDE, MCP Servers > Manage > View raw config opens the file. A stdio server needs command (plus args and env); a remote server needs serverUrl.

{
  "mcpServers": {
    "sqlite-explorer": {
      "command": "node",
      "args": ["/usr/local/bin/sqlite-mcp-server.js"],
      "env": { "SQLITE_DB_PATH": "/var/data/app.db" }
    },
    "my-remote-server": {
      "serverUrl": "https://api.example.com/mcp/",
      "headers": { "Authorization": "Bearer YOUR_API_TOKEN" }
    }
  }
}

4. Authenticate OAuth servers
Open Agent settings (Cmd+, on macOS, Ctrl+, on Windows and Linux), go to the Customizations tab and click Authenticate next to the server. Finish sign-in in the browser, copy the authorization code, paste it back and click Submit. Tokens are stored in ~/.gemini/antigravity/mcp_oauth_tokens.json and refreshed automatically.
5. Allow the server’s tools
Unconfigured MCP tools run in Ask mode, so Antigravity asks before each call. Add mcp() rules to your permissions to approve a single tool, a whole server or every MCP tool (see below).
```
mcp(server/tool)   one tool on one server
mcp(server/*)      every tool on a server
mcp(*)             every MCP tool on every server
```

mcp_config.json properties

Each entry under mcpServers needs one transport: command (a stdio executable) or serverUrl (a remote Streamable HTTP or SSE server). Optional fields are args, env, cwd, headers, authProviderType, oauth, disabled and disabledTools.

Set "authProviderType": "google_credentials" to sign in to Google Cloud servers with Application Default Credentials. For providers that don’t support dynamic client registration, add an "oauth" object with clientId and clientSecret and register https://antigravity.google/oauth-callback as the redirect URI.

Use "disabled": true to switch a server off without deleting it, and "disabledTools" to hide specific tools from the model.

How to allow all commands in Antigravity

Antigravity’s permission preset decides how much the agent can do without asking. Set it under Settings > General > Permission Settings, or override it for one project under Settings > Projects. The docs list three presets:

Default: the terminal sandbox is on. Commands run without asking inside the sandbox (workspace and temp folders, no network) and ask when they need to run outside it. MCP and web actions ask.

Request Review: no sandbox. The agent always asks before running a command, and file access is limited to the workspace.

Turbo: no sandbox. Terminal commands are allowed without restriction, the agent has full filesystem access, and MCP and web actions are allowed. This is the preset that allows all commands. Some people call it “yolo mode”; Google’s docs call it Turbo.

Turbo removes the safety prompts entirely, so many teams keep Default and allow just the commands they trust instead.

Fine-grained rules: allow some commands, block others

In Antigravity CLI, permissions live in ~/.gemini/antigravity-cli/settings.json as three lists: allow, deny and ask. Rules use the form action(target), such as command(git), command(regex:...), write_file(src/), read_url(...) and mcp(server/tool). Your rules are layered on top of the preset and always take precedence over it.

When rules conflict, Deny beats Ask, and Ask beats Allow. If command(*) is in ask and command(git) is in allow, Antigravity still asks before every command. The example below is adapted from Google’s docs.

{
  "permissions": {
    "allow": [
      "command(git)",
      "command(regex:npm run (build|lint|test))",
      "mcp(linter/*)"
    ],
    "deny": [
      "command(rm -rf)",
      "command(sudo)",
      "write_file(.git/)"
    ],
    "ask": [
      "mcp(sql/execute_mutation)"
    ]
  }
}

Coming from Gemini CLI?

Gemini CLI kept MCP servers in ~/.gemini/settings.json. Antigravity uses the separate mcp_config.json files above, and remote servers need serverUrl instead of url or httpUrl. Our Gemini CLI migration guide covers the rest of the move.

Tips

Keep tokens out of shared .agents/mcp_config.json files; use the OAuth flow or per-user global config for secrets.
Use disabledTools to remove risky tools, such as write or delete operations, rather than approving a whole server.
If a server fails to connect, open /mcp in the CLI (or MCP Servers in the IDE) to check its status and connection log, then reload.
Rules beat presets: a deny rule still blocks a command even under Turbo.