Google Antigravity und Gemini 3.7 Flash: Ein Multi-Agent-Fix für Mathe- und Ingenieuraufgaben

Google Antigravity und Gemini 3.7 Flash: Ein Multi-Agent-Ansatz für Mathematik- und Ingenieuraufgaben

Mathematische Herleitungen und technische Berechnungen haben eine schwierige Eigenschaft: Sie bestrafen kleine Fehler inmitten langer Ketten. Ein einziges falsch gesetztes Vorzeichen, eine vergessene Einheitenumrechnung oder eine ungeprüfte Randbedingung kann alles Weitere ungültig machen. Allgemeine Sprachmodelle sind wirklich gut darin, plausible Zwischenschritte zu erzeugen, aber Plausibilität ist nicht dasselbe wie Korrektheit. Wenn es sich um eine 30-Schritte-Balkenanalyse oder eine symbolische Integration handelt, die einer numerischen Überprüfung standhalten muss, arbeitet ein einzelner Agent allein gegen die Disziplin, die die Aufgabe erfordert.

Der nützliche Ausweg ist nicht ein größeres Modell oder ein längerer Prompt. Es ist eine strukturelle Änderung: die Arbeit auf spezialisierte Agenten aufzuteilen, die die Ergebnisse der jeweils anderen kritisieren, verifizieren und neu berechnen können. Google Antigravity in Kombination mit Gemini 3.7 Flash ist ein konkretes Beispiel für diese Idee. Laut dem Google AI Blog löst diese Kombination bemerkenswerte Multi-Agent-Probleme in Mathematik und Ingenieurwesen, die Single-Agent-Workflows ungelöst lassen. Dieser Artikel erklärt, warum diese Kombination funktioniert, wie man sie einrichtet und wie man sie für realistische technische Aufgaben nutzt.

Die strukturellen Grenzen eines einzelnen Agenten

Ein einzelner LLM-Aufruf ist von Natur aus ein einzelner Durchlauf von Aufmerksamkeit über einen Kontextfenster. Er kann planen, aber er kann nicht ohne externe Mechanismen leicht zwischen Planen und Prüfen wechseln. In Mathematik und Ingenieurwesen ist das eine ernsthafte Einschränkung.

Betrachten wir ein technisches Problem: die maximale Durchbiegung eines einfach gelagerten Trägers unter einer Streckenlast zu berechnen, einschließlich des Eigengewichts des Trägers. Die Aufgabe erfordert:

• Materialeigenschaften und ihre Einheiten abrufen,
• eine Differentialgleichung korrekter Ordnung aufstellen,
• Randbedingungen anwenden,
• symbolisch oder numerisch integrieren,
• und dann das Ergebnis in eine einheitenkorrekte, toleranzgeprüfte Antwort umwandeln.

Ein einzelner Agent könnte den Ansatz gut bewältigen und dann einen stillen Fehler im dritten Integrationsschritt machen. Wenn nichts das Zwischenergebnis verifiziert, pflanzt sich der Fehler fort. Schlimmer noch, das Vertrauen des Agenten in seine eigenen früheren Schritte neigt dazu, ihn gegen eine Revision zu resistent zu machen, wenn eine Abweichung auftaucht. Die Fehlerart ist nicht ein Mangel an Intelligenz; es ist ein Mangel an Trennung zwischen den Rollen des Erzeugens eines Ergebnisses und des Anfechtens desselben.

Eine Multi-Agent-Struktur behebt dies konstruktionsbedingt. Ein Lösungsagent erzeugt. Ein Verifiziereragent greift an. Ein Integrationsagent gleicht ab. Keiner von ihnen wird gebeten, unparteiisch gegenüber der eigenen Ausgabe zu sein, weil sie ihre eigene Ausgabe überhaupt nicht prüfen.

Was die Kombination von Antigravity und Gemini 3.7 Flash ändert

Die verifizierte Tatsache, die vom Google AI Blog stammt, ist präzise: Die Kombination von Google Antigravity mit Gemini 3.7 Flash löst bemerkenswerte Multi-Agent-Probleme in Mathematik und Ingenieurwesen. Die Quelle wurde am 2026-08-31 verifiziert und ist erreichbar unter:

https://blog.google/innovation-and-ai/technology/developers-tools/antigravity-teamwork-multi-agent

Was diese Kombination auf architektonischer Ebene bietet, ist ein Arbeitsbereich und ein Reasoner, die füreinander entworfen wurden. Antigravity liefert das kollaborative Gerüst: den Projektkontext, die Teamstruktur, die Fähigkeit, Nachrichten zwischen Rollen zu leiten, und einen Ort für Artefakte wie symbolische Ausdrücke, numerische Ergebnisse und Einheitendefinitionen. Gemini 3.7 Flash liefert das Denken innerhalb jeder Rolle. Es ist schnell genug, dass Verifizierungsschleifen keine interaktiven Engpässe werden, und es ist stark genug im symbolischen und numerischen Denken, um ein glaubwürdiger Kritiker der Arbeit eines anderen Agenten zu sein.

Es lohnt sich, präzise zu sein, was verifiziert ist und was Interpretation ist. Die verifizierte Behauptung ist, dass die Kombination bemerkenswerte Multi-Agent-Probleme in Mathematik und Ingenieurwesen löst. Die Erklärung, warum sie funktioniert — Rollentrennung, Arbeitsbereichsstruktur, Verifizierungsschleifen — ist eine vernünftige Interpretation dieser Tatsache, keine separate verifizierte Behauptung. Dieser Artikel hält diese beiden Ebenen getrennt.

Warum nicht einfach ein klügeres Modell verwenden?

Es gibt die verständliche Versuchung, die Multi-Agent-Mechanik zu überspringen und ein Grenzmodell für das Denken mit einem langen, sorgfältig entwickelten Prompt aufzurufen. Für einfache Arithmetik funktioniert das. Für echte Ingenieuraufgaben scheitert es aus Gründen, die nichts mit roher Leistungsfähigkeit zu tun haben.

Erstens erfordert Verifizierung, sich wie ein anderer Agent zu verhalten. Ein Modell, das gerade eine Durchbiegungsgleichung hergeleitet hat, ist schlecht positioniert, um seinen eigenen Substitutionsschritt zu misstrauen. Es hat in diesen Schritt investiert. Ein separater Verifiziereragent, der frisch startet, trägt diese Investition nicht.

Zweitens erzeugen technische Probleme heterogene Artefakte: Gleichungen, Matrizen, Einheitenumrechnungen, Nachschlagetabellen für Materialeigenschaften, numerische Integrationen. Ein einzelnes Kontextfenster, das all dies gleichzeitig enthält, wird zu einem Durcheinander. Ein Multi-Agent-Setup kann die symbolische Ebene von der numerischen Ebene getrennt halten und sie nur an expliziten Kontrollpunkten zusammenführen.

Drittens gibt es einen Debugging-Vorteil, der nichts mit Modellqualität zu tun hat. Wenn eine Multi-Agent-Pipeline eine falsche Antwort erzeugt, zeigt das Protokoll, welche Rolle versagt hat. Hat der Solver eine ungültige Randbedingung erzeugt? Hat der Verifizierer die falsche Toleranz verwendet? Hat der Integrationsagent Einheiten vermischt? Fehler einzelner Agenten kommen nicht mit dieser Diagnosestruktur. Die Kombination aus Antigravity und Gemini 3.7 Flash gibt jedem Fehler eine Heimatadresse.

Voraussetzungen

Bevor Sie etwas installieren, stellen Sie sicher, dass die Umgebung den Workflow unterstützen kann:

• Python 3.11 oder neuer für die Orchestrierungsskripte und das Google GenAI SDK.
• Ein Google Cloud-Projekt mit aktivierter Generative AI API.
• Anmeldedaten für Standardanwendungen (Application Default Credentials) auf dem Rechner oder einen API-Schlüssel für lokale Experimente.
• Den Antigravity-Client installiert und in der Lage, einen Projektarbeitsbereich zu öffnen.
• Netzwerkzugriff auf die API-Endpunkte von Google.
• Einen Code-Editor — Antigravity selbst bietet eine Editoroberfläche, aber die folgenden Beispiele setzen voraus, dass Sie mit einfachen Python-Dateien arbeiten können.

