Type to search by title, content, or category

Esc to close, Enter for all results

/ Coder

Official Plugins vs. Custom MCP in Antigravity: Differences and Selection Guide (with Notion)

Comparing Antigravity plugins and standalone MCP servers using Notion as an example, covering packaging, transport, migration steps, pitfalls, and selection.

1. Background and BLUF (Bottom Line Up Front)

While auditing my local Antigravity configuration in ~/.gemini/config/mcp_config.json today, I tested my existing Notion MCP setup and then noticed the official Notion plugin in the Antigravity Marketplace (antigravity-plugins-partners/plugin/notion). Just like Chrome DevTools—which exists both as a standalone chrome-devtools-mcp and an official chrome-devtools-plugin—Notion is available in both forms on the same machine.

After switching Notion from a standalone MCP entry to the plugin and testing both setups side by side, here is the takeaway:

In Antigravity, a plugin is not a separate tool protocol. Under the hood it still runs an MCP server, but bundles workflow Skills, lifecycle management, and native remote connection settings on top. Use official or partner plugins for standard SaaS tools where workflow Skills help; use standalone or custom MCP entries for local scripts, custom CLI flags, or cross-client reuse. You can mix both across different services, but only keep one active per service.

Using Notion as the concrete example, the table below summarizes the key differences:

DimensionAntigravity Plugin (Notion Plugin)Standalone / Custom MCP (~/.gemini/config/mcp_config.json)
What It IncludesMCP Server + 12 Workflow Skills (meeting prep, weekly digests, spec-to-tasks, research docs, etc.)Tool Layer Only: exposes raw API read/write and search tools without workflow instructions
Connection TransportNative Streamable HTTP ("serverUrl": "https://mcp.notion.com/mcp"), no local Node bridge neededOften bridged via npx -y mcp-remote@latest (or Stdio launching a local script)
Setup & LifecycleInstalled, updated, and hot-toggled from the Antigravity plugins UI without editing JSONManaged manually in mcp_config.json (arguments, env vars, or "disabled": true)
Tool NamespacePrefixed with the plugin name (verified runtime server name: notion_notion)Uses the config key directly (e.g., notion)
Cross-Client ReuseAntigravity ecosystem onlyPortable JSON structure across antigravity-cli, Claude Code, Codex, and other MCP clients
Remote Plan LimitsBound to your Notion plan; switching to the plugin unlocks nothing extraSame—enforced entirely by the remote account tier

2. Under the Hood: How Plugins and Standalone MCP Differ

It is easy to assume that a plugin uses a proprietary built-in API while MCP is an external protocol. Checking the local plugin directory and Antigravity's customization docs shows they are not competing protocols—the real difference is a packaged bundle vs. a bare server definition.

2.1 A Plugin Is a Bundle; MCP Is Just One Layer Inside It

In Antigravity's customization system, a Plugin is an installable unit that toggles together and can hold four components:

  • plugin.json: manifest metadata (name, version, author, repository);
  • mcp_config.json: the MCP server definition shipped with the plugin;
  • skills/: step-by-step runbooks teaching the agent how to use those tools effectively;
  • Optional rules/AGENTS.md and hooks.json.

Inspecting my installed Notion plugin at ~/.gemini/config/plugins/notion/ (published by Notion Labs), its mcp_config.json is just three lines, while its skills/ directory ships 12 workflow Skills, including notion-setup, notion-meeting-prep, notion-research-documentation, notion-weekly-project-digest, notion-database-designer, and notion-spec-to-implementation.

With a standalone MCP setup, the agent only gets raw page and database operations. With the plugin, it also gets standardized playbooks for turning specs into task databases or drafting weekly digests.

2.2 Transport and Maintenance: Native Streamable HTTP vs. Local Bridge

Antigravity supports two MCP transports: Stdio (spawning a local binary or script) and Streamable HTTP (connecting directly to a remote url / serverUrl). Legacy HTTP+SSE (spec 2024-11-05) is not supported directly and requires a Stdio bridge such as mcp-remote.

Comparing my two local Notion definitions makes the difference clear:

  • Standalone config (~/.gemini/config/mcp_config.json):
    "notion": {
      "command": "npx",
      "args": ["-y", "mcp-remote@latest", "https://mcp.notion.com/mcp"]
    }
    
    Every launch spawns a local npx bridge process, which depends on the local Node environment.
  • Plugin-bundled config (~/.gemini/config/plugins/notion/mcp_config.json):
    {
      "mcpServers": {
        "notion": {
          "serverUrl": "https://mcp.notion.com/mcp"
        }
      }
    }
    
    This uses native remote serverUrl directly, eliminating the local npx mcp-remote bridge and letting the Marketplace handle updates.

On the flip side, standalone MCP excels whenever you need full control over local commands and flags. For example, I run a custom local Gmail MCP by launching a local Python script with uv over Stdio, and I switched chrome-devtools-mcp in my main config from --isolated to --autoConnect so it attaches to my logged-in Chrome browser. Custom scripts and bespoke flags belong directly in mcp_config.json.

2.3 Cross-Client Config Boundaries

