antigravity-mcp-server

Lass zwei KI-Agenten gleichzeitig an deiner App arbeiten – ohne sich gegenseitig in die Quere zu kommen.

Dein Agent macht das Backend. Antigravity macht die UI. Keiner überschreibt die Dateien des anderen.

Das Problem

Zwei KI-Coding-Agenten gleichzeitig an einem Projekt klingt großartig – bis beide dieselbe Datei bearbeiten und sich gegenseitig die Arbeit zerstören.

Sie können einander nicht sehen. Das ist das ganze Problem.

Related MCP server: asynkor

Die Lösung

Ein kleiner Server, an den beide Agenten andocken. Er gibt ihnen einen gemeinsamen Speicher: wer macht was, welche Dateien belegt sind und was sie einander mitteilen müssen.

   Your AI agent                                    Antigravity
   Claude Code · Cursor · Windsurf                  (agy CLI)
   VS Code · Gemini CLI · OpenCode
          │                                              │
          │  MCP                                     MCP │
          └──────────────┐                ┌──────────────┘
                         ▼                ▼
              ┌─────────────────────────────────┐
              │        antigravity-mcp-server          │
              │                                 │
              │   board.json                    │
              │    ├─ tasks .... who does what  │
              │    ├─ locks .... files taken    │
              │    ├─ notes .... messages       │
              │    └─ presence . who is online  │
              └─────────────────────────────────┘
                              │
                              └──► starts `agy` in the background

Installation

npx antigravity-mcp-server init

Das war's. Dieser eine Befehl:

• findet jedes KI-Tool auf deinem Computer

• fügt den Server zu jedem hinzu

• schaltet die Berechtigung ein, die Antigravity braucht

Starte jetzt deine KI-Tools neu, damit sie die Änderung übernehmen.

Möchtest du es dauerhaft installiert haben, statt es bei jedem Lauf neu zu laden:

npm install -g antigravity-mcp-server
antigravity-mcp-server init

Weitere Befehle:

antigravity-mcp-server doctor           # is everything working?
antigravity-mcp-server doctor --probe   # same, plus a real round trip through agy
antigravity-mcp-server init --dry-run   # show changes, write nothing
antigravity-mcp-server init --all       # also write configs for tools you haven't installed
antigravity-mcp-server init --only claude-code,cursor

Du brauchst: Node 18.17 oder neuer und die Antigravity-CLI (agy). Ohne agy hast du trotzdem das gemeinsame Board – du kannst nur keine Aufgaben an Antigravity übergeben.

Wie du es verwendest

Du lernst keine Befehle. Du sprichst einfach mit deinem Agenten:

„Baue die Checkout-Seite mit Antigravity, während du die Payments-API machst.“

Dein Agent übernimmt. So läuft es ab:

  time ──────────────────────────────────────────────────────►

  your agent   ███ writes brief ███│████ payments API ████│ checks result
                                   │                      │
  Antigravity                      │███ checkout page ███ │
                                   │                      │
                                   └── both work at once ─┘

Dein Agent schreibt ein vollständiges Briefing, sperrt seine eigenen Dateien, startet Antigravity im Hintergrund und arbeitet weiter. Niemand wartet.

Warum das gemeinsame Board wichtig ist

1. Dateisperren

Bevor ein Agent eine Datei bearbeitet, beansprucht er sie. Das Sperren eines Ordners sperrt alles darin.

  my-app/
  ├── api/           [locked] your agent    ← Antigravity is told "taken"
  ├── db.ts          [locked] your agent
  ├── components/    [locked] Antigravity   ← your agent stays away
  └── styles/        [locked] Antigravity

Wenn ein Agent versucht, eine gesperrte Datei zu nehmen, bekommt er einen klaren Konflikt zurück. Kein stilles Überschreiben.

2. Notizen

Die UI wird gegen eine API gebaut, die noch nicht existiert. Also geben die beiden Agenten den Plan hin und her:

„POST /api/orders ist fertig. Es gibt { id, status } zurück. Hänge das Formular daran an.“

Das ist der Klebstoff, der beide Hälften zusammenhalten lässt.

3. Anwesenheit

Jeder Agent kann vor dem Start prüfen, was der andere tut, und wählt so Arbeit, die nicht kollidiert.

Die Werkzeuge

Dein Agent wählt sie selbst aus. Du tippst sie nie.

Zwei, die man kennen sollte:

coop_status – ein Aufruf beantwortet alles: wer online ist, was läuft, was gesperrt ist, was ungelesen ist.

ag_followup – führt die gleiche Antigravity-Unterhaltung fort. So behält „mach es jetzt mobil“ den gesamten Kontext, statt kalt zu starten.

Wie es intern funktioniert

Dateien auf der Festplatte

