Home / Numeri

Numeri

Come usare al meglio Fable 5.2 e Opus 5.5 a novembre 2026

Sui nuovi modelli il thinking non si spegne più e l’effort è l’unica leva: la scelta è cambiata di nuovo. Ti spiego da quale partire, quanto effort dare e quando passare all’altro, con i numeri

Danilo Giudice · 11 novembre 2026

Tipo

Numeri: una smentita con i dati

Durata

17 min di lettura

Livello

Intermedio

Ti porti a casa

• Da quale modello partire per ogni compito
• Quanto effort dare e quando salire a Fable 5.2
• Quanto costano la cache e il mix di modelli

A ogni compito devi scegliere due cose: il modello e il suo effort. Addy Osmani spiega come farlo nel post «Which Claude model should you build with?» del 9 novembre 2026. Un esempio dal post:

Fable 5.2 costa il doppio di Opus 5.5 a token, cioè per ogni pezzetto di testo che entra ed esce dal modello. Eppure su FrontierCode 2.0, una batteria di prove uguale per tutti i modelli (un benchmark), Fable 5.2 a effort high ha fatto 45,3 % e Opus 5.5 al massimo 45,5 %, con Fable a circa metà del costo per compito.

Lo spoiler: se arrivi in fondo sai da quale modello partire per ogni lavoro e in che ordine alzare effort e modello quando il risultato non basta. E ti porti a casa un file pronto da copiare, che fa leggere i log a Haiku 5.5 al posto del modello costoso.

Lavorando con Claude Code tutti i giorni mi sono accorto che il miglior compromesso, per fare quasi tutto, è Opus 5.5 a medium. Delegare l’esecuzione a Sonnet 5.5, però, fa risparmiare token e accelera il lavoro: Sonnet 5.5 costa la metà a token ed è il 30 % più rapido di Sonnet 5. Fable 5.2 lo uso per i lavori più difficili, a medium (più avanti ti faccio vedere perché).

Una nota sulle fonti: il post parla di questi modelli come «nostri», quindi prezzi e limiti li ho incrociati con il riferimento delle API di Claude, mentre i benchmark restano quelli di Anthropic.

Parti da Opus 5.5, con effort medium#

Veniamo al dunque. Il modello da cui partire è Opus 5.5, con l’effort a medium: è il predefinito di Claude Code e costa a token la metà di Fable 5.2.

Effort è il parametro che regola quanto lavoro fa il modello prima di restituire la risposta: quanti token di thinking genera (il testo intermedio prima della risposta, che Anthropic chiama ragionamento), quante chiamate agli strumenti fa, quanti controlli esegue. I livelli sono cinque: low, medium, high, xhigh e max.

In pratica è una manopola tra velocità e accuratezza. Più la alzi, più il modello lavora, e più paghi in token e in attesa. A low fa meno chiamate agli strumenti e risposte più asciutte; a high ne fa di più e controlla di più il proprio lavoro.

Ricordatelo, perché più alzi l’effort e più aspetti: con tanto thinking l’esecuzione arriva solo dopo, e su certi compiti non serve, è solo uno spreco di token e di tempo.

I quattro modelli e i loro prezzi#

Tutti e quattro lavorano su un contesto (tutto quello che il modello riceve in una richiesta) fino a 1 milione di token. Ogni risposta invece può essere lunga al massimo 128.000 token, thinking compreso: circa un ottavo del contesto. Cambiano prezzo e velocità.

Listino

Fable 5.2 costa il doppio di Opus 5.5

Dollari per milione di token in output. In input: 8, 4, 2 e 0,10.

Fable 5.2

40,0 $

Opus 5.5

20,0 $

Sonnet 5.5

10,0 $

Haiku 5.5

0,5 $

Haiku 5.5 costa un ventesimo di Sonnet 5.5.

Fonte: listino API di Claude, novembre 2026

Claude Mythos 5.2, per cybersicurezza e ricerca nelle scienze della vita, si usa solo con i programmi di verifica di Anthropic: qui non c’entra.

Quale modello per quale compito#

Come si sceglie il modello? Guardo due cose: quanto è difficile il compito e quanto costa sbagliare. Se il compito è scritto bene e un errore si vede subito (un test che fallisce, un’etichetta sbagliata), basta un modello piccolo. Se serve giudizio, o il lavoro è lungo e aperto, si sale. La tabella qui sotto, presa dal post, lo traduce in pratica, e due righe parlano di subagenti.

Subagente: un’istanza separata dell’agente, con un contesto suo, a cui l’agente principale passa un compito e da cui riceve solo il risultato.

È come un collega a cui chiedi «cercami questo file»: lui fa la ricerca, tu ricevi solo la risposta, e il tuo contesto resta pulito.

