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:
| Dimension | Antigravity Plugin (Notion Plugin) | Standalone / Custom MCP (~/.gemini/config/mcp_config.json) |
|---|---|---|
| What It Includes | MCP 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 Transport | Native Streamable HTTP ("serverUrl": "https://mcp.notion.com/mcp"), no local Node bridge needed | Often bridged via npx -y mcp-remote@latest (or Stdio launching a local script) |
| Setup & Lifecycle | Installed, updated, and hot-toggled from the Antigravity plugins UI without editing JSON | Managed manually in mcp_config.json (arguments, env vars, or "disabled": true) |
| Tool Namespace | Prefixed with the plugin name (verified runtime server name: notion_notion) | Uses the config key directly (e.g., notion) |
| Cross-Client Reuse | Antigravity ecosystem only | Portable JSON structure across antigravity-cli, Claude Code, Codex, and other MCP clients |
| Remote Plan Limits | Bound to your Notion plan; switching to the plugin unlocks nothing extra | Same—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.mdandhooks.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):
Every launch spawns a local"notion": { "command": "npx", "args": ["-y", "mcp-remote@latest", "https://mcp.notion.com/mcp"] }npxbridge process, which depends on the local Node environment. - Plugin-bundled config (
~/.gemini/config/plugins/notion/mcp_config.json):
This uses native remote{ "mcpServers": { "notion": { "serverUrl": "https://mcp.notion.com/mcp" } } }serverUrldirectly, eliminating the localnpx mcp-remotebridge 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
mcpServersin~/.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_sourcesis markedavailable_with_limit;query_multiple_data_sources,query_meeting_notes,connector_search, comment edit/delete/reactions, and suggested-edit tools returnplan_requiredorfull_version_required;searchworks, but parameters likefilters.edited_by_user_ids,filters.last_edited_date_range,filters.title_only, and non-relevancesortrequire 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:
- The old
notionMCP tool group is gone—no duplicate tool definitions are injected; - The plugin's server appears under the
notion_notionnamespace, alongside the 12 bundlednotion-*Skills.
Step 4: Run Read-Only Probes to Confirm Connectivity
Test notion_notion with two read-only calls:
- Call
notion-get-selfwith{}to confirm the active workspace and authenticated user; - Call
notion-list-recent-pageswith{"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
- Running Both at Once Doubles Context Overhead
- Symptom: Enabling the Notion plugin without disabling
mcp_config.jsonexposes bothnotionandnotion_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) inmcp_config.jsonimmediately after enabling the plugin.
- Symptom: Enabling the Notion plugin without disabling
- Previously "Always Allowed" Actions Prompt for Approval Again
- Symptom: Even though you previously approved
notion-fetchornotion-update-page, switching to the plugin triggers confirmation prompts again. - Cause: Existing grants in
~/.gemini/config/config.json(userSettings.globalPermissionGrants.allow) are keyed tomcp(notion/notion-fetch)andmcp(notion/notion-update-page), whereas the plugin exposes tools undernotion_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).
- Symptom: Even though you previously approved
- 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.jsonand~/.gemini/antigravity-cli/mcp_config.jsonare separate files. On my machine, the main config includes a localgmailscript and runschrome-devtoolswith--autoConnect, while the CLI config omitsgmail, runschrome-devtoolswith--isolated, and adds two CLI-only servers. - Fix: Always inspect both files separately when debugging discrepancies between desktop and CLI runs.
- Symptom: A local server available in the main Antigravity client is missing or behaves differently when running
- Meeting Notes or Connector Search Still Fail After Switching to the Plugin
- Symptom:
query_meeting_notesorconnector_searchremains unavailable even with the official Notion plugin active. - Cause: These tools return
plan_requiredorfull_version_requiredbased on your Notion workspace tier, not your local MCP setup. - Fix: Run
notion-get-tool-accessonce to inspect the exact capability matrix for your account before debugging local configs.
- Symptom:
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
serverUrlconnections without maintaining localnpx mcp-remoteprocesses.
- 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.
--autoConnectbrowser 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.
