Google Antigravity et Gemini 3.7 Flash : un correctif multi-agent pour les tâches de mathématiques et d'ingénierie

Google Antigravity et Gemini 3.7 Flash : une solution multi-agents pour les tâches de mathématiques et d'ingénierie

La dérivation mathématique et le calcul d'ingénierie partagent une propriété difficile : ils punissent les petites erreurs au milieu de longues chaînes. Un signe mal placé, une conversion d'unités oubliée ou une condition limite non vérifiée peuvent invalider tout ce qui suit. Les modèles de langage généralistes sont réellement capables de produire des étapes intermédiaires plausibles, mais la plausibilité n'est pas la même chose que l'exactitude. Lorsque la tâche est une analyse de poutre en 30 étapes ou une intégration symbolique qui doit survivre à une vérification numérique, un agent unique travaillant seul va à l'encontre de la discipline qu'exige la tâche.

La solution utile n'est pas un modèle plus grand ni une invite plus longue. C'est un changement structurel : répartir le travail entre des agents spécialisés capables de critiquer, vérifier et recalculer mutuellement leurs sorties. Google Antigravity associé à Gemini 3.7 Flash est un exemple concret de cette idée. Selon le blog Google AI, cette association résout des problèmes notables de mathématiques et d'ingénierie en mode multi-agents que les workflows à agent unique laissent non résolus. Cet article explique pourquoi cette association fonctionne, comment la configurer et comment l'utiliser pour des tâches techniques réalistes.

Les limites structurelles d'un agent unique

Un appel unique à un LLM est, par conception, un passage unique d'attention sur une fenêtre de contexte. Il peut planifier, mais il ne peut pas facilement alterner entre planification et vérification sans mécanisme externe. En mathématiques et en ingénierie, c'est une limitation sérieuse.

Prenons un problème d'ingénierie : calculer la flèche maximale d'une poutre simplement appuyée sous une charge répartie, en incluant l'effet du poids propre de la poutre. La tâche exige :

• de récupérer les propriétés des matériaux et leurs unités,
• de poser une équation différentielle du bon ordre,
• d'appliquer les conditions aux limites,
• d'intégrer symboliquement ou numériquement,
• puis de convertir le résultat en une réponse correcte en unités et vérifiée par tolérance.

Un agent unique pourrait bien gérer la mise en place, puis commettre une erreur discrète à la troisième étape d'intégration. Si rien ne vérifie le résultat intermédiaire, l'erreur se propage. Pire encore, la confiance de l'agent dans ses propres étapes antérieures tend à le faire résister à la révision lorsqu'une divergence apparaît. Le mode de défaillance n'est pas un manque d'intelligence ; c'est un manque de séparation entre les rôles de produire un résultat et de le contester.

Une structure multi-agents corrige cela par construction. Un agent solveur produit. Un agent vérificateur attaque. Un agent intégrateur réconcilie. Aucun d'eux n'est invité à être impartial à propos de sa propre sortie, car ils ne vérifient pas du tout leur propre sortie.

Ce que change l'association Antigravity et Gemini 3.7 Flash

Le fait vérifié, provenant du blog Google AI, est précis : l'association de Google Antigravity avec Gemini 3.7 Flash résout des problèmes notables de mathématiques et d'ingénierie en mode multi-agents. La source a été vérifiée le 2026-08-31 et est accessible à l'adresse :

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

Ce que cette association fournit, au niveau architectural, c'est un espace de travail et un raisonneur conçus l'un pour l'autre. Antigravity fournit l'échafaudage collaboratif : le contexte du projet, la structure de l'équipe, la capacité d'acheminer les messages entre les rôles, et un endroit pour les artefacts tels que les expressions symboliques, les résultats numériques et les définitions d'unités. Gemini 3.7 Flash fournit le raisonnement à l'intérieur de chaque rôle. Il est suffisamment rapide pour que les boucles de vérification ne deviennent pas des goulots d'étranglement interactifs, et il est suffisamment solide en raisonnement symbolique et numérique pour agir comme un critique crédible du travail d'un autre agent.

Il est important d'être précis sur ce qui est vérifié et ce qui relève de l'interprétation. L'affirmation vérifiée est que l'association résout des problèmes notables de mathématiques et d'ingénierie en mode multi-agents. L'explication du pourquoi cela fonctionne — séparation des rôles, structure de l'espace de travail, boucles de vérification — est une interprétation raisonnable de ce fait, et non une affirmation séparée vérifiée. Cet article maintient ces deux niveaux distincts.

Pourquoi ne pas simplement utiliser un modèle plus intelligent ?

