Integrate Unleash with Google Gemini and Antigravity

The Unleash MCP server connects Google’s agentic coding tools to your Unleash instance, enabling AI-assisted feature flag management. You can evaluate code changes, create flags, generate wrapping code, manage rollouts, and clean up flags from within the agent.

Google’s current agentic platform is Antigravity, the successor to Gemini CLI. It supports MCP across two local surfaces that share one engine and configuration:

• Antigravity desktop app — The flagship “agent control tower,” where you launch and supervise many agents in parallel
• Antigravity CLI — The same engine in the terminal, run with the agy command

Antigravity governs the agent while it writes code, through approval modes, a sandbox, a Human-in-the-Loop review pane, and hooks. Feature flags govern the code after it ships, through progressive rollout and instant rollback. The idea is to package your Unleash integration once, enforce which tools agents may use, and let the flag decide what actually reaches production.

If your team is still on Gemini Code Assist or Gemini CLI under a paid license, that setup remains supported. See Gemini Code Assist and Gemini CLI below.

Prerequisites

Before you begin, make sure you have the following:

• Node.js 18 or later: The MCP server is distributed as an npm package
• Antigravity: The desktop app or the CLI)
• A signed-in Antigravity session: Sign in with your Google account, or use Cloud OAuth against a Gemini Enterprise Agent Platform project for enterprise
• An Unleash instance: Cloud or self-hosted, with API access enabled
• A personal access token (PAT): With permissions to create and manage feature flags

Install the MCP server

Antigravity stores MCP configuration in a dedicated mcp_config.json file. The desktop app and the CLI read the same configuration, so you set up the server once.

$
mkdir -p ~/.unleash
$
cat > ~/.unleash/mcp.env << 'EOF'
$
UNLEASH_BASE_URL=https://your-instance.getunleash.io
$
UNLEASH_PAT=your-personal-access-token
$
UNLEASH_DEFAULT_PROJECT=default
$
EOF
$
chmod 600 ~/.unleash/mcp.env

$
# Unleash MCP credentials
$
if [ -f ~/.unleash/mcp.env ]; then
$
  source ~/.unleash/mcp.env
$
  export UNLEASH_BASE_URL UNLEASH_PAT UNLEASH_DEFAULT_PROJECT
$
fi

1
{
2
  "mcpServers": {
3
    "unleash": {
4
      "command": "npx",
5
      "args": ["-y", "@unleash/mcp@latest", "--log-level", "error"],
6
      "env": {
7
        "UNLEASH_BASE_URL": "${UNLEASH_BASE_URL}",
8
        "UNLEASH_PAT": "${UNLEASH_PAT}",
9
        "UNLEASH_DEFAULT_PROJECT": "${UNLEASH_DEFAULT_PROJECT}"
10
      }
11
    }
12
  }
13
}

/mcp

Approval and oversight model

Antigravity enforces an authoring-time boundary that also governs how MCP tool calls run. The controls differ slightly between the two surfaces.

In the CLI

The CLI gates agent actions through permission modes. Documented values include always-proceed, agent-decides, and asks-for-review, with stricter modes like request-review and strict. Useful flags:

• --mode sets the execution mode for the session (either accept-edits or plan)
• --sandbox runs with terminal restrictions
• --dangerously-skip-permissions auto-approves every tool request (reserve for isolated environments)

Keep a prompting mode for writes so you review the flag name, environment, or rollout before a write like create_flag or toggle_flag_environment runs.

In the desktop app

The desktop app applies the same gate through a Human-in-the-Loop review pane. As an agent works, it produces Artifacts (plans, task lists, walkthroughs, and browser recordings) that you review and comment on inline before it proceeds.

Desktop review can be relaxed to proceed automatically, which is convenient but removes the human gate. Treat local review as an authoring-time convenience, and rely on the feature flag (and, at enterprise scale, Cloud IAM) as the boundary that cannot be switched off. Enable change requests on production environments so enabling a flag requires human approval regardless of what any agent does.

Tool reference

The Unleash MCP server exposes the following tools.

Workflows

The Unleash MCP server supports these core workflows: evaluate and wrap code in feature flags, discover and audit flags, manage rollouts across environments, and clean up after rollout.

Evaluate and wrap code in feature flags

Use this workflow when implementing a change that might affect production stability, such as a payment integration, authentication flow, or external API call.

Evaluate whether the Stripe payment integration should be behind a feature flag.
The change modifies the checkout service and handles credit card processing.

Create a release flag for the Stripe payment integration.

Wrap the Stripe checkout handler with the stripe-payment-integration flag.
This is a Node.js Express application.

