Google Antigravity einrichten: 12 Schritte, 40 Min [2026]

Google hat seine agentische Entwicklungsumgebung im Mai 2026 auf Antigravity 2.0 aktualisiert und dabei Desktop-App, Kommandozeile und Preismodell neu geordnet. Wer jetzt einsteigen will, findet online vor allem Bruchstücke: ein YouTube-Video hier, ein Blogpost dort, kaum etwas mit echtem Tiefgang für den deutschsprachigen Raum. Diese Anleitung schließt die Lücke. Sie führt in zwölf Schritten von der Kontoeinrichtung bis zum ersten fertigen Projekt, inklusive CLI, IDE-Erweiterungen und einer ehrlichen Einschätzung, wann sich das kostenpflichtige AI-Ultra-Abo lohnt.

Die Zielgruppe: Entwicklerinnen und Entwickler in Österreich, die bereits mit VS Code, JetBrains oder der Kommandozeile arbeiten und wissen wollen, ob sich ein Umstieg auf einen Agenten-Workflow lohnt. Laut der Stack Overflow Developer Survey 2025 nutzen bereits über 84 Prozent der befragten Fachkräfte KI-Tools in ihrem Entwicklungsprozess oder planen dies, mehr als die Hälfte davon täglich (Stack Overflow Developer Survey 2025). Gleichzeitig gaben in derselben Befragung 46 Prozent an, der Genauigkeit von KI-Ausgaben nicht zu vertrauen (Stack Overflow, Pressearchiv). Diese Anleitung berücksichtigt genau diesen Spagat: Sie zeigt, wie man Antigravity produktiv nutzt, ohne dem Agenten blind zu vertrauen.

Was ist Google Antigravity 2.0?

Google Antigravity ist eine kostenlose, agentische Entwicklungsumgebung, die im November 2025 als Public Preview startete und beim Google I/O im Mai 2026 die Version 2.0 erhielt (Antigravity-Blog zu Google I/O 2026). Der Unterschied zu klassischen KI-Codeeditoren wie Cursor oder GitHub Copilot: Antigravity setzt nicht primär auf Zeile-für-Zeile-Vervollständigung, sondern auf Agenten, die ganze Aufgaben eigenständig übernehmen. Man formuliert ein Ziel, der Agent plant, schreibt Code, führt Terminal-Befehle aus, testet im Browser und meldet sich erst wieder, wenn die Aufgabe erledigt ist oder er Rückfragen hat.

Mit Version 2.0 hat Google die Produktpalette auf fünf Bausteine erweitert: die Desktop-App, eine eigenständige IDE, Erweiterungen für VS Code und JetBrains, eine neue Kommandozeile namens Antigravity CLI und ein Python SDK für eigene Integrationen. Damit reagiert Google auf ein Problem, das viele agentische Tools haben: Sie zwingen Entwicklerinnen und Entwickler, ihre gewohnte Umgebung zu verlassen. Wer lieber in JetBrains bleibt, kann Antigravity als Plugin nutzen, wer die Kommandozeile bevorzugt, greift zur CLI. TechCrunch bezeichnete den Schritt als Versuch, Googles verstreute KI-Coding-Tools unter einem Dach zu bündeln (TechCrunch, Mai 2026).

Für einen tieferen Blick auf die IDE-Integrationen lohnt sich unser separater Beitrag zu Google Antigravity in JetBrains und Zed. Diese Anleitung hier konzentriert sich auf die komplette Einrichtung von null bis zum ersten fertigen Projekt.

Voraussetzungen: Systemanforderungen und Accounts

Bevor der Download beginnt, lohnt sich ein Blick auf die Mindestanforderungen. Antigravity läuft auf macOS, Windows und Linux, allerdings mit unterschiedlichen Mindestversionen je Plattform. Wichtig für Firmenkunden: Die Public Preview funktioniert aktuell nur mit einem persönlichen Gmail-Konto, Google-Workspace-Konten werden noch nicht unterstützt. Wer im Team arbeitet, sollte das vorab klären, sonst scheitert die Anmeldung im letzten Schritt der Einrichtung.

Komponente	Mindestanforderung	Hinweis
macOS	Monterey 12 oder neuer	Intel und Apple Silicon werden unterstützt
Windows	Windows 10, 64-Bit oder neuer	Installer als .exe, keine Store-Version
Linux	glibc 2.28+, glibcxx 3.4.25+	.deb für Debian/Ubuntu, .rpm für Fedora/RHEL
Konto	Persönliches Gmail-Konto	Workspace-Konten aktuell nicht unterstützt
Arbeitsspeicher	Mindestens 8 GB empfohlen	Bei großen Codebasen eher 16 GB
Internetverbindung	Dauerhaft aktiv	Agenten laufen serverseitig, kein Offline-Betrieb

Ein Punkt wird oft übersehen: Antigravity braucht durchgehend eine Internetverbindung, weil die eigentliche Modellberechnung in Googles Rechenzentren läuft, nicht lokal. Wer im Zug oder an Orten mit schlechtem Empfang arbeitet, wird das schnell merken, weil Agenten-Läufe dann abbrechen oder hängen bleiben.

Wer bereits ein bestehendes Projektverzeichnis mitbringt, sollte zudem vorab sicherstellen, dass es sich um ein initialisiertes Git-Repository handelt. Antigravity funktioniert zwar auch ohne Versionskontrolle, verliert dabei aber einen entscheidenden Sicherheitsnetz-Effekt: Ohne Commits lässt sich eine unerwünschte Agenten-Änderung nur schwer rückgängig machen. Ein einmaliges git init und ein erster Commit vor dem Start der ersten Mission kosten wenig Zeit und ersparen im Zweifel deutlich mehr Aufwand später.

