# supergravity-mcp

![supergravity](https://raw.githubusercontent.com/presidentrice/supergravity-mcp/main/assets/hero.jpg)

An MCP server that lets Claude Code (or any MCP client) delegate tasks to the
**Google Antigravity** desktop app — by driving its real, already-logged-in UI.
No reverse engineering, no extracted credentials, no unofficial API calls.

## Why this exists

Antigravity ships a CLI (`agy`) for scripting it headlessly — but on older
Intel Macs, that CLI isn't available even though the desktop **app** runs fine
(confirmed working on a 2015 MacBook Pro, macOS Monterey, Intel). This project
is the missing bridge for anyone in that situation: it automates the app the
same way a human would use it, so it works anywhere the app itself works.

## How it works

1. Antigravity is relaunched with Chrome's remote-debugging flag
   (`--remote-debugging-port`), the same mechanism browser test tools like
   Playwright use to drive Electron apps.
2. A script connects to that debug port and: types your task into the chat
   box (via a simulated paste event — Antigravity's input is a rich-text
   editor, not a plain textarea, so it needs a real paste, not just poking
   text into the DOM), clicks send, and reads back the reply once it's done
   streaming.
3. Everything happens through your own existing login. This tool never
   touches Antigravity's stored credentials, internal code, or private APIs.

## Setup

Antigravity must be installed and already signed in. By default the tool
looks for it at `/Applications/Antigravity.app` or `~/Desktop/Antigravity.app`;
set `ANTIGRAVITY_APP_PATH` if it lives somewhere else.

### Easiest: install the plugin (MCP server + skill together)

```bash
claude plugin marketplace add presidentrice/supergravity-mcp
claude plugin install supergravity@supergravity-mcp
```

This gets you both the `delegate_to_antigravity` / `get_antigravity_quota`
tools and the `supergravity:delegate` skill, which teaches Claude how to
route natural requests ("use gemini", "ask antigravity", "check antigravity's
quota") to the right tool call and model.

### Or: just the MCP server, no skill

```bash
claude mcp add supergravity -- npx -y supergravity-mcp
```

Works fine without the skill — Claude still has the tools, just less
built-in guidance on picking a model or handling a quota-exhausted error.

### Building from source

```bash
npm install
npm run build
```

## The tools

### `delegate_to_antigravity(task, model?, timeoutMs?)`

- `task` — what to ask Antigravity to do.
- `model` — optional. One of the models in Antigravity's own selector
  (see `AVAILABLE_MODELS` in `src/antigravity-client.ts`).
- `timeoutMs` — optional, default 120000 (2 minutes).

If the task generates files (images, documents, etc.), the result also
includes a real filesystem path — Antigravity stores each conversation's
files at `~/.gemini/antigravity/brain/<conversation-id>/` on disk, confirmed
directly (not documented anywhere by Google). No need to fetch anything
through Antigravity's local server; just read the file.

### `delegate_to_antigravity_batch(tasks)`

Runs several independent tasks at once, each in its own Antigravity window —
genuinely concurrent, not queued. Confirmed with two simultaneous
~200-word generations that both completed correctly in the same ~16s window.
Opens extra windows automatically as needed (macOS's "New Window" menu
command via System Events, with a fallback for when zero windows are open).

Requires Accessibility permission for whatever process runs this (System
Settings > Privacy & Security > Accessibility) — macOS only. Don't run this
at the same time as a separate `delegate_to_antigravity` call; window
allocation between the two isn't coordinated.

```ts
delegateToAntigravityBatch([
  { task: "..." },
  { task: "...", model: "Claude Sonnet 4.6 (Thinking)" },
]);
```

### `list_antigravity_files(limit?)`

Every file Antigravity has generated, across every conversation, most recent
first — not scoped to a single delegate call. Useful for finding something
generated earlier in this session or a past one.

### `get_antigravity_quota()`

Reads Antigravity's Settings > Models panel and returns remaining quota —
Gemini models and Claude+GPT models draw from **separate pools**, each with a
weekly limit and a 5-hour limit. Useful to check before delegating, or to
explain a `send button is disabled` error (usually means that pool is
exhausted, not that the model is unavailable).

### Picking a model

Antigravity doesn't show per-message token cost, only pooled quota %. The
`model` parameter's description carries a rough cost/capability cheat sheet
(`MODEL_GUIDE` in `src/antigravity-client.ts`) built from third-party API
list prices and public benchmarks, researched mid-2026 — newer than this
tool's own training data, so treat it as a starting point, not gospel:

| Model | ~Price (in/out per 1M tokens) | Known for |
|---|---|---|
| Gemini 3.5 Flash | $1.50 / $9 | Fastest, cheapest frontier-tier option; strong coding/agentic benchmarks |
| Gemini 3.1 Pro | $2 / $12 | "Thinking" mode for harder reasoning (ARC-AGI-2 ~77%) |
| Claude Sonnet 4.6 | $3 / $15 | Coding quality, computer-use, agent workflows (SWE-bench ~80%) |
| Claude Opus 4.6 | $5 / $25 | Strongest complex/ambiguous reasoning; legal/financial/research-grade analysis |
| GPT-OSS 120B | ~$0.03–0.09 / $0.10–0.40 | Open-weight, near-o4-mini reasoning, far cheaper than the rest |

These are what the underlying models cost via their own APIs elsewhere —
Antigravity itself doesn't bill you per token, it draws down the pooled
quota above instead.

## Known limitations

- **A model's quota can run out.** If a non-default model (e.g. Claude Opus)
  has hit its usage limit, Antigravity's send button stays disabled after
  selecting it, even though it's still pickable in the dropdown. The tool
  fails fast with a clear error in that case instead of hanging until
  timeout — just retry later or pick a different model.
- **UI automation, not an API.** If Google changes Antigravity's screen
  layout, the CSS selectors this relies on (`data-testid="send-button"`, the
  message input's `aria-label`, etc.) may need updating. That's the tradeoff
  for staying entirely inside Antigravity's terms of use — see below.
- **Reply extraction is a text heuristic**, not a structured read. It looks
  for the "Thought for Ns" marker Antigravity renders before its answer and
  takes what follows. Works reliably in testing but is the most likely thing
  to break on a UI redesign.
- **Single-window assumption.** Only tested with one Antigravity window open.

## What this deliberately does NOT do

No unpacking of Antigravity's `app.asar`, no reading of stored auth tokens,
no calling of internal/undocumented endpoints. Everything here operates
through the same interface a human uses, which is why it doesn't carry the
legal risk that reverse-engineering approaches do.

## License

MIT