1
const { isEnabled } = require('unleash-client');
2
3
app.post('/checkout', async (req, res) => {
4
  const context = { userId: req.user.id };
5
6
  if (isEnabled('stripe-payment-integration', context)) {
7
    // New Stripe payment flow
8
    const result = await stripeService.processPayment(req.body);
9
    return res.json(result);
10
  } else {
11
    // Existing payment flow
12
    const result = await legacyPaymentService.process(req.body);
13
    return res.json(result);
14
  }
15
});

Discover and audit flags

Use this workflow to take inventory of existing flags before creating new ones, or to run a periodic audit for cleanup candidates.

Manage rollouts across environments

Use this workflow to enable a flag in staging for testing while keeping it disabled in production.

What is the current state and rollout strategies for stripe-payment-integration?

Clean up after rollout

Use this workflow when a feature has been fully rolled out and the flag is no longer needed.

Clean up the stripe-payment-integration flag. The feature is fully rolled out.

The agent calls cleanup_flag and returns:

• All files and line numbers where the flag is used
• Which code path to preserve (the “enabled” branch)
• Suggestions for tests to run after removal

Review the list, remove the conditional branches, and delete the flag from Unleash.

Package the integration as a plugin

Antigravity plugins (the successor to Gemini CLI extensions) bundle an MCP server, context files, skills, and hooks into one installable unit. Instead of asking every developer to edit mcp_config.json by hand, a platform team can publish one Unleash plugin and have everyone install the same governed setup.

A plugin declares its MCP servers in plugins/<name>/mcp_config.json and can carry a GEMINI.md or AGENTS.md context file, skills, and a hooks.json. Manage plugins with the CLI:

$
agy plugin install <source>     # install a plugin from a path or marketplace
$
agy plugin list                 # list installed plugins
$
agy plugin import gemini        # import an existing Gemini CLI setup
$
agy plugin import claude        # import an existing Claude Code plugin

Govern flag writes with hooks

Hooks are shell scripts that Antigravity runs automatically at set points in an agent’s execution, and they make a strong deterministic guardrail for flag writes. A PreToolUse hook runs before a tool call, inspects the tool name and arguments, and returns a decision of allow, deny, or ask. Because it fires on every matching call regardless of the agent’s approval mode, you can require human sign-off for flag mutations that no prompt wording can bypass.

Hooks are defined in a hooks.json file, either globally (~/.gemini/config/hooks.json), per workspace (.agents/hooks.json), or inside a plugin (plugins/<name>/hooks.json). Use a matcher to target the write tools:

1
{
2
  "hooks": {
3
    "PreToolUse": [
4
      {
5
        "matcher": "create_flag|toggle_flag_environment|set_flag_rollout|remove_flag_strategy",
6
        "command": "~/.unleash/confirm-flag-write.sh"
7
      }
8
    ]
9
  }
10
}

The script reads the tool call as JSON on standard input and writes a JSON decision (allow, deny, or ask) to standard output. Use it to always require confirmation, block writes to specific environments, or log every flag mutation for audit.

Context file templates

Antigravity reads GEMINI.md and AGENTS.md files for project instructions (no rename needed), along with rules under .agents/rules/. Store your FeatureOps policies there so the agent considers feature flags automatically in every session. A plugin can ship its own context file so the policy travels with the package.

1
# Feature Flag Conventions
2
3
When making changes to this codebase, follow these feature flag practices:
4
5
1. **Always evaluate risk** – Before implementing high-risk changes (payments,
6
   authentication, data migrations, external integrations), use the Unleash MCP
7
   server to evaluate whether a feature flag is needed.
8
9
2. **Naming conventions** – Use the format `{domain}-{feature}-{variant}`.
10
   Examples: `checkout-stripe-integration`, `auth-sso-google`, `api-rate-limiting`.
11
12
3. **Flag types**:
13
   - `release` – For gradual feature rollouts
14
   - `experiment` – For A/B tests and experiments
15
   - `operational` – For system behavior toggles
16
   - `kill-switch` – For emergency shutdowns
17
   - `permission` – For role-based access
18
19
4. **Prefer reuse** – Before creating a new flag, check if a similar flag already
20
   exists using the detect_flag tool.
21
22
5. **Clean up after rollout** – Once a feature is fully released (100% rollout for
23
   2+ weeks), use cleanup_flag to remove dead code.