Schritt 1 und 2: Google-Konto vorbereiten und Antigravity herunterladen

Der erste Schritt ist unspektakulär, aber wichtig: Man braucht ein persönliches Google-Konto, keines aus einer Firmen-Domain mit Workspace-Verwaltung. Wer beruflich nur ein Workspace-Konto hat, legt sich am besten ein separates Gmail-Konto für Testzwecke an, bis Google die Workspace-Unterstützung nachreicht.

Der Download läuft über die offizielle Seite antigravity.google. Dort erkennt die Seite automatisch das Betriebssystem und schlägt das passende Paket vor. Unter Linux empfiehlt sich die Installation über die Paketverwaltung, weil dabei Abhängigkeiten automatisch aufgelöst werden.

# Debian/Ubuntu: Paket herunterladen und installieren
wget https://antigravity.google/download/linux/antigravity.deb
sudo apt install ./antigravity.deb

# Fedora/RHEL: RPM-Paket installieren
wget https://antigravity.google/download/linux/antigravity.rpm
sudo dnf install ./antigravity.rpm

# macOS: Installation per DMG
# DMG-Datei öffnen und Antigravity in den Programme-Ordner ziehen

# Windows: Installer herunterladen und ausführen
# antigravity-setup.exe als Administrator starten

Nach der Installation lässt sich Antigravity wie jede andere Desktop-Anwendung starten. Der erste Start dauert spürbar länger als spätere, weil im Hintergrund Sprachserver und Erweiterungen initialisiert werden. Auf einem Notebook mit SSD und 16 GB RAM lag der erste Start in unseren Tests bei rund 20 bis 30 Sekunden.

Schritt 3 und 4: Ersteinrichtung, Anmeldung und die Oberfläche verstehen

Beim ersten Start fragt Antigravity eine Reihe von Konfigurationsoptionen ab. Zuerst die Anmeldung mit dem Google-Konto, danach die Wahl zwischen einem frischen Setup (“Start fresh”) oder dem Import bestehender VS-Code-Einstellungen. Wer bereits Tastenkürzel, Themes und Erweiterungen aus VS Code gewohnt ist, sollte den Import wählen, das erspart eine erneute Einrichtung. Anschließend folgt die Theme-Auswahl, rein kosmetisch, aber gut für die Augen nach zehn Stunden vor dem Bildschirm.

Die Oberfläche selbst gliedert sich in mehrere Bereiche, die sich deutlich von einer klassischen IDE unterscheiden. Der Editor-Bereich funktioniert wie gewohnt mit Tab-Autovervollständigung und Befehlen in natürlicher Sprache. Neu hinzu kommt der Agent Manager, eine Art Kontrollzentrum für alle laufenden und geplanten Agenten-Aufgaben. Das Artifacts-Panel sammelt alles, was ein Agent während einer Aufgabe erzeugt hat, etwa Screenshots von Testläufen oder Zwischenversionen von Dateien. Eine integrierte Browser-Vorschau erlaubt es, Web-Anwendungen direkt in der IDE zu testen, ohne den Editor zu verlassen, und ein klassisches Terminal-Panel bleibt für manuelle Eingriffe erhalten.

• Editor-Panel: Klassischer Code-Editor mit Tab-Autovervollständigung und Inline-Befehlen
• Agent Manager: Übersicht über laufende, wartende und abgeschlossene Agenten-Aufgaben
• Artifacts-Panel: Zwischenergebnisse, Screenshots und Protokolle der Agenten-Arbeit
• Browser-Vorschau: Live-Test von Web-Anwendungen direkt in der IDE
• Terminal: Klassischer Kommandozeilenzugriff für manuelle Eingriffe

Schritt 5: Das passende KI-Modell wählen

Antigravity ist kein Ein-Modell-Werkzeug. In den Einstellungen lässt sich zwischen mehreren Modellen wechseln, je nachdem, ob Geschwindigkeit, Codequalität oder Kosten im Vordergrund stehen. Standardmäßig ist Gemini 3 Pro als Hauptmodell voreingestellt, weil es bei komplexen, mehrstufigen Aufgaben die stabilsten Ergebnisse liefert. Für schnelle, kleinere Änderungen bietet sich Gemini 3 Flash an, spürbar zügiger, dafür mit etwas weniger Tiefgang bei komplizierter Logik.

Wer bereits mit Claude oder offenen Modellen arbeitet, findet in Antigravity auch Anthropics Claude Sonnet 4.6 sowie das quelloffene GPT-OSS-120B. Letzteres eignet sich laut Praxisberichten besonders für Projekte mit strengeren Datenschutzanforderungen, weil es sich in bestimmten Konfigurationen stärker isolieren lässt als geschlossene Modelle. Wer bereits Erfahrung mit Claude Code gesammelt hat, wird sich beim Umstieg auf Claude Sonnet 4.6 innerhalb von Antigravity schnell zurechtfinden, da Sprachstil und Codequalität ähnlich ausfallen.

Modell	Anbieter	Stärke	Verfügbarkeit
Gemini 3 Pro	Google	Beste Gesamtleistung, multimodal, Standardmodell	Kostenlose Stufe
Gemini 3 Flash	Google	Schneller, kosteneffizienter für kleine Aufgaben	Kostenlose Stufe
Claude Sonnet 4.6	Anthropic	Starke Codequalität, wenig Nacharbeit nötig	Kostenlose Stufe
GPT-OSS-120B	OpenAI (Open Source)	Offenes Modell, geeignet für sensible Projekte	Kostenlose Stufe

