Gemini 4 Argon vs GPT-6 Astra: confronto tra velocità, prezzi API e precisione

Il 23 ottobre 2026 abbiamo dato a Gemini 4 Argon e a GPT-6 Astra gli stessi tre compiti: correggere un bug di fatturazione, rispondere a domande su un log di 306 righe e trasformare un thread di email in JSON. Argon ha risposto bene a tutto. Astra è stato più veloce su due compiti, ma è costato da 3,4 a 4,9 volte tanto per compito e ha sbagliato due volte il conteggio degli errori nel log.

Entrambi sono disponibili nell'API. Il prezzo introduttivo di Argon finisce il 30 novembre. Dal 1° dicembre raddoppia, e Astra continuerà a costare circa il doppio per compito.

I prezzi di listino sono per milione di token, e quelli di Argon sono introduttivi fino al 30 novembre. Entrambi sono su OmniaKey: Gemini 4 Argon e GPT-6 Astra.

Si possono usare Gemini 4 Argon e GPT-6 Astra oggi?

Sì. Argon è disponibile nell'API Gemini a pagamento dal 13 ottobre 2026, e Astra nell'API OpenAI dal 3 settembre.

Alcune pagine della settimana di lancio dicono ancora che Argon non si può usare. Quando Google l'ha annunciato il 30 settembre, ha aperto il modello solo ai difensori informatici fidati del programma Fairwind. Questo è cambiato il 13 ottobre.

Nessuno dei due è nel livello gratuito del proprio fornitore. Argon arriva anche agli abbonati Google AI Ultra e Pro nell'app Gemini.

La finestra di Argon è condivisa tra input, ragionamento e output, e la modalità "long decode" porta l'output fino a 1.048.576 token. Argon accetta testo, immagini, video, audio e PDF. Astra accetta testo e immagini.

I livelli di ragionamento di Astra sono low, medium, high, xhigh e max, senza "none". In OpenAI le chiamate agli strumenti richiedono l'API Responses.

Con OmniaKey chiami entrambi con una sola chiave su https://api.omniakey.com/v1, usando gli ID qui sopra. Le tariffe sono sulla pagina di Gemini 4 Argon e sulla pagina di GPT-6 Astra.

Come abbiamo testato

• Modelli: Gemini 4 Argon (gemini-4-argon) e GPT-6 Astra (gpt-6-astra).
• Il 23 ottobre 2026, tramite l'API Chat Completions compatibile con OpenAI di OmniaKey, in streaming e senza impostazioni di ragionamento, quindi ogni modello ha usato il proprio valore predefinito. Google indica medium come livello di pensiero predefinito di Argon.
• Lo stesso prompt per entrambi i modelli. La correzione del bug e il compito del log sono stati eseguiti due volte per modello, il compito JSON una volta: 10 risposte in tutto.
• Il tempo va dall'invio della richiesta all'ultimo token, misurato dalla nostra parte e comprensivo di rete.
• Punteggio con script, non a gusto. Ogni correzione è stata eseguita contro 12 test che i modelli non hanno mai visto, in un processo Python separato. Le risposte sul log sono state confrontate con la chiave dello script che ha generato il log, e il JSON campo per campo con la propria chiave. L'unica domanda aperta, la causa probabile nel log, l'abbiamo giudicata leggendo.
• Costo: i token del nostro prompt e della risposta, moltiplicati per il prezzo di listino standard di ciascun fornitore, alla prima esecuzione (niente in cache).
• OmniaKey vende l'accesso API a entrambi i modelli, quindi i test sono passati da OmniaKey. Ogni prezzo qui è la tariffa di Google o di OpenAI, non la nostra.
• Prezzi, limiti e date vengono dalle pagine di Google e OpenAI elencate in Fonti, controllate il 23 ottobre 2026.

Sono una o due esecuzioni per compito, quindi leggi i risultati come esempi del comportamento di ciascun modello, non come un benchmark.

Cosa è successo con gli stessi tre compiti?

Entrambi hanno corretto il bug e compilato il JSON correttamente. Il log lungo li ha separati, e Astra è stato più veloce su due dei tre compiti.

Test 1: correggere un bug di fatturazione in Python

Il modello corregge ogni regola sbagliata di un piccolo file, non solo i tre test che falliscono?

Prompt:

You're fixing a bug report in our billing service. Below are billing.py, its test file and the test output. Three tests fail.

Fix billing.py so it follows every rule in its docstring, not only the failing tests. Keep the function names and signatures, and use only the Python standard library.

