Gemini 4 Hydrogen vs 3.8 Flash : vitesse, outils et coût

Sommaire
  1. Qu’apporte Hydrogen par rapport à 3.8 Flash ?
  2. Quelles fonctions d’Hydrogen un agent peut-il utiliser aujourd’hui ?
  3. Comment avons-nous mesuré la réussite d’une tâche d’agent ?
  4. Quel gain de vitesse sur les tâches simples ?
  5. Que s’est-il passé lors des défaillances d’outils ?
  6. Les modèles ont-ils réussi les corrections intermodules ?
  7. Quel effet a eu le relèvement du plafond par appel sur les migrations ?
  8. Quel modèle évaluer pour votre workflow ?
  9. FAQ
  10. Hydrogen coûtait-il moins cher par tâche terminée ?
  11. Pourquoi nos gains de vitesse diffèrent-ils des 2.5x de Google ?
  12. Hydrogen a-t-il besoin de xhigh pour regrouper les appels d’outils ?

Gemini 4 Hydrogen a terminé plus vite que Gemini 3.8 Flash dans 15 des 16 paires de tâches simples exécutées via Synthorai. Les deux modèles ont produit un résultat valide dans chaque paire. Google a lancé Hydrogen le 12 novembre 2026 pour les tâches de développement courantes et les agents utilisant des outils. Sur nos cas de test plus difficiles, Hydrogen a mené à bien davantage de modifications de code, tandis que Flash coûtait moins cher par rapprochement validé. Évaluation publiée par Google au lancement

TL;DR

  • Hydrogen et 3.8 Flash ont chacun réussi 16/16 exécutions simples. Le temps médian était de 8.59 contre 16.88 secondes.
  • Les deux modèles ont réussi 4/4 exécutions avec des défaillances d’outils programmées. Hydrogen a été plus rapide dans chaque paire, et Flash moins cher par réussite.
  • Hydrogen a réussi 4/4 corrections touchant plusieurs modules avec un plafond de 2,048 tokens par appel, et 3/4 migrations à 4,096. Flash a réussi 0/4 dans chaque groupe.
  • Hydrogen a regroupé trois lectures et renvoyé le bon résultat dans 4/4 sessions dédiées.

Qu’apporte Hydrogen par rapport à 3.8 Flash ?

Google annonce un meilleur score à Terminal-Bench 4.1 et une exécution plus rapide des tâches pour Gemini 4 Hydrogen par rapport à Gemini 3.8 Flash. Évaluation publiée par Google au lancement

Comparaison de Google au lancementMesureGemini 4 HydrogenGemini 3.8 Flash
Terminal-Bench 4.1Score moyen sur des tâches en terminal, corrigé pour tenir compte de la triche57.0%18.2%
Vitesse d’exécution des tâchesPar rapport à 3.8 Flash dans la comparaison de Google au lancement2.5x avec le réglage par défaut highRéférence 1.0x
Niveau de raisonnement natif par défautRéglage appliqué lorsque le paramètre est omis dans l’API de Googlehighmedium

Google a évalué Hydrogen sur Terminal-Bench 4.1 avec le niveau high, à raison de cinq tentatives par tâche, avec le runner mini-swe-agent vision. L’annonce ne donne ni durées absolues, ni protocole de chronométrage complet, ni réglage de raisonnement de Flash pour la comparaison à 2.5x. Notre étude utilise d’autres tâches et mesure le temps écoulé via Synthorai jusqu’à la validation finale. Elle permet de vérifier si cet avantage de vitesse se retrouve aussi dans ces workflows. Méthodologie d’évaluation de Google

Hydrogen ajoute le niveau xhigh pour approfondir le raisonnement. Google cite aussi le regroupement des lectures de fichiers et des appels de recherche parmi les améliorations apportées aux workflows d’agents. L’exemple suivant vérifie le comportement du regroupement des appels d’outils, du renvoi des signatures et du niveau de raisonnement supérieur via Synthorai. Guide de développement Hydrogen · Évaluation publiée par Google au lancement

Quelles fonctions d’Hydrogen un agent peut-il utiliser aujourd’hui ?

Gemini 4 Hydrogen a regroupé trois lectures indépendantes d’un catalogue dans sa première réponse lors des quatre sessions Synthorai Chat Completions. Le catalogue contenait les valeurs North = 17, South = 29 et West = 31. Nous avons demandé au modèle de lancer les lectures ensemble et d’en renvoyer la somme, 77. Chaque requête avait un plafond de sortie de 1,024 tokens.