Das Modell lässt sich pro Projekt oder sogar pro einzelner Agenten-Aufgabe wechseln. Für ein Refactoring über mehrere Dateien hinweg empfiehlt sich Gemini 3 Pro, für das schnelle Umbenennen einer Variablen reicht Gemini 3 Flash völlig aus und spart Kontingent.

Schritt 6: Agent-Modus festlegen

Bevor der erste Agent losläuft, muss man festlegen, wie viel Kontrolle man abgeben möchte. Antigravity bietet dafür drei Modi an. Im agentengesteuerten Modus arbeitet der Agent vollständig autonom, er schreibt Code, führt Befehle aus und committet Änderungen ohne Rückfrage. Im review-gesteuerten Modus hält der Agent vor jeder wesentlichen Aktion inne und wartet auf eine Freigabe. Der dritte Modus, agentengestützt, gilt als empfohlener Mittelweg: Der Agent arbeitet weitgehend selbstständig, holt sich aber vor kritischen Schritten wie dem Löschen von Dateien oder dem Ausführen von Shell-Befehlen mit Systemrelevanz eine Bestätigung ein.

Für den Einstieg empfiehlt sich klar der review-gesteuerte oder der agentengestützte Modus. Wer direkt in den vollautonomen Modus wechselt, verliert schnell den Überblick, welche Datei der Agent gerade warum verändert hat, gerade wenn man selbst noch nicht abschätzen kann, wie zuverlässig die Ausgaben in der eigenen Codebasis ausfallen. Der Modus lässt sich später jederzeit in den Projekteinstellungen ändern, ein Wechsel erfordert keinen Neustart der IDE.

In der Praxis pendeln erfahrene Nutzer zwischen den Modi, je nach Aufgabe. Für ein neues, unbekanntes Projekt bleibt der review-gesteuerte Modus die sicherere Wahl, weil man dabei lernt, wie der Agent an die eigene Codebasis herangeht. Bei wiederkehrenden, gut verstandenen Aufgaben wie dem Aktualisieren von Testdaten oder dem Formatieren von Dateien lohnt sich dagegen der agentengesteuerte Modus, weil er spürbar schneller durchläuft und das Risiko bei solchen Routineaufgaben ohnehin gering ist.

Schritt 7 und 8: Erstes Projekt starten und die erste Mission formulieren

Antigravity nennt eine Agenten-Aufgabe “Mission”. Man öffnet einen Ordner oder ein leeres Verzeichnis, öffnet den Agent Manager über das Seitenmenü und formuliert im Eingabefeld, was erreicht werden soll. Wichtig dabei: Je konkreter die Formulierung, desto besser das Ergebnis. Eine vage Anweisung wie “baue mir eine Website” führt zu einem Agenten, der viele eigene Annahmen trifft, die selten zur eigenen Vorstellung passen.

Mission: Erstelle eine einfache Aufgabenverwaltung als
Single-Page-Web-App mit HTML, CSS und Vanilla JavaScript.

Anforderungen:
- Aufgaben hinzufügen, als erledigt markieren, löschen
- Speicherung im localStorage, kein Backend nötig
- Responsive Layout für Desktop und Mobilgeräte
- Deutschsprachige Beschriftungen
- Keine externen Abhängigkeiten oder Frameworks

Teste die Anwendung anschließend im Browser-Vorschau-Panel
und behebe eventuelle Fehler in der Konsole selbstständig.

Sobald die Mission abgeschickt ist, erscheint im Agent Manager ein Fortschrittsprotokoll. Man sieht in Echtzeit, welche Datei gerade erstellt oder verändert wird, welche Terminal-Befehle laufen und wann der Agent die Browser-Vorschau zum Testen öffnet. Bei einem review-gesteuerten Setup pausiert der Agent an mehreren Stellen und fragt nach, etwa bevor er eine neue Datei anlegt oder ein Paket installiert.

Schritt 9: Antigravity CLI installieren und im Terminal nutzen

Nicht jede Aufgabe braucht die volle Desktop-Oberfläche. Für CI-Pipelines, Remote-Server oder schnelle Terminal-Sessions bringt Antigravity 2.0 eine eigene Kommandozeile mit, laut Google eine “leichtgewichtige, schnelle, terminal-erste Oberfläche” für den Umgang mit Agenten (Google Developers Blog, I/O 2026). Die CLI lässt sich unabhängig von der Desktop-App installieren und eignet sich besonders für Entwicklerinnen und Entwickler, die ohnehin viel Zeit im Terminal verbringen, etwa Nutzer, die parallel schon mit der OpenAI Codex CLI experimentiert haben.

# Installation über die offizielle Download-Seite
# (Installationsskript und Paketname je nach Version prüfen)
antigravity --version

# Anmeldung mit dem Google-Konto im Terminal
antigravity auth login

# Eine neue Mission direkt aus dem Terminal starten
antigravity agent run "Füge dem Projekt Unit-Tests hinzu"

# Laufende Hintergrund-Agenten auflisten
antigravity agent list

# Status einer bestimmten Aufgabe abfragen
antigravity agent status 

Die genaue Befehlssyntax kann sich mit künftigen Versionen leicht ändern, ein Blick auf antigravity --help nach der Installation zeigt immer den aktuellen Befehlsumfang. Praktisch ist die CLI vor allem für Hintergrund-Agenten, die längere Aufgaben wie das Schreiben einer vollständigen Testsuite übernehmen, während man selbst an etwas anderem weiterarbeitet.

