Gemini und Argon 4 mit Council-Architektur in Google Antigravity: Wie wir die Fähigkeiten verteilt haben

Zusammenfassung: Ein sehr leistungsfähiges KI-Modell in einem einzigen Chatfenster gleichzeitig als Rechercheur, der Hunderte von Dateien durchsucht, als Entwickler, der Code schreibt, als Testläufer und als Sicherheitsprüfer laufen zu lassen, senkt ab einem bestimmten Punkt die Effizienz. Je mehr sich das Kontextfenster mit Rohausgaben füllt, desto mehr lässt die Aufmerksamkeit des Modells nach, die anfänglichen Regeln geraten in Vergessenheit und die Token-Kosten steigen unnötig. In diesem Beitrag erkläre ich zunächst, warum wir das Modell Gemini 4 Argon auf Google Antigravity nicht als einzeln arbeitenden Ausführenden, sondern als Orchesterdirigent und letzte Kontrollinstanz positioniert haben, dann, wie wir unseren 12-köpfigen Rat aufgebaut haben, und wie wir 19 Erweiterungen, über 300 SKILL.md-Fähigkeitspakete und mehr als 45 MCP-Server nach Aufgabenbereichen aufgeteilt haben. Im letzten Abschnitt habe ich praktische Empfehlungen zusammengestellt, die sich direkt umsetzen lassen, wenn man Argon 4 in den eigenen Arbeitsabläufen effizienter nutzen möchte.

Warum stockt es, wenn man einem einzigen Modell jede Aufgabe aufbürdet?

In der täglichen Softwareentwicklung scheint es zunächst einfach, ein Modell mit hoher Denkfähigkeit wie Gemini 4 Argon zu öffnen und das gesamte Projekt in einer einzigen Sitzung erledigen zu lassen. Doch je größer die Aufgabe wird, desto deutlicher treten drei konkrete Probleme hervor:

Verschmutzung des Kontextfensters: Wenn man 30-40 verschiedene Dateien lesen lässt, um einen Fehler zu finden oder eine neue Funktion hinzuzufügen, und Build-Ausgaben sowie Fehlerprotokolle in denselben Chat stapelt, füllt sich der Arbeitsbereich (Kontext) des Modells mit Rauschen. Dieser in der Forschungsliteratur als Lost in the Middle (Verloren in der Mitte) bekannte Zustand führt dazu, dass das Modell die anfangs vorgegebenen Architekturregeln oder Sicherheitsbeschränkungen übersieht.
Für jede Aufgabe ein Modell gleichen Gewichts aufwenden: Ein mechanisches Umbenennen über viele Dateien, ein routinemäßiger Unit-Test oder eine einfache Aktualisierung einer Abhängigkeit mit dem leistungsfähigsten Denkmodell und einem riesigen Kontext wiederholt laufen zu lassen, verlängert sowohl die Dauer als auch verschwendet das Token-Budget.
Betriebsblindheit beim Prüfen des selbst geschriebenen Codes: Wenn das Modell, das den Code schreibt, und das Modell, das diesen Code prüft, denselben Chatverlauf teilen, neigt das Modell dazu, eine fehlerhafte Annahme aus der Schreibphase auch in der Prüfphase als richtig anzuerkennen.

Um diesen Engpass zu überwinden, haben wir unsere Arbeitsweise in Antigravity geändert. Wir haben Argon 4 von einem einzelnen Agenten, der jede Zeile selbst schreibt, zu einem Ratsvorsitzenden gemacht, der spezialisierte Werkzeuge und Untermodelle steuert.

Welche Modelle sitzen im Rat und wie haben wir die Rollen aufgeteilt?

In unserem System gibt es eine deklarative Aufgabenebene (ax.io/v1alpha1), die unter /home/ozdil/Projects/SubAgents/ax läuft. Wenn wir "konsey ile yap" sagen, laufen keine zufälligen Skripte; es treten 12 Ratsmitglieder in Aktion, von denen jedes seine eigene Binärdatei und eine abgegrenzte Aufgabendefinition hat:

Ratsmitglied	Arbeitswerkzeug	Übernommene Kernaufgabe
Antigravity (Gemini 4 Argon)	`antigravity-chief`	Orchesterdirigent, multimodale Recherche, Koordination von Erweiterungen/Fähigkeiten/MCP und abschließende Kontrolle der Phase 7 im Fullstack
Claude Code	`claude` (v2.1.302)	Systemarchitektur-Design, Cloud-Lösungsvorlagen, SecOps, IAM, WAF und HANCORE-Sicherheitsprüfung
J-Code Harness	`jcode` (v0.98.1)	Hochleistungsfähige Rust-Agent-Ausführung, Rust-Migrationen (`migrate-to-rust`), C/Rust-FFI-Bindings und Genkit-Aufbau (Go/Dart)
OpenAI Codex CLI	`codex` (v0.163.0)	Isolierte Sandbox-Ausführung auf Kernelebene, algorithmische Verifikation, Unit-/Komponententests und wissenschaftliche Berechnungen
Google Gemini CLI	`gemini-cli` (v0.64.0)	Lokales Durchsuchen von Coderepos mit langem Kontext von über 1 Mio. Token, Agent Platform, Cloud Run, AlloyDB/Spanner und Firebase-Integration
OpenCode	`opencode` (v1.19.3)	Statische Analyse auf Basis des Language Server Protocol (LSP) und moderne Flutter/Android-Oberflächenarchitektur (Jetpack Compose, CameraX, Media3, LiteRT)
Cline	`cline` (v3.0.72)	Autonome Aufgabenausführung, moderne Web- und Chrome-Erweiterungen, Performance-/Barrierefreiheitsanalyse mit Chrome DevTools MCP und Cloudflare-Integration
Grok	`grok` (v1.0.62)	Hochgeschwindigkeits-algorithmisches Denken, GKE und KI/TPU-Cluster-Infrastruktur, Cloud Monitoring/Logging/Trace und SLO/FinOps
Qwen Code	`qwen` (v0.25.2)	Data Agent Kit (10 DAK MCP-Server), BigQuery/Spark/Dataflow/Airflow-Pipelines, Bioinformatik (41 wissenschaftliche Fähigkeiten) und Lokalisierung
Mimo Code	`mimo` (v0.1.15)	Schnelles isoliertes Prototyping, Aufbau von Mikromodulen, Vorschauen von Oberflächenkomponenten und Integration von Mobile-Ad-/Media-SDKs
Aider	`aider` (v0.86.2)	Präzise Diff-Verwaltung über mehrere Dateien, Versions-Upgrades (AGP 9, Compose-Migrationen) und Zusammenführen von Patches
Jev Gate	`jev-gate` (v0.7.0)	Deterministisches Qualitätstor (Akzeptanzschwelle `0.85`), R8/Proguard-Analyse, Einhaltung der Store-Richtlinien und Prüfung der Quellenangaben

Die integrierten spezialisierten Subagents von Antigravity

Zusätzlich zu diesem 12-köpfigen Rat kann Gemini 4 Argon in seiner internen Laufzeit mit dem Werkzeug invoke_subagent direkt 5 integrierte Subagents starten. Der größte Vorteil dieser Subagents besteht darin, dass sie in ihrem eigenen isolierten Kontext arbeiten und nur das Ergebnis an Argon zurückgeben, ohne das Hauptchatfenster aufzublähen:

research: Ein reiner Lese-Recherche-Agent. Wenn im Coderepository Dutzende Dateien durchsucht werden müssen oder Web-/Dokumentationsrecherche erforderlich ist, übertragen wir die Arbeit an diesen Agenten. Die Hauptsitzung von Argon wird nicht mit hunderten Zeilen roher Dateiinhalte verunreinigt.
self: Ein Zwillingsagent, der alle Fähigkeiten von Argon erbt. Wenn zwei voneinander unabhängige Aufgaben parallel ausgeführt werden müssen, arbeitet er in einem separaten Arbeitsbereichszweig (branch oder share) und erledigt seine Arbeit.
firestore-rules-author: Der obligatorische spezialisierte Subagent, den wir zum Schreiben und Prüfen von Cloud Firestore-Sicherheitsregeln (firestore.rules) verwenden.
flutter_a11y_agent: Ein spezialisierter Agent, der Flutter-Bildschirme und -Komponenten nach den WCAG-Barrierefreiheitsstandards prüft.
image-generator: Ein Bildgenerierungsagent, der zum Einsatz kommt, wenn Oberflächenbilder oder Design-Assets benötigt werden.

