Skip to main content
plugin CX Codex

antigravity-2 — Claude Code plugin: Claude Code bridge to Antigravity 2.0

Runs a local Windows bridge between Claude and the Antigravity 2.0 desktop app, with MCP tools for setup checks, model limits and chat handoff.

MIT ★ 1,596 updated 2026-10-29

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add hashgraph-online/awesome-codex-plugins
/plugin install antigravity-2@awesome-codex-plugins
Open on GitHub

What antigravity-2 does

The plugin registers two MCP servers. antigravity-local covers setup, status, model limits and job submission; antigravity-devtools drives the Antigravity window through Chromium DevTools. Startup is passive. Claude will not open or restart Antigravity on its own, and DevTools attaches only when the app is already running.

A setup check ships with it: scripts\antigravity.ps1 setup reports whether Antigravity sits where expected, whether Node.js resolves, whether the DevTools endpoint answers and whether the local model-limit API is up. Node.js has to be on PATH, otherwise the DevTools bridge never comes up.

For work that doesn't need the visible UI, submit-agy-job runs the official agy CLI and writes results into .antigravity-bridge/jobs/<jobId>/, so Claude can read the artifacts afterwards. Reach for submit-job when the selected project or chat in the desktop matters. All of it assumes Windows and Antigravity at %LOCALAPPDATA%\Programs\Antigravity\Antigravity.exe.

What it helps with

  • launch Antigravity from a Claude session and confirm the process is alive
  • read per-model quota from the local language server
  • push a heavy task through the agy CLI and collect the artifacts
  • switch the desktop model once the current one is used up
  • hand a prompt into an open Antigravity chat without losing project context

Example prompts for the agent

  • Run antigravity-local.setup and tell me whether the bridge is ready.
  • Submit a headless job: fix the failing tests in C:\work\api with gemini-3.5-flash-low.
  • Switch Antigravity to flash-medium and hand this prompt off to the current chat.

How to install antigravity-2

Plugin marketplace

/plugin marketplace add hashgraph-online/awesome-codex-plugins
/plugin install antigravity-2@awesome-codex-plugins

Step by step, with commands for each platform: Claude Code plugins: marketplaces, installing, and building your own

Questions about antigravity-2

How do I install antigravity-2 in Claude Code?

Run /plugin marketplace add hashgraph-online/awesome-codex-plugins, then /plugin install antigravity-2@awesome-codex-plugins.

What does antigravity-2 do?

It connects Claude to the Antigravity 2.0 desktop app on Windows through two MCP servers, so Claude can check setup, read model limits and pass work into Antigravity projects and chats.

What do I need before installing?

Windows, Antigravity at %LOCALAPPDATA%\Programs\Antigravity\Antigravity.exe, Claude plugins loaded from %USERPROFILE%\plugins, and Node.js on PATH for the DevTools bridge.

Source text

antigravity-2-codex-plugin · MIT
# Google Antigravity Codex Plugin