Schritt 10: VS Code und JetBrains Erweiterungen einrichten

Wer nicht auf die eigenständige Antigravity-IDE umsteigen möchte, kann die Agenten-Funktionen als Erweiterung in die gewohnte Umgebung holen. In VS Code läuft die Installation über den regulären Marketplace, in JetBrains-Produkten wie IntelliJ IDEA oder PyCharm über das Plugin-Repository.

# VS Code: Erweiterung über die Kommandozeile installieren
code --install-extension google.antigravity

# JetBrains: über die IDE-Einstellungen
# Settings > Plugins > Marketplace > "Antigravity" suchen

Der Funktionsumfang der Erweiterungen deckt sich weitgehend mit der Desktop-App, allerdings fehlen einige Panels wie die integrierte Browser-Vorschau oder laufen in reduzierter Form. Wer bereits GitHub Copilot in VS Code eingerichtet hat, kann beide Werkzeuge parallel betreiben, sollte aber im Blick behalten, welches Tool gerade welche Änderung vorschlägt, um Verwirrung bei überlappenden Vorschlägen zu vermeiden.

Schritt 11: Praxisprojekt – eine komplette Aufgabenverwaltung bauen

Um zu zeigen, wie ein fertiges Ergebnis aussieht, folgt hier der Code einer einfachen, aber vollständig funktionsfähigen Aufgabenverwaltung, wie sie ein Agent auf Basis der Mission aus Schritt 7 erzeugen kann. Die Struktur besteht aus drei Dateien: HTML, CSS und JavaScript, ganz ohne externe Bibliotheken.

<!-- index.html -->
<!DOCTYPE html>
<html lang="de">
<head>
  <meta charset="UTF-8">
  <title>Aufgabenverwaltung</title>
  <link rel="stylesheet" href="style.css">
</head>
<body>
  <main>
    <h1>Meine Aufgaben</h1>
    <form id="task-form">
      <input type="text" id="task-input" placeholder="Neue Aufgabe..." required>
      <button type="submit">Hinzufügen</button>
    </form>
    <ul id="task-list"></ul>
  </main>
  <script src="script.js"></script>
</body>
</html>

// script.js
const STORAGE_KEY = "antigravity-tasks";
const form = document.getElementById("task-form");
const input = document.getElementById("task-input");
const list = document.getElementById("task-list");

function loadTasks() {
  return JSON.parse(localStorage.getItem(STORAGE_KEY) || "[]");
}

function saveTasks(tasks) {
  localStorage.setItem(STORAGE_KEY, JSON.stringify(tasks));
}

function renderTasks() {
  const tasks = loadTasks();
  list.innerHTML = "";
  tasks.forEach((task, index) => {
    const li = document.createElement("li");
    li.className = task.done ? "done" : "";
    li.innerHTML = `
      <span>${task.text}</span>
      <button data-action="toggle" data-index="${index}">✓</button>
      <button data-action="delete" data-index="${index}">✕</button>
    `;
    list.appendChild(li);
  });
}

form.addEventListener("submit", (event) => {
  event.preventDefault();
  const tasks = loadTasks();
  tasks.push({ text: input.value, done: false });
  saveTasks(tasks);
  input.value = "";
  renderTasks();
});

list.addEventListener("click", (event) => {
  const index = event.target.dataset.index;
  if (index === undefined) return;
  const tasks = loadTasks();
  if (event.target.dataset.action === "toggle") {
    tasks[index].done = !tasks[index].done;
  } else if (event.target.dataset.action === "delete") {
    tasks.splice(index, 1);
  }
  saveTasks(tasks);
  renderTasks();
});

renderTasks();

Ohne ein passendes Stylesheet bleibt jede Web-App unbrauchbar, deshalb liefert der Agent normalerweise auch gleich die dritte Datei mit. Ein einfaches, aufgeräumtes CSS reicht für den Testlauf völlig aus und lässt sich später beliebig verfeinern.

/* style.css */
body {
  font-family: system-ui, sans-serif;
  background: #f4f4f5;
  display: flex;
  justify-content: center;
  padding: 2rem;
}

main {
  background: #fff;
  border-radius: 12px;
  padding: 1.5rem 2rem;
  max-width: 480px;
  width: 100%;
  box-shadow: 0 1px 3px rgba(0,0,0,0.1);
}

#task-form {
  display: flex;
  gap: 0.5rem;
  margin-bottom: 1rem;
}

#task-input {
  flex: 1;
  padding: 0.5rem;
  border: 1px solid #ccc;
  border-radius: 6px;
}

#task-list li {
  display: flex;
  align-items: center;
  justify-content: space-between;
  padding: 0.5rem 0;
  border-bottom: 1px solid #eee;
}

#task-list li.done span {
  text-decoration: line-through;
  color: #999;
}

@media (max-width: 480px) {
  main { padding: 1rem; }
}

Nach dem ersten Lauf zeigt die Browser-Vorschau in Antigravity ein funktionierendes Formular mit Liste, responsiv und ohne zusätzliche Konfiguration. In der Praxis meldet der Agent an dieser Stelle oft von sich aus ein Testergebnis, etwa dass der Eintrag hinzugefügt wurde und die localStorage-Persistenz nach einem Seiten-Neuladen bestätigt ist. Solche Selbsttests laufen automatisch über die integrierte Browser-Vorschau, wenn der review-gesteuerte Modus aktiv ist. Bricht der Test fehl, zeigt das Artifacts-Panel den genauen Fehler aus der Browser-Konsole, meist reicht das für den Agenten, um den Fehler im nächsten Durchlauf selbst zu beheben.

