antigravity-manager

What this skill does

# Antigravity Manager

> Skill by [ara.so](https://ara.so) — Daily 2026 Skills collection.

Antigravity Manager is a professional AI account manager and proxy gateway. It takes Google (Gemini) and Anthropic (Claude) web session tokens and exposes them as standard API endpoints (OpenAI-compatible, Anthropic-native, and Gemini-native formats) with intelligent multi-account rotation, quota tracking, and automatic failover.

**Key capabilities:**
- Multi-account management with real-time quota dashboards
- Protocol conversion: web sessions → OpenAI / Anthropic / Gemini API
- Auto-rotation on 429/401 errors (millisecond failover)
- Model routing and remapping
- Desktop app (Tauri v2 + React + Rust) or headless Docker/server mode

---

## Installation

### Option A: One-line script (Linux/macOS)

```bash
curl -fsSL https://raw.githubusercontent.com/lbjlaq/Antigravity-Manager/v4.1.30/install.sh | bash
```

Install a specific version:
```bash
curl -fsSL https://raw.githubusercontent.com/lbjlaq/Antigravity-Manager/v4.1.30/install.sh | bash -s -- --version 4.1.30
```

Dry run (preview without installing):
```bash
curl -fsSL https://raw.githubusercontent.com/lbjlaq/Antigravity-Manager/v4.1.30/install.sh | bash -s -- --dry-run
```

### Option B: Windows (PowerShell)

```powershell
irm https://raw.githubusercontent.com/lbjlaq/Antigravity-Manager/main/install.ps1 | iex
```

### Option C: Homebrew (macOS / Linuxbrew)

```bash
brew tap lbjlaq/antigravity-manager https://github.com/lbjlaq/Antigravity-Manager
brew install --cask antigravity-tools
```

### Option D: Docker (recommended for servers/NAS)

```bash
docker run -d --name antigravity-manager \
  -p 8045:8045 \
  -e API_KEY=$ANTIGRAVITY_API_KEY \
  -e WEB_PASSWORD=$ANTIGRAVITY_WEB_PASSWORD \
  -e ABV_MAX_BODY_SIZE=104857600 \
  -v ~/.antigravity_tools:/root/.antigravity_tools \
  lbjlaq/antigravity-manager:latest
```

Docker Compose:

```yaml
# docker-compose.yml
version: "3.8"
services:
  antigravity:
    image: lbjlaq/antigravity-manager:latest
    container_name: antigravity-manager
    restart: unless-stopped
    ports:
      - "8045:8045"
    environment:
      - API_KEY=${ANTIGRAVITY_API_KEY}
      - WEB_PASSWORD=${ANTIGRAVITY_WEB_PASSWORD}
      - ABV_MAX_BODY_SIZE=104857600
    volumes:
      - ~/.antigravity_tools:/root/.antigravity_tools
```

```bash
docker compose up -d
docker logs antigravity-manager          # view logs / recover forgotten keys
```

### Option E: Manual download

Download from [GitHub Releases](https://github.com/lbjlaq/Antigravity-Manager/releases):
- macOS: `.dmg` (Apple Silicon + Intel)
- Windows: `.msi` or portable `.zip`
- Linux: `.deb`, `.rpm`, or `.AppImage`

---

## Authentication / Security Model

Antigravity uses two separate credentials:

| Credential | Env var | Config key | Purpose |
|---|---|---|---|
| API Key | `API_KEY` | `api_key` | Authenticates AI API calls (`Authorization: Bearer ...`) |
| Web Password | `WEB_PASSWORD` | `admin_password` | Logs into the management web UI |

**Scenario A — only `API_KEY` set:**
- Web UI login: use `API_KEY`
- API calls: use `API_KEY`

**Scenario B — both set (recommended):**
- Web UI login: `WEB_PASSWORD` only (API Key rejected for login)
- API calls: `API_KEY` only

Recover credentials:
```bash
docker logs antigravity-manager
# or
grep -E '"api_key"|"admin_password"' ~/.antigravity_tools/gui_config.json
```

---

## API Endpoints

The proxy server runs on port **8045** by default.

### OpenAI-compatible (works with any OpenAI SDK)

```
POST http://localhost:8045/v1/chat/completions
Authorization: Bearer $ANTIGRAVITY_API_KEY
```

### Anthropic-native (Claude Code, etc.)

```
POST http://localhost:8045/v1/messages
Authorization: Bearer $ANTIGRAVITY_API_KEY
```

### Gemini-native

```
POST http://localhost:8045/v1/models/{model}:generateContent
Authorization: Bearer $ANTIGRAVITY_API_KEY
```

---

## Code Examples

### Python — OpenAI SDK (Gemini via Antigravity)

```python
import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["ANTIGRAVITY_API_KEY"],
    base_url="http://localhost:8045/v1",
)

response = client.chat.completions.create(
    model="gemini-2.5-pro",
    messages=[
        {"role": "user", "content": "Explain quantum entanglement in simple terms."}
    ],
    stream=True,
)

for chunk in response:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)
```

### Python — Anthropic SDK (Claude via Antigravity)

```python
import os
import anthropic

client = anthropic.Anthropic(
    api_key=os.environ["ANTIGRAVITY_API_KEY"],
    base_url="http://localhost:8045",
)

message = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Write a haiku about distributed systems."}
    ],
)
print(message.content[0].text)
```

### Python — Streaming with Anthropic

```python
import os
import anthropic

client = anthropic.Anthropic(
    api_key=os.environ["ANTIGRAVITY_API_KEY"],
    base_url="http://localhost:8045",
)

with client.messages.stream(
    model="claude-opus-4-5",
    max_tokens=2048,
    system="You are a helpful coding assistant.",
    messages=[{"role": "user", "content": "Implement a binary search in Rust."}],
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)
```

### TypeScript / Node — OpenAI SDK

```typescript
import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.ANTIGRAVITY_API_KEY!,
  baseURL: "http://localhost:8045/v1",
});

async function chat(prompt: string): Promise<string> {
  const response = await client.chat.completions.create({
    model: "gemini-2.5-flash",
    messages: [{ role: "user", content: prompt }],
  });
  return response.choices[0].message.content ?? "";
}

// Image generation via Imagen 3
async function generateImage(prompt: string) {
  const response = await client.images.generate({
    model: "imagen-3.0-generate-002",
    prompt,
    size: "1024x1024",  // maps to Imagen 3 aspect ratio
    n: 1,
  });
  return response.data[0].url;
}
```

### cURL — quick test

```bash
# Test OpenAI-compatible endpoint
curl -s http://localhost:8045/v1/chat/completions \
  -H "Authorization: Bearer $ANTIGRAVITY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-2.5-pro",
    "messages": [{"role": "user", "content": "Hello!"}]
  }' | jq '.choices[0].message.content'

# Test Anthropic endpoint
curl -s http://localhost:8045/v1/messages \
  -H "Authorization: Bearer $ANTIGRAVITY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-4-5",
    "max_tokens": 256,
    "messages": [{"role": "user", "content": "Hello!"}]
  }' | jq '.content[0].text'
```

---

## Connecting Claude Code CLI

Claude Code uses the Anthropic protocol. Point it at Antigravity:

```bash
# Set environment variables before starting Claude Code
export ANTHROPIC_API_KEY=$ANTIGRAVITY_API_KEY
export ANTHROPIC_BASE_URL=http://localhost:8045

claude  # start Claude Code — it will use Antigravity as the backend
```

Or create a `.env` in your project root:

```bash
# .env
ANTHROPIC_API_KEY=your-antigravity-api-key
ANTHROPIC_BASE_URL=http://localhost:8045
```

---

## Connecting to Popular AI Clients

### Cherry Studio

1. Open Cherry Studio → Settings → API Provider
2. Select **OpenAI-compatible**
3. Base URL: `http://localhost:8045/v1`
4. API Key: your `ANTIGRAVITY_API_KEY`

### Cursor

In Cursor settings, set:
- OpenAI Base URL: `http://localhost:8045/v1`
- API Key: your `ANTIGRAVITY_API_KEY`

### Continue.dev

```json
// ~/.continue/config.json
{
  "models": [
    {
      "title": "Gemini Pro (Antigravity)",
      "provider": "openai",
      "model": "gemini-2.5-pro",
      "apiKey": "YOUR_ANTIGRAVITY_API_KEY",
      "apiBase": "http://localhost:8045/v1"
    },
    {
      "title": "Claude (Antigravity)",
      "provider": "anthropic",
      "model": "claude-sonnet-4-5",