Google Antigravity CLI Tutorial: Parallele KI-Agenten orchestrieren

Neu in agentischer KI? Unser AI Agent Fundamentals-Lernpfad gibt dir vorab ein solides Fundament.

Was ist neu in Google Antigravity 2.0?

Die Google I/O 2026 markierte eine deutliche Erweiterung der Antigravity-Plattform. Es ist nicht mehr nur ein Tool, sondern ein ganzes Ökosystem. Das wurde gelauncht:

Antigravity 2.0 Desktop-App

Anders als das ursprüngliche Antigravity-IDE (das für Entwickler weiterhin verfügbar bleibt), ist Antigravity 2.0 von Grund auf agent-first gebaut. Es bietet eine aufgeräumte Oberfläche, um mit Agenten zu interagieren, Projekte zu verwalten und Artefakte zu prüfen. Verfügbar für macOS, Linux und Windows.

Wichtige neue Funktionen:

• Dynamische Subagenten: Der Hauptagent kann spontan spezialisierte Subagenten definieren und starten, die fokussierte Teilaufgaben parallel bearbeiten – ohne sein eigenes Kontextfenster zu überfrachten.

• Asynchrones Aufgabenmanagement: Laufzeitintensive Prozesse laufen im Hintergrund, sodass weder der Hauptagent noch die UI blockiert werden.

• Projekte: Agenten werden nach „Projekten“ statt nach Repository organisiert. Ein Projekt kann mehrere lokale Ordner mit eigenen Berechtigungsbereichen umfassen.

• Geplante Aufgaben: Nutzer können Cron-ähnliche Zeitpläne definieren, die Agenten automatisch starten – etwa tägliche Zusammenfassungen, stündliche Health-Checks oder monatliche Reports – ganz ohne manuelles Anstoßen.

• JSON-Hooks: Diese greifen in definierte Lebenszyklusphasen ein (vor einem Tool-Call, nach einem Modell-Call, bei Abbruchbedingungen von Loops) und passen das Verhalten der Agenten über einfache JSON-Konfigs an.

• Live-Spracherkennung: Das Mikrofon transkribiert jetzt in Echtzeit mit Gemini Audio-Modellen und verwandelt freie Sprache in klare, versandfertige Prompts.

• Slash-Commands: 

• /goal: Läuft autonom bis zum Abschluss

•  /grill-me: Der Agent stellt zuerst Rückfragen zur Klärung

• /schedule: Einmalige oder wiederkehrende Ausführung

• /browser: Ermöglicht explizites Opt-in für den Browser

Antigravity CLI

Für terminalaffine Entwickler und Automatisierungs-Workflows liefert die Antigravity CLI (aufgerufen als agy) dasselbe Agentengerüst in einer schlanken, skriptfähigen Oberfläche. 

Sie ist die Nachfolgerin der Gemini CLI, und sie ist das Werkzeug, das wir in diesem Tutorial verwenden. Du zeigst auf deine Daten, beschreibst dein Ziel in einfachem Englisch, und der Rest läuft automatisch – inklusive der Entscheidung, wie die Aufgabe in Subagenten zerlegt wird. Keine Orchestrierungsskripte, keine Konfigdateien, keine manuell definierten Subagenten.

Antigravity SDK

Das Antigravity SDK bietet programmatischen Zugriff auf dasselbe Agentengerüst, das auch Googles eigene Produkte antreibt. Es ist für Gemini-Modelle optimiert und ermöglicht dir, benutzerdefinierte Agentenverhalten zu definieren und auf deiner eigenen Infrastruktur zu hosten.

Managed Agents in der Gemini API

Die entwicklerfreundlichste Neuerung der Gemini API sind die Managed Agents. Mit einem einzigen API-Call startest du einen Agenten, der begründet, Tools nutzt und Code in einer persistenten, isolierten Linux-Umgebung ausführt. 

Jede Interaktion lässt sich in späteren Aufrufen mit vollständigen Dateien und Zuständen fortsetzen. Diese Funktion basiert auf dem Antigravity-Agentengerüst und dem neuen Gemini 3.5 Flash, das 4× schneller als andere Frontier-Modelle läuft und Gemini 3.1 Pro in fast allen Benchmarks übertrifft.

Google AI Studio-Integrationen

Zum größeren Ökosystem gehören außerdem eine neue Google AI Studio Mobile-App, native Google Workspace API-Integration für Agenten, Export per Klick nach Antigravity aus AI Studio-Projekten sowie native Android-App-Unterstützung inklusive direkter Veröffentlichung in der Google Play Console.

