Google Antigravity führt /swarm ein: KI-Programmierung wandelt sich von der Ausführung durch einen einzelnen Agenten zur Teamarbeit mehrerer Agenten – eine Analyse der 4 Rollentypen

Anmerkung des Autors: Dieser Artikel stützt sich auf den offiziellen Blog und die Nutzungsdokumentation von Google Antigravity und erklärt, wie die Arbeit in /swarm auf mehrere Agents verteilt wird, wie sie zusammenarbeiten, wie sich das visualisieren und steuern lässt – und wo die Grenzen der Nutzung liegen.

Am 10. November 2026 wurde Gemini 4 Carbon offiziell freigegeben. Am selben Tag stellte das Google-Antigravity-Team die /swarm-Funktion für die Zusammenarbeit mehrerer Agents (Preview) vor. Diese eine Anweisung verwandelt ein einzelnes Gespräch in ein kleines Engineering-Team aus KI-Agenten: Einer zerlegt die Aufgabe, einer schreibt den Code, einer prüft das Ergebnis, und einer passt auf, wo der Fortschritt hängen bleibt.

Die Funktion ist öffentlich belegt: Der offizielle Blog von Antigravity und die Swarm-Dokumentation sind online, und laut Google nutzen die eigenen Entwickler sie seit rund fünf Wochen intern. Der Kern von /swarm ist auch nicht, einfach mehrere Chatfenster parallel aufzumachen. Es geht um ein System, das Aufgaben selbstständig zerlegt, parallel ausführt, den Fortschritt teilt, sich gegenseitig überprüft und Fehler laufend nachbessert.

Der Kern dieses Artikels: Nach der Lektüre wissen Sie, wie /swarm konkret abläuft, wie die einzelnen Rollen zusammenspielen, wie Sie als Nutzer zuschauen und eingreifen können und wo die tatsächlichen Grenzen bei Kontingenten und Berechtigungen liegen.

Hinweis der Übersetzung: Der Quelltext beschreibt Gemini 4 Carbon und die /swarm-Funktion mit Datum November 2026 als veröffentlichte Produkte. Ich kann diese Angaben nicht überprüfen und gebe sie unverändert als Aussage des Originaltexts wieder.

Google Antigravity /swarm: Die wichtigsten Begriffe

/swarm bringt gleich mehrere Rollenbegriffe mit. Wenn Sie diese Konzepte vorab klären, wird der Rest des Mechanismus deutlich verständlicher.

Was ist Google Antigravity /swarm? Die wichtigsten Infos im Überblick

/swarm wurde zusammen mit der offiziellen Freigabe von Gemini 4 Carbon veröffentlicht, aber die beiden sind nicht dasselbe. Das eine ist eine Funktion zur Orchestrierung mehrerer Agenten in Antigravity, das andere ein Modell. Die folgende Tabelle fasst zusammen, was offiziell bisher bekannt ist.

Warum ein einzelner Agent große Engineering-Aufgaben kaum stemmt

Ein einzelner Agent arbeitet bei einer Funktion oder einem einzelnen Bug sehr gut. Sobald die Aufgabe aber auf Dutzende Dateien, Abhängigkeiten zwischen mehreren Modulen oder wiederholte Testläufe anwächst, muss ein einziger Agent alle Details im selben Kontext im Kopf behalten. Je länger der Kontext wird, desto leichter werden frühere Vorgaben von späteren Ausführungsdetails verdrängt.

Auch die Aufgabenverteilung ist ein Problem. Ein einzelner Agent arbeitet nur sequenziell: Solange die Änderung an Modul A nicht fertig ist, muss die Untersuchung von Modul B warten. Viele Engineering-Aufgaben lassen sich jedoch von Natur aus aufteilen und parallel bearbeiten, etwa wenn fehlschlagende Tests in verschiedenen Softwarepaketen separat repariert werden. Wer das seriell erledigt, verschwendet Zeit.

Am leichtesten übersehen wird die Verifikation. Wenn ein Agent seinen eigenen Code prüft, übernimmt er leicht die ursprünglichen Annahmen und erkennt Denkfehler im Ansatz nicht. In menschlichen Teams übernimmt deshalb eine zweite Person das Code-Review. /swarm überträgt genau diese Arbeitsteilung auf den KI-gestützten Programmierprozess.

Google Antigravity /swarm: So starten Sie ein Agent-Team

