Antigravity Manager

Antigravity Manager

Skill by 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)

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

Install a specific version:

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):

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

Option B: Windows (PowerShell)

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

Option C: Homebrew (macOS / Linuxbrew)

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

Option D: Docker (recommended for servers/NAS)

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:

# 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

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

Option E: Manual download

Download from GitHub Releases:

• macOS: .dmg (Apple Silicon + Intel)
• Windows: .msi or portable .zip
• Linux: .deb, .rpm, or .AppImage

Authentication / Security Model

Antigravity uses two separate credentials:

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:

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)

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)

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

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

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

# 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:

# 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:

# .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

// ~/.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",