Checking configurations across clients on the same machine shows that each reads its own file:

  • Main Antigravity config: ~/.gemini/config/mcp_config.json (with permission grants in ~/.gemini/config/config.json)
  • Antigravity CLI: ~/.gemini/antigravity-cli/mcp_config.json
  • Claude Code: top-level mcpServers in ~/.claude.json
  • Codex: [mcp_servers.*] blocks in ~/.codex/config.toml

Plugins stay inside Antigravity, whereas standalone MCP commands and arguments transfer directly across clients.

2.4 Remote Plan Restrictions Stay Identical

Before switching, I called notion-get-tool-access on the standalone Notion MCP. On a personal/free Notion plan, core tools such as fetch, create_pages, update_page, list_recent_pages, and create_comment are available, while server-side tier limits still apply:

  • query_data_sources is marked available_with_limit;
  • query_multiple_data_sources, query_meeting_notes, connector_search, comment edit/delete/reactions, and suggested-edit tools return plan_required or full_version_required;
  • search works, but parameters like filters.edited_by_user_ids, filters.last_edited_date_range, filters.title_only, and non-relevance sort require Business or Enterprise.

Because both setups hit https://mcp.notion.com/mcp with the same Notion account, switching to the plugin does not bypass plan restrictions.


3. Step-by-Step Migration: Switching Notion from Standalone MCP to the Plugin

If you already configured Notion manually in mcp_config.json and want to switch cleanly without loading duplicate tools, follow these four steps.

Step 1: Disable the Existing Standalone MCP Entry

Open ~/.gemini/config/mcp_config.json and add "disabled": true to "notion" (disabling is safer than deleting if you ever want to roll back):

{
  "mcpServers": {
    "notion": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote@latest",
        "https://mcp.notion.com/mcp"
      ],
      "disabled": true
    }
  }
}

Step 2: Install and Enable the Notion Plugin from the Marketplace

Search for and install the Notion plugin (antigravity-plugins-partners/plugin/notion) in Antigravity. It installs into ~/.gemini/config/plugins/notion/ without requiring manual edits to ~/.gemini/config/config.json.

Step 3: Verify Clean Handover in a New Turn

Start a new session and confirm two things:

  1. The old notion MCP tool group is gone—no duplicate tool definitions are injected;
  2. The plugin's server appears under the notion_notion namespace, alongside the 12 bundled notion-* Skills.

Step 4: Run Read-Only Probes to Confirm Connectivity

Test notion_notion with two read-only calls:

  1. Call notion-get-self with {} to confirm the active workspace and authenticated user;
  2. Call notion-list-recent-pages with {"limit": 3} to confirm page and database retrieval works.

If both succeed, your OAuth session and plugin connection are ready.


4. Four Practical Gotchas from Testing

  1. Running Both at Once Doubles Context Overhead
    • Symptom: Enabling the Notion plugin without disabling mcp_config.json exposes both notion and notion_notion, injecting dozens of near-identical tool schemas into the prompt.
    • Fix: Strictly pick one per service. Set "disabled": true (or remove the old entry) in mcp_config.json immediately after enabling the plugin.
  2. Previously "Always Allowed" Actions Prompt for Approval Again
    • Symptom: Even though you previously approved notion-fetch or notion-update-page, switching to the plugin triggers confirmation prompts again.
    • Cause: Existing grants in ~/.gemini/config/config.json (userSettings.globalPermissionGrants.allow) are keyed to mcp(notion/notion-fetch) and mcp(notion/notion-update-page), whereas the plugin exposes tools under notion_notion.
    • Fix: Do not hand-edit config.json; simply re-approve once when prompted under the new namespace (and optionally clean up stale entries later).
  3. Tools Work in the Desktop App but Differ in antigravity-cli
    • Symptom: A local server available in the main Antigravity client is missing or behaves differently when running antigravity-cli.
    • Cause: ~/.gemini/config/mcp_config.json and ~/.gemini/antigravity-cli/mcp_config.json are separate files. On my machine, the main config includes a local gmail script and runs chrome-devtools with --autoConnect, while the CLI config omits gmail, runs chrome-devtools with --isolated, and adds two CLI-only servers.
    • Fix: Always inspect both files separately when debugging discrepancies between desktop and CLI runs.
  4. Meeting Notes or Connector Search Still Fail After Switching to the Plugin
    • Symptom: query_meeting_notes or connector_search remains unavailable even with the official Notion plugin active.
    • Cause: These tools return plan_required or full_version_required based on your Notion workspace tier, not your local MCP setup.
    • Fix: Run notion-get-tool-access once to inspect the exact capability matrix for your account before debugging local configs.

5. Summary and When to Use Which

Based on these tests, a hybrid per-service strategy works best in Antigravity:

  • Choose Official / Marketplace Plugins when:
    • You are connecting standard services with maintained plugins (such as Notion, Canva, or Chrome DevTools);
    • You want the bundled workflow Skills (meeting prep, weekly project digests, spec-to-task breakdowns);
    • You prefer one-click UI toggles, managed updates, and native serverUrl connections without maintaining local npx mcp-remote processes.
  • Choose Standalone / Custom MCP when:
    • You are running private local scripts or internal services (such as a custom Python or Node MCP server);
    • You need custom CLI flags (headless vs. isolated vs. --autoConnect browser attachment);
    • You only need Notion as a raw data pipe with existing mcp(<name>/...) whitelist rules untouched, or you want identical MCP definitions across multiple AI clients.