Wer die Vorlage erweitern möchte, kann in einer zweiten Mission etwa Kategorien, Fälligkeitsdaten oder eine Suchfunktion ergänzen lassen, jeweils als eigene, klar abgegrenzte Aufgabe formuliert. Aus Erfahrung funktioniert das deutlich zuverlässiger als eine einzige Mission mit allen Wünschen auf einmal, weil der Agent bei kleineren Schritten weniger Kontext gleichzeitig im Kopf behalten muss und seltener bestehenden Code unnötig umbaut.

Schritt 12: Projects, Automatisierung und Google AI Ultra verstehen

Für größere Vorhaben mit mehreren Repositories bietet der Agent Manager das Konzept “Projects”. Darin lassen sich mehrere Konversationen und Aufgaben bündeln, über mehrere Arbeitsbereiche hinweg verwalten und sogar zeitgesteuert automatisieren, etwa ein nächtlicher Lauf, der offene Pull-Request-Kommentare abarbeitet. Für Soloprojekte lohnt sich der Aufwand selten, ab einem Team mit mehreren aktiven Repositories macht die Struktur aber einen echten Unterschied, weil man nicht mehr jede Mission einzeln im Blick behalten muss.

Ein Projekt anzulegen dauert nur wenige Klicks: im Agent Manager auf “Neues Project” klicken, ein oder mehrere Repositories verknüpfen und optional feste Zeitfenster für automatisierte Läufe festlegen. Danach lassen sich einzelne Missionen einem Project zuordnen, was vor allem bei der Nachverfolgung hilft, wenn später jemand fragt, welcher Agent wann welche Änderung an welchem Repository vorgenommen hat. Für Teams, die mit mehreren Microservices arbeiten, ist das oft der Punkt, an dem sich Antigravity vom reinen Einzelplatz-Werkzeug zu einem festen Bestandteil der Entwicklungsroutine wandelt.

Wer über die kostenlose Stufe hinauswächst, landet früher oder später beim Google-AI-Ultra-Abo. Google hat beim I/O 2026 eine neue, günstigere Einstiegsstufe für 100 US-Dollar pro Monat eingeführt, die fünffach höhere Nutzungslimits in Antigravity bietet als der bisherige AI-Pro-Tarif. Gleichzeitig senkte Google den Preis der bisherigen Spitzenstufe von 250 auf 200 US-Dollar pro Monat, weiterhin mit zwanzigfach höheren Limits gegenüber AI Pro (Google Developers Blog). Für Nutzer in Österreich wird der Betrag über die hinterlegte Zahlungsmethode in Euro verrechnet, der genaue Kurs hängt vom Abrechnungszeitpunkt ab.

Tarif	Preis	Antigravity-Limit vs. AI Pro
Kostenlos (Public Preview)	0 USD	Großzügiges Basislimit für Gemini 3 Pro
Google AI Ultra (Einstieg)	100 USD/Monat	5-fach höhere Nutzungslimits
Google AI Ultra (Top-Tarif)	200 USD/Monat (zuvor 250 USD)	20-fach höhere Nutzungslimits
JetBrains AI Pro (zum Vergleich)	10 USD/Monat	10 KI-Credits pro 30 Tage

Ob sich das Upgrade lohnt, hängt stark vom eigenen Nutzungsmuster ab. Wer Antigravity nur für gelegentliche Skripte oder kleinere Refactorings nutzt, kommt mit der kostenlosen Stufe meist gut aus. Wer täglich mehrere umfangreiche Missionen startet, etwa das Schreiben ganzer Testsuiten oder größerer Feature-Branches, stößt an die Grenzen und merkt das an Warteschlangen oder gedrosselten Modellantworten.

Google Antigravity im Vergleich zu Cursor, Copilot und Claude Code

Antigravity tritt in einem Feld an, das keineswegs leer ist. Wer schon mit Cursor oder Claude Code arbeitet, wird den grundsätzlichen Ansatz wiedererkennen: natürlichsprachige Anweisungen, autonome Codeänderungen, Terminal-Zugriff. Der Unterschied liegt vor allem in der Modellvielfalt und dem Preis. Während Cursor und GitHub Copilot auf Abo-Modelle mit festen monatlichen Gebühren setzen, bleibt Antigravity in der Basisstufe kostenlos und finanziert sich über das optionale AI-Ultra-Abo für Vielnutzer.

Ein weiterer Unterschied betrifft die Offenheit bei der Modellwahl. Cursor und Copilot binden Nutzer stärker an ein Ökosystem, Antigravity erlaubt dagegen den freien Wechsel zwischen Gemini-, Claude- und offenen Modellen innerhalb derselben Oberfläche. Das macht das Tool interessant für Teams, die nicht von einem einzigen Modellanbieter abhängig sein wollen, bringt aber auch mehr Entscheidungsaufwand mit sich, weil man für jede Aufgabe neu abwägen muss, welches Modell am besten passt.

Bei der eigenständigen IDE-Oberfläche unterscheiden sich die Tools ebenfalls spürbar. Cursor baut konsequent auf einem VS-Code-Fork auf und fühlt sich für Umsteiger sofort vertraut an, während Antigravity mit dem Agent Manager, dem Artifacts-Panel und der eingebauten Browser-Vorschau eine eigene Bedienlogik mitbringt, die sich erst einspielen muss. Wer bereits produktiv mit GitHub Copilot in VS Code arbeitet und nur punktuell testen möchte, fährt daher meist besser mit der VS-Code-Erweiterung von Antigravity statt mit einem kompletten Umstieg auf die eigenständige IDE. Wer dagegen von Grund auf mit einem agentenzentrierten Workflow arbeiten will, profitiert stärker von der vollständigen Desktop-App mit allen Panels.