24
25
## Unleash MCP Server
26
27
This project uses the Unleash MCP server for feature flag management. Approve write
28
operations after reviewing the arguments.
29
30
Available tools: evaluate_change, detect_flag, create_flag, wrap_change,
31
list_projects, list_flags, get_flag_state, set_flag_rollout,
32
toggle_flag_environment, remove_flag_strategy, cleanup_flag.

Enterprise governance

Enterprises run Antigravity through the Gemini Enterprise Agent Platform. Developers connect the desktop app and the CLI to a Google Cloud project with Cloud OAuth and an Agent Platform Project ID and region. Agent inference then runs inside your own cloud boundary, with regional endpoints and Google Cloud’s standard data protections.

MCP tool use is governed by Google Cloud IAM, so you enforce the approved path centrally rather than per machine:

• Grant access deliberately — The roles/mcp.toolUser role controls who and what can call MCP tools.
• Allowlist tools — IAM Deny policies on mcp.googleapis.com/tools.call let you permit the vetted Unleash tools and block others, filtered by tool name, read-only status, service, or OAuth client.
• Secure the deployment — Agent Identity, Agent Gateway, Agent Security, and Agent Registry govern how agents authenticate and connect.

This pairs with Unleash’s own governance. The MCP server inherits the PAT’s permissions and cannot exceed them, so scope the token tightly. Enable change requests on production so enabling a flag requires human approval regardless of what any agent requests. Antigravity governs how the agent runs and which tools it can reach; Unleash governs how the release ships.

Managed agents and the remote server

Antigravity can run managed agents server-side, each in its own isolated, network-restricted sandbox. Those sandboxes cannot reach a local stdio server, so for flag operations inside a managed agent, use the remote Unleash MCP server with the serverUrl field:

1
{
2
  "mcpServers": {
3
    "unleash-remote": {
4
      "serverUrl": "https://your-instance.getunleash.io/api/admin/mcp",
5
      "headers": { "Authorization": "${UNLEASH_PAT}" }
6
    }
7
  }
8
}

Your Unleash instance exposes this endpoint at /api/admin/mcp once you enable it under Admin settings > Remote MCP server. Pass your PAT as the raw Authorization header value, with no Bearer prefix. Antigravity uses serverUrl for remote servers (Gemini CLI used url). Make the host reachable, allow write methods, and verify the authentication flow works in a headless environment. For everyday work in the desktop app and CLI, the local stdio server is simpler.

Gemini Code Assist and Gemini CLI

The move from Gemini CLI to Antigravity is a transition, not a hard cutover. On June 18, 2026, Gemini CLI and the Gemini Code Assist IDE extensions stopped serving the free, Google AI Pro, and Ultra tiers, and Gemini Code Assist for GitHub stopped accepting new installations. Access under a paid Gemini Code Assist Standard or Enterprise license remains unchanged, so those teams can keep using Gemini CLI and Code Assist today.

In that setup, configure the Unleash MCP server in ~/.gemini/settings.json under a mcpServers key (Gemini CLI supports both $VAR and ${VAR} expansion there):

1
{
2
  "mcpServers": {
3
    "unleash": {
4
      "command": "npx",
5
      "args": ["-y", "@unleash/mcp@latest"],
6
      "env": {
7
        "UNLEASH_BASE_URL": "${UNLEASH_BASE_URL}",
8
        "UNLEASH_PAT": "${UNLEASH_PAT}",
9
        "UNLEASH_DEFAULT_PROJECT": "${UNLEASH_DEFAULT_PROJECT}"
10
      }
11
    }
12
  }
13
}

When you move to Antigravity, the MCP configuration moves to mcp_config.json, and you can bring your existing setup across with agy plugin import gemini. The Unleash tools and workflows are identical on both.

Prompt patterns

The following prompt patterns help you use the MCP tools effectively.

Evaluate whether the [description of change] should be behind a feature flag.
The change modifies [component/service].

Before creating a new flag for [feature], check if a similar flag already exists
and suggest reusing it if appropriate.

Enable [flagName] in the staging environment.

What is the current state and rollout strategies for [flagName]?

Clean up the [flagName] flag now that the feature has fully shipped.

Clean up the [flagName] flag after the A/B testing experiment, only keep [variant].

List all feature flags in the [projectId] project and identify any that should be cleaned up.

Run a flag audit: list all projects, then check for flags at 100% rollout for more than 14 days.

Troubleshooting

Best practices

Follow these guidelines for effective feature flag management with Antigravity.

Related resources

• Unleash MCP server on GitHub
• Google Antigravity documentation
• Antigravity MCP configuration
• Antigravity hooks
• Gemini Enterprise Agent Platform
• Impact Metrics
• Unleash architecture overview