Wie haben wir 19 Plugins, über 300 Fähigkeitspakete und über 45 MCP-Server verteilt?

In unserer Antigravity-Umgebung gibt es 19 installierte Plugins, darunter über 300 SKILL.md-Fähigkeitsanleitungen und über 45 MCP-Server (Model Context Protocol). Wenn Sie all diese Fähigkeitsdateien und MCP-Werkzeugschemata gleichzeitig in den Startkontext von Argon 4 laden, haben Sie einen großen Teil des Kontextbudgets verbraucht, bevor Sie auch nur eine einzige Zeile Code geschrieben haben.

Um dies zu lösen, haben wir einen zweistufigen Verteilungsmechanismus eingerichtet: die Domänen-Fähigkeits-Zuordnungsmatrix (DOMAIN_SKILL_MATRIX) und die Eager/Lazy-MCP-Trennung.

1. Domänen-Fähigkeits-Zuordnungsmatrix (`DOMAIN_SKILL_MATRIX`)

Wenn ax-run ausgeführt wird, analysiert es die Schlüsselwörter der eingehenden Anfrage und das Zielprojektverzeichnis und ordnet die Arbeit den relevanten von 12 Ingenieursdomänen zu. Nur die Agenten, Plugins, SKILL.md-Pakete und MCP-Server der ausgewählten Domäne werden aktiviert:

Aufgabenbereich	Beim Abgleich aktivierte Plugins	Hervorgehobene Fähigkeiten (`SKILL.md`) und MCP-Tools
`flutter-dart`	`flutter`, `firebase`, `google-skills-catalog`	`flutter-apply-architecture-best-practices`, `dart-use-ffigen`, `dart-run-static-analysis`, `firebase-mcp-server`
`android-kotlin-devices`	`android-skills`, `android-cli-plugin`	`jetpack-compose-performance`, `navigation-3`, `litert-runtime`, `r8-analyzer`, `android-management-api`
`web-modern-extensions`	`modern-web-guidance-plugin`, `chrome-devtools-plugin`	`modern-web-guidance`, `a11y-debugging`, `debug-optimize-lcp`, `chrome-devtools-mcp`, `cloudflare-*`
`firebase-serverless`	`firebase`, `google-skills-catalog`	`firebase-data-connect`, `firestore-rules-creation`, `firebase-security-rules-auditor`, `cloudrun`
`agent-platform-gemini-genkit`	`google-antigravity-sdk`, `gemini-api`, `google-cloud-developer`	`google-antigravity-sdk`, `gemini-interactions-api`, `developing-genkit-go`, `gemini-api-docs`
`gke-ai-tpu-cloud-infra`	`google-skills-catalog`, `google-cloud-developer`	`gke-golden-path`, `gke-compute-classes`, `gke-ai-troubleshooting-tpu-*`, `google-kubernetes-engine`
`data-bigquery-lakehouse-spark`	`data-agent-kit-plugin`, `google-skills-catalog`	`bigquery-sql`, `bigquery-ai-ml`, `dbt-bigquery`, `gcp-spark`, `dak-bigquery`, `dak-gcs`
`secops-iam-waf-hancore`	`google-skills-catalog`, `firebase`, `android-skills`	`google-cloud-waf-security`, `secops-hunt`, `iam-helper-*`, `google-cloud-organization-policy`
`observability-sre-finops`	`google-skills-catalog`	`cloud-monitoring-promql-query`, `google-cloud-slo-alert-configuration`, `google-cloud-monitoring`
`science-bioinformatics-epigraphy`	`science`	`alphafold-database-fetch-and-analyze`, `alphagenome-variant-impact-score`, `predictingthepast`, `biomolecular_structure_viewer_mcp`
`workspace-maps-ads-media`	`gslides`, `gdocs`, `gsheets`, `gdrive`, `gcalendar`, `google_maps_platform`	`gslides`, `google-maps-platform`, `google-ads-api-mcp-setup`, `canva`, `gmp-code-assist`
`systems-rust-omarchy`	`google-skills-catalog`, `flutter`	`migrate-to-rust`, `dart-use-ffigen`, `agy-customizations`, `github-mcp-server`