Reply with the complete corrected billing.py in one ```python code block, then at most three short bullets on what you changed.

Sotto abbiamo incollato billing.py di 34 righe, i suoi quattro test e l'output: 3 falliti, 1 superato. Il file aveva quattro bug.

1. round() arrotonda al pari più vicino dove le regole chiedono l'arrotondamento per eccesso.
2. Gli sconti sul volume partivano da 11 e 51 unità invece che da 10 e 50.
3. Il coupon veniva applicato dopo le tasse.
4. Nessun controllo che il coupon fosse tra 0 e 100.

Abbiamo valutato ogni correzione con 12 test che i modelli non hanno mai visto.

• Gemini 4 Argon (10,8 s, 10,6 s): entrambe le correzioni hanno superato 12 test su 12. Entrambe usano il modulo decimal di Python con arrotondamento per eccesso. La prima ha un'annotazione di tipo (float | Decimal) che richiede Python 3.10 o successivo.
• GPT-6 Astra (17,3 s, 6,4 s): entrambe le correzioni hanno superato 12 test su 12. La prima usa frazioni esatte ed è l'unica risposta di Astra ad aver dichiarato token di ragionamento (185). È anche la risposta più lenta di questo test.

Dopo il punteggio abbiamo provato tre casi limite in più su tutte e quattro le correzioni. La seconda di Astra sbaglia di un centesimo in due: arrotonda il prezzo dopo il coupon invece del coupon. Un coupon del 50% su un ordine da 1.001 centesimi toglie 500 centesimi, non 501.

Verdetto: parità nei nostri test. Entrambi i modelli hanno corretto tutti e quattro i bug. Le due risposte di Argon hanno gestito anche ogni caso extra, e ciascuna è costata meno di un centesimo contro 3-5 centesimi di Astra.

Test 2: trovare la causa in un log di 306 righe

Il modello sa contare, cercare e ragionare su un testo lungo senza scivolare?

Prompt:

Below is a 20-minute slice of our API gateway's access log. Answer five questions using only this log.

Q1. When did the first 503 happen? Give the timestamp, the request ID and the upstream.

Q2. How many requests returned 503 in total, and which upstream or upstreams served them?

Q3. Which request was the slowest? Give its request ID, path and rt_ms.

Q4. List every request made by user u_4471, in order, as time method path status.

Q5. In one or two sentences: what most likely caused the 503s, and what would you check first?

Start each answer with Q1: to Q5:. No preamble.

Sotto le domande abbiamo incollato 306 righe (43 KB) di un log di gateway inventato che copre 20 minuti. Aveva delle trappole: un ID utente con due cifre scambiate (u_4417), uno scanner che colpiva pagine inesistenti e una ricerca lenta (9.214 ms) poco sotto la richiesta più lenta (9.871 ms). Uno script ha generato il log e la chiave delle risposte.

• Gemini 4 Argon (9,5 s, 10,0 s): 5 su 5 in entrambe le esecuzioni, compreso il conteggio di 14 errori, tutti da payments-1. La causa secondo lui: quel servizio falliva subito (2-9 ms, risposte identiche da 162 byte) dalle 14:07:12 alle 14:09:55, mentre payments-2 restava sano.
• GPT-6 Astra (5,7 s, 5,4 s): 4 su 5 in entrambe le esecuzioni. Ha contato 16 errori, poi 15. Erano 14. Tutto il resto era giusto, compresa la stessa causa.

Verdetto: Argon. Un conteggio sbagliato in un log è il tipo di errore che si vede solo controllando, e Astra l'ha fatto in entrambe le esecuzioni. Astra ha risposto in circa metà del tempo.

Se usi uno dei due modelli sui log, chiedi anche le righe corrispondenti insieme al conteggio, così controlli il numero in pochi secondi.

Test 3: trasformare un thread di email in JSON

Il modello estrae campi esatti da un testo disordinato e rispetta un formato rigoroso?

Prompt:

Turn this support email thread into one JSON object for our ticketing system.

Schema (every key is required):

• "order_id": string
• "customer_email": string, the From address of the customer's most recent message
• "items": array of objects with "sku" (string) and "quantity" (integer), only the items in the customer's latest request
• "requested_action": one of "refund", "replacement", "other"
• "refund_amount_cents": integer, or null if no refund is requested
• "deadline": "YYYY-MM-DD", or null if none is given; resolve relative dates against the Date header of the message they appear in
• "escalation_risk": boolean, true if the customer threatens a chargeback, a bank dispute or legal action

If the customer changed their mind, use the latest request. Return only the JSON object: no code fences, no comments, no extra keys.

Il thread conteneva due email della stessa persona. Lunedì, da un indirizzo di lavoro, chiedeva due lampade sostitutive.

Mercoledì, da un indirizzo personale, ha cambiato idea: rimborso per due lampade e un caricatore, 157,50 $ in tutto, entro "venerdì", altrimenti avrebbe contestato l'addebito in banca. Il thread cita anche un vecchio ordine senza problemi.

• Gemini 4 Argon (6,8 s): tutti e sette i campi giusti, in un JSON valido e senza nulla in più: un rimborso di 15.750 centesimi, l'indirizzo personale, entrambi gli articoli e "venerdì" risolto al 2026-10-16.
• GPT-6 Astra (3,9 s): lo stesso, campo per campo.

Verdetto: parità nella precisione. Astra ha risposto in circa metà del tempo. Argon è costato 0,003 $ contro 0,013 $.

Sulla velocità, Astra inizia a rispondere prima. Il suo primo token arriva in 3,1-3,8 secondi su tutte le risposte tranne quella che ha ragionato (9,4 s). Quello di Argon impiega 5,1-6,8 secondi, anche sul prompt JSON breve, e ha dichiarato 0 token di pensiero su tutte e cinque le risposte.

Se le risposte devono partire veloci, Astra ha il vantaggio. Se un conteggio o una ricerca devono essere esatti, Argon ha fatto meglio qui.

Cosa dicono i benchmark pubblicati?

Nella tabella di Google, Argon guida sei righe su dieci e Astra tre, con una parità. Artificial Analysis, un sito di benchmark indipendente, li valuta alla pari.

Sono i numeri di Google dalla scheda del modello Gemini 4 Argon, con risultati di ottobre 2026.

Le vittorie di Astra sono nelle righe degli agenti: FrontierSWE v2 (65,5% contro 55,0%), Terminal-bench 4.0 e OSWorld-2.0, che testano il coding in un terminale e l'uso del computer. I vantaggi più grandi di Argon sono nel lavoro di conoscenza: il test per agenti legali di Harvey (19,6% contro 5,4%), AutomationBench e il Vals Index.

Artificial Analysis dà 53 a entrambi nell'Intelligence Index, ma ha eseguito Argon con ragionamento alto e Astra con max. Con queste impostazioni Argon ha scritto circa il doppio dei token di output per compito (36k contro 17k) e ha comunque speso meno per compito (1,99 $ contro 3,26 $). Ha anche misurato Argon più veloce a generare una volta partito: 82 contro 56 token al secondo.

OpenAI dichiara 98% su FrontierMath Tier 4 e 99,9% su ARC-AGI-3 per Astra. La tabella di Google non include questi test, quindi non c'è un numero di Argon da mettere accanto.

Per gli agenti da terminale e l'uso del computer, anche i numeri di Google favoriscono Astra. Per il lavoro di conoscenza pieno di documenti favoriscono Argon.

Quanto costa un compito con ciascuno?

Ai prezzi di listino, Astra è costato da 3,4 a 4,9 volte tanto per compito rispetto ad Argon nelle nostre esecuzioni. Quando il prezzo di Argon raddoppierà il 1° dicembre, Astra costerà ancora da 1,7 a 2,4 volte tanto.

Questi prezzi vengono dalla pagina dei prezzi dell'API Gemini di Google e dalla pagina del modello GPT-6 Astra di OpenAI, controllate il 23 ottobre 2026.

Batch e Flex costano la metà su entrambi. Su Astra i prompt con più di 272K token di input costano 2x su input e cache e 1,5x sull'output per l'intera richiesta. La pagina dei prezzi di Google non elenca supplementi per prompt lunghi su Argon.

Per avere un'idea: 1.000 compiti di log come i nostri costano circa 60 $ su Argon fino al 30 novembre, circa 120 $ dal 1° dicembre e circa 205 $ su Astra.

Il divario è più piccolo del fattore 5 dei prezzi di listino per due motivi. Argon ha scritto risposte più lunghe (401 contro 218 token di output sul compito del log), e Google ha contato lo stesso log da 43 KB come più token di input rispetto a OpenAI.

Chiedi di nuovo lo stesso log due minuti dopo e entrambi fatturano gran parte a tariffa cache. La nostra seconda esecuzione sul log è costata circa 0,011 $ su Argon e circa 0,033 $ su Astra, circa l'80% in meno della prima.

Una regola di OpenAI da sapere: sui modelli GPT-6 la modalità cache predefinita fattura i token del prompt scritti in cache a 1,25 volte la tariffa di input. Quindi la prima chiamata sul log può costare circa 0,25 $ invece di 0,205 $.

Quale scegliere?

Scegli Argon per documenti lunghi, log e volumi elevati. Scegli Astra quando le risposte devono partire veloci o quando i tuoi agenti lavorano in un terminale o su un computer.

Il 1° dicembre il prezzo di Argon raddoppia a 4 $ e 20 $ per milione di token, che è ancora il 40% del prezzo di listino di Astra, quindi la scelta qui sopra vale ancora. Mescolarli è facile, perché girano sulla stessa API con una sola chiave.

Una divisione semplice: Argon dove un numero sbagliato costa caro, Astra dove costa caro una risposta lenta. Inizia da Gemini 4 Argon su OmniaKey e da GPT-6 Astra su OmniaKey.

Come eseguire lo stesso test con una sola chiave API?

Usa l'SDK Python di OpenAI puntato a OmniaKey e cambia una stringa per passare da un modello all'altro. Abbiamo eseguito questo codice il 23 ottobre 2026.

import os
import time

from openai import OpenAI

client = OpenAI(
    base_url="https://api.omniakey.com/v1",
    api_key=os.environ["OMNIAKEY_API_KEY"],
)

model = "gemini-4-argon"  # change to "gpt-6-astra" to compare
prompt = open("ticket-prompt.md").read()  # the support-ticket task from Test 3

start = time.perf_counter()
response = client.chat.completions.create(
    model=model,
    messages=[{"role": "user", "content": prompt}],
)
print(response.choices[0].message.content)
print(f"{time.perf_counter() - start:.1f} s", response.usage)

1. Crea una chiave su OmniaKey e impostala come OMNIAKEY_API_KEY.
2. Installa l'SDK: pip install openai.
3. Salva il tuo prompt come ticket-prompt.md, per esempio le istruzioni del test 3 seguite da un tuo thread di email.
4. Esegui lo script. Stampa la risposta, il tempo e i token usati.
5. Cambia model in "gpt-6-astra" ed eseguilo di nuovo.

Quando abbiamo eseguito questo script su Argon con il prompt del test 3, ha restituito il JSON corretto in 7,1 secondi, con 634 token di input e 152 di output.

Domande frequenti

Gemini 4 Argon è meglio di GPT-6 Astra?

Nei nostri tre compiti Argon ha sempre avuto ragione ed è costato meno, e Astra è stato più veloce su due. La tabella di Google mette Argon avanti in sei righe su dieci, e Artificial Analysis li valuta alla pari, a 53.

Gemini 4 Argon è disponibile per tutti?

È nell'API Gemini a pagamento dal 13 ottobre 2026, ma non nel livello gratuito. Gli abbonati Google AI Ultra e Pro lo hanno anche nell'app Gemini.

Quanto è più economico Gemini 4 Argon rispetto a GPT-6 Astra?

Fino al 30 novembre il prezzo di listino è un quinto di quello di Astra: 2 $ e 10 $ contro 10 $ e 50 $ per milione di token. Nei nostri compiti Astra è costato da 3,4 a 4,9 volte tanto. Dal 1° dicembre il prezzo di listino di Argon è il 40% di quello di Astra (4 $ e 20 $ contro 10 $ e 50 $).

Quale è meglio per programmare?

Entrambi hanno corretto il nostro bug e superato tutti i 12 test nascosti. Nella tabella di Google Argon guida DeepSWE v1.1 (77,9% contro 74,1%), mentre Astra guida FrontierSWE v2 (65,5% contro 55,0%) e Terminal-bench 4.0 (58,2% contro 57,4%).

Gemini 4 Argon pensa per impostazione predefinita?

Sì, a medium. Ha dichiarato 0 token di pensiero nei nostri tre compiti, ma ne ha spesi 471 su un puzzle di conteggio più difficile e l'ha risolto, quindi pensa quando il compito lo richiede.

Fonti

• Google: annuncio di Gemini 4 Argon (30 settembre 2026), post sulla disponibilità generale (13 ottobre 2026), registro delle modifiche dell'API Gemini, pagina del modello, prezzi, livelli di pensiero, scheda del modello
• OpenAI: annuncio di GPT-6 Astra, pagina del modello, prezzi, cache dei prompt, registro delle modifiche
• Artificial Analysis: pagina di confronto

Tutto controllato il 23 ottobre 2026.

Registro degli aggiornamenti

• 23 ottobre 2026: prima pubblicazione. Test eseguiti il 23 ottobre tramite l'API OmniaKey.