Il y a une tentation compréhensible de contourner le mécanisme multi-agents et d'appeler un modèle de raisonnement de pointe avec une invite longue et soigneusement conçue. Pour l'arithmétique simple, cela fonctionne. Pour de véritables tâches d'ingénierie, cela échoue pour des raisons qui n'ont rien à voir avec la capacité brute.

Premièrement, la vérification exige de se comporter comme un agent différent. Un modèle qui vient de dériver une équation de flèche est mal placé pour se méfier de sa propre étape de substitution. Il a investi dans cette étape. Un agent vérificateur séparé, reparti de zéro, ne porte pas cet investissement.

Deuxièmement, les problèmes d'ingénierie génèrent des artefacts hétérogènes : équations, matrices, conversions d'unités, tables de correspondance de propriétés des matériaux, intégrations numériques. Une fenêtre de contexte unique qui contient tout cela à la fois devient un fouillis. Une configuration multi-agents peut maintenir la couche symbolique séparée de la couche numérique et ne les fusionner qu'à des points de contrôle explicites.

Troisièmement, il y a un avantage de débogage qui n'a rien à voir avec la qualité du modèle. Lorsqu'un pipeline multi-agents produit une mauvaise réponse, le journal vous montre quel rôle a échoué. Le solveur a-t-il produit une condition limite invalide ? Le vérificateur a-t-il utilisé la mauvaise tolérance ? L'agent intégrateur a-t-il mélangé les unités ? Les échecs d'un agent unique ne sont pas accompagnés de cette structure de diagnostic. La combinaison d'Antigravity et de Gemini 3.7 Flash donne à chaque échec une adresse précise.

Prérequis

Avant d'installer quoi que ce soit, assurez-vous que l'environnement peut prendre en charge le workflow :

• Python 3.11 ou plus récent pour les scripts d'orchestration et le SDK Google GenAI.
• Un projet Google Cloud avec l'API Generative AI activée.
• Application Default Credentials sur la machine, ou une clé API pour les expériences locales.
• Le client Antigravity installé et capable d'ouvrir un espace de travail de projet.
• Un accès réseau aux points de terminaison de l'API Google.
• Un éditeur de code — Antigravity fournit lui-même une surface d'édition, mais les exemples ci-dessous supposent que vous pouvez travailler avec des fichiers Python simples.

Aucun matériel spécifique n'est requis au-delà de ce que l'API du modèle exige d'une machine cliente ; le calcul intensif se fait du côté de Google. L'accès à Gemini 3.7 Flash est soumis aux mêmes règles de quota et de disponibilité que les autres modèles GenAI. Vérifiez donc la disponibilité régionale actuelle dans la console Google Cloud plutôt que de supposer un accès universel.

Installation pas à pas

L'installation comporte trois parties : préparer un environnement Python, s'authentifier auprès de Google Cloud, et créer la définition de l'équipe d'agents qu'Antigravity exécutera.

1. Créer un répertoire de projet

Choisissez un espace de travail pour le projet et déplacez-vous dedans :

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

Ce répertoire contiendra les définitions d'agents, le script d'orchestration et les artefacts produits par chaque exécution.

2. Créer et activer un environnement virtuel

Un environnement virtuel isole les dépendances du SDK Google de votre Python système :

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

Vous devriez voir l'invite du shell changer pour indiquer que l'environnement virtuel est actif.

3. Installer le SDK Google GenAI

Le SDK est nécessaire pour appeler Gemini 3.7 Flash depuis Python :

pip install --upgrade google-genai

Cela installe le paquet google-genai actuel et ses dépendances transitives.

4. S'authentifier avec Application Default Credentials

Pour une machine de développement locale, la voie standard est l'ADC :

gcloud auth application-default login

Suivez le flux navigateur pour terminer la connexion. Les identifiants sont stockés localement et récupérés automatiquement par le SDK. Pour un serveur ou un environnement CI, une clé de compte de service assignée via GOOGLE_APPLICATION_CREDENTIALS est le modèle le plus approprié.

5. Vérifier que le SDK peut atteindre Gemini 3.7 Flash

Avant de construire l'équipe multi-agents, confirmez que l'identifiant du modèle se résout et qu'un appel de base fonctionne. Créez un fichier nommé 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)

Exécutez-le :

python smoke_test.py

Si le script affiche ok, le SDK, les identifiants et l'accès au modèle fonctionnent tous. Si l'authentification échoue, revérifiez l'étape ADC. Si l'identifiant du modèle est rejeté, consultez la liste des modèles dans la console de votre projet, car la chaîne d'identifiant exacte est soumise aux conventions de dénomination de la version du SDK installée.

6. Définir l'équipe d'agents

Antigravity traite les agents comme des membres d'équipe configurables avec des rôles, des instructions et une visibilité sur les artefacts partagés. Pour ce workflow, nous définissons trois rôles dans un fichier Python nommé team.py :