Dans chaque groupe, seul le premier appel d’outil portait une signature de raisonnement. Cette métadonnée aide l’API à poursuivre le raisonnement du modèle d’un appel d’outil à l’autre. Nous avons renvoyé le message de l’assistant sans le modifier, suivi des trois résultats d’outils dans l’ordre des appels. Hydrogen a renvoyé la bonne somme à chaque fois. Les nombres de tokens de raisonnement ci-dessous cumulent les deux requêtes au modèle de chaque session : celle qui demande les appels d’outils et celle qui fournit la réponse finale. Guide de développement Hydrogen de Google

Effort demandéTrois lectures dans une même réponseRéponse finale correcteTokens de raisonnement déclarés par session
medium2/22/295, 130
xhigh2/22/2245, 287

Regroupez les lectures indépendantes. L’exploration d’un dépôt, la recherche documentaire et les vérifications sur des enregistrements indépendants peuvent nécessiter moins de tours de modèle si toutes les lectures sont demandées ensemble. Le client peut aussi exécuter ces lectures en parallèle si les outils et leurs limites de débit le permettent. Gardez les étapes dépendantes séquentielles, par exemple l’écriture d’un correctif puis son test. Notre client exécutait les outils de façon séquentielle.

Conservez les signatures de raisonnement pendant l’aller-retour avec les outils. Ce point mérite une vérification particulière lors de la migration d’un agent qui stocke ou reconstruit les messages entre les requêtes. Conservez le message complet de l’assistant, avec la signature à son emplacement d’origine, et rattachez chaque résultat à l’identifiant de son appel d’outil. Si le client exécute les outils en parallèle, rassemblez les résultats puis renvoyez-les dans l’ordre initial des appels. L’API native de Google documente aussi la conservation des signatures sur le texte final et les règles de modification de l’historique de conversation. Notre vérification via la passerelle portait sur l’aller-retour signé avec les outils. Guide de développement Hydrogen de Google

Cette fonction Python effectue le renvoi une fois les outils exécutés. Elle construit l’historique de la requête suivante à partir de la réponse brute Chat Completions et d’un dictionnaire de résultats sérialisables en JSON, indexés par identifiant d’appel d’outil.

import json


def append_tool_turn(messages, response, results_by_id):
    assistant = response["choices"][0]["message"]
    tool_messages = [
        {
            "role": "tool",
            "tool_call_id": call["id"],
            "content": json.dumps(results_by_id[call["id"]]),
        }
        for call in assistant["tool_calls"]
    ]
    return [*messages, assistant, *tool_messages]

Établissez une référence avec medium avant d’augmenter l’effort. Google propose XHIGH comme niveau de raisonnement natif. Synthorai a accepté reasoning_effort: "xhigh" dans les deux sessions et déclaré davantage de tokens de raisonnement. Les deux réglages ont résolu la recherche. Nos corrections intermodules et nos migrations réussies utilisaient elles aussi medium. Commencez par ce réglage et relevez les livraisons validées, le temps écoulé et le coût par réussite. Pour les tâches difficiles qui échouent, comparez high et xhigh à cette même référence, avec les mêmes tests d’acceptation. Prévoyez assez de marge dans le plafond de sortie pour le correctif ou les arguments des outils, car le raisonnement consomme lui aussi ce budget. Guide de développement Hydrogen de Google

Comment avons-nous mesuré la réussite d’une tâche d’agent ?

Nous avons comparé huit tâches simples et six tâches complexes, avec deux exécutions par tâche et par modèle. La série de migrations au plafond relevé reprenait deux tâches complexes pour huit exécutions supplémentaires. Un contrôle distinct, sans réglage d’effort, a porté sur quatre tâches simples exécutées une fois par modèle. Il s’agit d’observations répétées sur un petit ensemble de tâches.

Une exécution était réussie si le fichier ou le correctif final passait les contrôles automatisés dans les 300 secondes. Pour les tâches de données, les contrôles vérifiaient les valeurs et les références aux sources. Pour le code, les tests s’exécutaient dans un environnement isolé. Les tâches de code les plus difficiles exigeaient aussi des tests de non-régression écrits par l’agent : ils devaient passer sur le correctif, et leur suite devait échouer sur le code d’origine. L’évaluateur des migrations vérifiait par mots-clés la présence des sujets requis dans le README. Par exemple, les deux exécutions CSV de Flash ont écrit un fichier valide avant de s’arrêter sur une limite de tokens. Toutes deux ont été comptées comme des livraisons terminées.

Nous avons utilisé les mêmes prompts, outils, entrées et contrôles pour Hydrogen et 3.8 Flash via Synthorai Chat Completions. Chaque exécution partait d’un espace de travail vierge et d’un marqueur unique dans le prompt pour réduire la réutilisation de requêtes identiques. Nous lancions une seule session à la fois et alternions le modèle exécuté en premier. Nos comparaisons principales demandaient reasoning_effort: "medium" aux deux modèles. Une même valeur peut entraîner une consommation de raisonnement différente. Le contrôle distinct sans réglage d’effort omettait ce champ et relevait le comportement exposé par la passerelle.