Laut offizieller Dokumentation läuft nach dem Aufruf von /swarm <task> alles in dieser Reihenfolge ab:

1. Der laufende Chat wird zum Coordinator: Der Agent, mit dem Sie gerade sprechen, übernimmt die Rolle des Koordinators und versteht die Gesamtaufgabe.
2. Die Arbeit wird aufgeteilt: Der Coordinator gliedert die Aufgabe nach ihrer Struktur in mehrere Teilaufgaben.
3. Eigenständige Worker entstehen: Jede Teilaufgabe bekommt einen Worker mit eigenem Kontext und einer öffentlich einsehbaren Aufgabenbeschreibung.
4. Ausführung und Prüfung: Worker ändern Code oder stellen Untersuchungen an; der Verifier prüft die Änderungen, führt Tests aus und meldet Probleme an den zuständigen Worker zurück.
5. Der Fix-Loop: Der Worker arbeitet die Rückmeldungen ein, und die überarbeitete Version geht erneut in die Prüfung.
6. Zusammenfassender Bericht: Der Coordinator bündelt die Ergebnisse aller Beteiligten und berichtet an Sie.

Der Kontext jedes Workers ist eigenständig und enthält nur die Informationen zu seinem Teil der Aufgabe – das Problem, dass sich lange Kontexte gegenseitig verunreinigen, wird dadurch entschärft. Die Aufgabenbeschreibungen sind öffentlich, alle Mitglieder sehen also, wer woran arbeitet, und die Zuständigkeiten bleiben klar abgegrenzt.

/swarm Teamaufteilung: Coordinator, Worker, Verifier und Monitor

Laut offizieller Dokumentation besteht ein Swarm-Team üblicherweise aus vier Rollen. Wichtig dabei: Das ist die typische Organisationsform, die offiziell beschrieben wird, keine feste Architektur, die für jede Aufgabe gleich gilt. Wie viele Worker angelegt werden und ob zusätzliche Mitglieder nötig sind, entscheidet der Coordinator je nach Aufgabe.

Die Mechanismen von Verifier und Monitor in /swarm

Im offiziellen Blog wird der Verifier als „adversarialer Verifikations-Agent“ bezeichnet. Seine Aufgabe ist es, Probleme zu finden: Er prüft die Änderungen anderer Agents, führt Tests aus und stellt unplausible Änderungen infrage. Der Worker behebt die Punkte nach dem Feedback und reicht erneut zur Prüfung ein. So schließt sich der Kreis aus Ausführung und Verifikation.

Der Monitor kümmert sich um eine andere Art von Risiko. Wenn mehrere Agents zusammenarbeiten, kann es passieren, dass alle aufeinander warten und niemand vorankommt. Der Monitor schläft normalerweise. Sobald er merkt, dass das Team insgesamt keine Aktivität mehr zeigt, die Aufgabe aber noch nicht fertig ist, weckt er die betroffenen Mitglieder. Dadurch muss man nicht allein darauf vertrauen, dass Nutzer bei einem Stillstand manuell eingreifen.

In /swarm können verschiedene Rollen verschiedene Modelle nutzen

Google empfiehlt im offiziellen Blog, Modelle nach den Eigenschaften der Rollen zuzuweisen, statt alle Agents mit dem teuersten Modell laufen zu lassen:

• Gemini 4 Carbon einsetzen: Gesamtarchitektur, Aufgabenkoordination, Sicherheitsprüfung, komplexe Code-Audits
• Schnellere, leichtere Modelle einsetzen: Standard-Codeimplementierung, parallele Dateiänderungen
• Spezialisierte Verifikations-Agents einsetzen: automatisierte Tests und Verifikation

Auch in den Beispielen der offiziellen Dokumentation gibt es Konstellationen, in denen verschiedene Modelle für die Codeimplementierung und die unabhängige Verifikation zuständig sind. Dahinter steckt ein Abwägen zwischen Kosten und Leistungsfähigkeit: Komplexe Entscheidungen übernimmt das starke Modell, die Masse an Ausführungsarbeit das schnelle.

💡 Empfehlung: Wenn Sie in einer selbst gebauten Multi-Agent-Pipeline ebenfalls Modelle rollenspezifisch kombinieren möchten, testen Sie zunächst über APIYI (apiyi.com) mit demselben API-Schlüssel, wie sich verschiedene Modelle bei Planung, Implementierung und Review schlagen. Sobald Sie für jede Rolle das passende Modell gefunden haben, legen Sie die Konfiguration fest. Zum Wechseln müssen Sie dann nur den Parameter model ändern.