2. Eager- (direkt) und Lazy- (bei Bedarf) MCP-Laden

Jeder der über 45 MCP-Server enthält Dutzende Untertools. Statt sie alle in den Kontext zu laden, haben wir sie in zwei Gruppen aufgeteilt:

Direkt geladene (Eager) Tools: Die häufig genutzten Tools gemini_search_docs und gemini_get_doc (gemini-api_gemini-api-docs) sind direkt als lokale Tools registriert. Argon 4 kann sofort auf die aktuellen Gemini-API- und SDK-Dokumente zugreifen.
Bei Bedarf geladene (Lazy) Tools: Über 40 Server wie chrome-devtools-mcp, cloudflare-bindings, data-agent-kit-plugin_dak-bigquery, google-kubernetes-engine oder canva liegen beim Start nur als Namensliste vor. Wenn Argon 4 eines dieser Tools verwendet, liest es zuerst die Schemadatei /home/ozdil/.gemini/antigravity/mcp/<sunucu>/<arac>.json und führt dann den Aufruf mit call_mcp_tool aus. Diese Struktur spart im anfänglichen Kontextfenster etwa 88 Prozent Token.

7-stufige Ausführungspipeline: Wie funktioniert die Sandwich-Orchestrierung?

Die wichtigste Designentscheidung des Konzepts war, das Modell Gemini 4 Argon sowohl an den Anfang als auch an das Ende des Prozesses zu setzen. Wir können das kurz Sandwich-Orchestrierung (Bookend Verification) nennen. Die 7 Stufen in unserer Datei tasks/pipeline.yaml laufen der Reihe nach so ab:

Erkundung und Aktivierung (1-discovery-plugins-skills-and-mcp): Den ersten Schritt leitet Gemini 4 Argon. Mit gemini-cli (1M+ Kontext) und dem research-Subagenten durchsucht es das Code-Repository und bestimmt über ax-run, welche Plugins, SKILL.md und MCP-Server verwendet werden.
Architektur und Lösungsdesign (2-architecture-and-solution-design): Unter der Leitung von claude-architect werden das Systemdiagramm, die Datentypen und die Sicherheitsregeln (in Begleitung von firestore-rules-author) erstellt.
Code-, Daten- und MCP-Ausführung (3-code-data-and-mcp-implementation): jcode (Rust/FFI), codex (Algorithmus), opencode (Mobil/Oberfläche), cline (modernes Web) und qwen (Daten/Wissenschaft) schreiben die Module in ihren jeweiligen Fachgebieten und führen die MCP-Tools aus.
Mehrdatei-Patching und Migration (4-multi-file-patching-and-migration): aider-patcher kommt zum Einsatz und führt mehrdateiliche Änderungen und Versionsübergänge zusammen.
Sandbox-Test, LSP und Qualitätsgate (5-jev-gate-and-sandbox-verification): codex-sandbox führt die Unit-Tests durch, opencode die statische LSP-Analyse, flutter_a11y_agent die Barrierefreiheitsprüfung und jev-gate die Qualitätskontrolle mit Schwellenwert 0.85.
SecOps-, WAF- und HANCORE-Prüfung (6-secops-waf-and-hancore-audit): In der netzwerkbeschränkten (offline-strict) Schicht werden Leckagen geheimer Schlüssel, IAM-Berechtigungen und Linux-HANCORE-Sicherheitsregeln (process_group(0) Prozessisolierung, 1 MiB Obergrenze für das Lesen von Dateien, atomare Dateiberechtigungen 0600) geprüft.
Argon-Fullstack-Abschlusskontrolle (7-argon-fullstack-verification): Das letzte Wort hat wieder Gemini 4 Argon. Die Aufgabe wird nicht abgeschlossen, bevor Frontend, Backend, Datenbank, MCP-Ausgaben, Build-Ergebnisse und Laufzeitintegrität durchgängig geprüft sind.

Was kann man tun, um Argon 4 effektiver zu nutzen?

