GPT-6.1 Terra vs Sol vs Luna per il coding: costo per task

La tua sessione dell'agente è terminata, il diff sembra a posto, e ora ti chiedi se il tier più costoso fosse necessario. Risposta breve: parti da Terra, invia i passaggi semplici in blocco a Luna, e paga Sol solo per il task che Terra ha già mancato. Su una modifica identica (40.000 token in input, 3.000 in output) i prezzi standard OpenAI danno $0,0055 su Luna, $0,055 su Terra e $0,11 su Sol.

Cosa dice il listino prezzi#

La pagina dei prezzi di OpenAI (verificata il 29 ottobre 2026, tier standard, input fino a 272K token) elenca questi prezzi per 1M di token:

Lo schema è ordinato. Sol costa esattamente il doppio di Terra su ogni colonna. Luna è un decimo di Terra su input e output, e un quinto sull'input in cache. Quindi la scala dei costi è fissa, e la vera domanda è quanto spesso un gradino più economico porta a termine il lavoro.

L'ultima colonna è pura aritmetica. Su Terra: 40.000 × 1,00 / 1.000.000 = 0,04 per l'input e 3.000 × 5,00 / 1.000.000 = 0,015 per l'output, quindi 0,04 + 0,015 = 0,055. Su Sol la stessa somma è 0,08 + 0,03 = 0,11, su Luna 0,004 + 0,0015 = 0,0055.

Una modifica, poi cinquanta#

Diciamo che fai 50 modifiche così al giorno: riscrivi una funzione, sistemi i test che ha rotto, circa 40.000 token di file e istruzioni in input e 3.000 token di patch e spiegazione in output. Un giorno allora costa 50 × 0,055 = 2,75 dollari su Terra, 50 × 0,11 = 5,50 su Sol e 50 × 0,0055 = 0,275 su Luna.

Nessuno sente $0,11 su una singola modifica. Un mese di Sol a quel ritmo è un discorso diverso, ed è il motivo per decidere il tier una volta per tipo di task invece che una volta per umore.

Ecco l'intero calcolo in poche righe che puoi incollare e rieseguire con i tuoi conteggi di token (prezzi di esempio dalla tabella sopra, inserisci quelli attuali):

PRICES = {  # $ per 1M tokens: (input, output), OpenAI, 29 Oct 2026
    'luna': (0.10, 0.50),
    'terra': (1.00, 5.00),
    'sol': (2.00, 10.00),
}

def cost(tier, tokens_in, tokens_out):
    p_in, p_out = PRICES[tier]
    return (tokens_in * p_in + tokens_out * p_out) / 1_000_000

print(cost('terra', 40_000, 3_000))  # 0.055

Loop degli agenti: l'input è la bolletta#

Una modifica è una richiesta. Un agente sono venti di fila, e ogni passaggio rilegge i file e la cronologia fino a quel punto. Prendi un loop di 20 passaggi in cui ogni passaggio invia circa 30.000 token e ne riceve circa 1.000. Sono 600.000 token in input e 20.000 in output.

Su Terra: 600.000 × 1,00 / 1.000.000 = 0,60 per l'input e 20.000 × 5,00 / 1.000.000 = 0,10 per l'output, quindi 0,60 + 0,10 = 0,70 dollari. Sol raddoppia a 1,40, Luna riduce a 0,07. Guarda la ripartizione: $0,60 dei $0,70 è ciò che invii, non ciò che il modello scrive. È l'opposto di come la maggior parte delle persone immagina la bolletta.

La cache cambia il quadro, se il tuo prefisso si ripete davvero. Supponi che 25.000 dei 30.000 token in ogni passaggio siano lo stesso prefisso e colpiscano la cache: 100.000 × 1,00 / 1.000.000 = 0,10 di input fresco, 500.000 × 0,05 / 1.000.000 = 0,025 di input in cache, più 0,10 di output, quindi Terra arriva a 0,10 + 0,025 + 0,10 = 0,225. Come funziona è spiegato in cos'è il prompt caching; perché la cronologia continua a crescere è in perché gli agenti AI usano così tanti token.

Il calcolatore qui sotto esegue lo stesso loop sui modelli CheapTokens. Cambia i passaggi e i token per adattarli al tuo agente.

Quale tier per quale task#

L'autore di un canale Telegram, che conduce esperimenti con l'AI, ha confrontato Terra con Sol e Luna in Codex e ha pubblicato un video il 28 ottobre 2026. La sua conclusione, nel suo stesso titolo, è che Terra è un tier intermedio e che non è un difetto (il post). Questa inquadratura è un buon riferimento: il gradino intermedio è il default, e gli altri due richiedono un motivo.

Il motivo di solito sono i retry. A parità di token, due tentativi su Terra costano 2 × 0,055 = 0,11, che è un tentativo su Sol. E dieci tentativi su Luna costano 10 × 0,0055 = 0,055, che è un tentativo su Terra. Quindi se Sol è l'unico tier che porta a termine una classe di task al primo colpo, si ripaga da solo su quei task. Se Luna porta a termine una classe di task più di una volta su dieci, è il modo più economico di ottenerli, prima ancora di contare il tempo speso a rivedere i fallimenti.

Scegli la situazione più vicina alla tua:

Quando basta un modello open-weight più economico#

La stessa modifica sui tre tier OpenAI accanto a tre modelli CheapTokens, con gli stessi 40.000 token in input e 3.000 in output:

Le barre mostrano il prezzo, non i risultati. Se uno di questi modelli sia abbastanza buono per le tue modifiche è qualcosa che verifichi allo stesso modo di Luna: rigiochi task reali e leggi i diff. Se passa, la bolletta scende ulteriormente. Per i loop degli agenti, DeepSeek-V4-Flash ha una context window di 380K, fino a 32.768 token in una risposta e un unico prezzo a qualsiasi ora del giorno. GLM-5.3-Flash ha una context window di 390K e MiniMax-M2.7 di 180K; tutti i prezzi sono sulla pagina dei prezzi, e i passaggi di connessione sono nella documentazione.

Rigioca i tuoi task#

La tabella ti dà il costo. La qualità la scopri in un pomeriggio: prendi dieci task dalla tua cronologia recente, esegui ciascuno su Luna, poi su Terra, e metti i diff fianco a fianco. Gli unici numeri che ti servono sono nella risposta, nel campo usage, il che rende facile calcolare il prezzo esatto di un'esecuzione. Con CheapTokens appare così:

curl https://api.cheaptokens.dev/v1/chat/completions \
  -H "Authorization: Bearer $CHEAPTOKENS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "deepseek-ai/DeepSeek-V4-Flash-0731", "messages": [{"role": "user", "content": "Rename the variable x to retry_count in this function: ..."}]}'

Nel JSON che torna indietro, usage.prompt_tokens e usage.completion_tokens sono il tuo input e output per quel task. Passali all'helper cost() qui sopra, e hai il costo per task per qualsiasi modello con un prezzo. Per i dettagli del lancio del nuovo tier, vedi prezzo API di GPT-6.1 Terra; per la ripartizione input/output, token di input vs output.