In Summe markiert dieses Ökosystem den Wechsel von Single-Turn-Prompting zu Always-on-Agenten – und die Subagenten-Architektur im Kern von Antigravity 2.0 ist der Motor, der das ermöglicht.

Dynamische Subagenten in Antigravity 2.0 verstehen

In einem Single-Agent-Setup übernimmt ein Agent alles nacheinander: erst bereinigen, dann analysieren, schließlich visualisieren. Das bringt zwei Probleme mit sich: Erstens dauert es länger, weil jeder Schritt auf den vorherigen wartet. Zweitens füllt sich das Kontextfenster des Agenten mit der kompletten Historie, was die Qualität des Schlussfolgerns in späteren Aufgaben beeinträchtigen kann.

Subagenten lösen beide Probleme. Der Orchestrator-Agent erhält dein übergeordnetes Ziel und entscheidet, wie er es in Teilaufgaben zerlegt. Dann definiert und startet er Subagenten, die jeweils eine Aufgabe in einem eigenen, isolierten Kontextfenster bearbeiten – parallel. Nach Abschluss fasst der Orchestrator die Ergebnisse zu einem finalen Output zusammen.

So kannst du es dir vorstellen:

Your prompt → Orchestrator Agent
                ├── reads & profiles the dataset
                ├── defines subagent roles autonomously
                ├── spawns data_cleaner           ──┐
                ├── spawns data_analyzer          ──┤ (parallel, once clean data is ready)
                └── spawns data_visualizer        ──┘
                         ↓ (all finish)
                Orchestrator: assembles → sales_report.html

Das Entscheidende: Du definierst die Subagenten nicht selbst. Der Orchestrator der CLI versteht die Aufgabe und entscheidet über die Zerlegung. Du lieferst nur Daten und Ziel.

Antigravity 2.0 Demo: Automatisiertes Sales-Dashboard mit einem einzigen CLI-Prompt

In diesem Abschnitt nehmen wir eine rohe CSV mit monatlichen (Dummy-)Umsätzen und erzeugen ein vollständiges interaktives HTML-Dashboard – ohne eine Zeile Code zu schreiben oder Subagenten manuell zu definieren.

Schritt 1: Antigravity CLI installieren

Starte mit der Installation der Antigravity CLI per Bash-Befehl. Die Antigravity CLI ist für mehrere Betriebssysteme verfügbar, darunter:

macOS und Linux

curl -fsSL https://antigravity.google/cli/install.sh | bash

Windows PowerShell

irm https://antigravity.google/cli/install.ps1 | iex

Windows CMD

curl -fsSL https://antigravity.google/cli/install.cmd -o install.cmd && install.cmd && del install.cmd

Schritt 2: Mit einem Google-Konto oder GCP-Projekt authentifizieren

Nach der Installation startest du Antigravity mit folgendem Befehl im Terminal:

agy

Anschließend authentifizierst du dich mit einem Google-Konto oder einem GCP-Projekt. Du erhältst einen Secret Key, den du im laufenden Antigravity-Terminal eingibst – damit ist die Anmeldung abgeschlossen.

Danach passt du optional dein Terminal-Theme an, erteilst Zugriff auf die benötigten Dateien – und schon kann es losgehen.

Die CLI identifiziert sich als Antigravity CLI 1.0.0 und verbindet standardmäßig mit Gemini 3.5 Flash (High).

Schritt 3: Projektordner vorbereiten

Du kannst diesen Schritt selbst ausführen oder die Antigravity CLI für dich arbeiten lassen:

mkdir AntigravityDemo
cd AntigravityDemo

Das ist dein komplettes Projekt-Setup. Keine Unterordner, keine Konfigdateien, keine Agentendefinitionen nötig.

Schritt 4: Dataset hinzufügen

Speichere die folgenden Dummy-Daten als sales_raw.csv direkt im Ordner AntigravityDemo – oder nutze eigene Daten. Die Datei enthält bewusst realistische Datenqualitätsprobleme wie fehlende Werte und einen $999,999-Ausreißerplatzhalter, damit die Subagenten etwas Sinnvolles zu tun haben.