~/.antigravity-mcp/
├── board.json                    shared state, written under a lock
└── runs/
    ├── <task_id>.json            agy's raw result
    ├── <task_id>.prompt.txt      the brief that was sent
    └── <task_id>.err             stderr, if the run failed

board.json enthält tasks, locks, notes, events und presence. Jeder Schreibvorgang holt sich eine exklusive Sperre (ein atomar erstelltes Verzeichnis – das einzige primitive Element, das sich unter Windows und POSIX gleich verhält), landet dann über write-temp-and-rename, sodass ein Absturz keine halb geschriebene Tafel hinterlassen kann. Veraltete Sperren, die älter als 20s sind, werden automatisch aufgehoben.

Es gibt kein SQLite. Ein nativer Build würde npx auf Rechnern ohne Compiler zerstören, und node:sqlite ist noch experimentell und Node 22+. Die Tafel bekommt nur eine Handvoll kleiner Schreibvorgänge pro Minute, also ist eine JSON-Datei das richtige Werkzeug.

Delegation

ag_delegate ruft auf:

agy --print <brief> --output-format json --print-timeout <n>s \
    --add-dir <cwd> --mode accept-edits --dangerously-skip-permissions

Der Kindprozess wird abgekoppelt gestartet, mit stdout direkt nach runs/<task_id>.json umgeleitet. Das bedeutet, dass ein langer Job einen Neustart des MCP-Servers überlebt – der Status wird durch Lesen der Laufdatei und Prüfen der PID wiederhergestellt, nicht durch Halten eines Kind-Handles.

ag_followup verwendet die conversation_id aus agys JSON-Ausgabe über --conversation wieder, sodass der Kontext über Aufrufe hinweg erhalten bleibt.

Pfadsperren

Pfade werden mit path.resolve normalisiert und unter Windows case-gefaltet, sodass C:\Proj und c:\proj dieselbe Sperre nicht umgehen können. Überlappungen werden in beide Richtungen geprüft – das Beanspruchen von api/routes.ts kollidiert mit einer gehaltenen api/, und das Beanspruchen von api/ kollidiert mit einer gehaltenen api/routes.ts.

Agentenidentität

Jede Seite führt dieselbe Binärdatei mit einer anderen --agent <id> aus. Diese ID wird jedem Board-Eintrag zugeordnet. Zwei Clients, die dieselbe ID teilen, machen ihre Sperren füreinander unsichtbar, was den ganzen Zweck zunichte macht.

Wo Konfigurationen geschrieben werden

init berührt nur gefundene Tools und sichert jede bearbeitete Datei als <file>.bak-antigravity-mcp.

Gut zu wissen

Lange Jobs sind sicher. Antigravity läuft abgekoppelt. Wenn dein Editor oder der Server neu startet, läuft der Job weiter.

Antigravity bearbeitet ohne Nachfrage. ag_delegate übergibt --dangerously-skip-permissions, damit es unbeaufsichtigt arbeiten kann. Übergib auto_approve: false, um es stattdessen bei Eingabeaufforderungen anzuhalten.

Eine Falle, die init für dich behandelt. Im headless-Modus lehnt agy jeden MCP-Aufruf automatisch ab, es sei denn, er ist in ~/.gemini/antigravity-cli/settings.json auf die Whitelist gesetzt. Fehlt diese Regel, läuft die Delegation zwar, aber die Koordination tut still nichts – die schlimmste Art von Fehler, weil es so aussieht, als ob es funktioniert. init fügt mcp(coop/*) hinzu; doctor prüft darauf.

Antigravity arbeitet in einem eigenen Scratch-Projekt, es sei denn, das Zielverzeichnis befindet sich in seinem Arbeitsbereich. Jede Übergabe übergibt --add-dir <cwd> und gibt das Projekt-Root im Briefing an.

Einstellungen

Manuelle Einrichtung

Füge dies zur MCP-Konfiguration deines Tools hinzu:

{
  "mcpServers": {
    "antigravity": {
      "command": "npx",
      "args": ["-y", "antigravity-mcp-server", "--agent", "claude-code"]
    }
  }
}

Auf der Antigravity-Seite nenne den Server coop, verwende --agent antigravity und füge dies zu ~/.gemini/antigravity-cli/settings.json hinzu:

{ "permissions": { "allow": ["mcp(coop/*)"] } }

Der Serverschlüssel muss mit der Erlaubnisregel übereinstimmen – hier coop, dort mcp(coop/*).

Am Code arbeiten

git clone https://github.com/adeelali4/antigravity-mcp
cd antigravity-mcp
npm install

npm test                    # 16 checks, two live stdio clients, no agy credits used
node test/delegation.js     # real end-to-end run (uses agy credits)
node src/cli.js init --local --dry-run

npm test startet zwei echte MCP-Clients als separate Prozesse gegen ein Board, sodass prozessübergreifende Sperren und Nachrichtenübermittlung real und nicht simuliert getestet werden.

MIT · erstellt von adeelali4