Gemini 4 Argon: 8 Coding-Aufgaben und versteckte Tests

Wir haben Gemini 4 Argon und Claude Opus 5.5 dieselben acht Aufgaben gestellt, je einen Aufruf pro Aufgabe und versteckte Tests, die keines der Modelle sehen konnte. Auf Python 3.14 bestanden beide alle 105 Prüfungen. Argon brauchte insgesamt 139.6 Sekunden, Opus 5.5 nur 57.2. Zum Listenpreis des jeweiligen Anbieters kosteten die acht Aufgaben $0.042 mit Argon und $0.112 mit Opus 5.5.

Acht Aufgaben mit je einem Lauf zeigen das Verhalten im Alltag. Bei der Korrektheit lagen beide gleichauf. Die Unterschiede liegen bei der Zeit, beim Preis und bei einer Antwort, die ein neueres Python verlangt. Google führt Argon seit dem 13. Oktober 2026 als allgemein verfügbar. Der Einführungspreis von $2 pro Million Eingabe-Tokens und $10 pro Million Ausgabe-Tokens gilt bis zum 30. November; ab dem 1. Dezember verdoppelt er sich auf $4 und $20 (Preisseite von Google, geprüft am 4. November 2026).

So haben wir getestet

Am 4. November 2026 haben wir jede Aufgabe an gemini-4-argon und claude-opus-5-5 geschickt, je einen Aufruf pro Aufgabe und Modell, ohne System-Prompt und ohne Reasoning-Einstellung. Beide liefen auf ihrer Standardstufe: medium bei Argon (Googles Thinking-Dokumentation, geprüft am 4. November 2026) und medium bei Opus 5.5 (Anthropics Effort-Dokumentation, am selben Tag). Jede Aufgabe ergab eine bewertete Antwort pro Modell.

Die Zeit ist die vom Anbieter gemeldete Latenz jedes Aufrufs, summiert; unsere Bewertungsläufe zählen nicht mit. Die Kosten ergeben sich aus dem Listenpreis des Anbieters und den Token-Zahlen, die die API zurückgegeben hat. OmniaKey verkauft beide Modelle, deshalb lief der Test mit einem Schlüssel darüber; jeder Preis hier ist Googles oder Anthropics eigener Tarif.

Ein Skript holte den Codeblock aus jeder Antwort und führte ihn gegen eine versteckte unittest-Datei aus, die kein Modell gesehen hatte, in einem isolierten Python-Prozess mit Zeitlimit. Der erste Durchlauf nutzte das System-Python 3.9.6; danach bewerteten wir dieselben gespeicherten Antworten erneut auf Python 3.14.3, ohne zusätzliche Aufrufe und ohne zusätzliche Kosten.

Die acht Aufgaben

Alle acht sind kleine Python-Arbeiten, wie sie an einem normalen Tag vorkommen: eine Fehlerbehebung, zwei kleine Klassen, ein Refactoring, ein Parser, ein Dauer-Formatierer, ein Termin-Helfer und eine Graphsuche. Jeder Prompt beschrieb das verlangte Verhalten in einfacher Prosa; keiner enthielt die Tests.

Aufgabe 1: einen Fehler beim Zusammenführen von Intervallen beheben

merge_intervals sortierte und führte Bereiche zusammen, ließ aber Paare wie (1, 3) und (3, 5), die sich berühren, getrennt. Ein Vergleich genügt.

• Gemini 4 Argon (5.6 s): 12 von 12.
• Claude Opus 5.5 (2.9 s): 12 von 12.

Fazit: Gleichstand bei den Prüfungen. Opus antwortete in etwa der halben Zeit.

Aufgabe 2: ein Token-Bucket-Rate-Limit

TokenBucket(rate_per_second, capacity) musste laufend auffüllen, die Kapazität einhalten und mit now-Werten umgehen, die rückwärts laufen.

• Gemini 4 Argon (6.6 s): 10 von 10.
• Claude Opus 5.5 (4.8 s): 10 von 10.

Fazit: Gleichstand. Beide kamen mit der rückwärts laufenden Uhr zurecht.

Aufgabe 3: ein LRU-Cache mit Treffer- und Fehlzählern

LRUCache brauchte die Auslagerungsreihenfolge, Aktualisierung an Ort und Stelle, Zähler in stats() und eine Schlüsselliste vom am längsten nicht genutzten zum zuletzt genutzten Eintrag.

• Gemini 4 Argon (7.1 s): 10 von 10.
• Claude Opus 5.5 (4.1 s): 10 von 10.

Fazit: Gleichstand. Opus war 3 s schneller.

Aufgabe 4: refaktorieren, ohne das Verhalten zu ändern

Das Modul lief. Die Antwort musste slugify und slug_counts behalten und sich bei Unicode-Buchstaben, Satzzeichen und wiederholten Trennern gleich verhalten.

• Gemini 4 Argon (15.9 s): 12 von 12.
• Claude Opus 5.5 (8.7 s): 12 von 12.

Fazit: Gleichstand. Beide hielten alle festgelegten Fälle ein.