Datenschutz und Sicherheit: Was passiert mit dem eigenen Code?

Wer Code an einen Cloud-Agenten übergibt, gibt zwangsläufig Kontrolle ab, und für Teams in Österreich stellt sich damit sofort die Frage nach Datenschutz und Geschäftsgeheimnissen. Da die Modellberechnung serverseitig läuft, verlässt der Quellcode während einer Mission die eigene Maschine und wird an Googles Infrastruktur übertragen. Für offene Beispielprojekte oder Lernprojekte ist das unproblematisch, bei Code mit Kundendaten, internen API-Schlüsseln oder unveröffentlichten Geschäftsgeheimnissen lohnt sich vorab ein Blick in die aktuellen Nutzungsbedingungen von Google, insbesondere zur Frage, ob und wie lange Eingaben zu Trainingszwecken verwendet werden dürfen.

Ein praktischer Kompromiss, den mehrere Teams in unseren Recherchen beschrieben haben: sensible Repositories grundsätzlich vom autonomen Agent-Modus ausschließen und stattdessen nur mit dem review-gesteuerten Modus arbeiten, bei dem jede Aktion vor der Ausführung sichtbar wird. Zusätzlich hilft es, API-Schlüssel und Zugangsdaten konsequent über Umgebungsvariablen statt direkt im Code zu verwalten, damit ein Agent sie erst gar nicht zu Gesicht bekommt. Wer mit dem quelloffenen GPT-OSS-120B arbeitet, hat je nach Konfiguration zusätzliche Möglichkeiten, die Verarbeitung stärker zu isolieren, auch wenn das in der Praxis mehr Einrichtungsaufwand bedeutet als der Standardpfad mit Gemini 3 Pro.

Für regulierte Branchen wie Finanzdienstleister oder Gesundheitswesen bleibt die nüchterne Empfehlung: vor dem produktiven Einsatz die eigene Rechtsabteilung oder Datenschutzbeauftragte einbinden, statt sich allein auf allgemeine Marketingaussagen zu verlassen. Das gilt im Übrigen für jedes Cloud-basierte KI-Coding-Tool, nicht nur für Antigravity.

Antigravity im Team: Zusammenarbeit und Code-Reviews

Ein einzelner Entwickler kann Agenten-Ausgaben noch relativ leicht im Kopf behalten, in einem Team mit mehreren Personen und mehreren parallel laufenden Missionen wird das schnell unübersichtlich. Deshalb lohnt sich eine klare Absprache, bevor Antigravity im Teamkontext zum Einsatz kommt. Ein bewährtes Muster: Agenten-Missionen laufen ausschließlich auf eigenen Feature-Branches, niemals direkt auf dem Hauptbranch. Erst nach einem klassischen Code-Review durch eine zweite Person wird gemergt, genau wie bei menschlich geschriebenem Code auch.

Die Projects-Funktion im Agent Manager hilft dabei, den Überblick zu behalten, wenn mehrere Teammitglieder gleichzeitig Missionen starten. Wichtig ist, dass Commit-Nachrichten klar kennzeichnen, welche Änderungen von einem Agenten stammen, etwa durch ein Präfix wie “agent:” in der Commit-Message. Das erleichtert es später, bei einem Bug gezielt nachzuvollziehen, ob eine bestimmte Änderung von einem Menschen oder von einem Agenten kam, was bei der Fehlersuche oft den entscheidenden Unterschied macht. Wer bereits Erfahrung mit der Team-Integration von GitHub Copilot hat, wird viele dieser Empfehlungen wiedererkennen, die Grundprinzipien für den verantwortungsvollen Einsatz von KI-Agenten im Team unterscheiden sich zwischen den Anbietern kaum.

Häufige Fehler beim Einstieg

Die folgenden Stolperfallen tauchen in Foren und Support-Kanälen immer wieder auf. Wer sie kennt, spart sich in den ersten Tagen viel Frust.

