Gemini 4 Argon: test di programmazione su 8 attività e test nascosti

Abbiamo dato a Gemini 4 Argon e a Claude Opus 5.5 le stesse otto attività, con una sola chiamata per attività e test nascosti che nessuno dei due poteva vedere. Su Python 3.14 entrambi superano i 105 controlli. Argon ha impiegato 139.6 secondi in totale, Opus 5.5 57.2. Al listino di ciascun fornitore le otto attività costano $0.042 con Argon e $0.112 con Opus 5.5.

Ogni attività è stata eseguita una volta sola, quindi va letta come comportamento d'uso quotidiano. Sulla correttezza i due modelli sono pari. Le differenze stanno nei tempi, nei costi e in una risposta che richiede un Python più recente. Google considera Argon generalmente disponibile dal 13 ottobre 2026, e il prezzo di lancio di $2 per milione di token in ingresso e $10 per milione in uscita vale fino al 30 novembre; dal 1° dicembre raddoppia a $4 e $20 (pagina dei prezzi Google, consultata il 4 novembre 2026).

Come abbiamo testato

Il 4 novembre 2026 abbiamo inviato ogni attività a gemini-4-argon e claude-opus-5-5, una chiamata per attività e per modello, senza prompt di sistema e senza impostazioni di ragionamento. Entrambi giravano al livello predefinito: medium per Argon (documentazione thinking di Google, consultata il 4 novembre 2026) e medium per Opus 5.5 (documentazione effort di Anthropic, lo stesso giorno). Ogni attività ha prodotto una risposta, valutata per modello.

Il tempo è la latenza dichiarata dal fornitore per ogni chiamata, sommata; le nostre esecuzioni di valutazione restano fuori. Il costo applica il listino del fornitore ai token restituiti dall'API. OmniaKey vende entrambi i modelli, quindi il test è passato da lì con una sola chiave; ogni prezzo qui è la tariffa di Google o di Anthropic.

Uno script estraeva il blocco di codice da ogni risposta e lo eseguiva contro un file unittest nascosto che nessun modello aveva visto, in un processo Python separato con un limite di tempo. Il primo giro ha usato il Python 3.9.6 di sistema; poi abbiamo valutato le stesse risposte salvate su Python 3.14.3, senza chiamate né costi aggiuntivi.

Le otto attività

Sono tutte piccole lavorazioni Python che capitano in una giornata normale: una correzione di bug, due classi piccole, un refactor, un parser, un formattatore di durate, un assistente per l'agenda e una ricerca su grafo. Ogni prompt descriveva il comportamento richiesto in prosa semplice, e nessuno conteneva i test.

Attività 1: correggere un bug di fusione degli intervalli

merge_intervals ordinava e univa gli intervalli, ma lasciava separati quelli che si toccano, come (1, 3) e (3, 5). Basta un confronto.

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

Verdetto: pari sui controlli. Opus ha risposto nella metà del tempo.

Attività 2: un limitatore di frequenza a secchio di token

TokenBucket(rate_per_second, capacity) doveva ricaricarsi di continuo, restare sotto la capacità e gestire valori di now che tornano indietro.

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

Verdetto: pari. Entrambi hanno gestito l'orologio che va all'indietro.

Attività 3: una cache LRU con contatori di successi e mancati

LRUCache chiedeva l'ordine di espulsione, l'aggiornamento sul posto, i contatori in stats() e l'elenco delle chiavi dalla meno usata alla più recente.

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

Verdetto: pari. Opus è stato 3 s più veloce.

Attività 4: rifattorizzare senza cambiare il comportamento

Il modulo funzionava. La risposta doveva mantenere slugify e slug_counts e comportarsi allo stesso modo su lettere Unicode, punteggiatura e separatori ripetuti.

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

Verdetto: pari. Entrambi hanno conservato tutti i casi fissati.

Attività 5: trasformare una riga di log in un dict

Un parser key=value con valori tra virgolette, virgolette con escape e barre rovesciate, un timestamp UTC e ValueError per chiavi duplicate, un key= vuoto e input senza senso.

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