Nel dubbio, Opus 5.5 a medium.

Un’avvertenza del post: una migrazione o un lavoro sulle prestazioni possono avere una specifica chiarissima e chiedere comunque Opus 5.5, o Fable 5.2 se sono grossi. Lo stesso vale per un modello finanziario complesso o per un documento costruito su tante fonti: lì si parte da Opus 5.5, non da Sonnet.

Prima l’effort, poi il modello#

Alzare l’effort serve sui compiti difficili, dove servono più passaggi e più controlli. Costa tempo e token, e non aggiunge al modello conoscenze o capacità che non ha.

Quanto costa ogni livello? Per Opus 5.5 su SWE-bench Pro, un benchmark di programmazione, il post dà questi numeri, con high come base.

Effort

Da high a xhigh 2,5 volte il costo

Opus 5.5 su SWE-bench Pro, costo per compito con high a 100. Valori approssimati.

low

33

medium

70

high

100

xhigh

250

Per 1,4 punti in più; medium ne perde 2,5.

Fonte: A. Osmani, claude.dev, 9/11/2026

Da high a xhigh paghi 2,5 volte per 1,4 punti. In punti, rispetto a high, low ne perde circa 8 e medium circa 2,5, e medium costa il 30 % in meno: per questo è il punto di partenza.

REGOLA: prima di cambiare modello, alza l’effort di un livello. Oltre high, invece, prova il modello sopra a un effort più basso, perché un livello in più può costare quanto un modello più grande.

{
  "model": "claude-opus-5-5",
  "max_tokens": 16000,
  "output_config": { "effort": "high" },
  "messages": [{ "role": "user", "content": "…" }]
}

Il modello più grosso al massimo non vince per forza#

L’assunto che sembra sensato a molti è questo: «il modello più capace costa di più, ma almeno il risultato è il migliore, quindi lo metto al massimo e non ci penso più». In realtà è un tranello.

Alla fine paghi il costo per compito finito. Il prezzo a token è come il prezzo al litro della benzina: conta quanto spendi per arrivare, e dipende anche da quanti litri consumi.

Il risultato? Su FrontierCode 2.0 Fable 5.2 a high pareggia Opus 5.5 al massimo, a circa metà prezzo. Su Terminal-Bench 3.0 succede il contrario: Opus 5.5 a high batte di poco Fable 5.1 al massimo, con metà dei token. Sarò onesto: sono numeri riportati da chi i modelli li vende, e il confronto su Terminal-Bench riguarda Fable 5.1, non 5.2 (il post lo prende da «Spending your effort», sullo stesso blog). In tutti e due i casi il livello massimo costa di più e non dà un punteggio migliore.

Per Fable 5.2 il miglior compromesso è medium, secondo i benchmark del lancio di Fable 5.2 (Anthropic, 9 novembre 2026). Su Chartography Fable 5.2 a medium fa 66,4 % contro il 64,4 % di Opus 5.5 al massimo, con meno di un decimo del costo per compito. Su WANDR, sempre a medium, pareggia il miglior punteggio di Opus 5.5 con circa il 40 % della spesa. Quindi Fable 5.2 a medium consuma molto meno di Opus 5.5 al massimo, con un risultato pari o migliore.

Benchmark

Fable a medium batte Opus al massimo

Chartography, senza strumenti. Lancio di Fable 5.2, Anthropic.

Punteggio

Max

Opus 5.5

64,4 %

costo per compito 100

Medium

Fable 5.2

66,4 %3,1 %

costo meno di 10

Più punti, meno di un decimo di spesa.

Fonte: Anthropic, lancio di Fable 5.2, 9/11/2026

Quando fai i conti, metti dentro anche i compiti più difficili, perché sono quelli che costano di più. Su un benchmark di ricerca da 20 problemi, due problemi, cioè il 10 %, hanno fatto il 43 % della spesa.

Opus 5.5 nel lavoro di tutti i giorni

• Parti da medium e sali a high per le funzioni grandi e i bug difficili.
• Dagli sempre un modo per controllare il proprio lavoro, per esempio un test da far passare.
• Per computer use e flussi con molte immagini è il punto di partenza, a medium.
• Il thinking non si spegne: per spendere meno, abbassa l’effort.
• Se serve velocità, sull’API c’è il fast mode: lo stesso modello genera più in fretta, a tariffa doppia (8 / 40 $ per milione di token).

Fable 5.2 per i lavori più difficili

