# Gemini 4 Argon : test de code sur 8 tâches et tests cachés

> Huit tâches, des tests cachés, un appel par modèle : Gemini 4 Argon et Claude Opus 5.5 réussissent les 105 vérifications sous Python 3.14, avec temps et coûts.

- Canonical HTML: https://omniakey.com/fr/blog/gemini-4-argon-coding-test
- Markdown: https://omniakey.com/fr/blog/gemini-4-argon-coding-test.md
- Published: 2026-11-04 (updated 2026-11-04)
- Author: Kiki, COO at OmniaKey
- Language: fr
- Category: Comparison
- Reading time: 10 min
- All posts: https://omniakey.com/blog/llms.txt

---

Nous avons confié les mêmes huit tâches à [Gemini 4 Argon](https://omniakey.com/fr/gemini-4-argon) et à [Claude Opus 5.5](https://omniakey.com/fr/claude-opus-5-5), avec un seul appel par tâche et des tests cachés qu'aucun des deux modèles ne pouvait voir. Sous Python 3.14, les deux réussissent les 105 vérifications. Argon a mis 139.6 secondes au total, contre 57.2 pour Opus 5.5, et a coûté $0.042 contre $0.112 au tarif catalogue de chaque fournisseur.

Huit tâches, une exécution chacune : voilà le comportement observé. Sur la correction, les deux modèles arrivent à égalité. Les écarts portent sur le temps, le coût et une réponse qui exige un Python plus récent. Google propose Argon en disponibilité générale depuis le 13 octobre 2026, et son tarif de lancement de $2 par million de tokens d'entrée et $10 par million de tokens de sortie court jusqu'au 30 novembre ; à partir du 1er décembre, il double à $4 et $20 (page tarifs de Google, consultée le 4 novembre 2026).

- **Gemini 4 Argon** (Argon si le coût prime): Les mêmes 105 vérifications pour $0.042 sur huit tâches au tarif Google. Plus lent partout, et une réponse demande Python 3.10 ou plus récent.
- **Claude Opus 5.5** (Opus 5.5 si la vitesse prime): Les mêmes 105 vérifications, 57.2 secondes au total et $0.112 au tarif d'Anthropic. Plus rapide sur les huit tâches.

## Notre méthode de test

Le 4 novembre 2026, nous avons envoyé chaque tâche à `gemini-4-argon` et `claude-opus-5-5`, un appel par tâche et par modèle, sans prompt système et sans réglage de raisonnement. Les deux tournaient à leur niveau par défaut : medium pour Argon ([documentation thinking de Google](https://ai.google.dev/gemini-api/docs/thinking), consultée le 4 novembre 2026) et medium pour Opus 5.5 ([documentation effort d'Anthropic](https://platform.claude.com/docs/en/build-with-claude/effort), le même jour). Chaque tâche a produit une réponse notée par modèle.

Le temps est la latence annoncée par le fournisseur pour chaque appel, additionnée ; nos exécutions de notation n'y entrent pas. Le coût applique le tarif catalogue de chaque fournisseur aux tokens renvoyés par l'API. OmniaKey vend aussi les deux modèles, donc le test est passé par lui avec une seule clé ; chaque prix ici est celui de Google ou d'Anthropic.

Un script extrayait le bloc de code de chaque réponse et l'exécutait contre un fichier `unittest` caché qu'aucun modèle n'avait vu, dans un processus Python isolé avec un délai maximum. La première passe a utilisé le Python 3.9.6 du système ; nous avons ensuite noté les mêmes réponses enregistrées sous Python 3.14.3, sans appel ni coût supplémentaire.

## Les huit tâches

Toutes sont de petits travaux Python qui tombent un jour normal : une correction de bug, deux petites classes, un refactor, un parseur, un formateur de durées, un assistant de planning et une recherche dans un graphe. Chaque énoncé décrivait le comportement attendu en prose simple ; aucun ne contenait les tests.

### Tâche 1 : corriger un bug de fusion d'intervalles

`merge_intervals` triait et fusionnait les plages, mais laissait séparées les paires qui se touchent, comme `(1, 3)` et `(3, 5)`. Une comparaison suffit.

- **Gemini 4 Argon** (5.6 s) : 12 sur 12.
- **Claude Opus 5.5** (2.9 s) : 12 sur 12.

**Verdict :** égalité sur les vérifications. Opus a répondu en moitié moins de temps.

### Tâche 2 : un limiteur de débit à seau de jetons

`TokenBucket(rate_per_second, capacity)` devait se remplir en continu, rester sous la capacité et gérer des valeurs de `now` qui reculent.

- **Gemini 4 Argon** (6.6 s) : 10 sur 10.
- **Claude Opus 5.5** (4.8 s) : 10 sur 10.

**Verdict :** égalité. Les deux ont géré l'horloge qui recule.

### Tâche 3 : un cache LRU avec compteurs de succès et d'échecs

`LRUCache` demandait l'ordre d'éviction, la mise à jour sur place, les compteurs de `stats()` et la liste des clés du moins récemment utilisé au plus récent.

- **Gemini 4 Argon** (7.1 s) : 10 sur 10.
- **Claude Opus 5.5** (4.1 s) : 10 sur 10.

**Verdict :** égalité. Opus a été 3 s plus rapide.

### Tâche 4 : refactoriser sans changer le comportement

Le module fonctionnait. La réponse devait garder `slugify` et `slug_counts` et se comporter pareil sur les lettres Unicode, la ponctuation et les séparateurs répétés.

- **Gemini 4 Argon** (15.9 s) : 12 sur 12.
- **Claude Opus 5.5** (8.7 s) : 12 sur 12.

**Verdict :** égalité. Les deux ont conservé tous les cas fixés.

### Tâche 5 : transformer une ligne de log en dict

Un parseur `key=value` avec valeurs entre guillemets, guillemets échappés et barres obliques inverses, un horodatage UTC, et `ValueError` pour les clés en double, un `key=` vide et les entrées fantaisistes.

- **Gemini 4 Argon** (16.1 s) : 13 sur 13.
- **Claude Opus 5.5** (10.9 s) : 13 sur 13.

**Verdict :** égalité. Les deux ont réussi l'échappement du premier coup.

### Tâche 6 : formater et analyser des durées

`format_duration` et `parse_duration` devaient arrondir la moitié loin de zéro, supprimer les parties vides (3601 devient 1h1s), refuser les formes invalides et faire l'aller-retour sur chaque valeur. Les jours ne s'affichent pas : 90000 devient 25h.

- **Gemini 4 Argon** (60.9 s) : 0 sur 14 sous Python 3.9, 14 sur 14 sous 3.14.
- **Claude Opus 5.5** (14.0 s) : 14 sur 14 sur les deux.

**Verdict :** égalité sous 3.14. Sous 3.9, la réponse d'Argon ne s'importait même pas, ce que raconte la section suivante.

### Tâche 7 : trouver les créneaux libres de salles de réunion

`free_slots` devait découper les réservations sur la journée de travail, fusionner celles qui se touchent, écarter les trous de moins de 15 minutes et refuser les entrées invalides.

- **Gemini 4 Argon** (18.9 s) : 17 sur 17.
- **Claude Opus 5.5** (5.0 s) : 17 sur 17.

**Verdict :** égalité sur les vérifications. Argon a pris presque quatre fois plus de temps.

### Tâche 8 : plus court chemin avec départage

`shortest_path` demandait Dijkstra avec le chemin le plus petit dans l'ordre lexicographique parmi les chemins de même longueur, plus les arêtes parallèles, les boucles et le cas sans chemin.

- **Gemini 4 Argon** (8.5 s) : 17 sur 17.
- **Claude Opus 5.5** (6.8 s) : 17 sur 17.

**Verdict :** égalité. Le plus serré des huit.

## Résultats : réussites, temps et coût

Sous Python 3.14, les deux modèles réussissent les 105 vérifications. Sous Python 3.9.6, Argon en réussit 91, parce qu'une réponse n'a pas pu être importée.

|Tâche|Vérifications|Argon|Opus 5.5|Argon s|Opus s|
|-|-|-|-|-|-|
|Fusion d'intervalles|12|12/12|12/12|5.6|2.9|
|Seau de jetons|10|10/10|10/10|6.6|4.8|
|Cache LRU|10|10/10|10/10|7.1|4.1|
|Refactor slugify|12|12/12|12/12|15.9|8.7|
|Ligne de log|13|13/13|13/13|16.1|10.9|
|Durées|14|14/14|14/14|60.9|14.0|
|Créneaux de salles|17|17/17|17/17|18.9|5.0|
|Plus court chemin|17|17/17|17/17|8.5|6.8|

Opus 5.5 a répondu plus vite sur chaque tâche. L'écart le plus court était sur le graphe (8.5 s contre 6.8 s), le plus large sur les durées (60.9 s contre 14.0 s).

Au tarif catalogue, les huit tâches coûtent $0.042 avec Argon et $0.112 avec Opus 5.5, environ 2.7 fois plus. Les réponses d'Argon ont utilisé 3,346 tokens d'entrée et 3,525 de sortie au total ; celles d'Opus 5.5, 4,419 et 4,692. Les deux API annoncent 0 token de réflexion à chaque appel, donc le raisonnement n'a rien ajouté à la facture.

Le tarif catalogue de Google est de $2 par million de tokens d'entrée et $10 par million de tokens de sortie jusqu'au 30 novembre 2026, puis $4 et $20 ([tarifs de l'API Gemini](https://ai.google.dev/gemini-api/docs/pricing), consultés le 4 novembre 2026). Celui d'Anthropic pour Opus 5.5 est de $4 et $20 ([tarifs Anthropic](https://platform.claude.com/docs/en/about-claude/pricing), le même jour). À partir du 1er décembre, les mêmes tokens coûtent deux fois plus cher avec Argon, ce qui rapproche les deux. Les tarifs des deux modèles figurent sur [la page tarifs](https://omniakey.com/fr/pricing).

Huit tâches ne séparent pas deux modèles de frontière sur la qualité. Choisissez selon la vitesse, le prix et la version de Python qui fait tourner vos tests.

### Ce qu'en disent les utilisateurs

Le clivage apparaît aussi dans les commentaires publics. Sur [Hacker News, le 31 octobre](https://news.ycombinator.com/item?id=50312107), A\_D\_E\_P\_T écrit : « Gemini 4-Argon is very good at coding. I prefer Opus 5.5 -- in large part because I've grown accustomed to Claude Code -- but Argon is undeniably strong. » Le [28 octobre](https://news.ycombinator.com/item?id=50277901), seizethecheese écrit à propos des agents de code locaux : « Argon is really bad. Literally the worst model in our initial ranking », avec Opus 5.5 en tête. Le [13 octobre](https://news.ycombinator.com/item?id=50077034), ariwilson rapporte qu'Argon a « solved 10 of 11 » petites corrections de bugs de ses propres projets.

Ce sont des avis d'utilisateurs sur leur propre environnement, pas des tests contrôlés. Le commentaire négatif vient de quelqu'un qui testait un harnais d'agent, pas d'un appel d'API direct comme les nôtres.

## Le seul échec : Python 3.9 n'importe pas la réponse d'Argon

La réponse d'Argon sur les durées ajoutait une annotation de type `float | int | Decimal` à une fonction utilitaire. Python 3.9 ne sait pas l'évaluer à l'import, donc le module a levé `TypeError: unsupported operand type(s) for |: 'type' and 'type'` et les 14 tests ont échoué avant de s'exécuter.

La logique était juste. Le même fichier s'importe et réussit 14 sur 14 sous Python 3.14.3. Cette syntaxe d'union demande Python 3.10 ou plus récent.

Le score dépend de l'interpréteur : sous le Python 3.9.6 du système, Argon termine 91 vérifications sur 105 et Opus 5.5 en termine 105. Sous 3.14, les deux en terminent 105.

Si une image serveur ou une machine de CI embarque encore 3.9, le piège est là. Deux habitudes le couvrent : nommer la version de Python dans l'énoncé et noter sur la version la plus ancienne que vous prenez en charge. Pour une cible 3.9, demandez `Union[float, int]` ou `from __future__ import annotations` en tête de fichier.

> Seul l'énoncé de la tâche de graphe nommait Python 3.14. La tâche sur les durées ne nommait aucune version et la première passe tournait sous 3.9.6, donc une réponse correcte a semblé cassée.

## Ce que disent les benchmarks de Google

La fiche modèle d'Argon (consultée le 4 novembre 2026) liste cinq tests de ses sections code et sécurité avec un chiffre pour Opus 5.5. Argon mène sur trois et recule sur deux.

|Benchmark|Gemini 4 Argon|Claude Opus 5.5|
|-|-|-|
|DeepSWE v1.1|77.9%|74.2%|
|FrontierSWE v2|55.0%|62.3%|
|Vibe Code Bench|91.9%|90.3%|
|Terminal-bench 4.0|57.4%|66.4%|
|CWE-bench v1|68.0%|67.0%|

Ces chiffres datent d'octobre 2026 ; la colonne Notes est vide sur ces lignes, donc le niveau de réflexion, le harnais et le nombre d'essais ne sont pas indiqués. Les tests sont aussi bien plus agentiques que nos petites fonctions.

L'annonce de Google du 13 octobre place Argon en tête du Vals Index, qui inclut le code, et signale une hausse de plus de 35 % des soumissions de code par agent dans Antigravity. Les deux chiffres sont ceux de Google.

Notre [comparaison de trois tâches avec GPT-6 Astra du 23 octobre](https://omniakey.com/fr/blog/gemini-4-argon-vs-gpt-6-astra) avait Argon réussissant les 12 tests cachés d'une correction de bug de facturation. Argon a réussi toutes les vérifications là-bas et la tâche 1 ici, et aucun résultat nouveau ne contredit cela.

## Comment lancer le même test vous-même

Un fichier d'énoncé par tâche, envoyé tel quel aux deux modèles, voilà toute la préparation. Nous avons utilisé l'endpoint `https://api.omniakey.com/v1` ; les deux modèles ont leur page sur [Gemini 4 Argon](https://omniakey.com/fr/gemini-4-argon) et [Claude Opus 5.5](https://omniakey.com/fr/claude-opus-5-5).

```python
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.omniakey.com/v1",
    api_key=os.environ["OMNIAKEY_API_KEY"],
)
prompt = open("task6-duration.md").read()

for model in ("gemini-4-argon", "claude-opus-5-5"):
    reply = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": prompt}],
        max_tokens=8000,
    )
    open(f"{model}.md", "w").write(reply.choices[0].message.content)
```

1. Enregistrez chaque tâche dans son propre fichier d'énoncé et envoyez-le tel quel, sans prompt système, pour que les deux modèles reçoivent les mêmes mots.
2. Envoyez chaque énoncé une fois par modèle à son niveau de réflexion par défaut, et notez l'ID du modèle, le temps et les tokens.
3. Découpez le bloc de code de chaque réponse et enregistrez-le comme le module que vos tests importent.
4. Lancez vos tests cachés dans un processus séparé avec un délai maximum et affichez les réussites à côté du total.
5. Refaites la notation sur le Python le plus ancien que vous prenez en charge. La seule erreur d'Argon est apparue sur la passe 3.9.
6. Calculez le coût à partir des tokens renvoyés et du tarif catalogue de chaque fournisseur.

## Questions fréquentes

### Gemini 4 Argon est-il bon en code ?

Sur nos huit tâches, il réussit les 105 tests cachés sous Python 3.14, comme Opus 5.5. Dans le tableau de Google, Argon devance sur trois lignes sur cinq et recule sur deux.

### Combien coûte le code avec Gemini 4 Argon ?

Google facture $2 par million de tokens d'entrée et $10 par million de tokens de sortie jusqu'au 30 novembre 2026, puis $4 et $20. Nos huit tâches reviennent à $0.042 au tarif de lancement. Opus 5.5 revient à $0.112 avec les $4 et $20 d'Anthropic.

### Gemini 4 Argon est-il plus rapide que Claude Opus 5.5 ?

Non. Opus 5.5 a été plus rapide sur les huit tâches : 57.2 secondes au total contre 139.6 pour Argon. L'écart le plus large était la tâche sur les durées, avec 14.0 secondes contre 60.9.

### Pourquoi Argon a-t-il échoué sur une tâche ?

La logique n'a pas échoué. Sa réponse sur les durées utilisait une annotation `float | int | Decimal`, que Python 3.9 ne peut pas évaluer à l'import, donc les 14 tests ont échoué avant de s'exécuter. Le même fichier réussit 14 sur 14 sous Python 3.14.

## Sources

- [Page du modèle Gemini 4 Argon](https://ai.google.dev/gemini-api/docs/models/gemini-4-argon)
- [Tarifs de l'API Gemini](https://ai.google.dev/gemini-api/docs/pricing)
- [Niveaux de réflexion de l'API Gemini](https://ai.google.dev/gemini-api/docs/thinking)
- [Fiche modèle Gemini 4 Argon](https://deepmind.google/models/model-cards/gemini-4-argon/)
- [Annonce de Gemini 4 Argon](https://blog.google/innovation-and-ai/models-and-research/gemini-models/introducing-gemini-4-argon/)
- [Gemini 4 Argon sur Vertex AI](https://cloud.google.com/vertex-ai/generative-ai/docs/models/gemini/4-argon)
- [Tarifs de l'API Anthropic](https://platform.claude.com/docs/en/about-claude/pricing)
- [Présentation de Claude Opus 5.5](https://platform.claude.com/docs/en/models/opus-5-5/overview)
- [Réglages effort chez Anthropic](https://platform.claude.com/docs/en/build-with-claude/effort)

Toutes consultées le 4 novembre 2026.

## Journal des mises à jour

- 4 novembre 2026 : première publication. Tests lancés le 4 novembre, notés sous Python 3.9.6 puis sous 3.14.3.