• Workspace-Konto statt persönlichem Gmail-Konto: Die Anmeldung schlägt fehl oder bleibt hängen, weil Firmenkonten mit Workspace-Verwaltung in der Public Preview noch nicht unterstützt werden. Wer das erst nach mehreren erfolglosen Anmeldeversuchen merkt, verliert unnötig Zeit, ein Blick in die Systemanforderungen am Anfang erspart den Ärger.
• Vager Mission-Text: Wer nur “verbessere den Code” schreibt, bekommt unvorhersehbare Ergebnisse, weil der Agent selbst entscheiden muss, was “besser” in diesem Kontext bedeutet. Konkrete Anforderungen mit klaren Rahmenbedingungen, etwa welche Datei betroffen ist und welches Ziel erreicht werden soll, liefern deutlich verlässlichere Ergebnisse und sparen am Ende auch Kontingent, weil weniger Korrekturrunden nötig sind.
• Direkt in den autonomen Modus wechseln: Ohne Erfahrung mit dem Tool führt der vollautomatische Modus schnell zu unerwünschten Änderungen, die erst spät auffallen, etwa wenn der Agent eine Konfigurationsdatei überschreibt, die man eigentlich unangetastet lassen wollte. Der review-gesteuerte Modus kostet anfangs etwas mehr Zeit, zahlt sich aber in Vertrauen und Nachvollziehbarkeit aus.
• Fehlende Versionskontrolle: Wer ohne aktives Git-Repository arbeitet, kann Agenten-Änderungen nicht rückgängig machen und muss im schlimmsten Fall von Hand rekonstruieren, was verändert wurde. Vor der ersten Mission sollte deshalb immer ein sauberer Commit stehen, damit sich jede Agenten-Änderung im Zweifel per git diff nachvollziehen und bei Bedarf zurücksetzen lässt.
• Alle Aufgaben mit dem teuersten Modell laufen lassen: Gemini 3 Pro für jede Kleinigkeit zu nutzen, verbraucht unnötig Kontingent und ist für simple Aufgaben oft auch spürbar langsamer als nötig. Kleine, klar umrissene Änderungen gehören zu Gemini 3 Flash, das schwerere Refactoring bleibt Gemini 3 Pro vorbehalten.
• Instabile Internetverbindung ignorieren: Da die Modellberechnung serverseitig läuft, brechen Missionen bei Verbindungsabbrüchen ab, oft ohne klare Fehlermeldung im Editor selbst. Wer viel unterwegs arbeitet, sollte größere Missionen eher in stabilen WLAN-Umgebungen starten statt im mobilen Netz mit schwankender Verbindung.
• Kein Blick auf die Kosten des gewählten Modells: Wer zwischen den kostenlosen Modellen und einem AI-Ultra-Abo wechselt, ohne die tatsächliche Nutzung zu beobachten, überschätzt oder unterschätzt schnell den eigenen Bedarf. Ein zweiwöchiger Testzeitraum mit der kostenlosen Stufe zeigt meist zuverlässig, ob ein Upgrade überhaupt nötig ist.

Troubleshooting: Die häufigsten Probleme lösen

Auch bei sorgfältiger Einrichtung tauchen typische Probleme auf. Die folgende Übersicht sammelt die häufigsten Fehlerbilder und passende Lösungsansätze.

• Anmeldung schlägt fehl: Zuerst prüfen, ob wirklich ein persönliches Gmail-Konto verwendet wird und nicht ein Workspace-Konto aus einer Firmen-Domain. Hilft das nicht, den Anwendungscache leeren (unter Windows meist im Ordner %APPDATA%\Antigravity, unter macOS in ~/Library/Application Support/Antigravity) und die Anmeldung neu starten.
• Installation unter Linux bricht ab: Meist fehlen aktuelle glibc- oder glibcxx-Versionen. Mit ldd --version die installierte glibc-Version prüfen und bei Bedarf die Distribution aktualisieren. Auf älteren LTS-Systemen kann das ein größeres Upgrade bedeuten, weshalb sich vorab ein Blick in die Systemanforderungen lohnt.
• Agent bleibt bei “Mission wird geplant” hängen: Zuerst die Internetverbindung prüfen, dann die Anwendung komplett neu starten statt nur den Tab zu schließen. Bleibt das Problem bestehen, lohnt ein Blick auf die Statusseite von Google, gelegentlich kommt es bei hoher Last zu Verzögerungen bei der Agenten-Zuteilung.
• Browser-Vorschau zeigt eine leere Seite: Häufig ein Portkonflikt mit einem bereits laufenden lokalen Entwicklungsserver, etwa wenn parallel noch ein anderes Projekt auf Port 3000 läuft. Einen anderen Port wählen oder den blockierenden Prozess mit dem Terminal-Panel beenden.
• Modellwechsel wird nicht übernommen: Den Editor-Tab schließen und neu öffnen, die Modellauswahl greift bei manchen Versionen erst bei einer neu gestarteten Mission, nicht bei einer bereits laufenden.
• CLI erkennt Anmeldedaten aus der Desktop-App nicht: Die CLI-Anmeldung separat mit antigravity auth login durchführen. Desktop-App und Kommandozeile teilen sich aktuell keine Sitzung automatisch, das ist kein Fehler, sondern der aktuelle Funktionsstand.
• Kontingent trotz kostenloser Stufe schnell erschöpft: Häufig durch mehrere parallel laufende Hintergrund-Agenten verursacht, die man selbst vergessen hat. Im Agent Manager nachsehen, ob noch alte Missionen aktiv sind, und diese bei Bedarf manuell beenden.
• JetBrains-Plugin erscheint nicht im Marketplace: Zuerst die installierte IDE-Version prüfen, ältere JetBrains-Versionen werden vom Antigravity-Plugin teils noch nicht unterstützt. Ein Update der IDE auf die aktuelle Version löst das Problem meist.
• Änderungen des Agenten lassen sich nicht nachvollziehen: Das Artifacts-Panel öffnen, dort werden alle Zwischenschritte, betroffenen Dateien und ausgeführten Befehle protokolliert. Zusätzlich hilft ein Blick in die Git-Historie, da jede Agenten-Änderung normalerweise als eigener Commit erscheint.
• Antigravity reagiert nach einem Systemupdate nicht mehr: Ein vollständiger Neustart der Anwendung inklusive Neuanmeldung behebt die meisten Fälle. Hilft das nicht, die Anwendung deinstallieren und die aktuellste Version neu installieren, da ältere Builds nach größeren Betriebssystem-Updates gelegentlich Kompatibilitätsprobleme zeigen.

Fortgeschrittene Tipps für den produktiven Alltag

