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

> Da quale modello partire tra Opus 5.5 e Fable 5.2, quanto effort dare e quando passare all’altro, con i benchmark di Anthropic e i costi della cache.

- URL: https://stocasticparrot.ai/numeri/fable-5-2-opus-5-5/
- Autore: Danilo Giudice
- Uscita: 2026-11-11

![Danilo, con il pappagallo sulla spalla e una lampadina accesa sopra la testa, scrive alla lavagna: Opus 5.5, parti da qui; la manopola dell’effort su medium; poi Fable 5.2](https://stocasticparrot.ai/numeri/fable-5-2-opus-5-5/img/01-apertura-lavagna.jpg)

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?»](https://claude.dev/blog/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à.

![Fable 5.2 costa il doppio di Opus 5.5: prezzi di output per milione di token, 40 $ per Fable 5.2, 20 $ per Opus 5.5, 10 $ per Sonnet 5.5, 0,50 $ per Haiku 5.5](https://stocasticparrot.ai/numeri/fable-5-2-opus-5-5/img/02-prezzi.jpg)

| Modello | Per cosa | Effort predefinito (API) |
|---|---|---|
| Fable 5.2 | Il lavoro tecnico più difficile e aperto: codice, finanza, scienze | high (medium in Claude Code) |
| Opus 5.5 | Codice complesso e lavoro sui documenti, tutti i giorni | medium |
| Sonnet 5.5 | Compiti ben definiti, il 30 % più veloce di Sonnet 5 | high (medium in Claude Code) |
| Haiku 5.5 | Volume, con il costo e l’attesa più bassi | medium |

> 💡 Pro-tip: **Haiku 5.5 è l’unico con il prezzo a scaglioni.** Oltre 100.000 token di prompt paghi 5 volte la tariffa bassa, che resta un quarto del prezzo di Sonnet 5.5. Se ogni chiamata ha un prompt lungo, confronta i due sul costo per compito finito, non sul listino.
>
> Il fast mode (dal riferimento API, non dal post) genera fino a 2,5 volte più token al secondo con lo stesso modello, a tariffa doppia: 8 / 40 $ su Opus 5.5, 16 / 80 $ su Fable 5.2. Ha un limite di richieste tutto suo, non c’è con la Batch API, e cambiare velocità invalida la cache.

| | Haiku 5.5 | Sonnet 5.5 | Opus 5.5 | Fable 5.2 |
|---|---|---|---|---|
| Cache read, per milione di token | 0,01 $ fino a 100.000 token, 0,05 $ oltre | 0,10 $ | 0,20 $ | 0,20 $ |
| Thinking sull’API | attivo, si può spegnere | attivo; `between_tools` salta quello iniziale | sempre attivo | sempre attivo |
| Fast mode | no | no | sì | sì |

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.

| Compito | Modello | Effort di partenza |
|---|---|---|
| Programmazione e correzione di bug di tutti i giorni, funzioni grandi da consegnare a tappe | Opus 5.5 | medium, poi high |
| Computer use (il modello che usa mouse e tastiera) e flussi con molte immagini | Opus 5.5 | medium |
| Non sai ancora da dove partire | Opus 5.5 | medium |
| Grandi riscritture del codice e migrazioni, architettura, coordinare molti subagenti | Fable 5.2 | medium, poi high |
| Ricerca approfondita, analisi scientifiche e quantitative | Fable 5.2 | medium, poi high |
| Opus 5.5 a high non basta, o sessioni lunghe senza supervisione | Fable 5.2 | medium, poi high |
| Correzioni di bug, funzioni da specifica | Sonnet 5.5 | medium, poi high |
| Documenti, slide e fogli di calcolo | Sonnet 5.5 | high (medium in Claude Code) |
| Agenti che ripetono lo stesso lavoro: indagini, revisioni, bozze | Sonnet 5.5 | medium |
| Chat e sessioni interattive | Sonnet 5.5 | low o medium |
| Classificazione, instradamento, estrazione ad alto volume | Haiku 5.5 | medium |
| Subagenti che cercano file, leggono log, riassumono | Haiku 5.5 o Sonnet 5.5 | il predefinito |

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.

![Da high a xhigh 2,5 volte il costo: Opus 5.5 su SWE-bench Pro, costo per compito con high a 100; low 33, medium 70, xhigh 250](https://stocasticparrot.ai/numeri/fable-5-2-opus-5-5/img/03-effort.jpg)

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.

> 💡 Pro-tip: **In Claude Code l’effort lo vedi con `/effort status`; sull’API sta dentro `output_config`, non al primo livello della richiesta.** Il predefinito dell’API è medium su Opus 5.5 e high su Fable 5.2: scrivilo sempre a mano, così un cambio del predefinito non ti sorprende. Su Opus 5.5 e Fable 5.2 il thinking non si spegne, e `temperature`, `top_p` e `top_k` danno errore 400: l’unica leva è l’effort.
>
> Per Fable 5.2 il riferimento API consiglia di partire da high, perché sopra i guadagni sono irregolari. Cambiare effort a metà conversazione invalida la cache dei messaggi; su Opus 5.5 e Fable 5.2 c’è l’effort per messaggio (beta `mid-conversation-output-config-2026-07-01`, con il thinking attivo), che la lascia intatta.

```json
{
  "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.

| Benchmark | Confronto | Punteggio | Costo |
|---|---|---|---|
| Chartography | Fable 5.2 a medium contro Opus 5.5 al massimo | 66,4 % contro 64,4 % | meno di un decimo per compito |
| FrontierCode 2.0 | Fable 5.2 a high contro Opus 5.5 al massimo | 45,3 % contro 45,5 % | circa la metà per compito |
| Terminal-Bench 3.0 | Opus 5.5 a high contro Fable 5.1 al massimo | 58,9 % contro 58,0 % | metà dei token |

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»](https://claude.dev/blog/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](https://www.anthropic.com/claude-fable-and-mythos-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.

![Fable a medium batte Opus al massimo: su Chartography Fable 5.2 a medium fa 66,4 % e Opus 5.5 al massimo 64,4 %, con meno di un decimo del costo per compito](https://stocasticparrot.ai/numeri/fable-5-2-opus-5-5/img/04-chartography.jpg)

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](https://platform.claude.com/docs/en/build-with-claude/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](https://platform.claude.com/docs/en/build-with-claude/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).

> 💡 Pro-tip: **Fable 5.2 vuole la conservazione dei dati a 30 giorni.** Senza un’autorizzazione di Anthropic non funziona in zero data retention: alle organizzazioni non in regola l’API restituisce un errore 400. Niente prefill dell’ultimo turno, niente `tool_choice` forzato, niente `temperature`, `top_p` e `top_k`.
>
> Il testo del thinking non arriva mai per intero: con `display: "summarized"` ricevi un riassunto, altrimenti il campo arriva vuoto. Con l’advisor tool, un esecutore Fable 5.2 accetta come consulente solo Fable 5.2 o Mythos 5.2. Il fast mode costa 16 / 80 $ per milione di token, nelle richieste dirette all’API e non in Managed Agents.

## Quando non basta, cambia una cosa alla volta

> 💡 Pro-tip: **Quando un modello non ce la fa, giro le manopole in quest’ordine, una alla volta.** Primo: controllo che possa verificare il proprio lavoro, con un test, una compilazione o uno script che prova davvero il servizio (spesso il problema è qui, e non nel modello). Secondo: alzo l’effort di un livello. Terzo: passo al modello sopra, partendo da un effort più basso di quello che usavo, cioè da Opus 5.5 a high passo a Fable 5.2 a medium.
>
> **E se l’esito si controlla in automatico, faccio girare tutto a low e rilancio a high solo i compiti falliti.** Serve un controllo automatico che dica quali compiti rilanciare.

![Tutto a low, i falliti a high: Opus 5.5 su un sottoinsieme di SWE-bench Pro supera circa il 97 % dei compiti a 0,17 $ l’uno, contro il 95,3 % a 0,29 $ con tutto a high](https://stocasticparrot.ai/numeri/fable-5-2-opus-5-5/img/05-low-high.jpg)

## 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](https://claude.com/blog/claude-opus-5-5-built-for-coding-sessions-that-use-more-context).

> **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.

![Riprendere dopo un’ora riscrive la cache: con 150.000 token su Opus 5.5 si passa da circa 0,03 $ a circa 1,20 $, 40 volte tanto](https://stocasticparrot.ai/numeri/fable-5-2-opus-5-5/img/06-cache.jpg)

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»](https://stocasticparrot.ai/spiegoni/igiene-claude-code/).

> 💡 Pro-tip: **La cache appartiene al modello che l’ha scritta: cambia modello solo tra un lavoro e l’altro.** Se lo cambi a metà, il nuovo modello riparte senza cache. In Claude Code il post suggerisce `/compact` prima del cambio; io preferisco un HANDOFF.md e un `/clear`, e ho spiegato perché in [«L’auto-compaction è una cagata pazzesca»](https://stocasticparrot.ai/spiegoni/auto-compaction/). Sull’API, apri la conversazione del nuovo modello con un riassunto del lavoro fatto.

## 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](https://code.claude.com/docs/en/sub-agents).

> 💡 Pro-tip: **Il file di un subagente su Haiku 5.5: salvalo come `.claude/agents/log-reader.md`.** È l’esempio del post: legge i log e riporta i casi falliti, senza toccare i file. `CLAUDE_CODE_SUBAGENT_MODEL` sceglie il modello dei subagenti che non ne dichiarano uno, e `ANTHROPIC_DEFAULT_HAIKU_MODEL` fissa il modello dietro l’alias `haiku`.
>
> Il subagente Explore integrato usa il modello della sessione, al massimo Opus sull’API: per esplorare spendendo poco, definisci un tuo `Explore` con `model: haiku`. Sull’API Anthropic l’alias `haiku` punta a Haiku 5.5 da Claude Code 2.1.293 in poi; su Amazon Bedrock, Google Cloud, Microsoft Foundry e Claude Platform on AWS punta ancora a Haiku 4.5.

`.claude/agents/log-reader.md`:
```
---
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**

![Un Opus 5.5 che coordina 25 Sonnet 5.5 spende un terzo in meno di Opus 5.5 da solo, con lo stesso punteggio, nella ricerca di difetti su circa 22 milioni di token di codice](https://stocasticparrot.ai/numeri/fable-5-2-opus-5-5/img/07-delega.jpg)

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](https://platform.claude.com/docs/en/managed-agents/multiagent-orchestration) di Claude Managed Agents.

**opusplan e advisor: misura prima**

In Claude Code [`opusplan`](https://code.claude.com/docs/en/model-config) 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](https://platform.claude.com/docs/en/agents-and-tools/tool-use/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](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence) però ammette che nessuna coppia ha battuto chiaramente l’esecutore da solo.

> 💡 Pro-tip: **Un esempio di advisor dal post: esecutore Opus 5.5 a high, consulente Fable 5.1.** 90,1 % a 2,92 $ a tentativo: 1,7 punti sopra Opus 5.5 da solo a high, per circa 2,1 volte la spesa. Un esecutore Sonnet 5.5 accetta come consulente Fable 5.2, Opus 5.5, Opus 5 e Sonnet 5.5, e il consulente deve essere capace almeno quanto l’esecutore, altrimenti l’API restituisce un errore 400.

> 💡 Pro-tip: **I modelli più grandi leggono i blocchi di thinking dei più piccoli, non il contrario.** Conta quando cambi modello nella stessa conversazione, su Claude API e Claude Models on Google Cloud: Opus 5.5 legge quelli di Sonnet 5.5 e Haiku 5.5, Sonnet 5.5 quelli di Haiku 5.5, Fable 5.2 quelli di tutti e tre. Se passi da Fable 5.2 a un altro modello, i suoi blocchi di thinking si perdono; quando un modello non può leggerli, l’API li scarta e la richiesta va avanti lo stesso.

**Come lo faccio io: octopus**

Per i lavori lunghi in Claude Code uso [octopus](https://stocasticparrot.ai/tool/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.

> 💡 Pro-tip: **Controlla sempre `stop_reason` prima di leggere `content`.** I classificatori possono rifiutare una richiesta con HTTP 200 e `stop_reason: "refusal"`. Su Opus 5.5, Fable 5.2 e Sonnet 5.5 il riferimento API consiglia di attivare di serie il fallback lato server, con l’header beta `anthropic-beta: server-side-fallback-2026-07-01` e il parametro `"fallbacks": "default"`, che sceglie il modello di riserva in base al tipo di rifiuto. Su Amazon Bedrock, Vertex e Foundry il fallback lato server non c’è e serve il middleware lato client degli SDK: prima di andare in produzione, controlla i nomi esatti nella documentazione.

## 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.

## Fonti

I benchmark vengono dal post e dal lancio di Anthropic, cioè da chi i modelli li vende, e non li ho verificati in modo indipendente. I cento turni, il 10 % dei problemi e il costo per riprendere dopo un’ora sono miei calcoli.

- Addy Osmani, [«Which Claude model should you build with? Fable, Opus, Sonnet, or Haiku»](https://claude.dev/blog/which-claude-model-should-you-build-with/), claude.dev, 9 novembre 2026: tabelle, benchmark, schemi per mescolare i modelli, note di migrazione.
- Anthropic, [«Introducing Claude Fable 5.2 and Claude Mythos 5.2»](https://www.anthropic.com/claude-fable-and-mythos-5-2), 9 novembre 2026: i confronti tra Fable 5.2 e Opus 5.5 su Chartography, WANDR e FrontierCode 2.0.
- [«Spending your effort»](https://claude.dev/blog/spending-your-effort/), claude.dev: il confronto su Terminal-Bench 3.0, come lo riporta il post di Osmani.
- La documentazione che il post collega: [Choosing a model](https://platform.claude.com/docs/en/about-claude/models/choosing-a-model), [Effort](https://platform.claude.com/docs/en/build-with-claude/effort), [Fast mode](https://platform.claude.com/docs/en/build-with-claude/fast-mode), [Preserved thinking](https://platform.claude.com/docs/en/build-with-claude/preserved-thinking), [Optimizing for cost and intelligence](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence), [Advisor tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/advisor-tool), [Multiagent orchestration](https://platform.claude.com/docs/en/managed-agents/multiagent-orchestration), [Claude Code model configuration](https://code.claude.com/docs/en/model-config), [Subagents](https://code.claude.com/docs/en/sub-agents).
- Riferimento delle API di Claude (Anthropic), copia del 3 novembre 2026: prezzi del fast mode, conservazione dei dati di Fable 5.2, effort per messaggio, fallback lato server.