/swarm: Wie mehrere Agents zusammenarbeiten, ohne sich gegenseitig zu stören

Das gemeinsame Message Board: offene Kommunikation zwischen den Agents

Alle Agents teilen sich ein gemeinsames, rein anfügendes Message Board (Shared Message Board), auf dem der Abstimmungsprozess und der Aufgabenfortschritt festgehalten werden. Nachrichten werden nur angehängt, nie überschrieben – die Kommunikationshistorie des Teams bleibt vollständig nachvollziehbar. Während ein Agent auf andere Mitglieder wartet, kann er schlafen und wird erst wieder geweckt, wenn er Eingaben braucht; laut Google verbraucht dieses Leerlaufen keine Token.

Dieses Design ist transparenter, als wenn Agents sich gegenseitig verdeckt aufrufen würden. Das Feedback des Verifiers an die Worker und die Dispositionsentscheidungen des Coordinators liegen offen zutage – beim späteren Nachvollziehen sieht man als Nutzer genau, an welcher Stelle es gehakt hat.

Gemeinsamer Workspace und eigenständige Arbeitskopien: der Unterschied

Hier formulieren der offizielle Blog und die Dokumentation unterschiedlich, da passiert schnell ein Fehler. Der Blog betont, dass parallele Worker in isolierten Git-Worktrees arbeiten können, damit sie nicht direkt dasselbe Verzeichnis bearbeiten. Die Dokumentation beschreibt die Regeln detaillierter:

• Standardfall: Die Workers teilen sich den aktuellen Workspace.
• Isolation nach Bedarf: Wenn mehrere Worker gleichzeitig am Projekt Änderungen vornehmen oder es bauen müssen, kann der Coordinator ihnen eigenständige Arbeitskopien des Codes zuweisen.
• Entfernen heißt löschen: Wird ein Worker entfernt, wird seine Arbeitskopie gelöscht – Ergebnisse müssen also vorher gemergt oder committet werden.

Richtig formuliert heißt das: Das System stellt isolierte Arbeitskopien je nach Bedarf der parallelen Aufgaben bereit, statt dass jeder Agent von Natur aus über einen vollständig eigenen Git-Worktree verfügt. Für Aufgaben, die nur recherchieren und keine Dateien ändern, reicht der gemeinsame Workspace; wenn mehrere Worker gleichzeitig Code ändern und Builds ausführen, verringern getrennte Kopien die Dateikonflikte.

So beobachten und steuern Sie ein /swarm-Team in Antigravity

Bei parallel arbeitenden Multi-Agent-Systemen ist die größte Sorge, dass man nicht mehr weiß, was im Inneren gerade passiert. Antigravity bietet dafür drei zentrale Ansichten, und auch in der CLI gibt es passende Tastenkürzel und Befehle.

Ihre Kontrolle beschränkt sich nicht darauf, am Ende das Ergebnis zu sehen. Über diese Zugänge können Sie den Arbeitsverlauf jedes Agents nachvollziehen, direkt in einen einzelnen Worker eingreifen und die Vorgaben für den Coordinator anpassen. Alt + J und Ctrl + K zeigen außerdem: Die Freigabe von Tool-Aufrufen bleibt in Ihrer Hand. Will ein Agent eine sensible Operation ausführen, hält er an und wartet auf Ihre Bestätigung.

Welche komplexen Engineering-Aufgaben löst /swarm?

Google nennt intern drei Haupteinsatzszenarien: Migration mehrerer Softwarepakete, Ursachenanalyse über Subsystem-Grenzen hinweg und Neugestaltung komplexer Softwarearchitekturen. Gemeinsam ist ihnen: Der Aufwand ist groß, die Arbeit lässt sich aufteilen, und die Ergebnisse müssen überprüft werden.

Die Beispiele aus der offiziellen Nutzungsdokumentation liegen näher am Entwickleralltag:

• Mehrere API-Handler getrennt anpassen und für jeden Handler eigene Tests einrichten
• Die Ursache für einen langsamen CLI-Start parallel untersuchen
• Fehlgeschlagene Tests eines großen Projekts nach Softwarepaket gruppieren und an verschiedene Agenten zur Behebung verteilen
• Unterschiedliche Modelle für die Code-Implementierung und die unabhängige Verifikation einsetzen