month,product,region,revenue,units_sold
2024-01,Laptop Pro,North,45200,38
2024-01,Wireless Earbuds,South,12300,205
2024-01,Mechanical Keyboard,East,8900,89
2024-02,Laptop Pro,North,47800,40
2024-02,Wireless Earbuds,South,,198
2024-02,Mechanical Keyboard,East,9100,91
2024-03,Laptop Pro,North,51200,43
2024-03,Wireless Earbuds,South,13100,218
2024-03,Mechanical Keyboard,East,,
2024-04,Laptop Pro,North,999999,42
2024-04,Wireless Earbuds,South,13800,230
2024-04,Mechanical Keyboard,East,9600,96
2024-05,Laptop Pro,North,55100,46
2024-05,Wireless Earbuds,South,14200,237
2024-05,Mechanical Keyboard,East,10100,101
2024-06,Laptop Pro,North,57300,48
2024-06,Wireless Earbuds,South,14900,248
2024-06,Mechanical Keyboard,East,10500,105

Sobald die CSV im Arbeitsverzeichnis liegt, können wir in der CLI loslegen.

Schritt 5: CLI mit dem Befehl /goal ausführen

Mit vorbereitetem Arbeitsordner und dem Dataset sales_raw.csv startest du jetzt den Orchestrator der Antigravity CLI für den gesamten Analyse-Workflow. Öffne ein Terminal und führe aus: 

agy

Als Nächstes bitten wir Gemini, unsere Daten zu bereinigen, zu analysieren und zu visualisieren:

/goal I have a sales dataset at /Users/yourname/Desktop/AntigravityDemo/sales_raw.csv.
Spin up multiple subagents to clean, analyze, and visualize it.
Produce a final HTML report and save all outputs in this folder.

Das Präfix /goal ist wichtig, weil die CLI damit die gesamte Aufgabe bis zum Ende durchführt, ohne zwischendurch um Freigaben oder Bestätigungen zu bitten. Ohne /goal hält der Agent an und fragt vor jedem größeren Schritt: „Möchtest du fortfahren?“ 

Der autonome Ablauf startet sofort durch den Orchestrator. Hier sind fünf detaillierte Phasen – von der Profilierung bis zur finalen Zusammenführung:

Phase 1: Umgebungsprofilierung

Der Orchestrator hat zunächst die Umgebung geprüft, noch bevor eine Zeile Code geschrieben wurde:

ListPermissions  (confirmed read and write access to the workspace)
ListDir          (/Users/aashidutt/Desktop/AntigravityDemo)
Read             (sales_raw.csv)
Thought for 3s, 1.5k tokens — Analyzing Data Quality Issues
Bash             (python3 --version)
Bash             (python3 -c "import pandas, matplotlib, seaborn...")
Thought for 4s, 463 tokens — Initiating Implementation Planning

Er listete Berechtigungen auf, las das Verzeichnis, lud die CSV, prüfte die verfügbare Python-Version und verifizierte die nötigen Bibliotheken – alles, bevor die Planung begann. Diese Vorab-Profilierung ermöglicht fundierte Entscheidungen über Subagentenrollen statt Blindplanung.

Hinweis zur Berechtigungsabfrage: Auch mit /goal bat die CLI einmalig um Freigabe, bevor Bash-Befehle ausgeführt wurden. Das ist Antigravitys Human-in-the-Loop-Sicherheitsmodell: Du gibst eine Klasse von Operationen einmal frei – danach wird nicht erneut gefragt. Eine bewusste Designentscheidung, damit Automatisierung nicht zur Blackbox wird, besonders in produktiven Umgebungen.

Phase 2: Planung und Definition der Subagenten

Der Orchestrator erstellte anschließend einen internen Umsetzungsplan und definierte drei Subagenten:

Create          (implementation_plan.md → written to ~/.gemini/ant.../  scratch folder)
DefineSubagent  ("data_cleaner" defined successfully)
DefineSubagent  ("data_analyzer" defined successfully)
DefineSubagent  ("data_visualizer" defined successfully)

Die Datei implementation_plan.md wird in ein internes .gemini-Scratch-Verzeichnis geschrieben, nicht in deinen Projektordner. Es ist das eigene Planungsartefakt der CLI – du musst es weder lesen noch verwalten. Wenn du /goal nutzt, wird es automatisch freigegeben und die Ausführung läuft direkt weiter.

Die drei Subagenten-Namen data_cleaner, data_analyzer und data_visualizer wurden vollständig aus deiner Zielbeschreibung abgeleitet.

Phase 3: data_cleaner läuft

Der erste Subagent kümmerte sich um Datenqualitätsprobleme: Er imputete die zwei fehlenden revenue-Werte und den fehlenden Wert bei units_sold über Produktmediane, identifizierte den $999,999-Eintrag für April/Laptop Pro als Systemplatzhalter (wie erwartet) und ersetzte ihn durch $50.106 (Median-Stückpreis $1.193 × 42 Einheiten). So wurden statistische Verzerrungen behoben, bevor die bereinigten Daten weitergegeben wurden.