Verdetto: pari. Entrambi hanno azzeccato l'escape al primo tentativo.

Attività 6: formattare e analizzare le durate

format_duration e parse_duration dovevano arrotondare la metà lontano da zero, togliere le parti vuote (3601 diventa 1h1s), rifiutare le forme non valide e fare andata e ritorno su ogni valore. I giorni non compaiono: 90000 diventa 25h.

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

Verdetto: pari su 3.14. Su 3.9 la risposta di Argon non si è nemmeno importata, e la sezione seguente spiega perché.

Attività 7: gli spazi liberi delle sale riunioni

free_slots doveva ritagliare le prenotazioni sulla giornata lavorativa, unire quelle che si toccano, scartare i buchi sotto i 15 minuti e rifiutare gli input non validi.

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

Verdetto: pari sui controlli. Argon ha impiegato quasi quattro volte tanto.

Attività 8: cammino minimo con spareggio

shortest_path richiedeva Dijkstra con il cammino lessicograficamente minore tra quelli di pari lunghezza, più archi paralleli, cappi e il caso senza cammino.

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

Verdetto: pari. Il più stretto degli otto.

Risultati: controlli, tempi e costo

Su Python 3.14 entrambi i modelli superano i 105 controlli. Su Python 3.9.6 Argon ne supera 91, perché una risposta non si è potuta importare.

Opus 5.5 ha risposto più in fretta su ogni attività. Il divario più stretto era sul grafo (8.5 s contro 6.8 s), il più ampio sulle durate (60.9 s contro 14.0 s).

Al listino le otto attività costano $0.042 con Argon e $0.112 con Opus 5.5, circa 2.7 volte tanto. Le risposte di Argon hanno usato 3,346 token in ingresso e 3,525 in uscita in totale; quelle di Opus 5.5, 4,419 e 4,692. Le due API dichiarano 0 token di pensiero a ogni chiamata, quindi il ragionamento non ha aggiunto nulla alla fattura.