Es ist keine spezielle Hardware erforderlich, über das hinaus, was die Modell-API von einem Client-Rechner verlangt; die schwere Berechnung findet auf der Seite von Google statt. Der Zugriff auf Gemini 3.7 Flash unterliegt denselben Kontingent- und Verfügbarkeitsregeln wie andere GenAI-Modelle. Überprüfen Sie daher die aktuelle regionale Verfügbarkeit in Ihrer Google Cloud-Konsole, anstatt von universellem Zugriff auszugehen.

Schritt-für-Schritt-Installation

Die Installation besteht aus drei Teilen: Vorbereiten einer Python-Umgebung, Authentifizierung bei Google Cloud und Erstellen der Agententeam-Definition, die Antigravity ausführen wird.

1. Ein Projektverzeichnis erstellen

Wählen Sie einen Arbeitsbereich für das Projekt und wechseln Sie hinein:

mkdir antigravity-math-team
cd antigravity-math-team

Dieses Verzeichnis enthält die Agentendefinitionen, das Orchestrierungsskript und die Artefakte, die bei jedem Lauf erzeugt werden.

2. Virtuelle Umgebung erstellen und aktivieren

Eine virtuelle Umgebung hält die Google-SDK-Abhängigkeiten von Ihrem System-Python isoliert:

python3 -m venv .venv
source .venv/bin/activate

Sie sollten sehen, wie sich die Eingabeaufforderung der Shell ändert, um anzuzeigen, dass die virtuelle Umgebung aktiv ist.

3. Das Google GenAI SDK installieren

Das SDK ist erforderlich, um Gemini 3.7 Flash von Python aus aufzurufen:

pip install --upgrade google-genai

Dies installiert das aktuelle Paket google-genai und seine transitiven Abhängigkeiten.

4. Mit Application Default Credentials authentifizieren

Für einen lokalen Entwicklungsrechner ist der Standardweg ADC:

gcloud auth application-default login

Folgen Sie dem Browser-Ablauf, um die Anmeldung abzuschließen. Die Anmeldedaten werden lokal gespeichert und vom SDK automatisch übernommen. Für einen Server oder eine CI-Umgebung ist ein Dienstkonto-Schlüssel, der über GOOGLE_APPLICATION_CREDENTIALS zugewiesen wird, das geeignetere Muster.

5. Überprüfen, ob das SDK Gemini 3.7 Flash erreichen kann

Bevor Sie das Multi-Agent-Team aufbauen, bestätigen Sie, dass die Modellkennung aufgelöst wird und ein grundlegender Aufruf funktioniert. Erstellen Sie eine Datei namens smoke_test.py:

from google import genai

client = genai.Client(project="your-project-id")
response = client.models.generate_content(
    model="gemini-3.7-flash",
    contents="Reply with the single word: ok",
)
print(response.text)

Führen Sie sie aus:

python smoke_test.py

Wenn das Skript ok ausgibt, funktionieren SDK, Anmeldedaten und Modellzugriff. Wenn die Authentifizierung fehlschlägt, überprüfen Sie den ADC-Schritt erneut. Wenn die Modellkennung abgelehnt wird, konsultieren Sie die Modellliste in der Konsole Ihres Projekts, da die genaue Kennungszeichenfolge den Namenskonventionen der installierten SDK-Version unterliegt.

6. Das Agententeam definieren

Antigravity behandelt Agenten als konfigurierbare Teammitglieder mit Rollen, Anweisungen und Sichtbarkeit auf gemeinsame Artefakte. Für diesen Workflow definieren wir drei Rollen in einer Python-Datei namens team.py:

# team.py — Rollendefinitionen für das Mathematik-/Ingenieur-Multi-Agent-Team
SOLVER = {
    "name": "solver",
    "model": "gemini-3.7-flash",
    "instruction": (
        "Produce complete symbolic or numerical derivations. "
        "Show every intermediate step. Do not skip unit conversions."
    ),
}

VERIFIER = {
    "name": "verifier",
    "model": "gemini-3.7-flash",
    "instruction": (
        "Attack the solver's result. Recompute critical steps independently, "
        "check units, and test boundary conditions. Return PASS or FAIL "
        "with a precise reason."
    ),
}