SérieNombre maximal d’appels au modèle par tâcheNombre maximal de tokens de sortie par appel
Tâches simples, contrôle sans effort inclus82,048
Tâches complexes, comparaison initiale des migrations incluse102,048
Migrations au plafond relevé104,096

Le runner conservait un budget cumulé de 8,000 tokens de sortie par tâche. Le plafond par appel couvre le raisonnement, les arguments des outils et le texte visible. Avant d’envoyer une requête, le runner additionnait la consommation d’entrée déclarée jusque-là et une estimation prudente de la requête suivante, puis vérifiait que le total restait sous le seuil de 40,000 tokens.

Nous mesurons le temps réel écoulé entre la première requête API et la validation finale, exécution des outils comprise. Nous comparons le délai de livraison uniquement pour les paires où les deux modèles ont réussi. Le coût par réussite est la somme des frais déclarés par la passerelle pour toutes les tentatives d’un groupe, échecs compris, divisée par le nombre de réussites. S’il n’y a aucune réussite, ce coût n’est pas défini.

Quel gain de vitesse sur les tâches simples ?

Hydrogen et 3.8 Flash ont réussi toutes les exécutions simples. Ces huit cas de test couvraient de petits workflows de données et de documents, ainsi que des modifications de code ciblées. Le temps médian d’Hydrogen était environ deux fois plus court que celui de Flash. Hydrogen a effectué 60 appels au modèle sur l’ensemble de ses exécutions, contre 81 pour Flash.

ModèleRéussitesTemps médian de bout en boutCoût totalCoût par réussite
Hydrogen16/168.59 s$0.1365$0.00853
3.8 Flash16/1616.88 s$0.1429$0.00893

Le rapport entre la médiane de Flash et celle d’Hydrogen donne un gain de vitesse de 1.97x. Lors d’un contrôle distinct sur quatre tâches sans réglage d’effort, les deux modèles ont de nouveau tout réussi. Hydrogen a été plus rapide dans les quatre paires. Les médianes étaient respectivement de 8.26 et 13.54 secondes, soit un rapport de 1.64x, pour des coûts totaux de $0.0248 et $0.0198. Les deux comparaisons vont dans le sens du gain de vitesse annoncé par Google, selon nos tâches et notre définition du temps mesuré.

La série de tâches simples avec medium a coûté légèrement moins cher avec Hydrogen. Si l’on exclut les deux paires CSV, l’ordre s’inverse : $0.1025 pour Hydrogen et $0.0831 pour Flash. La répartition des workflows peut donc changer le modèle le moins cher, même lorsque les deux réussissent toutes les tâches.

Que s’est-il passé lors des défaillances d’outils ?

Hydrogen et 3.8 Flash ont chacun terminé les quatre exécutions de reprise sur erreur. Dans les deux tâches synthétiques de rapprochement, le fichier principal des remboursements renvoyait toujours un résultat vide, et la première lecture des règlements renvoyait toujours une erreur transitoire. L’agent devait lire l’archive, retenter la lecture des règlements et produire les bons montants avec leurs références aux sources. Les deux modèles ont suivi ce parcours à chaque fois.

Hydrogen a terminé plus vite dans les quatre paires, avec une médiane de 12.93 secondes contre 17.48 secondes. Son coût par rapprochement validé était de $0.0120, contre $0.0079 pour Flash. Google met en avant la reprise après un échec d’outil ou un résultat vide. Les deux modèles l’ont démontrée ici, avec des consignes explicites de repli et de nouvelle tentative. Chaque modèle a demandé plusieurs lectures dans 8/20 réponses sur cette charge de travail. La rapidité observée ne permet donc pas d’attribuer le gain au seul regroupement des appels.

Les modèles ont-ils réussi les corrections intermodules ?

Hydrogen a réussi quatre exécutions sur quatre, et 3.8 Flash zéro sur quatre. Dans ces tâches de conversion d’unités et de devises, le point d’entrée passait par un adaptateur avant d’atteindre le convertisseur utilisé. Les deux dépôts contenaient aussi un convertisseur au nom similaire, hors du périmètre de la modification demandée. L’évaluateur exigeait de corriger le chemin réellement utilisé et d’ajouter un test de non-régression.

Flash a omis le test de non-régression lors des deux exécutions sur les unités. Lors des deux exécutions sur les devises, il s’est arrêté avant de livrer la modification du convertisseur utilisé et le test. Hydrogen a terminé les quatre exécutions pour $0.0722, soit $0.01805 par réussite. Les quatre tentatives de Flash ont coûté $0.0553. Aucune paire de cette série n’a été réussie par les deux modèles, ce qui empêche une comparaison directe de vitesse.