Il listino Google è $2 per milione di token in ingresso e $10 per milione in uscita fino al 30 novembre 2026, poi $4 e $20 (prezzi dell'API Gemini, consultati il 4 novembre 2026). Quello Anthropic per Opus 5.5 è $4 e $20 (prezzi Anthropic, lo stesso giorno). Dal 1° dicembre gli stessi token costano il doppio con Argon, e i due modelli si avvicinano. Le tariffe di entrambi sono nella pagina dei prezzi.

Otto attività non separano due modelli di frontiera sulla qualità. La scelta dipende da velocità, prezzo e versione di Python su cui girano i vostri test.

Cosa dicono gli utenti

La spaccatura emerge anche nei commenti pubblici. Su Hacker News, il 31 ottobre, A_D_E_P_T scrive: «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». Il 28 ottobre seizethecheese scrive degli agenti di coding locali: «Argon is really bad. Literally the worst model in our initial ranking», con Opus 5.5 in cima. Il 13 ottobre ariwilson racconta che Argon ha «solved 10 of 11» piccole correzioni di bug nei suoi progetti.

Sono opinioni di utenti sul proprio ambiente, non test controllati. Il commento negativo arriva da chi provava un'impalcatura per agenti, non da una chiamata API diretta come le nostre.

L'unico errore: Python 3.9 non importa la risposta di Argon

La risposta di Argon sulle durate aggiungeva a una funzione di supporto l'annotazione di tipo float | int | Decimal. Python 3.9 non riesce a valutarla durante l'import, quindi il modulo ha lanciato TypeError: unsupported operand type(s) for |: 'type' and 'type' e i 14 test sono falliti prima di partire.

La logica era giusta. Lo stesso file si importa e supera 14 su 14 su Python 3.14.3. Quella sintassi di unione richiede Python 3.10 o successivo.

Il punteggio dipende dall'interprete: sul Python 3.9.6 di sistema Argon chiude 91 controlli su 105 e Opus 5.5 ne chiude 105. Su 3.14 entrambi ne chiudono 105.

Se un'immagine server o una macchina di CI porta ancora il 3.9, la trappola è lì. Due abitudini la coprono: indicare la versione di Python nel prompt e valutare sulla versione più vecchia che supportate. Per un obiettivo 3.9 chiedete Union[float, int] o from __future__ import annotations in cima al file.

Cosa dicono i benchmark di Google

La scheda del modello Argon (consultata il 4 novembre 2026) elenca cinque test delle sezioni coding e sicurezza con il numero di Opus 5.5. Argon è avanti su tre e indietro su due.

Quei numeri sono di ottobre 2026; la colonna Notes è vuota su queste righe, quindi livello di thinking, impalcatura e numero di tentativi non sono indicati. I test sono anche molto più agentici delle nostre piccole funzioni.

L'annuncio Google del 13 ottobre mette Argon in cima al Vals Index, che include il coding, e riporta una crescita di oltre il 35% negli invii di codice da parte di agenti dentro Antigravity. Entrambi i numeri sono di Google.

Il nostro confronto su tre attività con GPT-6 Astra del 23 ottobre aveva Argon che superava i 12 test nascosti di una correzione di bug di fatturazione. Argon ha superato tutti i controlli lì e nell'attività 1 qui, e nessun risultato nuovo lo contraddice.

Come rifare lo stesso test

Un file di prompt per attività, inviato così com'è a entrambi i modelli, è tutta la preparazione. Noi abbiamo usato l'endpoint https://api.omniakey.com/v1; i due modelli hanno pagina su Gemini 4 Argon e 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. Salvate ogni attività in un file di prompt a sé e inviatelo così com'è, senza prompt di sistema, perché entrambi i modelli ricevano le stesse parole.
2. Inviate ogni prompt una volta per modello al livello di thinking predefinito e annotate ID del modello, tempo e token.
3. Tagliate il blocco di codice da ogni risposta e salvatelo come il modulo che i vostri test importano.
4. Eseguite i test nascosti in un processo separato con un limite di tempo e stampate i successi accanto al totale.
5. Ripetete la valutazione sul Python più vecchio che supportate. L'unico errore di Argon è comparso nel giro su 3.9.
6. Calcolate il costo dai token restituiti e dal listino del fornitore.

Domande frequenti

Gemini 4 Argon è bravo a programmare?

Nelle nostre otto attività ha superato tutti i 105 test nascosti su Python 3.14, come Opus 5.5. Nella tabella di Google Argon è avanti su tre righe su cinque e indietro su due.

Quanto costa programmare con Gemini 4 Argon?

Google chiede $2 per milione di token in ingresso e $10 per milione in uscita fino al 30 novembre 2026, poi $4 e $20. Le nostre otto attività sono costate $0.042 al prezzo di lancio. Opus 5.5 è costato $0.112 con i $4 e $20 di Anthropic.

Gemini 4 Argon è più veloce di Claude Opus 5.5?

No. Opus 5.5 è stato più veloce su tutte e otto le attività: 57.2 secondi in totale contro 139.6 di Argon. Il divario più ampio era sulle durate, 14.0 secondi contro 60.9.

Perché Argon ha fallito un'attività?

Non ha fallito la logica. La risposta sulle durate usava un'annotazione float | int | Decimal, che Python 3.9 non riesce a valutare durante l'import, quindi i 14 test sono falliti prima di partire. Lo stesso file supera 14 su 14 su Python 3.14.

Fonti

• Pagina del modello Gemini 4 Argon
• Prezzi dell'API Gemini
• Livelli di thinking dell'API Gemini
• Scheda del modello Gemini 4 Argon
• Annuncio di Gemini 4 Argon
• Gemini 4 Argon su Vertex AI
• Prezzi dell'API Anthropic
• Panoramica di Claude Opus 5.5
• Impostazioni effort di Anthropic

Tutte consultate il 4 novembre 2026.

Registro degli aggiornamenti

• 4 novembre 2026: prima pubblicazione. Test eseguiti il 4 novembre, valutati su Python 3.9.6 e poi su 3.14.3.