Außerdem hat Google eine offizielle Demo gezeigt: Mithilfe der Multi-Agent-Zusammenarbeit von Antigravity verarbeitete Carbon 7 öffentlich zugängliche Stadtplanungs-PDFs, extrahierte 206 technische Zeichnungsansichten und erzeugte daraus ein interaktives Three.js-Gebäudemodell mit rund 906.000 Dreiecksflächen. Der gesamte Prozess umfasste 10 nächtliche Iterationsrunden. Das ist ein offizielles Google-Beispiel und keine unabhängige Überprüfung durch Dritte, es zeigt aber gut, wie Multi-Agent-Systeme bei langlaufenden Aufgaben die Arbeit untereinander aufteilen.

Kosten, Berechtigungen und Preview-Einschränkungen von /swarm

Kontingentverbrauch bei mehreren Agenten

Wartende Agenten verbrauchen keine Token. Das heißt aber nicht, dass /swarm Geld spart: Jeder Worker ist ein eigenständiger Agent, und wenn mehrere gleichzeitig arbeiten, verbraucht das Gesamtkontingent deutlich schneller als bei einer einzelnen Unterhaltung. Auch Google weist selbst darauf hin.

Eine weitere Falle: Wenn ein Worker sein Kontingent aufgebraucht hat, wird er pausiert. Auch wenn sich das Kontingent später wieder auffüllt, macht er nicht automatisch weiter, sondern muss manuell fortgesetzt werden. Bevor Sie eine große, lang laufende Aufgabe starten, sollten Sie daher abschätzen, ob das Kontingent ausreicht.

Swarm-Berechtigung ≠ Berechtigung für das Carbon-Modell

Das ist der Punkt, der am leichtesten verwechselt wird: Wer /swarm nutzen kann, kann deshalb noch nicht automatisch Carbon innerhalb von Swarm verwenden.

Anders gesagt: Pro-Nutzer können den Zusammenarbeitsmechanismus von Swarm ausprobieren, aber welche Modelle die Agenten verwenden dürfen, hängt weiterhin von den Modellberechtigungen des jeweiligen Abos ab.

Auswirkungsanalyse: /swarm bringt die KI-Programmierung vom Assistenten zum Team

Auswirkungen auf Entwickler

• Rollenwechsel: Entwickler sind nicht mehr die, die dem Modell Fragen stellen, sondern die, die ein KI-Team organisieren. Wie sauber die Aufgaben zerlegt sind und wie die Abnahmekriterien aussehen, schlägt direkt auf das Ergebnis durch.
• Verifikation von Anfang an: Der Verifier-Mechanismus macht Tests und Review zum festen Bestandteil des Ablaufs – nicht mehr zu einer Reparatur, die erst nach der Generierung ansteht.
• Kostenmanagement wird wichtiger: Wenn mehrere Worker parallel laufen, muss man Kontingente, die Kombination der Modelle und die Granularität der Aufgaben im Blick behalten. Das Erlebnis einer einzelnen Unterhaltung reicht als Maßstab nicht mehr aus.

Auswirkungen auf die Branche

• Multi-Modell-Kollaboration etabliert sich als Deployment-Ansatz: Starke Modelle übernehmen Planung und Prüfung, schnelle Modelle die Massenabarbeitung – diese Arbeitsteilung dürften sich immer mehr Agent-Frameworks abschauen.
• Der Wettbewerb verschiebt sich auf die Aufgabenerfüllung: Bei den Modellen geht es nicht mehr um Punktzahlen im Einzelfrage-Antwort-Spiel, sondern um Planung, Ausführung, Verifikation und Lieferung bei Aufgaben, die sich über einen längeren Zeitraum ziehen.

Die /swarm-Multi-Agent-Idee mit der API nachbauen: ein minimalistisches Beispiel

Wer das Muster „Koordinator zerlegt die Arbeit, Worker führen sie aus“ im eigenen Projekt ausprobieren will, kommt mit einer OpenAI-kompatiblen Schnittstelle zu einem minimalen Prototyp. Der folgende Code zeigt ausschließlich die Kollaborationsstruktur und ist keine Implementierung von Antigravity /swarm. Die Modellnamen sind durch Modelle zu ersetzen, die im eigenen Account tatsächlich verfügbar sind.

from openai import OpenAI

client = OpenAI(api_key="YOUR_API_KEY", base_url="https://api.apiyi.com/v1")