Aufgabe 5: eine Logzeile in ein dict parsen

Ein key=value-Parser mit Werten in Anführungszeichen, maskierten Anführungszeichen und Backslashes, einem UTC-Zeitstempel und ValueError bei doppelten Schlüsseln, einem leeren key= und Unsinn.

• Gemini 4 Argon (16.1 s): 13 von 13.
• Claude Opus 5.5 (10.9 s): 13 von 13.

Fazit: Gleichstand. Beide hatten das Escaping beim ersten Versuch richtig.

Aufgabe 6: Dauern formatieren und parsen

format_duration und parse_duration mussten die Hälfte von der Null weg runden, leere Teile weglassen (3601 wird zu 1h1s), falsche Formen ablehnen und jeden Wert hin und zurück abbilden. Tage werden nicht ausgegeben: 90000 wird zu 25h.

• Gemini 4 Argon (60.9 s): 0 von 14 auf Python 3.9, 14 von 14 auf 3.14.
• Claude Opus 5.5 (14.0 s): 14 von 14 auf beiden.

Fazit: Gleichstand auf 3.14. Auf 3.9 ließ sich Argons Antwort gar nicht importieren, dazu der nächste Abschnitt.

Aufgabe 7: freie Zeitfenster für Besprechungsräume

free_slots musste Buchungen auf die Arbeitszeit zuschneiden, sich berührende Buchungen zusammenführen, Lücken unter 15 Minuten verwerfen und falsche Eingaben ablehnen.

• Gemini 4 Argon (18.9 s): 17 von 17.
• Claude Opus 5.5 (5.0 s): 17 von 17.

Fazit: Gleichstand bei den Prüfungen. Argon brauchte fast viermal so lange.

Aufgabe 8: kürzester Pfad mit Tie-Break

shortest_path verlangte Dijkstra mit dem lexikografisch kleinsten Pfad unter gleich langen Pfaden, dazu parallele Kanten, Selbstschleifen und den Fall ohne Pfad.

• Gemini 4 Argon (8.5 s): 17 von 17.
• Claude Opus 5.5 (6.8 s): 17 von 17.

Fazit: Gleichstand. Der knappste der acht Vergleiche.

Ergebnisse: Treffer, Zeit und Kosten

Auf Python 3.14 bestanden beide Modelle alle 105 Prüfungen. Auf Python 3.9.6 bestand Argon 91, weil sich eine Antwort nicht importieren ließ.

Opus 5.5 antwortete bei jeder Aufgabe schneller. Am kleinsten war der Abstand bei der Graphaufgabe (8.5 s gegen 6.8 s), am größten bei den Dauern (60.9 s gegen 14.0 s).

Zum Listenpreis kosteten die acht Aufgaben $0.042 mit Argon und $0.112 mit Opus 5.5, etwa 2.7-mal so viel. Argons Antworten nutzten insgesamt 3,346 Eingabe- und 3,525 Ausgabe-Tokens; die von Opus 5.5 4,419 und 4,692. Beide APIs meldeten bei jedem Aufruf 0 Thinking-Tokens, das Denken schlug also nicht auf die Rechnung.

Googles Listenpreis liegt bis zum 30. November 2026 bei $2 pro Million Eingabe-Tokens und $10 pro Million Ausgabe-Tokens, danach bei $4 und $20 (Gemini-API-Preise, geprüft am 4. November 2026). Anthropics Listenpreis für Opus 5.5 ist $4 und $20 (Anthropic-Preise, am selben Tag). Ab dem 1. Dezember kosten dieselben Tokens mit Argon doppelt so viel, womit beide näher zusammenrücken. Die Tarife beider Modelle stehen auf der Preisseite.

Acht Aufgaben trennen zwei Frontier-Modelle nicht in der Qualität. Entscheiden Sie nach Tempo, Preis und der Python-Version, auf der Ihre Tests laufen.

Was Nutzer sagen

Die Spaltung zeigt sich auch in öffentlichen Kommentaren. Bei Hacker News am 31. Oktober schrieb A_D_E_P_T: „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.“ Am 28. Oktober schrieb seizethecheese über lokale Coding-Agenten: „Argon is really bad. Literally the worst model in our initial ranking“, mit Opus 5.5 an der Spitze. Am 13. Oktober berichtete ariwilson, Argon habe „10 of 11“ kleine Fehlerbehebungen aus eigenen Projekten gelöst.

Das sind Meinungen von Nutzern über ihre eigenen Setups, keine kontrollierten Tests. Der negative Kommentar kam von jemandem, der ein Agenten-Harness testete, nicht von einem direkten API-Aufruf wie unseren.

Der eine Ausfall: Python 3.9 kann Argons Antwort nicht importieren

Argons Dauer-Antwort setzte an eine Hilfsfunktion die Typannotation float | int | Decimal. Python 3.9 kann das beim Import nicht auswerten, deshalb warf das Modul TypeError: unsupported operand type(s) for |: 'type' and 'type' und alle 14 Tests scheiterten vor dem Start.

An der Logik war nichts falsch. Dieselbe Datei ließ sich auf Python 3.14.3 importieren und bestand 14 von 14. Die Union-Syntax braucht Python 3.10 oder neuer.