INTEGRATOR = {
    "name": "integrator",
    "model": "gemini-3.7-flash",
    "instruction": (
        "Merge verified results into a final engineering answer. "
        "Preserve units, report tolerances, and cite which step verified each part."
    ),
}

Die wichtigste Designentscheidung ist, dass die Anweisung des Verifizierers Höflichkeit verbietet. Er wird nicht gebeten, die Antwort des Solvers zu verbessern; er wird gebeten, sie zu brechen. Diese konfrontative Haltung macht die Multi-Agent-Schleife zuverlässiger als ein einzelnes Modell, das eine Selbstüberprüfung durchführt.

Anwendungsbeispiele

Beispiel 1: Durchbiegung eines einfach gelagerten Trägers

Lassen Sie uns das Team für eine konkrete technische Aufgabe einsetzen: maximale Durchbiegung eines einfach gelagerten Stahlträgers, gleichmäßige Länge, mit einer gleichmäßig verteilten Last zusätzlich zum Eigengewicht des Trägers.

Das Orchestrierungsskript führt die drei Agenten in Sequenz aus und überträgt die Ausgabe des Solvers in die Eingabe des Verifizierers:

# run_beam_check.py
from google import genai
from team import SOLVER, VERIFIER, INTEGRATOR

client = genai.Client(project="your-project-id")

problem = """
Steel beam, simply supported, span L = 6.0 m.
Uniform distributed load w = 12 kN/m (applied load).
Beam self weight: use steel density 7850 kg/m^3,
cross-section 0.2 m x 0.4 m rectangular.
Calculate maximum deflection, then compare it to
the commonly used limit of L/360.
"""

solver_output = client.models.generate_content(
    model=SOLVER["model"],
    contents=(
        f"{SOLVER['instruction']}\n\n"
        f"Task:\n{problem}\n\n"
        "Provide the derivation and the final deflection value with units."
    ),
).text

print("--- SOLVER OUTPUT ---")
print(solver_output)

verifier_prompt = (
    f"{VERIFIER['instruction']}\n\n"
    f"Solver produced this result:\n{solver_output}\n\n"
    "Independently recompute the bending stiffness EI, total load per meter, "
    "maximum moment, and deflection. Verify the L/360 comparison."
)
verifier_output = client.models.generate_content(
    model=VERIFIER["model"],
    contents=verifier_prompt,
).text

print("--- VERIFIER OUTPUT ---")
print(verifier_output)

if "PASS" in verifier_output.upper():
    final = client.models.generate_content(
        model=INTEGRATOR["model"],
        contents=(
            f"{INTEGRATOR['instruction']}\n\n"
            f"Solver output:\n{solver_output}\n\n"
            f"Verifier output:\n{verifier_output}\n\n"
            "Write the final report with the deflection value, the L/360 limit, "
            "and the PASS/FAIL conclusion."
        ),
    ).text
    print("--- FINAL REPORT ---")
    print(final)
else:
    print("Verification failed. Re-run the solver with the verifier's critique.")

Führen Sie das Skript aus mit:

python run_beam_check.py

Der Workflow ist bewusst einfach: lösen, angreifen, integrieren. In der Praxis stellt der Verifizierer oft fest, dass der Solver den Eigengewichtsterm in der Biegesteifigkeit weggelassen oder eine nominale Stahldichte verwendet hat, ohne sie konsistent umzurechnen. Da der Verifizierer ein separater Agent ist, erscheinen diese Fehler explizit in der Ausgabe, anstatt still absorbiert zu werden.

Beispiel 2: Symbolische Integration mit numerischem Gegencheck

Das zweite Beispiel zielt auf ein reines Mathematikproblem: ein bestimmtes Integral symbolisch zu berechnen und das Ergebnis dann numerisch zu verifizieren.

# run_math_check.py
from google import genai
from team import SOLVER, VERIFIER

client = genai.Client(project="your-project-id")

integral = "Integral from 0 to pi of exp(-x) * sin(2x) dx"

symbolic = client.models.generate_content(
    model=SOLVER["model"],
    contents=(
        f"{SOLVER['instruction']}\n\n"
        f"Compute this exactly: {integral}. Show the antiderivative."
    ),
).text