def ask(model, prompt):
    resp = client.chat.completions.create(
        model=model, messages=[{"role": "user", "content": prompt}]
    )
    return resp.choices[0].message.content

plan = ask("STRONG_MODEL", "把“修复 3 个 API Handler 的失败测试”拆成独立子任务，每行一个")
for task in [t for t in plan.splitlines() if t.strip()]:
    print(ask("FAST_MODEL", f"完成这个子任务并给出补丁：{task}"))

import concurrent.futures as cf
from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.apiyi.com/v1"  # OpenAI-kompatible Schnittstelle von APIYI
)

COORDINATOR_MODEL = "STRONG_MODEL"   # Planung und Zusammenfassung, durch ein starkes Reasoning-Modell ersetzen
WORKER_MODEL = "FAST_MODEL"          # Massenausführung, durch ein schnelles, leichtes Modell ersetzen
VERIFIER_MODEL = "REVIEW_MODEL"      # unabhängige Prüfung, sollte sich vom Worker unterscheiden
board = []                           # append-only geführtes, gemeinsames Message-Board

def ask(model, system, prompt):
    resp = client.chat.completions.create(
        model=model,
        messages=[{"role": "system", "content": system},
                  {"role": "user", "content": prompt}],
    )
    return resp.choices[0].message.content

def worker(task, max_rounds=3):
    patch = ask(WORKER_MODEL, "你是 Worker，只负责分配给你的子任务。", task)
    for i in range(max_rounds):
        review = ask(VERIFIER_MODEL,
                     "你是 Verifier，检查补丁问题。没有问题只回复 PASS。",
                     f"任务：{task}\n补丁：\n{patch}")
        board.append(f"[Verifier] {task[:20]}... 第{i+1}轮：{review[:60]}")
        if review.strip().startswith("PASS"):
            return patch
        patch = ask(WORKER_MODEL, "根据审查意见修复补丁。",
                    f"任务：{task}\n原补丁：{patch}\n意见：{review}")
    return patch + "\n# 未通过验证，需人工检查"

goal = "为 users、orders、payments 三个 API Handler 补充输入校验并修复失败测试"
plan = ask(COORDINATOR_MODEL, "你是 Coordinator，把目标拆成互不重叠的子任务，每行一个。", goal)
tasks = [t.strip() for t in plan.splitlines() if t.strip()]
board.append(f"[Coordinator] 拆分为 {len(tasks)} 个子任务")

with cf.ThreadPoolExecutor(max_workers=4) as pool:
    results = list(pool.map(worker, tasks))

summary = ask(COORDINATOR_MODEL, "汇总各 Worker 结果，列出完成情况与风险。",
              "\n\n".join(results))
print("\n".join(board))
print(summary)

🚀 Schnellstart: Wenn du solche Mehrrollen-Prototypen aufbaust, hol dir den API-Schlüssel und das kostenlose Testkontingent für neue Nutzer am besten über APIYI apiyi.com. Die Plattform bietet eine OpenAI-kompatible Schnittstelle, über die sich OpenAI-, Claude- und Gemini-Modelle aus einem einzigen Codebestand heraus aufrufen lassen. Genau das brauchst du, um zu prüfen, ob die Aufteilung „starkes Modell plant, schnelles Modell führt aus, heterogenes Modell prüft“ zu deinem Projekt passt.

Häufig gestellte Fragen (FAQ)

Google Antigravity /swarm – die Kernpunkte (Key Takeaways)

• Ausführungsmechanismus: /swarm <task> macht den laufenden Dialog zum Coordinator, zerlegt die Aufgabe und legt eigenständige Worker an.
• Typische Rollenverteilung: Coordinator, Worker, Verifier und Monitor – üblicherweise kommt auf 2 bis 4 Worker ein Verifier.
• Zusammenarbeit: Die Kommunikation läuft offen über ein gemeinsames, nur anhängendes Message-Board; Agenten, die im Leerlauf warten, verbrauchen keine Tokens.
• Workspace-Regeln: Standardmäßig wird ein gemeinsamer Workspace verwendet; bei parallelen Änderungen werden nach Bedarf getrennte Arbeitskopien zugewiesen.
• Visuelle Steuerung: die drei Ansichten Board, Members und Graph, dazu CLI-Befehle wie /swarm board und /agents.
• Grenzen der Praxis: Preview-Status, viele Worker verbrauchen das Kontingent schnell, und Swarm-Rechte sind nicht gleich Carbon-Rechte.
• Selbst bauen: Über APIYI apiyi.com lassen sich mehrere Modelle hinter einer einheitlichen Schnittstelle kombinieren, um einen eigenen Multi-Rollen-Prototyp aufzusetzen.