# team.py — role definitions for the math/engineering 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."
    ),
}

Le choix de conception clé est que l'instruction du vérificateur interdit la politesse. Il n'est pas invité à améliorer la réponse du solveur ; il est invité à la casser. Cette posture antagoniste est ce qui rend la boucle multi-agents plus fiable qu'un modèle unique faisant de l'auto-évaluation.

Exemples d'utilisation

Exemple 1 : Flèche d'une poutre simplement appuyée

Utilisons l'équipe pour une tâche d'ingénierie concrète : la flèche maximale d'une poutre en acier simplement appuyée, de longueur uniforme, avec une charge uniformément répartie en plus du poids propre de la poutre.

Le script d'orchestration exécute les trois agents en séquence et transmet la sortie du solveur à l'entrée du vérificateur :

# 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.")

Exécutez le script avec :

python run_beam_check.py

Le workflow est volontairement simple : résoudre, attaquer, intégrer. En pratique, le vérificateur constate souvent que le solveur a omis le terme de poids propre dans la rigidité de flexion ou a utilisé une densité nominale de l'acier sans la convertir de manière cohérente. Parce que le vérificateur est un agent séparé, ces défaillances apparaissent explicitement dans la sortie au lieu d'être silencieusement absorbées.

Exemple 2 : Intégration symbolique avec recoupement numérique

Le deuxième exemple cible un problème purement mathématique : calculer une intégrale définie symboliquement, puis vérifier le résultat numériquement.

# 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)

Ici, le vérificateur ne fait pas confiance au mécanisme symbolique. Il recalcule les valeurs aux bornes et effectue sa propre intégration numérique. Cela détecte une classe de défaillance courante : une primitive d'apparence correcte qui diffère de la vraie par une constante, ce qui corromprait silencieusement la valeur de l'intégrale définie.

Ce que la source dit et ne dit pas

Le niveau de preuve de l'affirmation centrale est A : une source primaire accessible a été vérifiée. Ce qu'elle établit, c'est que l'association d'Antigravity et de Gemini 3.7 Flash résout des problèmes notables de mathématiques et d'ingénierie en mode multi-agents.

Ce qu'elle n'établit pas, et que cet article ne prétend donc pas, comprend :

• Aucun benchmark de performance. Aucun chiffre de débit, pourcentage de précision ou tableau de latence n'est rapporté ici.
• Aucun prix de produit ni quota. Le coût d'accès et les limites de débit varient selon la configuration du projet Google Cloud.
• Aucune garantie pour chaque classe de problèmes. L'affirmation vérifiée concerne des problèmes notables résolus, et non une supériorité universelle sur tous les autres frameworks multi-agents.
• Aucune matrice de compatibilité de versions spécifique. L'identifiant de modèle gemini-3.7-flash utilisé dans les exemples suit les conventions standard du SDK, mais la disponibilité exacte dépend de la région et de la version du SDK installée.

Considérez la source comme une preuve que l'association est une solution fonctionnelle, et non comme une preuve qu'elle est la seule solution. L'argument architectural en faveur de la séparation des rôles tient debout par lui-même ; la source confirme que Google a exercé cette combinaison spécifique sur des tâches techniques réelles.

Conclusion

Les systèmes multi-agents ne servent pas à rendre les modèles plus intelligents. Ils servent à rendre les erreurs visibles. Un solveur qui produit, un vérificateur qui attaque et un intégrateur qui réconcilie créent une relation de travail dans laquelle aucune étape n'est simplement crue parce qu'elle semblait confiante. Google Antigravity donne à cette relation un espace de travail, et Gemini 3.7 Flash donne à chaque rôle un raisonneur compétent et rapide.

Pour les tâches de mathématiques et d'ingénierie, cela importe plus que pour la génération de texte générale. Un syntagme nominal décalé dans une dissertation est un problème de style ; une conversion d'unités omise dans une analyse de poutre est un effondrement structurel. L'association d'Antigravity avec Gemini 3.7 Flash — vérifiée comme solution à des problèmes notables de mathématiques et d'ingénierie en mode multi-agents dans ce domaine — transforme la fragilité d'un agent unique en un pipeline gérable et inspectable.

La configuration est modeste : un environnement virtuel, le SDK Google GenAI, des identifiants authentifiés et une équipe d'agents à trois rôles définie en quelques lignes de Python. Le bénéfice est que lorsque le pipeline échoue, il échoue de manière claire et spécifique. Le vérificateur vous dit exactement quelle étape il n'a pas pu reproduire. C'est la différence entre une IA qui aggrave les problèmes de mathématiques et une qui aide réellement les ingénieurs à faire confiance à leurs chiffres.