Created by [comprono](https://github.com/comprono).

This Google Antigravity Codex Plugin is a community local Windows bridge for Codex and Google Antigravity. It helps OpenAI Codex Antigravity workflows connect to the Antigravity 2.0 desktop app using a Codex MCP plugin, DevTools MCP Antigravity controls, and local helper commands.

This is a local Codex plugin that helps Codex connect to Antigravity 2.0 on Windows. It now uses the official Antigravity CLI first for low-RAM headless work, and only opens or drives the desktop UI when visible project/chat, Manager, Editor, or model-picker state is required. It can open Antigravity, inspect whether it is running, discover the Chromium DevTools endpoint exposed by the Electron app, read model quota state from the local language server, inspect visible projects and chats, verify the visible model, and hand off prompts into Antigravity conversations.

After setup, you can start from the ChatGPT mobile app, open Codex, and use this local plugin as the bridge into your Windows Antigravity desktop session.

## Google Antigravity Codex Plugin

This is a community Codex plugin for Google Antigravity / Antigravity 2.0. It lets OpenAI Codex connect to a local Antigravity desktop app on Windows using MCP tools, Chromium DevTools, and local PowerShell helper commands. It provides an Antigravity 2.0 Codex bridge for people who want Codex, including Codex sessions started from ChatGPT on mobile, to hand off work into a locally running Antigravity desktop environment.

Keywords: Google Antigravity Codex plugin, OpenAI Codex Antigravity, Antigravity 2.0 Codex bridge, Codex MCP plugin, DevTools MCP Antigravity.

## What It Does

- Launches the local Antigravity desktop app.
- Reports install path, user data path, running process IDs, setup readiness, and DevTools port.
- Reports Antigravity model quota state from the local language server.
- Uses the official `agy` CLI for headless Antigravity jobs when UI state is not needed.
- Connects to Antigravity's bundled `chrome-devtools-mcp` server when available.
- Exposes local setup/model/status and active-model switch commands as MCP tools, so Codex can use them even when skill files are unavailable.
- Creates durable `.antigravity-bridge/jobs/<jobId>/` folders so Codex can submit work once and later read compact result artifacts.
- Helps Codex inspect live project/chat context from the UI.
- Supports safe handoff to continue an existing chat, start a new chat in an existing project, or start a new project.
- Provides a local privacy scan for sensitive data before publishing changes.

## Requirements

- Windows.
- Antigravity installed at `%LOCALAPPDATA%\Programs\Antigravity\Antigravity.exe`.
- Codex plugins loaded from `%USERPROFILE%\plugins`.
- Node.js available on `PATH` for the DevTools MCP bridge.

## Install

Clone this repository into your Codex plugins directory:

```powershell
git clone https://github.com/comprono/antigravity-2-codex-plugin.git "$env:USERPROFILE\plugins\antigravity-2"
```

Then install or refresh the plugin from your Codex personal marketplace.

For a setup check after cloning:

```powershell
powershell -ExecutionPolicy Bypass -File "$env:USERPROFILE\plugins\antigravity-2\scripts\antigravity.ps1" setup
```

The setup report tells Codex whether Antigravity is installed, whether Node.js is available, whether the bundled DevTools MCP package exists, whether the DevTools endpoint is reachable, and whether the local language-server model-limit API is ready.

## MCP Tools

The plugin registers two MCP servers:

- `antigravity-local`: direct local tools for `quick`, `setup`, `doctor`, `status`, `open`, `repair-live`, `inspect`, `live`, `devtools-health`, `submission-guide`, `prepare-offload`, `create-job`, `submit-job`, `agy-status`, `agy-models`, `submit-agy-job`, `list-jobs`, `read-job`, `cancel-job`, `retry-job`, `switch-model`, `submit-offload`, `limits-summary`, `limits`, `models`, `offload-advice`, `handoff-template`, and `privacy`.
- `antigravity-devtools`: Chromium DevTools controls for inspecting and driving the Antigravity UI.

Startup is passive. Opening Codex must not open, close, restart, or repair Antigravity. The DevTools MCP server only connects when Antigravity is already running and inspectable; use `antigravity-local.open` or `antigravity-local.repair-live` only after the user asks to use Antigravity.

Codex should call `antigravity-local.submit-agy-job` first for nontrivial workspace work that does not require visible desktop project/chat state. It uses official Antigravity CLI print mode, creates the same durable job folder, and avoids desktop RAM overhead. Use `antigravity-local.submit-job` only when the correct visible Antigravity project/chat is already selected and that UI context matters. Use `antigravity-local.submit-offload` only for lightweight selected-chat handoffs that do not need a durable job folder. If Sonnet/Opus/GPT-OSS is exhausted or the user asks for Flash in desktop UI, Codex should call `antigravity-local.switch-model` with `modelPreference=flash-medium` before submitting. If the MCP tool list is stale and does not show the job/model tools, use the PowerShell helper `antigravity.ps1 submit-agy-job` / `antigravity.ps1 submit-job` / `antigravity.ps1 switch-model` before falling back to DevTools choreography. Use `antigravity-local.prepare-offload` when Codex should show the plan first or when the selected chat is uncertain. For nontrivial workspace, repo, browser, UI, research, planning, debugging, review, implementation, and job-application work, the intended cost split is: Antigravity explores and works locally; Codex plans, gates safety, reviews final changes, and summarizes from job artifacts. Use `antigravity-local.quick` for general setup checks. If `ReadyForLiveUiInspection` is false, call `antigravity-local.repair-live` once before using DevTools. If repair restarts Antigravity, an already-started DevTools MCP connection may need to reconnect to the new port. If `antigravity-devtools` fails with `Transport closed`, call `antigravity-local.devtools-health`; do not keep retrying `list_pages` in the same broken transport. Use `limits-summary` for normal quota checks and full `limits` only when the complete per-model JSON is needed.

Headless CLI check:

```powershell
powershell -ExecutionPolicy Bypass -File "$env:USERPROFILE\plugins\antigravity-2\scripts\antigravity.ps1" agy-status
powershell -ExecutionPolicy Bypass -File "$env:USERPROFILE\plugins\antigravity-2\scripts\antigravity.ps1" agy-models
```

Headless CLI job:

```powershell
powershell -ExecutionPolicy Bypass -File "$env:USERPROFILE\plugins\antigravity-2\scripts\antigravity.ps1" submit-agy-job -Goal "<goal>" -Workspace "<path>" -Mode fast -NextStep "<next step>" -AgyModel gemini-3.5-flash-low
```

Existing-chat submissions are strict. If `expectedChat` is provided, it must match the active Antigravity document title, not merely a sidebar item or previous message. The helper refuses to submit in a new chat and records `submit_failed` when Antigravity does not accept the prompt. Codex must not wait for artifacts unless the helper returns `Submitted: true`.

For the lowest-token phone workflow, prefer `antigravity-local.submit-job` over raw chat watching. It creates:

```text
.antigravity-bridge/
  jobs/
    <jobId>/
      request.md
      status.json
      result.md
      changed-files.txt
      diff.patch
      test-output-summary.md
```

Codex should submit the job, stop watching the UI, and later call `read-job` to read only `result.md`, `changed-files.txt`, `diff.patch`, `test-output-summary.md`, and `status.json`.

## Usage

Check status:

```powershell
powershell -ExecutionPolicy Bypass -File "$env:USERPROFILE\plugins\antigravity-2\scripts\antigravity.ps1" status
```

Fast combined readiness and quota summary:

```powershell
powershell -ExecutionPolicy Bypass -File "$env:USERPROFILE\plugins\antigravity-2\scripts\antigravity.ps1" quick
```

Open Antigravity:

```powershell
powershell -ExecutionPolicy Bypass -File "$env:USERPROFILE\plugins\antigravity-2\scripts\antigravity.ps1" open
```

Repair live DevTools inspection if Antigravity is running but exposes zero pages:

```powershell
powershell -ExecutionPolicy Bypass -File "$env:USERPROFILE\plugins\antigravity-2\scripts\antigravity.ps1" repair-live
```

Inspect integration details:

```powershell
powershell -ExecutionPolicy Bypass -File "$env:USERPROFILE\plugins\antigravity-2\scripts\antigravity.ps1" inspect
```

Inspect live UI connection:

```powershell
powershell -ExecutionPolicy Bypass -File "$env:USERPROFILE\plugins\antigravity-2\scripts\antigravity.ps1" live
```

After a DevTools MCP `Transport closed` error, use the local fallback:

```text
Call antigravity-local.devtools-health.
```

If it reports pages are ready, restart Codex to recreate the DevTools MCP transport or use `antigravity-local.handoff-template` for a manual paste into Antigravity for the current turn.

Report model quota state:

```powershell
powershell -ExecutionPolicy Bypass -File "$env:USERPROFILE\plugins\antigravity-2\scripts\antigravity.ps1" limits-summary
powershell -ExecutionPolicy Bypass -File "$env:USERPROFILE\plugins\antigravity-2\scripts\antigravity.ps1" models
```

The `limits-summary` command gives a compact availability summary. The `models` and `limits` commands call Antigravity's local language server over its gRPC-web API (`LanguageServerService/GetAvailableModels` and `GetLoadCodeAssist`) and return the fuller per-model data. This is the same source the Antigravity Models tab uses. It returns per-model quota metadata such as remaining fraction and reset time when available. It does not expose a raw all-model token ledger if Antigravity itself does not publish one.

Switch the current Antigravity chat to a cost-saving available model:

```powershell
powershell -ExecutionPolicy Bypass -File "$env:USERPROFILE\plugins\antigravity-2\scripts\antigravity.ps1" switch-model -ModelPreference flash-medium -ExpectedProject "<visible project>" -ExpectedChat "<visible chat>"
```

`switch-model` uses the local model-limit summary to choose an available model, then uses the local CDP bridge to select it in the visible Antigravity chat. `flash-medium` prefers `Gemini 3.5 Flash (Medium)` when available, then falls back to another available Flash/Gemini model.

Run a local repository privacy scan:

```powershell
powershell -ExecutionPolicy Bypass -File "$env:USERPROFILE\plugins\antigravity-2\scripts\antigravity.ps1" privacy
```

## Codex Operating Model

This plugin intentionally combines two local surfaces:

- Stable status and model-limit checks use local helper commands and Antigravity's local language server.
- Project/chat actions use the live Antigravity UI through the `antigravity-devtools` MCP bridge, because the UI is the source of truth for selected projects, selected conversations, composer state, and model selection.

For chat actions, Codex should verify the target project, conversation, and selected model before sending anything. For new projects or new chats, Codex should use the visible Antigravity controls through DevTools automation and report whether Antigravity accepted the action or showed an error/quota state.

For nontrivial work, Codex should act as the orchestrator, not the main worker. Codex gives Antigravity compact tasks, waits, reads only status artifacts or targeted diffs, reviews the result, and sends the next improvement task back to Antigravity. Codex should avoid duplicating Antigravity's broad file reading, browser operation, and long reasoning unless Antigravity is blocked or final verification requires it.

For prompt submission, Codex should call `antigravity-local.submission-guide` or follow the same rule: fill/type the prompt without a `submitKey`, then click the visible Send/arrow button. If a keyboard submit is required, use a separate key call with a simple accepted key such as `Enter`. Do not use `Control+Enter`, `Ctrl+Enter`, or chord strings unless the active tool schema explicitly lists that exact value; some DevTools tools reject those strings with `Unknown key`.

## Token-Saving Offload Pattern

Use this plugin to make Codex the router and verifier while Antigravity does the long work. Codex should avoid reading huge files, full logs, or full Antigravity chat transcripts. Instead, Codex sends Antigravity a compact handoff, lets Antigravity inspect the workspace locally, and reads back only a small artifact or status checkpoint.

Token savings are not automatic. First decide whether the task is worth offloading:

- Keep Codex direct only for arithmetic, short factual answers, tiny shell checks, small summaries, and prompts that do not need workspace context.
- Use Antigravity by default for project work, implementation, debugging, reviews, planning, research, UI operation, job-search/application workflows, and analysis where Antigravity can inspect local files and write a compact result.
- In existing project chats, assume Antigravity may inspect attached folders before answering. That is useful for real project work and wasteful for tiny tests.
- If Antigravity starts broad folder exploration for a small task, cancel it and answer directly in Codex.

Recommended flow:

1. If the task does not need visible desktop UI state, run `antigravity-local.submit-agy-job` first.
2. If the correct Antigravity project/chat is already selected and visible UI context matters, run `antigravity-local.submit-job` with `submit=true`, plus `expectedProject` and `expectedChat` when known.
3. If the selected chat is uncertain, run `antigravity-local.prepare-offload`, then use DevTools only to select the project/chat; use `switch-model` for model changes.
4. If it returns `codex-direct`, do not open or drive Antigravity.
5. Ask Antigravity to write progress to `.antigravity-bridge/jobs/<jobId>/status.json` and the required result/diff/test artifacts.
6. Codex reads only `read-job`, a targeted diff, or a compact visible UI status.
7. If the result is incomplete, Codex sends a short follow-up task or `retry-job` back to Antigravity with the exact gap instead of pulling broad context into Codex.
8. Codex summarizes for the user after Antigravity has produced a useful result or is clearly blocked.

If a Codex session cannot see MCP tools and can only run shell commands, use the equivalent PowerShell helper:

```powershell
powershell -ExecutionPolicy Bypass -File "$env:USERPROFILE\plugins\antigravity-2\scripts\antigravity.ps1" submit-agy-job -Goal "<goal>" -Workspace "<path>" -Mode fast -NextStep "<next step>" -AgyModel gemini-3.5-flash-low
```

For selected-chat direct submission through the PowerShell helper:

```powershell
powershell -ExecutionPolicy Bypass -File "$env:USERPROFILE\plugins\antigravity-2\scripts\antigravity.ps1" submit-offload -Goal "<goal>" -Workspace "<path>" -StatusFile "notes/antigravity-status.md" -NextStep "<next step>" -ExpectedProject "<project text>" -ExpectedChat "<chat text>" -ModelPreference auto -Submit true
```

Use `-Submit false` for verify-only; it should not fill the composer. Use `-FillOnly true` only when the user wants to manually review the handoff before sending.

For durable job submission through the PowerShell helper:

```powershell
powershell -ExecutionPolicy Bypass -File "$env:USERPROFILE\plugins\antigravity-2\scripts\antigravity.ps1" submit-job -Goal "<goal>" -Workspace "<path>" -Mode fast -NextStep "<next step>" -ExpectedProject "<project text>" -ExpectedChat "<chat text>" -ModelPreference auto
powershell -ExecutionPolicy Bypass -File "$env:USERPROFILE\plugins\antigravity-2\scripts\antigravity.ps1" list-jobs -Workspace "<path>"
powershell -ExecutionPolicy Bypass -File "$env:USERPROFILE\plugins\antigravity-2\scripts\antigravity.ps1" read-job -Workspace "<path>" -JobId latest
```

Modes are `fast`, `deep`, `review`, and `patch`. Use `create-job` when you want to create the folder without touching Antigravity, `retry-job` to resubmit an existing request, and `cancel-job` to mark the bridge job cancelled.

If UI submission is blocked by a stale DevTools port, use `antigravity-local.handoff-template` to generate the compact prompt and avoid repeated CDP probing. Restart Codex or paste the generated handoff manually so the next session attaches to the current Antigravity port.

Compact handoff template:

```text
Goal: <goal>
Workspace: <path>
Constraints: inspect files locally; do not paste full files, full logs, or full source; use search before reading whole files.
Token rule: work token-efficiently; write progress to <small-status-file>; output max 10 bullets plus changed file list.
Next step: <specific next action>
If blocked: ask one concise question; otherwise continue autonomously.
```

## Safety

This plugin operates only on the local machine and local Antigravity profile. It does not patch Antigravity internals, commit runtime tokens, or call Antigravity cloud APIs directly. Treat Antigravity user data, settings, chats, and workspace files as user-owned state.

Before publishing changes, run:

```powershell
powershell -ExecutionPolicy Bypass -File ".\scripts\antigravity.ps1" privacy
```

## License

MIT

© comprono · MIT · hashgraph-online/awesome-codex-plugins

Similar plugins

All plugins for Agent setup: memory, context, orchestration →

From the same set391

The whole set →
axonflow axonflow is a Claude Code plugin that checks Codex actions against policies, detects PII and secrets, and records audit events. Blocked calls get a decision_id. CX Codex ★ 1,596repo stars autocad-tianzheng-tools autocad-tianzheng-tools wires Claude to AutoCAD and Tianzheng HVAC through a local MCP server, so the agent can open DWG drawings and carry out drawing operations. CX Codex ★ 1,596repo stars arcmira arcmira searches YouTube and podcast transcripts for timestamped quotes, speakers, and sponsors. It helps analyze brand mentions and prep for interviews. CX Codex ★ 1,596repo stars apple-calendar The apple-calendar plugin for Claude Code and Codex connects to local macOS Calendar and Reminders for agenda views, event creation, and reminder management. CX Codex ★ 1,596repo stars anime-reaction-gif anime-reaction-gif — a plugin for Claude Code and Codex that builds looping reaction GIFs and MP4s from generated pose sheets. It drives image_gen for key poses, then hands the frames to FFmpeg for timing and export. CX Codex ★ 1,596repo stars aient Connect Claude Code to Aient’s MCP server to inspect production telemetry, investigate problems, and work through remediation. Useful when an agent needs operational context. CX Codex ★ 1,596repo stars aident-loadout aident-loadout — a remote MCP server that gives your agent access to the apps you authorise and 400+ skills, with a single setup shared across Claude, Claude and other clients. CX Codex ★ 1,596repo stars agentmart agentmart connects a remote MCP server offering persistent agent utilities like webhook inboxes, memory lockers, and queues. Helps when an agent needs infrastructure that stays online. CX Codex ★ 1,596repo stars

Project sponsors

Companies that keep this analytics open