Quel effet a eu le relèvement du plafond par appel sur les migrations ?

Hydrogen a réussi trois migrations sur quatre avec un plafond de 4,096 tokens par appel. 3.8 Flash n’en a réussi aucune. Les deux cas de test d’importeurs exigeaient une règle conditionnelle sur un champ, la prise en charge des champs numérotés, la rétrocompatibilité, des tests de non-régression et une documentation mise à jour. Nous avons modifié le plafond par appel sans changer les cas de test, l’évaluateur, l’effort demandé medium, la limite de 10 appels, le budget cumulé de 8,000 tokens de sortie, le garde-fou d’entrée ni le délai maximal.

Plafond par appelModèleRéussitesCoût totalCoût par réussite
2,048Hydrogen0/4$0.0719Non défini
2,0483.8 Flash0/4$0.0995Non défini
4,096Hydrogen3/4$0.1894$0.0631
4,0963.8 Flash0/4$0.1163Non défini

Avec le plafond relevé, Hydrogen a terminé les deux exécutions de comptage et une exécution d’expédition. Lors de l’autre exécution d’expédition, une réponse a consacré 3,877 des 4,096 tokens de sortie déclarés au raisonnement et s’est terminée sans appel d’écriture de fichier. Les deux exécutions d’expédition de Flash ont été arrêtées par le garde-fou budgétaire du runner. Le journal utilise le même motif pour le seuil d’entrée estimé et le contrôle du budget de sortie restant : il ne permet pas de les distinguer. Une exécution de comptage de Flash a écrit les fichiers, mais a échoué au contrôle du champ conditionnel avant d’atteindre la limite d’appels. L’autre a atteint le plafond de sortie par appel avant d’écrire les fichiers.

Les deux réglages de plafond ont été testés l’un après l’autre, avec deux répétitions par cas. Le résultat indique ce qui a été livré dans ces configurations. La variabilité de génération et le moment d’exécution des séries peuvent aussi avoir contribué au changement. Les échecs de Flash ne permettent pas de conclure sur ses résultats avec d’autres limites.

Quel modèle évaluer pour votre workflow ?

Sur les six tâches complexes avec un plafond de 2,048 tokens par appel, Hydrogen a réussi 8/12 exécutions et 3.8 Flash 4/12. Ce total comprend, pour chaque modèle, quatre tentatives de reprise sur erreur, quatre corrections intermodules et quatre migrations. La série de migrations à 4,096 tokens est présentée séparément plus haut. La facture totale d’Hydrogen était légèrement supérieure, mais répartie sur deux fois plus de livraisons acceptées.

ModèleRéussitesCoût totalCoût par réussite
Hydrogen8/12$0.1922$0.0240
3.8 Flash4/12$0.1866$0.0466

Pour une boucle de rapprochement fixe avec une procédure de repli documentée, 3.8 Flash est le candidat le moins cher dans notre échantillon. Choisissez Hydrogen si le gain de temps observé compte davantage pour ce workflow. Pour des modifications sur plusieurs fichiers qui doivent être livrées avec des tests, commencez par évaluer Hydrogen sur vos propres dépôts. Mesurez le délai jusqu’à l’acceptation du correctif, le taux de réussite et la facture complète. Si le modèle s’arrête avant d’écrire le correctif, consignez précisément la limite atteinte. Une réponse tronquée et un nombre maximal d’appels atteint n’appellent pas le même ajustement.

FAQ

Hydrogen coûtait-il moins cher par tâche terminée ?

Hydrogen coûtait moins cher par réussite sur notre série mixte de tâches complexes, où il a terminé davantage de tâches. 3.8 Flash coûtait moins cher par réussite sur le sous-ensemble des rapprochements, où les deux modèles ont réussi toutes les exécutions.

Pourquoi nos gains de vitesse diffèrent-ils des 2.5x de Google ?

Hydrogen et 3.8 Flash ont exécuté nos petits workflows via Synthorai, avec un chronométrage allant jusqu’à la validation finale. Notre comparaison principale demandait medium aux deux modèles. Google évalue Hydrogen à high sur sa propre charge de travail et fournit peu de détails sur le chronométrage. Les rapports de 1.97x et 1.64x concernent nos deux séries de tâches simples.

Hydrogen a-t-il besoin de xhigh pour regrouper les appels d’outils ?

Hydrogen a regroupé les trois lectures avec medium comme avec xhigh lors du contrôle sur le catalogue. Le réglage supérieur a consommé davantage de tokens de raisonnement déclarés et renvoyé la même réponse correcte.

← Retour au blog