Fazit

Die Kernpunkte von Google Antigravity /swarm:

1. Von Parallelität zu Zusammenarbeit: Der Wert von /swarm liegt in einem vollständigen Kreislauf aus Aufgabenzerlegung, unabhängigen Kontexten, adversarialer Verifikation und Fortschrittskontrolle – die parallele Ausführung ist nur ein Teil davon.
2. Isolation nach Bedarf: Gemeinsamer Workspace und getrennte Arbeitskopien wechseln sich je nach Aufgabe ab; der Zeitpunkt des Zusammenführens bleibt eine Aufgabe für den Nutzer.
3. Leistung und Kosten zugleich: Mehrere Agenten erhöhen die Leistungsfähigkeit bei komplexen Engineering-Aufgaben, bringen aber auch höheren Kontingentverbrauch und aufwendigeres Ressourcenmanagement mit sich – aktuell noch Preview.

Für Entwickler bedeutet /swarm einen Wandel der Arbeitsweise: nicht mehr nur dem Modell Fragen stellen, sondern ein KI-Team organisieren, das Aufgaben aufteilt, ausführt, prüft und abliefert. Auch wer Antigravity vorerst nicht nutzen kann, kann diesen Ansatz – Modelle nach Rollen zuzuweisen und die Verifikation von der Ausführung zu trennen – in eigenen Agent-Systemen verwenden. Um das Zusammenspiel mehrerer Modelle schnell zu testen, empfiehlt sich APIYI apiyi.com: Die Plattform bietet kostenloses Testkontingent und eine einheitliche Schnittstelle für viele Modelle.

📚 Referenzen

1. Offizielle Dokumentation zu Google Antigravity Swarm: Ausführungsmechanismus von /swarm, Rollenkonfiguration, Arbeitskopien und CLI-Bedienung
2. Link: antigravity.google/docs/swarm

3. Hinweis: Primärquelle zu Coordinator, Verifier und Monitor sowie zu den Ansichten Board / Members / Graph

4. Offizieller Google-Antigravity-Blog: Gemini 4 Carbon in Google Antigravity

5. Link: antigravity.google/blog/gemini-4-carbon-in-google-antigravity

6. Hinweis: Informationen zur Veröffentlichung von /swarm, zur Multi-Agent-Architektur und Empfehlungen zur Rollenverteilung der Modelle

7. Offizielle Google-Ankündigung: Gemini 4 Carbon is now available

8. Link: blog.google/innovation-and-ai/models-and-research/gemini-models/gemini-4-carbon-now-available

9. Hinweis: Umfang der offiziellen Freigabe von Carbon und Hintergrund zur /swarm-Preview

10. Seite zu den Google-AI-Abo-Leistungen: Modellzugriff bei AI Pro und Ultra

11. Link: one.google.com/about/google-ai-plans

12. Hinweis: Zeigt, welche Abostufe Zugriff auf das Carbon-Modell bietet

13. Bericht von The Verge zur Veröffentlichung: Google releases Gemini 4 Carbon with agent swarm feature

14. Link: theverge.com/ai-artificial-intelligence/1030787/google-gemini-4-carbon-public-rollout
15. Hinweis: Hintergründe zur Veröffentlichung und Zugriffsbeschränkungen aus Sicht eines unabhängigen Mediums

Autor: APIYI-Technikteam
Austausch: Besuchen Sie uns gern auf der Startseite von APIYI (apiyi.com), um sich über Multi-Agent-Praxis auszutauschen. Weitere Informationen zur Anbindung finden Sie im Dokumentationszentrum unter docs.apiyi.com

Weiterführende Artikel

• Gemini 4 Carbon: Analyse der Veröffentlichung – mit 59 Punkten vor Opus 5.5, 15 von 17 Disziplinen gewonnen, aber nicht aufrufbar: Gemini 4 Carbon führt den Intelligenzindex von Artificial Analysis mit 59 Punkten an und gewinnt 15 von 17 offiziellen Vergleichen, hat aber weder API-Modell-ID noch Freigabeplan; der Artikel erklärt die Bewertung und fehlende Verfügbarkeit sowie gemini-4-argon als Alternative für Entwickler in China.