numerical_check = client.models.generate_content(
    model=VERIFIER["model"],
    contents=(
        f"{VERIFIER['instruction']}\n\n"
        f"The solver claims: {symbolic}\n\n"
        "Evaluate the claimed antiderivative at the endpoints, "
        "then approximate the integral with at least 5-point Simpson's rule. "
        "State whether the two agree to 1e-6."
    ),
).text

print("SYMBOLIC RESULT ->")
print(symbolic)
print("\nNUMERICAL CHECK ->")
print(numerical_check)

Der Verifizierer vertraut hier der symbolischen Maschinerie nicht. Er leitet die Endpunktwerte neu ab und führt seine eigene numerische Integration durch. Dies fängt eine häufige Fehlerklasse: eine korrekt aussehende Stammfunktion, die sich von der wahren um eine Konstante unterscheidet, was den Wert des bestimmten Integrals stillschweigend korrumpieren würde.

Was die Quelle sagt und was nicht

Das Evidenzniveau für die zentrale Behauptung ist A: Eine zugängliche Primärquelle wurde verifiziert. Was sie belegt, ist, dass die Kombination aus Antigravity und Gemini 3.7 Flash bemerkenswerte Multi-Agent-Probleme im Mathematik- und Ingenieurbereich löst.

Was sie nicht belegt, und was dieser Artikel daher nicht behauptet, umfasst:

• Keine Leistungsbenchmarks. Hier werden keine Durchsatzahlen, Genauigkeitsprozentsätze oder Latenztabellen berichtet.
• Keine Produktpreise oder Kontingente. Zugriffskosten und Ratengrenzen variieren je nach Google Cloud-Projektkonfiguration.
• Keine Garantie für jede Problemklasse. Die verifizierte Behauptung betrifft bemerkenswerte gelöste Probleme, nicht universelle Überlegenheit gegenüber allen anderen Multi-Agent-Frameworks.
• Keine spezifische Versionskompatibilitätsmatrix. Die in den Beispielen verwendete Modellkennung gemini-3.7-flash folgt Standard-SDK-Konventionen, aber die genaue Verfügbarkeit hängt von der Region und der installierten SDK-Version ab.

Behandeln Sie die Quelle als Beleg dafür, dass die Kombination eine funktionierende Lösung ist, nicht als Beleg dafür, dass sie die einzige Lösung ist. Das architektonische Argument für Rollentrennung steht für sich selbst; die Quelle bestätigt, dass Google diese spezifische Kombination an realen technischen Aufgaben erprobt hat.

Fazit

Multi-Agent-Systeme machen Modelle nicht klüger. Sie machen Fehler sichtbar. Ein Solver, der erzeugt, ein Verifizierer, der angreift, und ein Integrator, der abgleicht, schaffen eine Arbeitsbeziehung, in der kein einzelner Schritt nur deshalb vertraut wird, weil er selbstbewusst klang. Google Antigravity gibt dieser Beziehung einen Arbeitsbereich, und Gemini 3.7 Flash gibt jeder Rolle einen fähigen und schnellen Reasoner.

Für Mathematik- und Ingenieuraufgaben ist dies wichtiger als für allgemeine Textgenerierung. Eine verspätete Nominalphrase in einem Aufsatz ist ein Stilproblem; eine weggelassene Einheitenumrechnung in einer Balkenanalyse ist ein struktureller Einsturz. Die Kombination von Antigravity mit Gemini 3.7 Flash — verifiziert als Lösung für bemerkenswerte Multi-Agent-Probleme in diesem Bereich — verwandelt die Fragilität eines einzelnen Agenten in eine handhabbare, überprüfbare Pipeline.

Der Aufbau ist bescheiden: eine virtuelle Umgebung, das Google GenAI SDK, authentifizierte Anmeldedaten und ein Drei-Rollen-Agententeam, das in ein paar Zeilen Python definiert ist. Der Nutzen ist, dass die Pipeline, wenn sie versagt, laut und spezifisch versagt. Der Verifizierer sagt Ihnen genau, welchen Schritt er nicht reproduzieren konnte. Das ist der Unterschied zwischen einer KI, die Mathematikprobleme schlimmer macht, und einer, die Ingenieuren wirklich hilft, ihren Zahlen zu vertrauen.