• Tienilo per i lavori in cui Opus 5.5 a high non basta e per le sessioni lunghe senza supervisione: grandi migrazioni, architettura, ricerca, analisi quantitative.
• Effort: io parto da medium, che in Claude Code è già il predefinito (sull’API il predefinito è high). Sopra, solo dove hai misurato un guadagno.
• Dagli tutto il compito all’inizio, e metti in conto che una richiesta può durare molti minuti: fatti mandare la risposta a pezzi mentre arriva (lo streaming) e fai vedere a chi aspetta che il lavoro va avanti.
• Non modificare i messaggi già inviati: se cambi qualcosa prima di un blocco di thinking, l’API restituisce un errore 400 (è il preserved thinking).
• Genera output fino al 30 % più veloce di Fable 5.1. E se coordina altri agenti, mettigli sotto subagenti più economici (ci arriviamo tra poco).

Quando non basta, cambia una cosa alla volta#

Escalation

Tutto a low, i falliti a high

Opus 5.5 su un sottoinsieme di SWE-bench Pro. Valori approssimati.

Compiti superati

Prima

Tutto a high

95,3 %

0,29 $ a compito

Dopo

Low, poi high

97,0 %1,8 %

0,17 $ a compito

Circa il 40 % di spesa in meno.

Fonte: A. Osmani, claude.dev, 9/11/2026

Il contesto costa, anche in cache#

Ogni turno di una conversazione rimanda al modello tutto il contesto. Nelle sessioni lunghe, quindi, la maggior parte dell’input si paga come cache read.

Cache del prompt: la parte iniziale della richiesta, uguale a quella dei turni precedenti, che il servizio tiene da parte e fattura a una tariffa ridotta. Quella lettura si chiama cache read.

Su Opus 5.5 e Fable 5.2 la cache read costa 0,20 $ per milione di token. Un turno con 20.000 token in cache costa circa 0,004 $, uno con 150.000 circa 0,03 $: 7,5 volte tanto. Cento turni fanno circa 0,40 $ contro circa 3 $.

Fable 5.2 e Opus 5.5 hanno la stessa tariffa di cache read. Su una sessione piena di cache, la differenza tra i due sta nell’input fuori cache e nell’output, dove Fable costa il doppio.

Quanto costa riprendere dopo un’ora

Nella mia configurazione di Claude Code la cache dura un’ora. Se riprendo un lavoro dopo, la prima richiesta riscrive in cache tutto il contesto, e sull’API una scrittura che dura un’ora costa il doppio dell’input normale: su Opus 5.5 è 40 volte una cache read. Con 150.000 token di contesto si passa da circa 0,03 $ a circa 1,20 $, solo per ricominciare.

Cache

Riprendere dopo un’ora riscrive la cache: costa 40 volte una lettura

40×

1,20 $Cache scaduta

0,03 $Cache calda

150.000 token su Opus 5.5. Mio calcolo sul listino API

Per questo nella barra di stato di Claude Code, sul mio terminale Warp, ho messo un indicatore della cache. Finché è calda mostra quanti minuti le restano (cache 48m, in giallo quando sta per scadere); quando si è congelata mostra un fiocco di neve e i token che la prossima richiesta dovrà riscrivere (cache ❄ +150k). Così so quanto mi costa riprendere un lavoro prima ancora di scrivere il primo messaggio.

La conseguenza pratica: il contesto del modello costoso tienilo per le decisioni, e la lettura lunga di file e log falla fare ai subagenti. Di quanto pesa il contesto di Claude Code ho scritto in «L’igiene di Claude Code».

Mescolare i modelli: quando conviene e quando no#

Il post descrive tre casi, e solo la delega in massa ha un risparmio misurato. Vediamoli pezzo per pezzo, e alla fine ti racconto come lo faccio io.

Subagenti piccoli per il lavoro che si controlla a colpo d’occhio

Cercare file, lanciare test, leggere log: se l’errore si vede subito, Haiku 5.5 o Sonnet 5.5 bastano. Le modifiche al codice e le scelte che contano restano sul modello principale. Come si definiscono è nella documentazione di Claude Code.

---
name: log-reader
description: Reads test output and logs, and reports each failing case. Use after a test run.
tools: Read, Grep, Glob, Bash
model: haiku
---

Read the logs you're given. For each failure, report the file, the test name and the first error line. Don't edit any files.

La delega in massa, se il lavoro si divide

Delega

Opus 5.5 che coordina 25 Sonnet 5.5 spende un terzo in meno

−33%

100Opus da solo

67Opus + 25 Sonnet

Benchmark interno, circa 22 milioni di token. A. Osmani, claude.dev

Il benchmark è interno: la ricerca di difetti in circa 22 milioni di token di codice, 22 volte il contesto massimo di un modello, con lo stesso punteggio di Opus 5.5 da solo. Non vale per passaggi che dipendono l’uno dall’altro, né per un lavoro che sta in un solo contesto. Lo strumento, nel post, è l’orchestrazione a più agenti di Claude Managed Agents.