Wer über die Grundfunktionen hinaus will, profitiert von ein paar Gewohnheiten erfahrener Nutzer. Erstens: Missionen in kleinere, klar abgegrenzte Aufgaben aufteilen statt einer riesigen Anforderung. Ein Agent, der “baue die komplette Anwendung mit Login, Datenbank und Zahlungsanbindung” bekommt, liefert seltener brauchbare Ergebnisse als einer, der nacheinander drei fokussierte Missionen erhält.

Zweitens lohnt sich der gezielte Einsatz der Projects-Funktion für wiederkehrende Wartungsaufgaben, etwa das wöchentliche Aktualisieren von Abhängigkeiten oder das Beheben von Linter-Warnungen. Drittens: Die Kombination aus CLI und Desktop-App macht Sinn, wenn man lange laufende Hintergrund-Agenten über die Kommandozeile startet, während man selbst in der grafischen Oberfläche an etwas anderem arbeitet. Und viertens, vielleicht der wichtigste Tipp: Jede automatisch erzeugte Änderung vor dem Merge selbst lesen, gerade bei sicherheitsrelevantem Code wie Authentifizierung oder Datenbankzugriffen. Die 46 Prozent an Entwicklerinnen und Entwicklern, die laut Stack Overflow der Genauigkeit von KI-Ausgaben skeptisch gegenüberstehen, liegen damit nicht falsch, ein Review-Schritt bleibt sinnvoll, egal wie gut das Modell im Einzelfall abschneidet.

Fünftens lohnt sich ein bewusster Umgang mit dem Kontextfenster der verwendeten Modelle. Gemini-Modelle können sehr große Codebasen auf einmal einlesen, was praktisch klingt, in der Praxis aber dazu verleitet, dem Agenten ganze Repositories ungefiltert vorzuwerfen. Bessere Ergebnisse liefert es meist, den Agenten gezielt auf die relevanten Verzeichnisse oder Dateien hinzuweisen, statt ihn das gesamte Projekt selbst durchsuchen zu lassen, das spart Zeit und reduziert das Risiko, dass er an der falschen Stelle Änderungen vorschlägt.

Für den Einstieg in strukturierte Lernpfade bietet Google zudem ein offizielles Codelab an, das einzelne Funktionen Schritt für Schritt erklärt (Google Codelabs: Getting Started with Antigravity). Das eignet sich gut als Ergänzung, wenn man einzelne Funktionen wie die Projects-Automatisierung noch vertiefen möchte.

Häufig gestellte Fragen

Ist Google Antigravity komplett kostenlos?
Für Einzelpersonen ist die Basisstufe kostenlos, mit großzügigen, aber begrenzten Nutzungslimits für Gemini 3 Pro. Wer mehr Kapazität braucht, kann auf das kostenpflichtige Google-AI-Ultra-Abo ab 100 US-Dollar pro Monat upgraden.

Funktioniert Antigravity mit einem Firmen-Google-Konto?
Aktuell nicht zuverlässig. Die Public Preview unterstützt nur persönliche Gmail-Konten, Google-Workspace-Konten sind noch ausgeschlossen.

Ist Google Antigravity ein VS-Code-Fork?
Die eigenständige IDE basiert auf ähnlichen Grundlagen wie VS Code, lässt sich aber auch als Erweiterung direkt in VS Code oder JetBrains-Produkten installieren, ohne die gewohnte Umgebung zu wechseln.

Welche KI-Modelle stehen zur Auswahl?
Standardmäßig Gemini 3 Pro und Gemini 3 Flash, dazu Anthropics Claude Sonnet 4.6 und das offene GPT-OSS-120B. Das Modell lässt sich pro Mission wechseln.

Braucht man die Antigravity CLI zwingend?
Nein. Sie ist optional und richtet sich vor allem an Entwicklerinnen und Entwickler, die viel im Terminal arbeiten oder Agenten in CI-Pipelines einbinden wollen. Die Desktop-App und die IDE-Erweiterungen funktionieren vollständig ohne CLI.

Läuft Antigravity auch offline?
Nein. Die Modellberechnung findet serverseitig statt, eine dauerhafte Internetverbindung ist zwingend erforderlich.

Wie unterscheidet sich Antigravity von Cursor oder GitHub Copilot?
Antigravity setzt stärker auf eigenständig arbeitende Agenten statt reiner Codevervollständigung, bietet eine kostenlose Basisstufe und lässt Nutzer frei zwischen mehreren Modellanbietern wechseln, statt an ein einziges Ökosystem gebunden zu sein.

Was passiert, wenn das kostenlose Kontingent aufgebraucht ist?
Antigravity drosselt die Antwortgeschwindigkeit oder schaltet vorübergehend auf ein kleineres Modell um, bis das Kontingent zurückgesetzt wird oder man auf ein kostenpflichtiges Abo wechselt.

Kann man Antigravity und GitHub Copilot gleichzeitig nutzen?
Ja, beide lassen sich parallel als VS-Code-Erweiterungen betreiben. Sinnvoll ist das vor allem zum Vergleichen, im produktiven Alltag sollte man sich aber meist für ein Haupttool entscheiden, um überlappende Vorschläge und doppelte Kosten zu vermeiden.

Eignet sich Antigravity für Einsteiger ohne Programmiererfahrung?
Bedingt. Die Agenten übernehmen zwar viel Schreibarbeit, doch ohne Grundverständnis von Code lässt sich kaum beurteilen, ob eine Änderung sinnvoll ist oder Fehler enthält. Für erste Lernprojekte eignet sich der review-gesteuerte Modus, weil er jeden Schritt einzeln nachvollziehbar macht.