Das Ergebnis hängt vom Interpreter ab: Auf dem System-Python 3.9.6 beendete Argon 91 von 105 Prüfungen, Opus 5.5 beendete 105. Auf 3.14 beendeten beide 105.

Wenn ein Server-Image oder eine CI-Maschine noch 3.9 mitbringt, liegt dort die Falle. Zwei Gewohnheiten decken sie ab: die Python-Version im Prompt nennen und auf der ältesten Version bewerten, die Sie unterstützen. Für ein 3.9-Ziel verlangen Sie Union[float, int] oder from __future__ import annotations am Dateianfang.

Was Googles eigene Benchmarks sagen

Googles Modellkarte für Argon (geprüft am 4. November 2026) listet fünf Tests aus den Bereichen Coding und Security mit einer Zahl für Opus 5.5. Argon führt bei drei und liegt bei zwei hinten.

Diese Zahlen sind von Oktober 2026; die Spalte Notes ist in diesen Zeilen leer, Thinking-Stufe, Harness und Versuche sind also nicht angegeben. Die Tests sind außerdem deutlich agentischer als unsere kleinen Funktionen.

Googles Ankündigung vom 13. Oktober nennt Argon auf Platz eins des Vals Index, der Coding einschließt, und meldet einen Anstieg von mehr als 35 % bei agentischen Code-Beiträgen in Antigravity. Beides sind Googles eigene Zahlen.

Unser Vergleich mit GPT-6 Astra über drei Aufgaben vom 23. Oktober hatte Argon mit allen 12 versteckten Tests bei einer Fehlerbehebung in der Abrechnung. Argon bestand dort jede Prüfung und hier Aufgabe 1, und kein neues Ergebnis widerspricht dem.

Denselben Test selbst ausführen

Eine Prompt-Datei pro Aufgabe, unverändert an beide Modelle geschickt, ist das ganze Setup. Wir nutzten den Endpunkt https://api.omniakey.com/v1; beide Modelle stehen auf den Seiten Gemini 4 Argon und Claude Opus 5.5.

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. Speichern Sie jede Aufgabe als eigene Prompt-Datei und schicken Sie sie unverändert, ohne System-Prompt, damit beide Modelle dieselben Worte bekommen.
2. Schicken Sie jeden Prompt einmal pro Modell auf der Standard-Thinking-Stufe und notieren Sie Modell-ID, Zeit und Token-Zahlen.
3. Schneiden Sie den Codeblock aus jeder Antwort und speichern Sie ihn als Modul, das Ihre Tests importieren.
4. Führen Sie Ihre versteckten Tests in einem eigenen Prozess mit Zeitlimit aus und geben Sie die Treffer neben der Gesamtzahl aus.
5. Wiederholen Sie die Bewertung auf dem ältesten Python, das Sie unterstützen. Im 3.9-Lauf erschien Argons einziger Ausfall.
6. Rechnen Sie die Kosten aus den zurückgegebenen Tokens und dem Listenpreis des Anbieters.

Häufige Fragen

Ist Gemini 4 Argon gut zum Programmieren?

In unseren acht Aufgaben bestand es alle 105 versteckten Tests auf Python 3.14, genau wie Opus 5.5. In Googles Tabelle liegt Argon in drei von fünf Zeilen vorn und in zwei hinten.

Was kostet Programmieren mit Gemini 4 Argon?

Google berechnet $2 pro Million Eingabe-Tokens und $10 pro Million Ausgabe-Tokens bis zum 30. November 2026, danach $4 und $20. Unsere acht Aufgaben kamen zum Einführungspreis auf $0.042. Opus 5.5 kam mit Anthropics $4 und $20 auf $0.112.

Ist Gemini 4 Argon schneller als Claude Opus 5.5?

Nein. Opus 5.5 war in unserem Lauf bei allen acht Aufgaben schneller: 57.2 Sekunden insgesamt gegen 139.6 Sekunden bei Argon. Am größten war der Abstand bei den Dauern, mit 14.0 Sekunden gegen 60.9.

Warum ist Argon bei einer Aufgabe gescheitert?

An der Logik lag es nicht. Die Dauer-Antwort nutzte eine Annotation float | int | Decimal, die Python 3.9 beim Import nicht auswerten kann, deshalb scheiterten alle 14 Tests vor dem Start. Dieselbe Datei bestand 14 von 14 auf Python 3.14.

Quellen

• Modellseite Gemini 4 Argon
• Gemini-API-Preise
• Thinking-Stufen der Gemini-API
• Modellkarte Gemini 4 Argon
• Ankündigung Gemini 4 Argon
• Gemini 4 Argon auf Vertex AI
• Anthropic-API-Preise
• Überblick Claude Opus 5.5
• Effort-Einstellungen bei Anthropic

Alle am 4. November 2026 geprüft.

Änderungsverlauf

• 4. November 2026: Erstveröffentlichung. Tests am 4. November ausgeführt, auf Python 3.9.6 und erneut auf 3.14.3 bewertet.