
Grok 4.6 vs Grok 4.5: abbiamo fatto 80 chiamate API il giorno del lancio – stesso 40/40, 1.38× la spesa
Grok 4.6 ci è costato $0.2992 per completare 40 task valutati. Grok 4.5 ne è costato $0.2174 per gli stessi 40, restituendo le stesse risposte.
Lo abbiamo misurato il 12 agosto 2026, poche ore dopo che SpaceXAI (ex xAI) ha rilasciato il modello. Stesso listino: $2 per milione di token in input, $6 in output. Stesso punteggio: 40/40 contro 40/40. Il divario è di 1.90× i token di output mediani su 4.6, che si traduce in una fattura più alta del 38%.
Cosa ha rilasciato SpaceXAI il 12 agosto
SpaceXAI ha rilasciato Grok 4.6 il 12 agosto 2026 a $2 per milione di token in input e $6 in output, lo stesso listino di Grok 4.5. È uscito alle 08:56 PT secondo 9to5Mac, e l'annuncio ufficiale (consultato il 2026-08-12) punta tutto sulla codifica agentica, senza pubblicare alcun dato su costo operativo, latenza o consumo di token.
- Disponibile dal giorno stesso come
grok-4.6sull'API SpaceXAI e comex-ai/grok-4.6su OpenRouter. - Una finestra di contesto di 500K token, invariata rispetto a Grok 4.5.
- $2/M in input, $6/M in output, più una variante fast al doppio del prezzo.
- Un punteggio Artificial Analysis Intelligence Index di 61, presentato dal produttore come equivalente a GPT-5.6 Sol.
- Un solo confronto qualitativo con 4.5: prime bozze più solide su progetti visivi e interattivi.
L'articolo di lancio di Cursor sembra una validazione di terze parti, ma non lo è: SpaceX ha accettato di acquisire Anysphere, l'azienda dietro Cursor, per $60B in azioni il 16 giugno 2026.
Conviene passare a Grok 4.6?
Resta su 4.5 per il lavoro strutturato di routine: le nostre 80 chiamate hanno restituito risposte identiche per 1.38× la spesa. Il listino è identico byte per byte su entrambe le pagine modello di OpenRouter, quindi nessuna pagina prezzi può avvisarti. Il conteggio dei token sì.
| Metrica | Grok 4.6 | Grok 4.5 |
|---|---|---|
| AA Intelligence Index | 61 | 56 |
| Prezzo per M (input / output) | $2 / $6 | $2 / $6 |
| Input in cache per M | $0.50 | $0.30 |
| Task superati (nostri, 80 chiamate) | 40/40 | 40/40 |
| Token di output mediani (nostri) | 409 | 215 |
| Costo per la stessa risposta (misurato) | $0.2992 | $0.2174 |
| Latenza mediana (nostra) | 5.25 s | 4.17 s |
| Scegli questo se | lavoro agentico long-horizon | chiamate strutturate brevi ad alto volume |
Le righe indicate come "nostre" sono nostre, misurate il giorno del lancio; le righe su indice e cache sono di Artificial Analysis, consultate il 2026-08-12.
Stesso listino, 1.90× i token, quindi circa 1.38× la fattura per le stesse risposte. Questa è la domanda grok 4.6 vs grok 4.5 per la maggior parte del traffico in produzione: stesso prezzo per token, una fattura diversa.
Cosa hanno mostrato davvero 80 chiamate API il giorno del lancio
Su 80 chiamate del giorno del lancio a temperatura zero, entrambi i modelli hanno segnato 40/40, mentre 4.6 ha speso 1.90× i token di output mediani.
Abbiamo inviato ogni prompt due volte, una a x-ai/grok-4.6 e una a x-ai/grok-4.5, misurati tramite OpenRouter a temperature: 0. Il round 1 (24 chiamate) era facile: i task JSON-schema che abbiamo valutato, un calcolo di prezzo, un bug fix in Python, un task di scrittura vincolata. Il round 2 (24 chiamate) è diventato più difficile dopo che il round 1 ha saturato: un rompicapo di pianificazione, una trappola di conversione di unità, un recupero ago-nel-pagliaio di 402 righe con un'esca REVOKED, e un task di specifica in cui retry_on deve contenere 429 e 503 ma non 500. Il round 3 (32 chiamate) è il controllo qui sotto. Ogni valutatore è deterministico; niente è giudicato da un LLM. Script grok_bench.py, grok_bench_hard.py, grok_bench_effort.py; output grezzo in benchmark-raw.json, benchmark-hard-raw.json, benchmark-effort-raw.json. Spesa totale, $0.52.
for model in ("x-ai/grok-4.6", "x-ai/grok-4.5"):
r = httpx.post("https://openrouter.ai/api/v1/chat/completions",
headers={"Authorization": f"Bearer {KEY}"},
json={"model": model, "temperature": 0,
"messages": [{"role": "user", "content": PROMPT}]}).json()
u = r["usage"]
print(model, u["completion_tokens"],
u["completion_tokens_details"]["reasoning_tokens"])| Round a effort predefinito | Grok 4.6 | Grok 4.5 |
|---|---|---|
| 1, facile (24 chiamate) | 12/12, 468 tok di output mediani | 12/12, 241 tok |
| 2, difficile (24 chiamate) | 12/12, 493 tok di output mediani | 12/12, 332 tok |
Il consenso pre-lancio, un post su X di @haider1 datato 11 agosto e ripreso da vari blog aggregatori, sosteneva che 4.6 avrebbe mantenuto la velocità e l'efficienza di token di 4.5. SpaceXAI non lo ha mai affermato; il suo annuncio non contiene alcuna dichiarazione sui token. Unite.AI ha notato il giorno del lancio che "nessuna valutazione indipendente ha ancora confermato" le affermazioni del modello, quindi eccone una. Grok 4.6 ha usato 409 token di output mediani contro i 215 di Grok 4.5 sugli stessi prompt a temperatura zero, 365 token di reasoning mediani contro 200, e 27,565 totali contro 13,929. Qualunque sia il vantaggio di 4.6, lo paga con 1.90× i token di output mediani.
La coda è dove fa più male
Stesso prompt, temperature: 0, tre tentativi di unit_trap nei round a effort predefinito:
| Tentativo | Grok 4.6 | Grok 4.5 |
|---|---|---|
| 1 | 12.25 s / 726 tok | 8.38 s / 414 tok |
| 2 | 23.20 s / 1,400 tok | 15.32 s / 750 tok |
| 3 | 81.61 s / 4,770 tok | 10.08 s / 480 tok |
Uno scarto di 6.6× su 4.6 contro 1.8× su 4.5, su input identici byte per byte. Quando dimensioni un timeout o un budget di token per richiesta, quella coda conta più della mediana, ed è un argomento a favore di quando il modello più recente è la scelta predefinita sbagliata.
L'unico task che è andato in direzione opposta
Su constraint_schedule, 4.6 è stato più veloce alla mediana nei round a effort predefinito: 26.38 s contro 34.21 s, e anche con meno token di output (1,644 contro 1,710). Riportare solo i numeri che confermano una tesi è esattamente ciò che lettori e Google penalizzano.
È il modello, o è il default?
Fissare reasoning_effort allo stesso valore su entrambi i modelli non chiude il divario; lo allarga, da 1.51× a 2.91×. docs.x.ai (consultato il 2026-08-12) elenca quattro livelli (low, medium, high, xhigh) e i round 1 e 2 non ne hanno mai impostato uno, quindi il divario poteva essere semplicemente un default di fabbrica. Il round 3 lo ha fissato esplicitamente su 32 chiamate.
| Effort allineato | Output mediano 4.6 | Output mediano 4.5 | Rapporto | Accuratezza |
|---|---|---|---|---|
| low | 222 tok | 147 tok | 1.51× | 8/8 vs 8/8 |
| high | 606 tok | 208 tok | 2.91× | 8/8 vs 8/8 |
Se il divario si fosse azzerato a parità di effort, il titolo onesto sarebbe stato "it's just a default". Non è successo.
Come ridurre la spesa in token di Grok 4.6?
Imposta reasoning_effort su low e l'output mediano di 4.6 scende da 438 a 222 token, con l'accuratezza invariata a 8/8. Stessi quattro task in entrambi i casi: la cifra a default aggrega dodici chiamate dei primi due round, quella a low otto dal controllo.
{
"model": "x-ai/grok-4.6",
"messages": [{"role": "user", "content": "..."}],
"temperature": 0,
"reasoning": {"effort": "low"}
}Si tratta di una riduzione del 49%, pari a circa $1.30 ogni mille chiamate di questo tipo a $6 per milione di token di output. Un solo parametro della richiesta dimezza quasi la spesa in output di Grok 4.6 sul lavoro strutturato di routine, senza alcuna perdita misurabile. Quattro task sono un indizio, non una regola: testalo prima sul tuo mix di traffico.
Cosa mostrano i contatori di altri
Artificial Analysis, sulla propria suite di valutazione, ha speso $1,068.47 per valutare Grok 4.6 contro $579.21 per Grok 4.5. I loro numeri, non i nostri, dalle pagine modello di Grok 4.6 e Grok 4.5 su artificialanalysis.ai, consultate il 2026-08-12.
| Metrica (Artificial Analysis) | Grok 4.6 (high) | Grok 4.5 (high) | Rapporto |
|---|---|---|---|
| Intelligence Index | 61 | 56 | +5 pt |
| Token di output per eseguire l'indice | 72M | 60M | 1.20× |
| Costo per eseguire l'indice | $1,068.47 | $579.21 | 1.84× |
| Tempo al primo token | 32.30 s | 8.68 s | 3.72× |
| Prezzo cache-hit per M | $0.50 | $0.30 | 1.67× |
Il loro 1.84× e il nostro 1.38× non coincidono, e il motivo è istruttivo: il loro mix di task è più pesante, e il loro totale include i token di input dove il nostro isola solo l'output. Due strumenti di misura diversi, stessa direzione.
La riga sulla cache è stata segnalata per prima dall'utente HN pzo nel thread di lancio (commento 49275740) e trova conferma su entrambe le pagine: +67%, e a pagarne il conto sono soprattutto i workload agentici long-running a cui punta 4.6, dove il riutilizzo della cache è tutto il punto.
Grok 4.6 è migliore di Claude per la programmazione?
Sulla correttezza è alla pari: Grok 4.6, Claude Sonnet 5 e Claude Opus 4.8 hanno superato ciascuno 10 task di codifica eseguiti su 10. Questo è il titolo, e per Grok un guadagno reale.
Per questo confronto abbiamo smesso di valutare il testo. Cinque task con unit test nascosti, due prove ciascuno, 30 chiamate: matching semver incluso il caso ^0.x, una cache LRU con TTL a orologio esplicito, l'unione di intervalli con estremi che si toccano, un parser di durate che deve rifiutare 1m30h e 1.5h, e un troncamento sicuro sui grafemi che non deve isolare un segno diacritico combinante né spezzare un'emoji. Ogni risposta viene eseguita in un subprocess e supera il test solo se ogni asserzione regge. Script grok_vs_claude_coding.py, dati grezzi in benchmark-coding-raw.json.
p = subprocess.run([sys.executable, path], capture_output=True, timeout=20)
ok = p.returncode == 0 and "ALLPASS" in p.stdout # the model never sees the tests| Modello | Superati | Latenza mediana | Token di output mediani | Output $/M | Costo totale |
|---|---|---|---|---|---|
| Grok 4.6 | 10/10 | 26.82 s | 2,016 | $6 | $0.1169 |
| Claude Sonnet 5 | 10/10 | 6.76 s | 500 | $10 | $0.0596 |
| Claude Opus 4.8 | 10/10 | 4.96 s | 411 | $25 | $0.1006 |
Il pareggio sulla correttezza è la notizia. Il conto è la trappola: Grok 4.6 ha impiegato 4.0× il tempo di Sonnet 5 e 5.4× quello di Opus 4.8, con 4.0× e 4.9× i token di output mediani. Quell'appetito di token divora per intero il vantaggio di prezzo. Grok 4.6 è costato più di Claude Opus 4.8 su questi cinque task nonostante i suoi token di output siano 4.2× più economici, perché ha emesso 18,345 token di output contro i 3,630 di Opus 4.8. Contro Sonnet 5 è costato 1.96× tanto, e la tariffa per token in output di Sonnet è la più alta delle due. Una tariffa più bassa non è un modello più economico, la stessa lezione che i numeri di 4.6 contro 4.5 insegnano una sezione più sopra.
Un giudizio, segnalato come tale e non come misura: sulle pipeline media e di automazione dei contenuti finora abbiamo preferito Grok a Claude, soprattutto per la sua ingestione nativa di X e la gestione più permissiva del copy marketing. Non abbiamo alcun benchmark per questo e non ne presentiamo uno. Sul lavoro di codifica che possiamo valutare in modo deterministico, i tre sono alla pari sulla correttezza e Grok paga da quattro a cinque volte i token.
Cosa non abbiamo testato
I nostri task hanno saturato a 40/40, quindi questo misura il costo sul lavoro di routine, non la capacità sui compiti agentici per cui SpaceXAI ha ottimizzato il modello. Cinque limiti:
- Il pareggio in accuratezza è un effetto soffitto, non la prova che 4.6 non sia più intelligente. I nostri task hanno esaurito la difficoltà prima dei modelli, e non mettono alla prova la codifica long-horizon di frontiera.
- Due o tre tentativi per task. Sufficienti per indicare una direzione e una storia di varianza, non un intervallo di confidenza.
- Misurato tramite OpenRouter, non l'endpoint proprio di SpaceXAI. Il routing aggiunge una latenza che non è del modello, motivo per cui a reggere l'argomento sono i conteggi di token indipendenti dal provider.
- Un task è andato contro la tesi,
constraint_schedule, dove 4.6 è stato più veloce alla mediana. - Anche il confronto con Claude ha saturato. Cinque task di codifica, tutti e tre i modelli a 10/10, quindi separa costo e latenza ma non dice nulla su quale modello sia più forte al limite superiore.
Non abbiamo nemmeno testato ciò che SpaceXAI afferma davvero: prime bozze più solide su progetti visivi e interattivi. Non esiste un valutatore deterministico per questo, quindi non lo mettiamo in discussione. Non abbiamo alcun rapporto commerciale con SpaceXAI e abbiamo pagato ogni chiamata di tasca nostra.
Chi dovrebbe passare a 4.6, e chi dovrebbe restare su 4.5?
Passa a 4.6 se il tuo traffico è lavoro agentico long-horizon; resta su 4.5 se sono chiamate strutturate brevi ad alto volume. Sull'asse dell'indice che ogni altro articolo del giorno del lancio usa, 4.6 vince a parità di listino. Sul costo misurato per risposta corretta, grok 4.6 vs grok 4.5 si capovolge nella direzione opposta.
| Il tuo workload | Scelta | Cosa la ribalta |
|---|---|---|
| Chiamate strutturate o JSON ad alto volume | Grok 4.5 | un task su cui 4.5 fallisce davvero |
| Codifica agentica long-horizon | Grok 4.6 | niente di quello che abbiamo misurato; è il suo caso |
| Percorsi utente sensibili alla latenza | Grok 4.5 | la chiamata di coda da 81.61 s, finché non limiti l'effort |
| Sessioni con forte riuso della cache | fai due conti | $0.50 contro $0.30 per M possono superare il divario sui token |
| Già su 4.6 | resta, ma imposta l'effort | lasciarlo non impostato costa il 49% in più di output |
Grok 4.5 resta il modo più economico per ottenere la stessa risposta sul lavoro strutturato di routine. Questo non significa che 4.6 sia peggiore: i suoi vantaggi li compra pensando più a lungo, e nelle chiamate di produzione quotidiane quello scambio è un aumento di costo senza alcun ritorno in accuratezza che siamo riusciti a misurare. Un altro argomento a favore di fissare una versione del modello in uno stack ad agenti invece di seguire latest.
Tre script, una chiave OpenRouter e meno di un dollaro di credito: è tutto quello che costa verificare se il tuo traffico assomiglia al nostro.
Domande frequenti
Esiste un Grok 5 o un Grok 5.6?
Nessuno dei due esiste. Al 12 agosto 2026, Grok 4.6 è il modello più recente rilasciato. Grok 4.7 era stato annunciato per fine agosto o inizio settembre e non era ancora uscito nel momento in cui abbiamo scritto questo articolo; tutto ciò che viene dopo è previsto per la fine del 2026. Il "5.6" è quasi certamente GPT-5.6 Sol, un modello OpenAI contro cui Grok 4.6 viene confrontato nei benchmark.
Grok 4.6 costa di più di Grok 4.5?
Stesso listino, $2/M in input e $6/M in output per entrambi. Le nostre 80 chiamate misurate hanno restituito risposte identiche per 1.38× il costo totale, perché 4.6 emette 1.90× i token di output mediani. Anche l'input in cache è salito da $0.30 a $0.50 per milione.
Grok 4.6 è più lento di Grok 4.5?
Alla nostra mediana, 1.26× più lento: 5.25 s contro 4.17 s su 40 chiamate ciascuno. Alla nostra chiamata peggiore, 2.27×: 81.61 s contro 35.98 s. Artificial Analysis, misurando separatamente, riporta un tempo al primo token di 32.30 s contro 8.68 s. Nota che abbiamo misurato tramite OpenRouter, quindi il routing aggiunge una latenza di cui il modello stesso non è responsabile.
Qual è la finestra di contesto di Grok 4.6 e come si chiama tramite API?
500K token, invariata rispetto a Grok 4.5. Lo slug è x-ai/grok-4.6 su OpenRouter e grok-4.6 sull'API SpaceXAI, con una variante fast al doppio del prezzo standard. Imposta reasoning_effort esplicitamente invece di ereditarlo; il default è high, e sui nostri quattro task di controllo abbassarlo a low ha dimezzato i token di output senza costare nemmeno una risposta corretta.
Conviene restare su Grok 4.5?
Per il lavoro strutturato ad alto volume, sì: ha restituito le stesse risposte per meno soldi su tutte le 80 chiamate. Per la codifica agentica long-horizon, il workload per cui SpaceXAI ha ottimizzato 4.6, i nostri task non lo dirimono e non lo abbiamo testato. Misura il tuo mix specifico.