Selbst wenn Sie in Ihrem eigenen System keinen vollständigen Rat aus 12 Modellen aufstellen, steigern die folgenden sechs Gewohnheiten bei der Nutzung von Gemini 4 Argon in Antigravity direkt den Nutzen, den Sie aus dem Modell ziehen:

Lagern Sie umfangreiche Dateidurchsuchungen an den research-Subagenten aus: Wenn zum Verständnis eines Problems 15-20 Dateien gelesen werden müssen, lassen Sie diese nicht einzeln im Hauptchat öffnen. Beauftragen Sie den research-Subagenten mit invoke_subagent. Der Recherche-Agent liest alle Dateien in seinem eigenen Kontext und gibt Argon 4 nur die saubere Zusammenfassung mit Zeilenverweisen zurück. So wird die Aufmerksamkeit von Argon 4 nicht abgelenkt.
Lassen Sie vor dem Schreiben von Code die relevante SKILL.md-Datei lesen: Statt sich auf das allgemeine Trainingsgedächtnis des Modells zu verlassen, lassen Sie zuerst eine SKILL.md-Fähigkeitsdatei lesen, die zu Ihrer Aufgabe passt (zum Beispiel bigquery-sql, jetpack-compose-performance oder migrate-to-rust). So gelangen aktuelle API-Regeln direkt in den Arbeitskontext.
Führen Sie den self-Subagenten für unabhängige Aufgaben parallel aus: Wenn zwei voneinander unabhängige Module geschrieben werden sollen, warten Sie nicht darauf, dass Argon 4 beide nacheinander in einem einzigen Fenster schreibt. Starten Sie den self-Subagenten im isolierten Arbeitsbereichsmodus (branch oder share) und lassen Sie ihn parallel laufen.
Richten Sie bei Hintergrundaufgaben keine Polling-Schleife ein: In Antigravity gibt es ein System für reaktives Aufwecken (reactive wakeup). Wenn Sie einen langwierigen Build oder einen Subagenten starten, müssen Sie keine sleep- oder Statusabfrage-Schleife einrichten; gehen Sie in den Wartezustand, wenn der Tool-Aufruf beendet ist, und das System weckt Argon automatisch, sobald die Aufgabe abgeschlossen ist.
Verwenden Sie bei großen Dateien gezielte Patches statt vollständigem Schreiben der Datei: Wenn Sie eine bestehende lange Datei ändern, ist das Neuschreiben der gesamten Datei (write_to_file) sowohl langsam als auch mit dem Risiko verbunden, dass vorhandene Kommentarzeilen verloren gehen. Bevorzugen Sie stattdessen das zeilenbereichsbasierte Tool replace_file_content oder bei mehrdateilichen Arbeiten diff-orientierte Tools wie aider.
Nutzen Sie Argon 4 immer als „letztes Freigabe-Gate“: Lassen Sie Argon 4 nach Abschluss der Codeerzeugung unbedingt den Build-Test, die Unit-Tests und, falls es eine Weboberfläche gibt, die Live-Konsolen-/Barrierefreiheitsprüfung über chrome-devtools-mcp durchführen. Die größte Stärke des Modells ist, dass es die Ausgaben verschiedener Schichten gemeinsam bewerten und übersehene Integrationsfehler erkennen kann.

Meine Einschätzung

Sicher ist: Egal wie groß das Kontextfenster des Modells ist, alles in einen einzigen Chatverlauf zu packen, senkt ab einem bestimmten Punkt sowohl die Qualität als auch die Geschwindigkeit. Aufgabenteilung und die Nutzung spezialisierter Subagenten sind inzwischen keine Option mehr, sondern bei großen Projekten eine Notwendigkeit.
In der Praxis am wirkungsvollsten: Über 45 MCP-Server in eager und lazy zu unterteilen und umfangreiche Recherchen an den research-Subagenten zu übergeben, hat den Arbeitspeicher von Argon 4 dramatisch entlastet.
Zusammenfassend: Wenn Sie Gemini 4 Argon nicht wie einen Arbeiter einsetzen, der jeden Stein allein trägt, sondern wie einen Dirigenten, der die Arbeit an die richtigen Spezialisten verteilt, die Architektur aufbaut und am Ende alles durchgängig prüft, erkennen Sie seine wahre Stärke.