Phase 4: data_analyzer und data_visualizer laufen parallel

Sobald sales_clean.csv vorlag, startete der Orchestrator beide verbleibenden Subagenten gleichzeitig. Der Analyzer berechnete MoM-Wachstumsraten, Produktaufschlüsselungen und Regionssummen und speicherte sie in analysis_summary.json, während der Visualizer parallel drei Diagramm-PNGs erzeugte. Der Orchestrator überwachte beide und meldete den Status in Echtzeit.

Hinweis: Wenn du aufgefordert wirst, den Umsetzungsplan oder ein Artefakt zu prüfen, kannst du mit /artifact den Artefaktordner öffnen und den Inhalt ansehen – oder du vertraust dem Modell und lässt es direkt laufen.

Phase 5: Finale Zusammenführung

Nach Abschluss aller Subagenten investierte der Orchestrator 12 Sekunden in gezieltes Reasoning, prüfte die Vollständigkeit der Dateien und setzte dann das finale Dashboard zusammen. Ergebnis war eine vollständig eigenständige HTML-Datei ohne externe Abhängigkeiten.

Das generierte Dashboard ist keine statische Seite, sondern eine interaktive Oberfläche in Produktionsqualität. Highlights:

• Dunkles, glasartiges Theme mit blauem Akzent und klarer Typografie
• Vier KPI-Kacheln: Gesamtumsatz ($444.389), Gesamtverkaufte Einheiten (2.168), Top-Produkt (Laptop Pro, 69,0 % Anteil) und Top-Region (North)
• Drei umschaltbare Tabs:
• Übersicht und Trends: Monatliches Umsatzliniendiagramm und MoM-Tabelle mit farbcodierten Wachstumsraten (grün positiv, rot negativ)
• Produkt- und Regions-Insights: Donut-Chart nach Region sowie detaillierte Produkt/Region-Tabelle mit Stückpreisen und Umsatzanteilen
• Bereinigtes Dataset: Ein Tab mit vollständiger bereinigter Datentabelle inkl. Live-Suche, Spaltenfiltern und sortierbaren Headern
• Download-Buttons oben rechts für die bereinigte CSV und die Analyse-JSON
• Abschnitt mit Datenqualitäts- und Business-Notizen unten, der exakt erklärt, was bereinigt wurde.

Fazit

In diesem Tutorial haben wir in unter fünf Minuten eine komplette Multi-Agent-Datenpipeline mit der Antigravity CLI ausgeführt. Der Orchestrator profilierte die rohe CSV, definierte drei Subagenten autonom, ließ zwei davon parallel laufen, sobald die bereinigten Daten vorlagen, und erzeugte einen vollständig eigenständigen HTML-Report mit Tabs, KPI-Karten und sortierbaren Tabellen.

Die Subagenten-Architektur ist nicht nur ein Performance-Boost, sondern ein Designmuster, das dem realen Ablauf komplexer Analysearbeit entspricht: Spezialisierte Agenten arbeiten parallel dort, wo sie am stärksten sind – und ein Orchestrator setzt die Ergebnisse zusammen. Dasselbe Muster skaliert weit über Datenanalyse hinaus – etwa für Dokumentenverarbeitung, Code-Review-Pipelines, Research-Synthesen und mehr.

Wenn du weitergehen willst, hier ein paar Ideen:

• Automatisiere mit geplanten Aufgaben, indem du in der Antigravity 2.0 Desktop-App den Befehl /schedule in deinen Prompt einfügst. Die Pipeline läuft dann gemäß Zeitplan automatisch mit der jeweils aktualisierten CSV.
• Nutze /grill-me für mehr Kontrolle, wenn die CLI vor dem Start Rückfragen stellen soll. Setze dafür /grill-me an den Anfang statt /goal.
• Bette sie über die Managed Agents API ein, wenn die Pipeline in eine Webanwendung soll. Die Gemini API liefert dieselben Subagenten-Fähigkeiten mit einem einzigen API-Call. Da jeder Agent in einer persistenten, isolierten Linux-Umgebung läuft, kannst du Sitzungen fortsetzen.
• Mit der Workspace-Integration von Antigravity kann dein Orchestrator den finalen Report direkt in Google Docs schreiben oder per Gmail verteilen – einfach im Ziel-Prompt erwähnen, und der Agent übernimmt die API-Calls.