opusplan e advisor: misura prima

In Claude Code opusplan fa pianificare Opus e scrivere il codice a Sonnet, cioè il contrario di quanto sopra: provalo sui tuoi compiti prima di farne il predefinito. L’advisor tool (in beta) affianca a un esecutore economico un consulente più forte, e quasi tutti i token li paghi alla tariffa dell’esecutore. La guida ai costi di Anthropic però ammette che nessuna coppia ha battuto chiaramente l’esecutore da solo.

Come lo faccio io: octopus

Per i lavori lunghi in Claude Code uso octopus, un comando per Claude Code che mi sono costruito e che divide il lavoro tra tre modelli. Opus 5.5 pianifica e decide. Sonnet 5.5 compila, lancia i test, rimette insieme i pezzi e rivede il lavoro con un contesto pulito. Haiku 5.5 esegue i sotto-compiti meccanici, e quando un sotto-compito è più difficile lo stesso esecutore riparte su Sonnet 5.5.

Il post consiglia di tenere le modifiche al codice sul modello principale. Io le delego, ma solo quando Opus 5.5 le ha già pianificate, con i file da toccare e i criteri di verifica scritti, e con un revisore che controlla il risultato.

Un’ultima cosa. Se la regola di instradamento è semplice, per esempio un modello per ogni tipo di passaggio, il modello lo sceglie il codice, non un altro modello.

Prima di migrare, sei punti da controllare#

Se sposti su questi modelli codice scritto per quelli precedenti, alcune richieste che prima passavano adesso restituiscono un errore.

• Fable 5.2, il thinking conservato. Errore 400 se cambia qualcosa prima di un blocco di thinking (system prompt, strumenti, messaggi precedenti), a meno di chiedere di scartarlo. Tieni la cronologia in sola aggiunta: aggiungi, non riscrivere.
• Opus 5.5 e Fable 5.2, il thinking. Errore se provi a spegnerlo: regola l’effort. Sonnet 5.5 ha il thinking attivo di serie; su Haiku 5.5 si può spegnere, ma solo a effort high o inferiore. Leggi i blocchi della risposta per type.
• Sonnet 5.5, Opus 5.5 e Fable 5.2, tool_choice. Errore 400 con any o tool: usa auto, strumenti con strict: true, e scrivi nel prompt quando usarli.
• Tutti e quattro, computer use. Funziona solo con computer_toolset_20260801, su Claude API e Claude Models on Google Cloud: aggiorna lo strumento.
• Da Haiku 4.5 a Haiku 5.5. Errore 400 con temperature, top_p e top_k non predefiniti, o con un ultimo messaggio dell’assistente, e budget_tokens non c’è più: passa a un livello di effort, togli quei parametri e chiudi messages con un turno dell’utente.
• I classificatori di sicurezza. Segnalano soprattutto richieste su cybersicurezza e biologia. In Claude Code una richiesta segnalata può ripartire su un modello più vecchio, con un avviso: Opus 4.8 per la cybersicurezza, Opus 5 per la biologia. Costruisci ogni richiesta per il modello più severo, e prevedi il fallback.

Misura sul tuo lavoro#

I benchmark dicono da dove partire. La scelta finale la fai misurando sui tuoi compiti, con il metodo del post in quattro passi:

1. Prendi un campione di compiti veri e scrivi per ognuno un controllo dell’esito: un test che passa, un ticket chiuso, un numero di righe giusto.
2. Fai girare ogni candidato a due o tre livelli di effort, ognuno in una sessione a parte, e segna il costo per compito dal campo usage di ogni risposta.
3. Metti in un grafico il punteggio contro la spesa. Tieni una combinazione di più modelli solo se batte ogni punto a modello singolo.
4. Prova il vincitore in ombra su una parte del traffico vero, prima di passare tutto.

Se hai cinque minuti adesso: prendi un compito dalla tua lista, fallo girare su due modelli con /model e confronta quello che riporta /usage.

La morale#

Quindi? La morale? Parti da Opus 5.5 a medium, delega l’esecuzione ai modelli più piccoli e passa a Fable 5.2, a medium, quando Opus non basta. Fine.

Il resto della settimana te lo ripeto io, a pappagallo

Io la seguo, tu il lunedì mattina sai cosa provare e cosa ignorare dell’AI, con le fonti per controllare.

La tua email

Mandamela il lunedì

Lascia vuoto questo campo

Una email il lunedì mattina. Ti cancelli con un clic. Privacy

Preferisci Telegram? Lì arrivano news e tutorial appena escono.

Avvisami su Telegram