---
title: Ottimizzare costo e intelligenza
url: https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence
description: Bilancia costi e intelligenza sulla Claude Platform, con risultati misurati per la cache dei prompt, l'effort, la scelta del modello, i limiti di output e le strategie multi-modello.
---

Il modello più capace può risultare troppo costoso su larga scala, e il modello meno costoso può non raggiungere la qualità necessaria. La Claude Platform ti offre il controllo diretto su questo compromesso. Scegli il modello, il livello di “effort” (impegno) e l’architettura per ogni richiesta, il che ti permette di collocare un carico di lavoro quasi ovunque sulla frontiera tra costo e intelligenza.

Costo e intelligenza vengono solitamente rappresentati come una frontiera in cui l’uno si ottiene a spese dell’altra. Il primo gruppo di leve in questa pagina avvicina un carico di lavoro a quella frontiera riducendo i costi senza toccare la qualità; solo il secondo gruppo lo sposta lungo di essa:

<Frame>
  ![Schema della frontiera tra costo e intelligenza: una freccia riduce la spesa a parità di qualità, l'altra scambia qualità con costo](https://platform.claude.com/docs/it/images/cost-intel/frontier.svg)
</Frame>

Le leve sono di due tipi:

* **Vantaggi gratuiti**: riducono la spesa senza toccare la qualità. Sono la “prompt caching” (cache dei prompt), l’igiene dei token, una revisione dei prompt rispetto al modello che stai usando e l’[elaborazione batch](https://platform.claude.com/docs/it/build-with-claude/batch-processing) con uno sconto del 50% per il lavoro che può attendere fino a 24 ore.
* **Compromessi**: scambiano costo con intelligenza. Sono la scelta del modello, l’effort, i limiti di output e i budget di sessione, un orologio del tempo trascorso e le architetture multi-modello.

Un [limite di spesa del workspace](https://platform.claude.com/docs/it/api/rate-limits#setting-lower-limits-for-workspaces) è la rete di sicurezza per entrambi i tipi di leva: vedi [Imposta budget e limiti di output](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#set-budgets-and-output-caps).

Ogni leva è accompagnata da risultati misurati e dalla regola che indica quando conviene. Nelle misurazioni di Anthropic, la cache dei prompt è stata di solito la leva più importante. Le leve multi-modello hanno un ambito più ristretto; un secondo modello è stato misurato in due configurazioni, un advisor e un orchestratore.

## Inizia da qui

Trova la riga che corrisponde alla tua situazione.

| La tua situazione                                                | Cosa fare                                                                                                                                                                                          | Dove                                                                                                                                                                                                                                                                                                      |
| ---------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Qualsiasi carico di lavoro, qualsiasi modello                    | Attiva la cache dei prompt e taglia i token non necessari; entrambe le cose sono gratuite                                                                                                          | [Metti in cache il contesto ripetuto](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#cache-repeated-context) · [Taglia i token](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#trim-input-and-context-tokens) |
| Una persona attende tra un turno e l’altro                       | Conta gli intervalli tra le tue richieste, poi scegli la durata della cache dalla tabella in quella sezione                                                                                        | [Scegli la durata della cache](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#pick-the-cache-duration)                                                                                                                                                      |
| I costi sono troppo alti; la qualità va bene                     | Prova un effort più basso sul modello che usi ora                                                                                                                                                  | [Regola l’effort](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#tune-effort)                                                                                                                                                                               |
| Non usi il modello più recente                                   | Aggiorna il modello; sui benchmark di coding in quella sezione ogni modello più recente ha risolto almeno tante attività quante il precedente, di solito a un costo inferiore per attività risolta | [Aggiorna il modello](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#upgrade-the-model)                                                                                                                                                                     |
| Stai scegliendo o cambiando modello                              | Confronta il costo per attività completata, non per token                                                                                                                                          | [Confronta i modelli](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#compare-models-on-cost-per-task)                                                                                                                                                       |
| Lavoro ad alto volume con output verificabili                    | Prova prima Claude Haiku 5.5                                                                                                                                                                       | [Confronta i modelli](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#compare-models-on-cost-per-task)                                                                                                                                                       |
| La qualità non è sufficiente                                     | Se hai abbassato l’effort, ripristinalo; altrimenti prova il livello superiore con il suo effort predefinito                                                                                       | [Regola l’effort](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#tune-effort) · [Confronta i modelli](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#compare-models-on-cost-per-task)                         |
| I tentativi terminano con `stop_reason: max_tokens`              | Aumenta `max_tokens` a 64.000: nei test di Anthropic solo 7 turni su circa 18.000 sono stati più lunghi, e il costo per attività risolta non è aumentato                                           | [Imposta budget](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#set-budgets-and-output-caps)                                                                                                                                                                |
| Puoi verificare gli output (test, un verificatore)               | Esegui con effort `low` e riesegui i fallimenti con `high`: nei test di Anthropic, circa il 40% di costo in meno rispetto a eseguire tutto con `high`, con lo stesso tasso di successo             | [Riesegui i fallimenti](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#re-run-failures-at-higher-effort)                                                                                                                                                    |
| Loop agentici con alcune esecuzioni molto costose                | Imposta un budget di sessione di Claude Managed Agents e un limite di spesa del workspace                                                                                                          | [Imposta budget](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#set-budgets-and-output-caps)                                                                                                                                                                |
| Vuoi che le esecuzioni degli agenti terminino prima              | Di’ al modello che il tempo conta e mostragli il tempo trascorso: dal 7% al 47% di tempo in meno nei test di Anthropic, al prezzo di qualche punto di punteggio                                    | [Mostra al modello il tempo trascorso](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#show-the-model-elapsed-time)                                                                                                                                          |
| Un modello meno costoso si blocca solo sulle decisioni difficili | Prova un advisor. Può aiutare solo quando il tuo modello lo consulta; prima valuta il costo del suo modello da solo con effort basso e misura il tasso di consultazione                            | [Strategia advisor](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#advisor-strategy-escalate-hard-decisions)                                                                                                                                                |
| Il lavoro supera una “context window” (finestra di contesto)     | Suddividi il lavoro e affida le parti a modelli meno costosi                                                                                                                                       | [Strategia orchestratore](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#orchestrator-strategy-delegate-bulk-work)                                                                                                                                          |

Questi risultati provengono da misurazioni interne di Anthropic ([Benchmark citati](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)) e sono indicativi, non garanzie. Misura quindi sul tuo carico di lavoro con il [metodo in quattro passaggi](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#measure-on-your-own-workload).

## Riduci la spesa senza perdere qualità

La cache dei prompt, l’igiene dei token, l’elaborazione batch e un audit dei prompt rispetto al tuo modello attuale riducono tutti ciò che paghi senza ridurre la qualità dell’output. Valgono due avvertenze: l’elaborazione batch scambia latenza con il suo sconto, e il “context editing” (modifica del contesto), una leva di igiene dei token, è costato più di quanto ha fatto risparmiare nell’esecuzione breve misurata in questa sezione e non ha cambiato nulla in quella lunga.

### Metti in cache il contesto ripetuto

#### Perché la cache viene prima

Attiva la [cache dei prompt](https://platform.claude.com/docs/it/build-with-claude/prompt-caching) prima di qualsiasi altra leva, perché per impostazione predefinita ogni turno di un’attività agentica reinvia l’intera conversazione in crescita: prompt di sistema, definizioni degli strumenti e ogni turno precedente.

* Un’attività di 40 turni invia il suo primo turno 40 volte, quindi il costo dell’attività cresce all’incirca con il quadrato del numero di turni.
* La cache non interrompe il reinvio, ma ogni reinvio costa circa un decimo (un ventesimo su Claude Opus 5.5 e Claude Sonnet 5.5, un quarantesimo su Claude Fable 5.2, Claude Mythos 5.2, Claude Fable 5.1, e Claude Mythos 5.1) e viene elaborato più velocemente.
* Il prefisso viene fatturato alla [tariffa di lettura della cache](https://platform.claude.com/docs/it/build-with-claude/prompt-caching#pricing) invece che al prezzo di input, e ogni turno paga la tariffa di scrittura della cache di 1,25x solo per ciò che è nuovo.

I [thread di messaggi](https://platform.claude.com/docs/it/build-with-claude/message-threads), in beta, interrompono il reinvio per tutta la durata di un thread, cioè finché non sono trascorsi 5 minuti dalla sua ultima richiesta. Riducono il tempo al primo token, non il costo: il modello legge comunque l’intera conversazione, quindi mantieni `cache_control` su ogni richiesta. I thread non supportano la compattazione né la maggior parte della modifica del contesto.

**Come appare un buon risultato.**

* Nell’arco di un’intera giornata di traffico reale, i loop di agenti hanno letto dalla cache una mediana dell’84% del loro input, e il 10% migliore di essi, di coding o meno, ha letto il 94% o più<sup>[17](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup>.
* In una fase avanzata di un’attività, un ciclo ben costruito paga il prezzo pieno su meno dell’1% del suo input.
* Sotto circa l’80%, cerca qualcosa che rompe la cache (vedi [Cosa rompe la cache](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#what-breaks-the-cache)).

Anthropic ha calcolato il prezzo delle esecuzioni di DeepResearch Bench II<sup>[7](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup> con e senza lo sconto della cache:

<Frame>
  ![Grafico, DeepResearch Bench II: la cache riduce Fable 5.1 da $40,58 USD a $5,64 USD per attività; Sonnet 5.5, da $5,13 USD a $1,05 USD](https://platform.claude.com/docs/it/images/cost-intel/caching-repriced.svg)
</Frame>

La durata predefinita della cache è di 5 minuti e i turni di un loop di agenti sono distanziati di pochi secondi, quindi lo sconto si applica alla maggior parte dei token a ogni turno. Le esecuzioni del grafico sulla cache hanno letto dalla cache dall’89% al 93% dei loro token di input.

Calcolando allo stesso modo il costo dei conteggi di token registrati in altre esecuzioni, ogni modello al suo effort predefinito, si ottiene il costo medio in token per attività senza cache:

| Benchmark                                                                                                                                                                                                                                                                                                                                | Modello           | Senza cache                     |
| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------- | ------------------------------- |
| SWE-bench Pro<sup>[3](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup>                                                                                                                                                                                                           | Claude Opus 5.5   | 3,3 volte il costo con la cache |
| SWE-bench Pro                                                                                                                                                                                                                                                                                                                            | Claude Sonnet 5.5 | 3,1 volte il costo con la cache |
| Set di attività di Claude Managed Agents<sup>[25](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup>, le cui sessioni sono brevi                                                                                                                                                   | Claude Haiku 5.5  | 1,7 volte il costo con la cache |
| Un piccolo agente che smista segnalazioni di bug ([Taglia i token di input e di contesto](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#trim-input-and-context-tokens))<sup>[16](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup> | Claude Sonnet 5.5 | 7,3 volte il costo con la cache |

Il risparmio varia in base a quanti turni richiede un’attività, perché i loop più brevi rileggono meno.

<Note>
  Con Claude Haiku 5.5 sulla Messages API, [compatta una conversazione lunga](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#manage-the-context-lifecycle) tra un’attività e l’altra, prima che il suo prompt superi i 100.000 token. Oltre tale soglia, ogni token della richiesta costa 5 volte tanto, output incluso. Le letture e le scritture della cache contano ai fini dei 100.000 (vedi [Prezzi del contesto lungo](https://platform.claude.com/docs/it/about-claude/pricing#long-context-pricing)).

  Se usi invece la [compattazione a una soglia di token](https://platform.claude.com/docs/it/build-with-claude/compaction-threshold#parameters), imposta il suo `trigger` poco al di sotto di 100.000 meno la crescita massima del tuo prompt tra una richiesta e l’altra (il valore predefinito è 150.000). Nel test di Anthropic con turni di 10.000 token, un trigger di 90.000 è costato il 70% in meno per richiesta rispetto al valore predefinito<sup>[18](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup>.
</Note>

#### Scegli la durata della cache

Se il tuo ciclo attende una persona tra un turno e l’altro, usa la [durata della cache di 1 ora](https://platform.claude.com/docs/it/build-with-claude/prompt-caching#1-hour-cache-duration) quando circa 1 turno su 20 segue una pausa compresa tra 5 minuti e un’ora e pochi intervalli superano l’ora. Su Claude Fable 5.2, Claude Fable 5.1, Claude Opus 5.5 e Claude Sonnet 5.5, mantenere attiva la cache di 5 minuti può costare meno.

La durata di 1 ora costa di più in scrittura (2x il prezzo di input invece di 1,25x). Un cache miss su una qualsiasi delle due durate fattura l’intero prefisso al prezzo di scrittura invece che al prezzo di lettura.

Scegli la durata della cache all’inizio di una conversazione. Nel test di Anthropic, il primo turno aggiunto con la cache di 1 ora a una conversazione in cache con la durata di 5 minuti ha riscritto l’intero prompt, una volta: $0,80 USD a 100.000 token su Claude Opus 5.5, rispetto a $0,02 USD di input per un turno che ha letto la cache<sup>[16](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup>.

Anthropic ha misurato un piccolo agente che smista segnalazioni di bug ([Taglia i token di input e di contesto](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#trim-input-and-context-tokens)) con pause inserite prima di alcuni turni per simulare il ritardo di una persona<sup>[16](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup>. L’accuratezza è rimasta entro il rumore tra un’esecuzione e l’altra in ogni impostazione misurata. Anthropic ha misurato anche richieste aggiuntive che mantengono attiva la cache di 5 minuti (richieste keep-alive).

Per decidere, conta gli intervalli tra richieste consecutive in una conversazione e trova la tua riga nella tabella seguente. Una riga che nomina il tuo modello ha la precedenza su una riga con “Qualsiasi” nella colonna Modello:

| I tuoi intervalli tra le richieste                                                                                        | Modello                             | Usa                                                              |
| ------------------------------------------------------------------------------------------------------------------------- | ----------------------------------- | ---------------------------------------------------------------- |
| I turni arrivano a pochi secondi di distanza                                                                              | Qualsiasi                           | Predefinita di 5 minuti                                          |
| Circa 1 intervallo su 20 o più cade tra 5 minuti e un’ora, e pochi intervalli superano l’ora                              | Qualsiasi                           | Durata di 1 ora                                                  |
| Gli intervalli superiori a un’ora sono comuni: circa il 60% o più delle tue pause superiori a 5 minuti supera anche l’ora | Qualsiasi                           | Predefinita di 5 minuti                                          |
| Solo 1 o 2 intervalli su 20 cadono tra 5 minuti e un’ora, e nessuno dura più di circa mezz’ora                            | Claude Opus 5.5 e Claude Sonnet 5.5 | Cache di 5 minuti mantenuta attiva, invece della durata di 1 ora |
| Una pausa di più di 5 minuti precede ogni turno, e poche pause superano l’ora                                             | Claude Opus 5.5 e Claude Sonnet 5.5 | Durata di 1 ora                                                  |
| Le pause durano alcuni minuti                                                                                             | Claude Fable 5.1 e Claude Fable 5.2 | Cache di 5 minuti mantenuta attiva, invece della durata di 1 ora |
| Le pause si avvicinano all’ora, e poche superano l’ora                                                                    | Claude Fable 5.1 e Claude Fable 5.2 | Durata di 1 ora                                                  |

Su Claude Haiku 5.5, usa le righe “Qualsiasi”: legge la cache alla tariffa standard di 0,1x il prezzo di input, il doppio dello 0,05x di Claude Opus 5.5 e Claude Sonnet 5.5, quindi in base ai prezzi di listino ciascuna richiesta keep-alive costa, in rapporto al prezzo di input, il doppio che su quei due modelli. Una richiesta con `max_tokens: 0` ha aggiornato la sua cache in un test separato (riferimento 16).

**Perché, riga per riga.**

* **Qualsiasi modello.**

  * **I turni arrivano a pochi secondi di distanza.** Nessuna pausa: la predefinita è costata circa il 19% in meno rispetto all’impostazione di 1 ora su Claude Sonnet 5.5, circa dal 15% al 18% in meno su Claude Opus 5.5.
  * **Circa 1 intervallo su 20 o più.** Il punto di pareggio, calcolato dai conteggi di token, è di circa 1 turno su 30 su Claude Sonnet 5.5 e Claude Opus 5.5.
  * **Gli intervalli superiori a un’ora sono comuni.** Su qualsiasi modello, un intervallo superiore a un’ora fa scadere entrambe le durate, e l’impostazione di 1 ora riscrive poi il prefisso al suo prezzo di scrittura più alto.

* **Claude Opus 5.5 e Claude Sonnet 5.5**, le cui letture dalla cache costano 0,05x il prezzo di input.

  * **Solo 1 o 2 intervalli su 20.** Con l’effort predefinito, le richieste keep-alive costano dall’8% al 13% in meno rispetto alla durata di 1 ora su Claude Opus 5.5, dall’8% al 16% in meno su Claude Sonnet 5.5.
  * **Una pausa precede ogni turno.** Su Claude Opus 5.5 e Claude Sonnet 5.5, le richieste keep-alive costano qualche punto percentuale in più rispetto alla durata di 1 ora con pause di 6 minuti e oltre il 50% in più con pause di 45 minuti.

* **Claude Fable 5.1 e Claude Fable 5.2**, le cui [letture dalla cache](https://platform.claude.com/docs/it/about-claude/pricing#prompt-caching) costano 0,025x il prezzo di input.

  * **Le pause durano alcuni minuti.** Su Claude Fable 5.2, le richieste keep-alive<sup>[19](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup> costano circa dal 4,5% al 19% in meno rispetto alla cache di 1 ora, sia con il 10% dei turni in pausa sia con una pausa di 6 minuti prima di ogni turno.
  * **Le pause si avvicinano all’ora.** Su Claude Fable 5.2, solo con una pausa di 45 minuti prima di ogni turno la cache di 1 ora ha prevalso, di circa $0,12 USD<sup>[19](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup> su una sessione di 5 segnalazioni di bug.

Il grafico seguente mostra il costo per sessione in funzione della quota di turni in pausa su Claude Sonnet 5.5:

<Frame>
  ![Grafico a linee: costo per sessione di triage in base alla quota di turni dopo una pausa; la cache di 1 ora è più economica oltre circa 1 turno su 30](https://platform.claude.com/docs/it/images/cost-intel/cache-ttl-sonnet-5-5.svg)
</Frame>

Il grafico seguente aggiunge la cache di 5 minuti mantenuta attiva dalle richieste keep-alive, su Claude Fable 5.1, Claude Opus 5.5 e Claude Sonnet 5.5:

<Frame>
  ![Grafici dei costi: il keep-alive batte la cache di 1 ora su Fable 5.1 in tutti i punti rappresentati; su Opus 5.5 e Sonnet 5.5 solo se pochi turni sono in pausa](https://platform.claude.com/docs/it/images/cost-intel/cache-keepalive-sonnet-5-5.svg)
</Frame>

**Cosa sapere.**

* La regola di 1 su 20 lascia un margine rispetto al punto di pareggio di circa 1 turno su 30. Con 1 turno su 20 l’impostazione di 5 minuti e quella di 1 ora sono costate circa lo stesso su Claude Sonnet 5.5, entro la variazione tra un’esecuzione e l’altra; con 1 turno su 10 l’impostazione di 5 minuti è costata il 54% in più (riferimento 16).
* Sui modelli diversi da Claude Sonnet 5.5 e Claude Opus 5.5, i prezzi collocano il punto di pareggio nello stesso intervallo: ogni modello attuale usa gli stessi moltiplicatori di scrittura della cache, e tutti i modelli tranne Claude Fable 5.2, Claude Mythos 5.2, Claude Fable 5.1, Claude Mythos 5.1, Claude Opus 5.5 e Claude Sonnet 5.5 lo stesso prezzo di lettura.
* I dati sul keep-alive di Claude Opus 5.5 e Claude Sonnet 5.5 provengono da richieste inviate con `max_tokens: 1`. Una richiesta con `max_tokens: 0` ha anche aggiornato una voce di cache esistente su Claude Fable 5.1, Claude Opus 5.5, Claude Sonnet 5.5 e Claude Haiku 5.5 (riferimento 16).

Per mantenere attiva la cache:

1. Prendi la richiesta precedente, imposta `max_tokens` a 0 e rimuovi `stream` se era impostato. Non modificare nemmeno un byte del prefisso.
2. Reinvia gli header della richiesta insieme al suo corpo. Senza l’header `anthropic-beta` della richiesta originale, i campi soggetti a beta nel corpo riprodotto vengono rifiutati.
3. Inviala entro 4 minuti dall’inizio della richiesta precedente, e poi ogni 4 minuti, finché non arriva il turno successivo o la sessione termina. Conta dall’inizio della richiesta, perché la [durata di 5 minuti della cache](https://platform.claude.com/docs/it/build-with-claude/prompt-caching#how-prompt-caching-works) decorre da lì.

Questa è la [richiesta di pre-riscaldamento](https://platform.claude.com/docs/it/build-with-claude/prompt-caching#pre-warming-the-cache): aggiorna la durata della cache, non restituisce output e costa poco più della lettura dalla cache. Una volta scaduta la cache, la richiesta successiva, keep-alive o meno, riscrive il prefisso al prezzo di scrittura della cache<sup>[16](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup>.

Una richiesta con `max_tokens: 0` viene rifiutata nei seguenti casi:

* La richiesta imposta `thinking.type: "enabled"` (il ragionamento adattivo predefinito su Claude Fable 5.1 e Claude Fable 5.2 va bene), gli output strutturati o una scelta forzata dello strumento ([le sue limitazioni](https://platform.claude.com/docs/it/build-with-claude/prompt-caching#limitations)). Su questi carichi di lavoro, acquista invece la durata di 1 ora.
* La richiesta contiene il parametro di primo livello `compaction`, quindi non reinviare una richiesta di compattazione della [compattazione su richiesta](https://platform.claude.com/docs/it/build-with-claude/compaction-on-demand) come richiesta keep-alive.

<CodeGroup exclude="shell:CLI, python, typescript, csharp, go, java, php, ruby">
  ```bash cURL
  # Entro 4 minuti dall'inizio dell'ultima richiesta (il tempo di generazione conta
  # ai fini della durata della cache), reinvia quella richiesta con max_tokens impostato a
  # 0, scartando stream (una richiesta con max_tokens: 0 non può usare lo streaming). Invia gli stessi
  # header della richiesta originale, incluso l'eventuale header anthropic-beta.
  jq '.max_tokens = 0 | del(.stream)' last_request.json | \
    curl https://api.anthropic.com/v1/messages \
      -H "x-api-key: $ANTHROPIC_API_KEY" \
      -H "anthropic-version: 2026-10-21" \
      -H "content-type: application/json" \
      --data-binary @-
  ```
</CodeGroup>

#### Attiva la cache

La configurazione richiede poco lavoro. La [cache automatica](https://platform.claude.com/docs/it/build-with-claude/prompt-caching#automatic-caching) posiziona i breakpoint per te; in alternativa, la [skill Claude API](https://platform.claude.com/docs/it/agents-and-tools/agent-skills/claude-api-skill) inclusa in Claude Code può aggiungere la cache a un’integrazione esistente con un solo prompt:

Lascia che Claude Code aggiunga la cache per te

```text
/claude-api aggiungi la cache dei prompt a questa integrazione
```

Sul codice che ha prodotto queste misurazioni, la skill ha inserito un breakpoint sul blocco di sistema e uno su ciascuno dei due turni utente più recenti; [Breakpoint di cache espliciti](https://platform.claude.com/docs/it/build-with-claude/prompt-caching#explicit-cache-breakpoints) spiega dove posizionarli.

#### Cosa rompe la cache

Inserisci il testo specifico di ogni richiesta, come una riga di stato, alla fine del turno utente più recente, dopo l’ultimo breakpoint di cache. Nelle richieste successive, lascia ogni turno precedente così come lo hai inviato, con la sua vecchia riga di stato ancora al suo interno. Effettua le modifiche che invalidano la cache in un punto di interruzione naturale, come la prima richiesta dopo una compattazione. Sui [modelli che eseguono il controllo del prefisso](https://platform.claude.com/docs/it/build-with-claude/preserved-thinking/prefix-checks#enforcement), una richiesta che modifica il prompt di sistema o `tools` può ricevere un [errore 400](https://platform.claude.com/docs/it/api/errors#thinking-block-conversation-mismatch) anche in un tale punto di interruzione. Invia invece queste modifiche in `messages`, dove la tua piattaforma lo supporta (vedi [Modifica strumenti o istruzioni senza fallire il controllo del prefisso](https://platform.claude.com/docs/it/build-with-claude/preserved-thinking/change-tools-or-instructions)). La cache è una corrispondenza esatta byte per byte del prefisso sulla richiesta nel suo ordine (strumenti, poi prompt di sistema, poi messaggi), quindi una modifica in qualsiasi punto invalida tutto ciò che segue.

Quando qualcosa deve cambiare a metà conversazione, invialo nella forma che mantiene la cache, dove il modello la supporta. Anthropic ha testato ciascuna modifica in entrambi i modi su Claude Fable 5.1, Claude Opus 5.5 e Claude Sonnet 5.5, su una conversazione in cache di circa 100.000 token che conteneva la prima risposta del modello con il suo ragionamento. Modificare il prompt di sistema è costato da circa 25 a 50 volte quanto è costato lo stesso testo come messaggio di sistema a metà conversazione. Cambiare l’effort al primo livello è costato da 20 a 40 volte quanto è costato cambiarlo in un messaggio<sup>[18](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup>:

<Frame>
  ![Grafico a barre: modifica del prompt di sistema fino a $1,26 USD, modifica dell'effort di primo livello fino a $1,02 USD, entrambe in un messaggio fino a $0,026 USD](https://platform.claude.com/docs/it/images/cost-intel/cache-break-cost.svg)
</Frame>

Quando una modifica invalida la cache, la parte del prefisso interessata viene scritta di nuovo invece di essere letta. Una scrittura nella cache di 5 minuti costa 1,25x il prezzo di input, e una lettura dalla cache costa una piccola frazione del prezzo di input. Ai prezzi di listino, quella scrittura costa 50 volte una lettura su Claude Fable 5.2, Claude Mythos 5.2, Claude Fable 5.1 e Claude Mythos 5.1, dove una lettura dalla cache costa 0,025x il prezzo di input. Quella scrittura costa 25 volte una lettura su Claude Opus 5.5 e Claude Sonnet 5.5 (0,05x), e 12,5 volte su Claude Haiku 5.5 (0,1x). I dati del grafico provengono dalla Messages API.

In un test separato di Anthropic su Claude Opus 5.5 e Claude Fable 5.2, le richieste che modificavano il prompt di sistema o `tools` e rinviavano blocchi di ragionamento precedenti hanno comunque ricevuto l’errore 400. Lo hanno ricevuto anche come prima richiesta dopo una compattazione a una soglia di token<sup>[18](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup>.

**Cosa fare.**

* Non inserire nulla che cambi a ogni richiesta, come un timestamp o una posizione in coda, prima del prefisso stabile: trasforma ogni richiesta in una scrittura completa della cache. Nel test di Anthropic, una riga di stato di 25 token all’inizio del prompt di sistema ha fatto sì che ogni richiesta scrivesse l’intera conversazione; spostata alla fine del turno utente più recente, ha lasciato intatta la lettura della cache<sup>[18](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup>.
* La pagina sulla [cache dei prompt](https://platform.claude.com/docs/it/build-with-claude/prompt-caching#what-invalidates-the-cache) elenca le modifiche che invalidano la cache, come una modifica a [`effort`](https://platform.claude.com/docs/it/build-with-claude/effort), alla configurazione del ragionamento, all’impostazione [`speed`](https://platform.claude.com/docs/it/build-with-claude/fast-mode), al prompt di sistema o a una definizione di strumento. Cambiare il formato di output invalida la cache per quella conversazione (vedi [output strutturati](https://platform.claude.com/docs/it/build-with-claude/structured-outputs#prompt-modification-and-token-costs)).
* Verifica quali modelli supportano ciascuna forma: i [messaggi di sistema a metà conversazione](https://platform.claude.com/docs/it/build-with-claude/mid-conversation-system-messages), e l’[effort per messaggio](https://platform.claude.com/docs/it/build-with-claude/effort-per-message), che è in beta.
* Dopo una modifica che invalida la cache, verifica che le letture dalla cache non siano diminuite; se lo sono, la [diagnostica della cache](https://platform.claude.com/docs/it/build-with-claude/cache-diagnostics) mostra dove il prefisso è divergente.

Su un modello precedente, Anthropic ha misurato quando effettuare una tale modifica, sulle sessioni lunghe dell’agente di triage delle issue descritto in [Taglia i token di input e di contesto](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#trim-input-and-context-tokens)<sup>[18](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup>. Le sessioni che hanno apportato modifiche sono partite con effort basso, poi sono passate all’effort predefinito e hanno aggiunto uno strumento. Apportare le due modifiche a metà sessione è costato di più. Apportarle sulla richiesta che ha attivato la compattazione è costato quasi altrettanto, perché quella richiesta portava ancora l’intera conversazione e l’ha scritta di nuovo nella cache. Apportarle sulla richiesta successiva, la prima dopo la compattazione, è costato di meno. L’accuratezza è rimasta entro il rumore tra un’esecuzione e l’altra. Quel modello non esegue il controllo del prefisso. Su un modello che lo esegue, aggiungi invece lo strumento in un messaggio: vedi [Aggiungi, rimuovi o disattiva strumenti](https://platform.claude.com/docs/it/build-with-claude/preserved-thinking/change-tools-or-instructions#tool-changes), che è in beta. Il grafico seguente mostra anche sessioni senza modifiche. Non sono una baseline confrontabile, perché sono state eseguite con l’effort predefinito per tutto il tempo e due di esse sono state compattate una seconda volta:

<Frame>
  ![Grafico a barre, costo per sessione di triage: $0,81 USD senza modifiche, $0,95 USD a metà sessione, $0,92 USD alla compattazione, $0,75 USD dopo](https://platform.claude.com/docs/it/images/cost-intel/compaction-timing.svg)
</Frame>

### Taglia i token di input e di contesto

La maggior parte delle richieste degli agenti porta token che non influenzano mai la risposta. Tagliarli raramente costa qualità dell’output, anche se non ogni leva qui ha fatto risparmiare denaro quando misurata. Due posti dove guardare:

* **Riduzione dell’input.**

  * Il [filtraggio dinamico](https://platform.claude.com/docs/it/agents-and-tools/tool-use/web-fetch-tool#dynamic-filtering) nello strumento web fetch tiene fuori il contenuto superfluo dalle pagine recuperate.
  * Il [ridimensionamento delle immagini](https://platform.claude.com/docs/it/build-with-claude/vision#evaluate-image-size) dimensiona correttamente gli input visivi.
  * La [ricerca degli strumenti con caricamento differito](https://platform.claude.com/docs/it/agents-and-tools/tool-use/tool-search-tool) carica le definizioni degli strumenti solo quando necessario (vedi [Differisci le definizioni degli strumenti non usate](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#defer-unused-tool-definitions)).
  * La [chiamata programmatica degli strumenti](https://platform.claude.com/docs/it/agents-and-tools/tool-use/programmatic-tool-calling) consente a Claude di eseguire diverse chiamate agli strumenti dal codice, in modo che solo il risultato filtrato entri nel contesto; la sua documentazione riporta il 24% di token di input in meno sui benchmark di ricerca agentica, con un punteggio più alto.
  * [Gestire il contesto degli strumenti](https://platform.claude.com/docs/it/agents-and-tools/tool-use/manage-tool-context) confronta la ricerca degli strumenti, la chiamata programmatica degli strumenti, la cache dei prompt e la modifica del contesto.

* **Ciclo di vita del contesto.** Il [meccanismo di modifica del contesto](https://platform.claude.com/docs/it/build-with-claude/context-editing) rimuove i risultati obsoleti degli strumenti, e la [compattazione automatica](https://platform.claude.com/docs/it/build-with-claude/compaction-threshold) con la sua soglia impedisce ai loop lunghi di portarsi dietro l’intera cronologia.

Le leve interagiscono con la cache e tra loro, quindi valutale in base all’effetto netto e usa la [diagnostica della cache](https://platform.claude.com/docs/it/build-with-claude/cache-diagnostics) per confermare che il tuo prefisso in cache sopravviva a ogni modifica.

In misurazioni su un modello precedente<sup>[28](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup>, Anthropic le ha applicate a un agente di triage delle issue che elaborava 20 segnalazioni di bug reali con screenshot provenienti da un repository pubblico, e a una variante più lunga dello stesso lavoro con 2,6 volte i token. Con la cache attiva, la riduzione dell’input (ridimensionamento delle immagini e ricerca degli strumenti) ha ridotto ulteriormente il costo di entrambe le esecuzioni.

#### Differisci le definizioni degli strumenti non usate

Ogni definizione di strumento allegata a una richiesta è input a ogni turno, e pochi server MCP ne aggiungono centinaia.

In una misurazione su un modello precedente<sup>[27](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup>, Anthropic ha eseguito l’agente di triage con i suoi due strumenti più un catalogo di definizioni di strumenti reali provenienti da server MCP pubblici, per un totale di fino a 502 strumenti, caricandoli tutti oppure contrassegnando quelli aggiuntivi con `defer_loading` dietro la [ricerca degli strumenti](https://platform.claude.com/docs/it/agents-and-tools/tool-use/tool-search-tool):

<Frame>
  ![Grafico a linee: con tutti gli strumenti caricati, il costo dell'esecuzione sale da $0,55 USD a $1,02 USD con 502 strumenti; la ricerca strumenti lo mantiene a $0,56 USD](https://platform.claude.com/docs/it/images/cost-intel/tool-search.svg)
</Frame>

* Con tutte le definizioni caricate, il costo dell’esecuzione è aumentato con la crescita del catalogo, seguendo i token dello schema in ogni richiesta.
* Con la ricerca degli strumenti, il costo dell’esecuzione è rimasto costante per ogni dimensione del catalogo.
* L’accuratezza è rimasta nello stesso intervallo in entrambi i casi, e il modello non ha mai chiamato uno strumento sbagliato, quindi a questa scala le definizioni inutilizzate costano denaro, non correttezza.
* [Mantieni caricati i 3-5 strumenti che usi di più](https://platform.claude.com/docs/it/agents-and-tools/tool-use/tool-search-tool#deferred-tool-loading), così Claude può chiamarli senza doverli prima cercare.
* Sullo stesso modello precedente, differire il set di strumenti di un server MCP pubblico di GitHub (`default_config: {defer_loading: true}` sul [connettore MCP](https://platform.claude.com/docs/it/agents-and-tools/mcp-connector)) ha ridotto il costo dell’esecuzione a parità di accuratezza. Con il set di strumenti differito e senza lo strumento di ricerca strumenti nella richiesta, nessuna esecuzione ha chiamato gli strumenti del server.

#### Tieni i file di dati fuori dal prompt

Quando il modello deve calcolare su una tabella, caricala con la [Files API](https://platform.claude.com/docs/it/build-with-claude/files) e lascia che il modello la interroghi con l’[esecuzione di codice](https://platform.claude.com/docs/it/agents-and-tools/tool-use/code-execution-tool) invece di incollarla. Anthropic ha posto 25 domande aggregate<sup>[15](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup> (somme, conteggi filtrati, group-by e un filtro per data) su un CSV pubblico di 1.862 righe, con le risposte calcolate da pandas:

<Frame>
  ![Grafico a dispersione: file caricato con esecuzione del codice, 25 su 25 corrette a $0,40 USD; incollato nel prompt, 7 su 25 a $5,01 USD](https://platform.claude.com/docs/it/images/cost-intel/data-files.svg)
</Frame>

Incollata nel prompt, la tabella occupa circa 91.000 token di input in ogni richiesta, e Claude Sonnet 5 ha risposto correttamente a 7 domande su 25. Caricata, con l’esecuzione del codice, ha risposto a tutte e 25, e l’esecuzione è costata circa un dodicesimo. Claude Opus 5 ha mostrato lo stesso andamento. Nessuno dei due approcci ha usato la cache dei prompt.

#### Gestisci il ciclo di vita del contesto

Le leve del contesto ripagano solo su una sessione abbastanza lunga da averne bisogno:

<Frame>
  ![Grafico a barre per lunghezza dell'esecuzione: la modifica del contesto aggiunge il 73% sull'esecuzione breve; la compattazione fa risparmiare il 32% e la potatura il 39% su quella lunga](https://platform.claude.com/docs/it/images/cost-intel/hygiene.svg)
</Frame>

Anthropic ha misurato queste leve su un modello precedente<sup>[28](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup>:

* In queste esecuzioni, la potatura era una breve funzione nel codice stesso dell’agente di triage delle issue: a ogni confine tra attività, sostituiva ogni risultato di ricerca di oltre 2.000 caratteri con un estratto di una riga.
* Sull’esecuzione da 20 issue le leve hanno fatto risparmiare poco o nulla, e la modifica del contesto ha fatto costare di più l’esecuzione.
* Sull’esecuzione lunga sia la potatura sia la compattazione hanno ridotto il costo, mentre la modifica del contesto non ha cambiato nulla.
* Se usi la modifica del contesto, [elimina in pochi grandi blocchi](https://platform.claude.com/docs/it/build-with-claude/context-editing#context-editing-and-prompt-caching), perché ogni eliminazione costa una scrittura nella cache.

<Note>
  Non usare la potatura su Claude Fable 5.2, Claude Mythos 5.2, Claude Fable 5.1, Claude Mythos 5.1, Claude Opus 5.5, Claude Sonnet 5.5 o Claude Haiku 5.5. Su questi modelli, se la tua applicazione riscrive un risultato di uno strumento precedente, questo invalida ogni blocco di ragionamento già presente nella cronologia successivo al risultato (vedi [Cosa deve rimanere invariato e perché](https://platform.claude.com/docs/it/build-with-claude/preserved-thinking/prefix-checks#prefix-check)), e la richiesta potrebbe fallire (vedi [Cosa fa ciascun modello quando il controllo del prefisso non viene superato](https://platform.claude.com/docs/it/build-with-claude/preserved-thinking/prefix-checks#outcomes)). La potatura è stata misurata su un modello precedente senza [ragionamento preservato](https://platform.claude.com/docs/it/build-with-claude/preserved-thinking). Usa invece la [compattazione](https://platform.claude.com/docs/it/build-with-claude/compaction): nello stesso test, ha ridotto anch’essa il costo dell’esecuzione lunga. La compattazione e la [modifica del contesto](https://platform.claude.com/docs/it/build-with-claude/context-editing) vengono entrambe eseguite sul server, quindi nessuna delle due invalida i blocchi di ragionamento. [Rinvia i turni dell’assistente esattamente come sono](https://platform.claude.com/docs/it/build-with-claude/preserved-thinking/change-tools-or-instructions#append-assistant-turns-exactly-as-returned): scartare i loro blocchi di ragionamento costa token di output a ogni turno, perché Claude [ricrea il ragionamento](https://platform.claude.com/docs/it/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#drop-block-cost).
</Note>

### Metti in batch il lavoro che può attendere

Instrada ogni richiesta che nessuno sta aspettando attraverso la [Batch API](https://platform.claude.com/docs/it/build-with-claude/batch-processing), e mantieni il percorso interattivo per il resto. La Batch API applica uno sconto del 50% su ogni token di una richiesta, compresi quelli in cache, in cambio di risultati che arrivano in qualsiasi momento entro 24 ore.

* L’elaborazione in batch è la seconda leva gratuita più importante dopo la cache per il lavoro degli agenti non presidiato: esecuzioni di valutazione, backfill e job pianificati come un’esecuzione ricorrente dell’agente di triage delle issue della [misurazione sulla riduzione dei token](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#trim-input-and-context-tokens).
* L’elaborazione in batch si combina con la maggior parte di ciò che è descritto in questa pagina, ma non con la [modalità veloce](https://platform.claude.com/docs/it/build-with-claude/fast-mode), né con i thread di messaggi, né con le sessioni di Claude Managed Agents (vedi [Prezzi di Claude Managed Agents](https://platform.claude.com/docs/it/about-claude/pricing#claude-managed-agents-pricing)).

### Verifica i prompt rispetto al modello attuale

Rivedi i prompt rispetto al modello che usi ora, e di nuovo ogni volta che cambi modello: è un vantaggio gratuito.

* Ogni generazione di modelli risponde ai prompt in modo diverso, quindi un prompt accumula testo scritto per un modello che non usi più.
* Il caso tipico sono istruzioni eccessivamente specifiche aggiunte per compensare un modello più vecchio: “verifica due volte”, “sii il più accurato possibile”, una procedura obbligatoria passo dopo passo o uno scratchpad di ragionamento fatto a mano.
* Un modello più recente segue tali istruzioni alla lettera, producendo round di strumenti e testo aggiuntivi che paghi senza alcun guadagno in accuratezza.

L’audit è un solo comando. La [skill Claude API](https://platform.claude.com/docs/it/agents-and-tools/agent-skills/claude-api-skill) fornita con Claude Code ha un comando `prompt-audit` che legge i prompt e il codice delle richieste di un progetto e riporta cosa è stato scritto per un modello diverso:

Lascia che Claude Code riveda i tuoi prompt per te

```text
/claude-api prompt-audit
```

Questo estratto abbreviato mostra il comando eseguito su un prompt di support desk e codice delle richieste contenente quegli schemi:

```text wrap
$ claude
> /claude-api prompt-audit

10 findings. The three that matter most:

1. budget_tokens returns a 400 on Opus 5 (support_agent.py:10). This code
   does not run against its own target model. Everything else here is
   quality; this one is an outage.
2. The prompt contains two live contradictions. Line 15 says confirm before
   every refund, line 17 says process every eligible refund immediately.
   Line 19 asks for a complete recap *and* a three-sentence maximum.
3. The reasoning scaffold and the 6-step script fight the model rather than
   steer it. <scratchpad> + "reason step by step" is now a request
   parameter, not prose; the mandatory 6-step procedure plus "investigate
   fully even when the ticket looks simple" forces four tool calls on a
   "where's my package" ticket.
...
-After any refund or escalation, verify twice before submitting: re-fetch
-the order, re-check every figure in your reply against the fresh lookup,
-and review the reply a second time for errors.
+Before submitting a refund or an escalation, re-fetch the order and confirm
+every figure in your reply matches the fresh lookup.
```

Il comando propone poi le sue modifiche come diff (un hunk mostrato) ed elenca cosa ha deliberatamente lasciato invariato: la finestra di rimborso, il requisito di tono e la soglia di qualità. Rivedi una patch, non una riscrittura.

Anthropic ha misurato l’effetto su una valutazione di help desk<sup>[14](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup>, in due migrazioni tra modelli precedenti:

<Frame>
  ![Grafico a dispersione, valutazione di support desk: il vecchio prompt costa di più sul nuovo modello; revisionato, è più economico e altrettanto accurato](https://platform.claude.com/docs/it/images/cost-intel/prompt-audit.svg)
</Frame>

* Da Claude Opus 4.8 a Claude Opus 5, i prompt scritti per il modello più vecchio sono costati di più per ticket sul modello più recente, senza alcuna variazione di accuratezza.
* Eseguire la revisione sugli stessi prompt ha reso Claude Opus 5 sia più economico della versione non rivista sia più accurato, un guadagno al di fuori del rumore.
* Da Claude Sonnet 4.6 a Claude Sonnet 5, la revisione ha ridotto il costo per ticket a parità di accuratezza.

I due tipi di testo obsoleto hanno costi diversi:

<Frame>
  ![Grafici a barre per schema legacy: le istruzioni seguite troppo alla lettera costano denaro; le impostazioni non funzionanti e le regole contraddittorie costano accuratezza](https://platform.claude.com/docs/it/images/cost-intel/prompt-audit-patterns.svg)
</Frame>

* Le istruzioni che il nuovo modello segue troppo alla lettera costano denaro: rimuovere “verifica due volte” ha ridotto il costo per ticket di Claude Opus 5, e rimuovere “sii il più accurato possibile” lo ha ridotto quasi altrettanto.
* Il testo che non si adatta più al modello costa invece accuratezza: un’impostazione di ragionamento dismessa, regole contraddittorie e uno scratchpad fatto a mano in conflitto con il ragionamento del modello stesso hanno ciascuno ripristinato l’accuratezza su Claude Opus 5 una volta rimossi.

Gli stessi schemi tendono ad apparire nelle descrizioni degli strumenti e nelle skill, che vale la pena verificare anch’esse.

## Bilancia costo e intelligenza

Queste leve determinano dove si colloca un singolo modello tra costo e intelligenza: la scelta del modello, l’effort, la riesecuzione dei fallimenti con un’impostazione più alta, i budget e i limiti entro cui opera, e se può vedere quanto tempo è trascorso. Se sei indietro di un modello o due, aggiorna prima il modello ([Aggiorna il modello](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#upgrade-the-model)); altrimenti, inizia con una variazione progressiva dell’effort sul tuo modello attuale ([Regola l’effort](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#tune-effort)). Dal costo e dalla capacità più bassi ai più alti, i modelli attuali sono Claude Haiku 5.5, Claude Sonnet 5.5, Claude Opus 5.5 e Claude Fable 5.2 (il modello di frontiera); la [Panoramica dei modelli](https://platform.claude.com/docs/it/models/overview) riporta la gamma completa e i prezzi.

### Confronta i modelli sul costo per attività

Confronta i modelli in base al costo per attività completata, non per token, perché paghi per le attività completate. Per la maggior parte dei carichi di lavoro degli agenti, inizia con Claude Opus 5.5 al suo effort predefinito (`medium`).

Un modello più capace può completare un’attività con meno lavoro, e questo può compensare gran parte del sovrapprezzo per token. Anthropic lo ha misurato sul sottoinsieme di SWE-bench Pro<sup>[3](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup>, i cui punteggi non sono confrontabili con la classifica pubblica, con i prezzi calcolati come vengono fatturati a un cliente:

<Frame>
  ![Grafico a dispersione, SWE-bench Pro: Claude Opus 5.5 con effort low eguaglia Sonnet 5.5 al suo valore predefinito per circa il 7% in più per attività risolta](https://platform.claude.com/docs/it/images/cost-intel/cost-per-task-sonnet-5-5.svg)
</Frame>

La tabella seguente elenca i risultati:

| Benchmark                                                                                                                                                               | Modello           | Effort                 | Punteggio                                                                               | Costo                                                                                                                  |
| ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------- | ---------------------- | --------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------- |
| Sottoinsieme di SWE-bench Pro<sup>[3](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup>                          | Claude Sonnet 5.5 | `high` (predefinito)   | 87,6% delle attività risolte                                                            | $0,11 USD per attività risolta                                                                                         |
| Sottoinsieme di SWE-bench Pro                                                                                                                                           | Claude Opus 5.5   | `low`                  | 87,4% delle attività risolte                                                            | $0,12 USD per attività risolta                                                                                         |
| Sottoinsieme di SWE-bench Pro                                                                                                                                           | Claude Opus 5.5   | `medium` (predefinito) | 92,8% delle attività risolte                                                            | $0,22 USD per attività risolta                                                                                         |
| Sottoinsieme di SWE-bench Pro                                                                                                                                           | Claude Fable 5.1  | `high` (predefinito)   | 92,3% delle attività risolte (una singola esecuzione)                                   | $1,19 USD per attività risolta                                                                                         |
| Benchmark interno di coding agentico<sup>[11](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup>                  | Claude Opus 5.5   | `medium` (predefinito) | 86,6%                                                                                   | $0,84 USD per tentativo                                                                                                |
| Benchmark interno di coding agentico                                                                                                                                    | Claude Fable 5.2  | `medium`               | 88,9% (una singola esecuzione)                                                          | $1,34 USD per tentativo                                                                                                |
| GPQA Diamond<sup>[9](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup>                                           | Claude Haiku 5.5  | `medium` (predefinito) | 85% di accuratezza, rispetto al 91% di ciascuno tra Claude Opus 5.5 e Claude Sonnet 5.5 | Circa un ventesimo del costo per risposta corretta di Claude Opus 5.5 e circa un decimo di quello di Claude Sonnet 5.5 |
| Set di attività di Claude Managed Agents<sup>[25](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup>, 79 attività | Claude Haiku 5.5  | `medium`               | 93% dei tentativi superati (una singola esecuzione)                                     | Circa $0,011 USD per tentativo superato                                                                                |

Su 463 dei 478 problemi del sottoinsieme di SWE-bench Pro, quelli le cui soluzioni di riferimento superano i test anche senza accesso alla rete (riferimento 3), Claude Fable 5.2 con `high`, il suo valore predefinito sulla Messages API, ha risolto il 96,3% delle attività per $1,39 USD per attività risolta. La stessa esecuzione di Claude Fable 5.1 al suo valore predefinito, conteggiata su questi 463 problemi, ha risolto il 92,4% per $1,17 USD. Con `low`, Fable 5.2 ha risolto il 94,6% per $0,39 USD per attività risolta: più attività di Fable 5.1 al suo valore predefinito, per circa un terzo del costo. A un tasso di successo simile, Claude Opus 5.5 costa comunque meno per attività risolta su questi problemi: al suo valore predefinito ha risolto il 93,1% per $0,22 USD, con `high` il 95,5% per $0,30 USD e con `xhigh` il 96,5% per $0,75 USD, alla pari con Fable 5.2 con `high` per poco più della metà del costo.

**Cosa fare.**

* Inizia con Claude Opus 5.5 al suo effort predefinito: sul sottoinsieme di SWE-bench Pro ha eguagliato Claude Fable 5.1 al suo valore predefinito, entro il rumore tra un’esecuzione e l’altra, per circa un quinto del costo per attività risolta. Opus 5.5 e Fable 5.1 saturano entrambi in larga misura il sottoinsieme di SWE-bench Pro. Usa Claude Fable 5.2 per il ragionamento impegnativo e il lavoro agentico a lungo orizzonte, oppure quando le tue valutazioni su Claude Opus 5.5 con effort più elevato risultano ancora insufficienti.
* All’altro estremo, Claude Haiku 5.5 è adatto al lavoro ad alto volume e sensibile alla latenza con output verificabili.
* Calcola il prezzo di ogni candidato in costo per attività completata sul tuo traffico, includendo Claude Opus 5.5 al suo effort predefinito e il modello di frontiera con effort ridotto. Ciascuno dei prezzi per token di Claude Opus 5.5, letture dalla cache incluse, è il doppio di quello di Claude Sonnet 5.5, ma sul sottoinsieme di SWE-bench Pro Opus 5.5 con `low` ha risolto circa la stessa quota di attività di Sonnet 5.5 al suo valore predefinito, entro il rumore tra esecuzioni, per circa il 7% in più per attività risolta.
* Misura cosa compra un modello più costoso sul tuo carico di lavoro. Sulle 44 attività di DeepResearch Bench II<sup>[7](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup> valutate per ogni modello, con l’effort predefinito sulla Messages API, Claude Opus 5.5 ha ottenuto 2,4 punti in più di Claude Sonnet 5.5 a 1,5 volte il costo per attività. Claude Fable 5.2 è costato 4,3 volte Claude Sonnet 5.5 senza alcun guadagno misurabile di punteggio, e 2,9 volte Claude Opus 5.5 per un punteggio inferiore di 1,9 punti. Rispetto a Claude Fable 5.1, è costato dal 20% al 61% in meno a ciascun livello di effort e ha ottenuto da 4,7 a 7,0 punti in meno. Su tutte le 50 attività, Claude Opus 5.5 non è misurabilmente in vantaggio su Claude Sonnet 5.5: le salvaguardie lo hanno quasi sempre fermato su quattro attività di biologia a cui Claude Sonnet 5.5 ha risposto, e un tentativo fermato conta come fallimento.
* Calcola il prezzo della coda del tuo carico di lavoro, non della mediana: confronta i modelli sul decimo più difficile delle tue attività, non su quelle tipiche.

La fattura è determinata dalle attività in cui il modello più economico fallisce, perché un’attività fallita fattura comunque i suoi token, poi il nuovo tentativo, poi qualunque cosa il fallimento costi a valle. La coda è anche il punto in cui va il denaro anche quando nulla fallisce. In un’esecuzione di WideSearch<sup>[1](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup> su 20 problemi, due problemi hanno rappresentato il 43% della spesa:

<Frame>
  ![Grafico a barre di 20 problemi di WideSearch ordinati per costo: i primi due rappresentano il 43% della spesa e la metà più economica il 10%](https://platform.claude.com/docs/it/images/cost-intel/tail.svg)
</Frame>

Le [strategie multi-modello](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#combine-models) servono proprio a impiegare l’intelligenza di frontiera su quella coda senza pagare tariffe di frontiera per tutto il resto.

### Aggiorna il modello

Se sei indietro di un modello o due, la leva più economica è la stringa del modello. Sui benchmark di coding di questa sezione e in [Confronta i modelli](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#compare-models-on-cost-per-task), ogni modello più recente ha risolto almeno tante attività quante il precedente; la maggior parte è costata meno per attività risolta, e Claude Fable 5.2, con `high`, è costato più di Claude Fable 5.1. Su un benchmark di ricerca, Claude Fable 5.2 ha fatto il contrario: è costato meno per attività di Claude Fable 5.1 a ciascun livello di effort e ha ottenuto un punteggio inferiore ([Confronta i modelli](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#compare-models-on-cost-per-task)). Il grafico mostra i modelli Claude recenti su due benchmark in cui un agente lavora da solo su un’unica attività scritta e dei test verificano il risultato: il sottoinsieme di SWE-bench Pro<sup>[3](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup>, dove ogni modello è stato eseguito con la stessa configurazione di test, e Terminal-Bench 3<sup>[20](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup>. La tabella elenca cosa ha cambiato ciascun aggiornamento:

<Frame>
  ![Grafici: su SWE-bench Pro, Opus 5.5 e Sonnet 5.5 riducono maggiormente il costo per attività risolta; su Terminal-Bench 3, Opus scende a $28 USD](https://platform.claude.com/docs/it/images/cost-intel/upgrade-ladder-sonnet-5-5.svg)
</Frame>

| Benchmark                                                                                                                                                  | Aggiornamento                          | Effort                                     | Punteggio                                                        | Costo                                                                                                        |
| ---------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------- | ------------------------------------------ | ---------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------ |
| Sottoinsieme di SWE-bench Pro<sup>[3](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup>             | Da Claude Sonnet 4.6 a Claude Sonnet 5 | Predefinito                                | 5 punti in più                                                   | 16% in meno per attività risolta                                                                             |
| Sottoinsieme di SWE-bench Pro                                                                                                                              | Da Claude Sonnet 5 a Claude Sonnet 5.5 | Predefinito                                | Circa 10 punti in più                                            | 87% in meno per attività risolta; 85% in meno ai prezzi di Claude Sonnet 5                                   |
| Sottoinsieme di SWE-bench Pro                                                                                                                              | Da Claude Opus 5 a Claude Opus 5.5     | Predefinito: da `high` a `medium`          | Circa lo stesso: dal 91,9% al 92,8% delle attività risolte       | 78% in meno per attività risolta; circa il 69% in meno ai prezzi di Claude Opus 5                            |
| Sottoinsieme di SWE-bench Pro                                                                                                                              | Da Claude Fable 5 a Claude Fable 5.1   | Predefinito                                | Punteggio circa uguale                                           | 43% in meno per attività risolta                                                                             |
| Terminal-Bench 3<sup>[20](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup>                         | Da Claude Opus 4.7 a Claude Opus 4.8   | `high`                                     | Dal 7% al 15% delle attività risolte                             | Da $183 USD a $63 USD per attività risolta                                                                   |
| Terminal-Bench 3                                                                                                                                           | Da Claude Opus 4.8 a Claude Opus 5     | `high`                                     | Dal 15% al 41% delle attività risolte                            | Da $63 USD a $28 USD per attività risolta, un risparmio del 56%                                              |
| Set di attività di Claude Managed Agents<sup>[25](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup> | Da Claude Haiku 4.5 a Claude Haiku 5.5 | Come servito; `medium` su Claude Haiku 5.5 | Dal 62% al 93% dei tentativi superati, un’esecuzione per modello | Da $0,041 USD a circa $0,010 USD di costo in token per tentativo; circa l’84% in meno per tentativo superato |

**Quando conviene.**

* L’entità del risparmio dipende dal lavoro. Da Claude Opus 5 a Claude Opus 5.5, è del 78% per attività risolta sul sottoinsieme di SWE-bench Pro e del 40% sui carichi di lavoro tipici ([Introducing Claude Opus 5.5](https://www.anthropic.com/news/claude-opus-5-5)). Da Claude Sonnet 5 a Claude Sonnet 5.5, è dell’87% sullo stesso sottoinsieme e fino al 30% per la maggior parte del lavoro ([Introducing Claude Sonnet 5.5](https://www.anthropic.com/news/claude-sonnet-5-5)).
* Dove i modelli più vecchi risolvono già la maggior parte delle attività, è il costo di ogni tentativo a determinare il risparmio: sul sottoinsieme di SWE-bench Pro, Claude Opus 5.5 ottiene circa lo stesso punteggio di Claude Opus 5 per il 78% in meno per attività risolta.
* Dove i modelli più vecchi falliscono per lo più, è il tasso di successo a determinare il risparmio: su Terminal-Bench 3<sup>[20](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup>, l’aggiornamento da Claude Opus 4.8 a Claude Opus 5 porta le attività risolte dal 15% al 41% e costa il 56% in meno per attività risolta.
* Confronta in base al costo per attività risolta, non per token: lo stesso testo costa circa il 30% di token in più su Claude 4.7 e sui modelli successivi, quindi un confronto per token fa sembrare i modelli più recenti più costosi per costruzione.

### Regola l’effort

Esplora i livelli di effort sul tuo carico di lavoro prima di aggiungere un secondo modello. Un effort più basso costa meno ed è spesso più veloce, e quanta accuratezza sacrifica dipende dall’attività: nel coding a lungo orizzonte, l’effort ha comprato accuratezza, e nelle attività di ricerca ne ha comprata molta in una misurazione e poca in un’altra. Il parametro [`effort`](https://platform.claude.com/docs/it/build-with-claude/effort) regola quanto ragionamento, quante chiamate agli strumenti e quanta autoverifica esegue il modello; sulla Messages API, `high` è il valore predefinito sulla maggior parte dei modelli, e `medium` su Claude Opus 5.5 e Claude Haiku 5.5.

La tabella seguente elenca le misurazioni di Anthropic su due benchmark con modelli attuali; punteggi e costi non sono confrontabili tra i due benchmark. I costi sono per attività, non per attività risolta come in [Confronta i modelli sul costo per attività](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#compare-models-on-cost-per-task). Ogni punteggio aggrega due esecuzioni su SWE-bench Pro e tre su DeepResearch Bench II, salvo diversa indicazione nella cella:

| Benchmark                                                                                                                                      | Modello          | Effort                                  | Punteggio                                             | Costo per attività |
| ---------------------------------------------------------------------------------------------------------------------------------------------- | ---------------- | --------------------------------------- | ----------------------------------------------------- | ------------------ |
| Sottoinsieme di SWE-bench Pro<sup>[3](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup> | Claude Opus 5.5  | `low`                                   | 87,4% delle attività risolte                          | $0,11 USD          |
| Sottoinsieme di SWE-bench Pro                                                                                                                  | Claude Opus 5.5  | `medium` (predefinito)                  | 92,8% delle attività risolte                          | $0,21 USD          |
| Sottoinsieme di SWE-bench Pro                                                                                                                  | Claude Opus 5.5  | `high`                                  | 95,3% delle attività risolte                          | $0,29 USD          |
| Sottoinsieme di SWE-bench Pro                                                                                                                  | Claude Opus 5.5  | `xhigh`                                 | 96,7% delle attività risolte (una singola esecuzione) | $0,74 USD          |
| DeepResearch Bench II<sup>[7](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup>         | Claude Fable 5.2 | `low`                                   | Punteggio della rubrica 54,5%                         | $1,49 USD          |
| DeepResearch Bench II                                                                                                                          | Claude Fable 5.2 | `medium`                                | Punteggio della rubrica 55,0%                         | $2,16 USD          |
| DeepResearch Bench II                                                                                                                          | Claude Fable 5.2 | `high` (predefinito sulla Messages API) | Punteggio della rubrica 57,7%                         | $4,82 USD          |

Il grafico seguente mostra l’accuratezza rispetto al costo per attività per Claude Opus 5.5 sul sottoinsieme di SWE-bench Pro<sup>[3](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup>:

<Frame>
  ![Grafico a linee dell'accuratezza rispetto al costo per attività per livello di effort: ripido da low a high per Claude Opus 5.5 su SWE-bench Pro](https://platform.claude.com/docs/it/images/cost-intel/effort-sweep-opus-5-5-swe-bench-pro.svg)
</Frame>

Il grafico seguente mostra il punteggio della rubrica rispetto al costo per attività per Claude Fable 5.1 su DeepResearch Bench II<sup>[7](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup>:

<Frame>
  ![Grafico a linee, DeepResearch Bench II, Fable 5.1: punteggio della rubrica 60,5% con effort low, 60,5% a medium, 63,0% a high, all'aumentare del costo](https://platform.claude.com/docs/it/images/cost-intel/effort-limit-repriced.svg)
</Frame>

**Cosa fare.**

* Esplora due o tre livelli di effort su un campione del tuo traffico, ciascuno in una sessione separata: cambiare l’effort di primo livello a metà sessione [invalida la cache](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#cache-repeated-context) e distorce il confronto. La curva è la baseline che qualsiasi strategia multi-modello deve battere ([passaggio 2 della misurazione sul tuo carico di lavoro](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#measure-on-your-own-workload)).
* Nel coding a lungo orizzonte, l’effort è un vero compromesso, che [rieseguire i fallimenti con un effort più alto](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#re-run-failures-at-higher-effort) trasforma di nuovo in un risparmio. Con `medium`, Claude Sonnet 5.5 ha ottenuto circa 7 punti in meno rispetto al suo valore predefinito, `high`, sul sottoinsieme di SWE-bench Pro<sup>[3](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup> per circa il 59% del costo per attività (2 esecuzioni ciascuno), e ha ottenuto il 62,7% rispetto al 77,8% sul benchmark interno di coding agentico<sup>[11](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup> (1 tentativo per attività).
* Con `xhigh` e `max`, Claude Sonnet 5.5 può avviare propri cicli di revisione dopo aver terminato un’attività, il che richiede più tempo e token. Per mantenere quel lavoro focalizzato sull’attività, aggiungi al tuo prompt di sistema il prompt riportato in “Accuratezza con effort `xhigh` e `max`” in [Scrivere prompt per Claude Sonnet 5.5](https://platform.claude.com/docs/it/build-with-claude/prompt-engineering/prompting-claude-sonnet-5-5#steer-initiative-and-scope).
* Nelle attività di ricerca, misura il modello che distribuisci. Claude Fable 5.2 ha ottenuto 3,3 punti in più con `high` rispetto a `low` su DeepResearch Bench II, a 3,2 volte il costo, e un punteggio non misurabilmente più alto con `medium` rispetto a `low`; Claude Opus 5.5 ha ottenuto 13,3 punti in meno con `low` rispetto a `medium` su DRACO<sup>[21](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup>. I due risultati provengono da modelli diversi su benchmark diversi, quindi mostrano che la risposta varia, non il perché.
* Con `low`, l’attività tipica di Claude Opus 5.5 ha richiesto l’84% di tempo in meno rispetto a `medium` su DRACO<sup>[21](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup>, il 30% in meno su HLE<sup>[22](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup> e il 47% in meno su un set interno di problemi di fisica<sup>[23](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup>, e ha ottenuto rispettivamente 13,3, 3,4 e 14,0 punti in meno (3, 3 e 4 tentativi per attività).
* Su un benchmark interno di ricerca di difetti<sup>[8](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup> (10 esecuzioni per impostazione), Claude Opus 5.5 ha ottenuto 34 punti in meno con `low` rispetto a `medium`, per circa un quinto del costo. Claude Fable 5.2 ha ottenuto 4,3 punti in meno con `low` rispetto a `high`, a un costo inferiore del 37%.

### Riesegui i fallimenti con un effort più alto

Quando l’esito di un’attività è verificabile, la politica più economica sulla curva dell’effort non è un’impostazione fissa: esegui ogni attività con un’impostazione bassa e riesegui solo i fallimenti con una più alta.

Anthropic ha calcolato questa politica attività per attività a partire dalle esecuzioni di Claude Opus 5.5 con i vari livelli di effort sul sottoinsieme di SWE-bench Pro<sup>[3](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup> in [Regola l’effort](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#tune-effort):

<Frame>
  ![Grafico, SWE-bench Pro, Opus 5.5: effort low o medium con i fallimenti rieseguiti con high eguaglia qualsiasi effort fisso a un costo inferiore a high](https://platform.claude.com/docs/it/images/cost-intel/escalation-opus-5-5.svg)
</Frame>

Nella tabella seguente, i costi di riesecuzione includono i tentativi economici falliti:

| Politica                                   | Attività risolte | Costo per attività |
| ------------------------------------------ | ---------------- | ------------------ |
| `low`, fallimenti rieseguiti con `high`    | Circa 97%        | Circa $0,17 USD    |
| `medium`, fallimenti rieseguiti con `high` | Circa 97%        | Circa $0,24 USD    |
| Tutto con `high`                           | 95,3%            | $0,29 USD          |

* Con `low`, il 13% delle attività è fallito. Rieseguendo queste con `high`, il tasso di successo è stato leggermente superiore rispetto a eseguire tutto con `high`, per poco più della metà del costo.
* Usa questa politica per il risparmio, non per il miglioramento. La maggior parte del piccolo miglioramento deriva dal secondo tentativo: rieseguire con `high` i fallimenti di un’esecuzione con `high` ottiene circa lo stesso punteggio, spendendo di più.

Si applicano due condizioni. Primo, ti serve un segnale di fallimento (qui, i test del benchmark stesso); un verificatore che approva lavoro scadente lascia passare quei fallimenti. Secondo, ogni fallimento al primo passaggio richiede il tempo reale di due esecuzioni, quindi il risparmio si paga in latenza sui fallimenti.

### Imposta budget e limiti di output

Due controlli svolgono due compiti diversi: un budget di sessione limita quanto può spendere una sessione di Claude Managed Agents, e `max_tokens` limita la lunghezza di una risposta. Imposta ciascuno dove si applica, con un [limite di spesa del workspace](https://platform.claude.com/docs/it/api/rate-limits#setting-lower-limits-for-workspaces) come ultima protezione.

* **I budget di sessione su Claude Managed Agents** sono un arresto rigido della spesa. Un [budget di sessione](https://platform.claude.com/docs/it/managed-agents/budgets) è un limite in dollari sul [costo di listino](https://platform.claude.com/docs/it/managed-agents/budgets#how-list-cost-is-measured) di una sessione, che la piattaforma misura per token, ricerche web e tempo di esecuzione della sessione.
* Al raggiungimento del limite, o poco oltre, la sessione si mette in pausa con `stop_reason: budget_reached`; aumentare il budget la riprende. È applicato dalla piattaforma e funziona su qualsiasi modello con un prezzo di listino. I deployment applicano lo stesso budget a ogni sessione che avviano.
* **`max_tokens`** limita una singola risposta, in modo invisibile al modello, quindi abbassarlo non fa economizzare il modello. I turni che avevano bisogno di spazio vengono scartati e comunque fatturati. Ritentare i tentativi troncati raramente aiuta: con lo stesso limite la maggior parte fallisce di nuovo, e con uno più alto paghi anche il tentativo sprecato.
* Imposta `max_tokens` a 64.000 per il lavoro agentico, oppure a 128.000, il massimo, quando un singolo tentativo troncato è costoso. Usa lo [streaming delle risposte](https://platform.claude.com/docs/it/build-with-claude/streaming) così grandi, tratta [`stop_reason: max_tokens`](https://platform.claude.com/docs/it/build-with-claude/handling-stop-reasons#max-tokens) come un fallimento e risparmia con l’effort, che il modello può vedere.
* Su Claude Haiku 5.5, aumenta un `max_tokens` piccolo o abbassa l’effort: il ragionamento è attivo per impostazione predefinita e conta ai fini del limite, quindi una risposta può terminare prima di qualsiasi testo (vedi la [guida alla migrazione di Claude Haiku 5.5](https://platform.claude.com/docs/it/models/haiku-5-5/migration-guide#configure-thinking)).

La tabella seguente mostra cosa ha risolto ciascun modello e quanto è costata un’attività risolta con ciascun limite su un benchmark interno di attività su repository<sup>[12](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup>, un tentativo per attività, ciascun modello al suo effort predefinito sulla Messages API. Le righe a 16.384 sono la media di due esecuzioni, e le altre righe sono un’esecuzione ciascuna:

| Modello          | `max_tokens` | Tentativi terminati dal limite | Attività risolte | Costo per attività risolta     |
| ---------------- | ------------ | ------------------------------ | ---------------- | ------------------------------ |
| Claude Opus 5.5  | 16.384       | 25%                            | 57,6%            | $5,38 USD a prezzi di listino  |
| Claude Opus 5.5  | 64.000       | 0%                             | 75,6%            | $5,38 USD a prezzi di listino  |
| Claude Opus 5.5  | 128.000      | 0%                             | 68,9%            | $5,94 USD a prezzi di listino  |
| Claude Fable 5.2 | 16.384       | 85%                            | 20,3%            | $27,96 USD a prezzi di listino |
| Claude Fable 5.2 | 64.000       | 2%                             | 77,4%            | $24,42 USD a prezzi di listino |
| Claude Fable 5.2 | 128.000      | 0%                             | 78,2%            | $24,52 USD a prezzi di listino |

**Claude Opus 5.5 a 64.000 e 128.000:** nessun tentativo è stato troncato con nessuno dei due limiti, quindi il limite non spiega perché queste due righe differiscano nelle attività risolte o nel costo per attività risolta. Ogni riga è un’esecuzione.

Confronta i limiti all’interno di ciascun modello. I due modelli sono stati misurati in esecuzioni separate.

Sulle attività interne su repository<sup>[12](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup>, quasi ogni turno termina molto al di sotto di un limite di 16.384 token, ma un solo turno più lungo termina l’intero tentativo: con un limite più alto, l’1,7% dei turni di Claude Fable 5.2 ha superato i 16.384 token, e a 16.384 il limite ha terminato l’85% dei suoi tentativi. Il raro turno lungo è ciò che compra un limite più alto (Claude Opus 5.5 e Claude Fable 5.1 sono i due modelli di questo grafico):

<Frame>
  ![Grafico a punti dell'output per turno per Opus 5.5 e Fable 5.1: mediane di qualche centinaio di token, i più lunghi 61k e 128k, rispetto ai limiti](https://platform.claude.com/docs/it/images/cost-intel/max-tokens-ladder-opus-5-5.svg)
</Frame>

Chiedi risposte più brevi. I token di output costano cinque volte i token di input su Claude Haiku 5.5, Claude Sonnet 5.5, Claude Opus 5.5, Claude Fable 5.2 e Claude Fable 5.1, e in un ciclo agentico ogni token che il modello scrive ritorna come input in ogni turno successivo, quindi paghi una risposta lunga più e più volte.

In una misurazione su un modello precedente<sup>[26](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup>, Anthropic ha eseguito un piccolo agente che smista segnalazioni di bug ([Taglia i token di input e di contesto](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#trim-input-and-context-tokens)) con tre istruzioni diverse per la risposta finale, tre esecuzioni ciascuna, con lo stesso modello e gli stessi strumenti:

* L’originale chiedeva due righe.
* La variante più breve ne chiedeva una.
* La variante più lunga chiedeva un memo con sei sezioni con intestazione.

Il grafico seguente mostra il costo per esecuzione di ciascun formato:

<Frame>
  ![Grafico a barre: formato a una riga $0,49 USD per esecuzione, formato originale a due righe $0,57 USD, memo $1,40 USD, tutti corretti dal 78% all'85%](https://platform.claude.com/docs/it/images/cost-intel/output-format.svg)
</Frame>

Tutti e tre hanno ottenuto punteggi entro il rumore tra esecuzioni l’uno dall’altro rispetto alle etichette corrette, quindi i formati differiscono in ciò che paghi molto più che in ciò che azzeccano. Chiedi la risposta che leggerai, non quella che sembra esaustiva.

### Mostra al modello il tempo trascorso

Per far terminare prima un agente e farlo costare meno, digli che il tempo conta e mostragli il tempo trascorso a ogni richiesta. Nella misurazione di Anthropic, le due modifiche hanno ridotto il tempo di un singolo agente Claude Opus 5.5 con effort `medium` del 47% e il suo costo del 60% sull’attività di ricerca tipica (mediana) di DRACO<sup>[21](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup>, e il suo punteggio medio è stato inferiore di 4,1 punti.

Su HLE<sup>[22](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup> e su un set interno di fisica<sup>[23](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup>, l’attività tipica ha richiesto rispettivamente il 14% e il 7% di tempo in meno, e il punteggio di fisica è stato inferiore di 3,0 punti. Abbassare l’effort a `low` ha fatto risparmiare più tempo e costo rispetto alle modifiche, e ha perso più punteggio (riferimento 21). Verifica il punteggio sulle tue attività prima di adottare le modifiche.

Il riferimento 21 riporta il testo esatto usato per entrambe le modifiche nelle esecuzioni misurate. Per codice funzionante, consulta la ricetta del Claude Cookbook [Multi-agent teams under latency pressure and budgets](https://github.com/anthropics/claude-cookbooks/blob/main/patterns/agents/latency_multi_agent.ipynb), che applica entrambe le modifiche a un team di agenti. Per usare il prompt di sistema invece del primo messaggio `user` per indicare che il tempo conta, consulta [Segnali temporali per harness multiagente](https://platform.claude.com/docs/it/build-with-claude/prompt-engineering/prompting-claude-opus-5-5#time-signals-for-multi-agent-harnesses).

Il grafico seguente mostra anche un team, il cui agente principale ha avviato raramente agenti ausiliari, e un singolo agente con effort `low`:

<Frame caption="Con entrambe le modifiche, un singolo agente ha impiegato il 47% di tempo in meno sull'attività tipica di DRACO, e il suo punteggio medio è stato inferiore di 4,1 punti.">
  ![Grafici a dispersione e a barre, DRACO, HLE e l'insieme di fisica: le modifiche fanno risparmiare più tempo su DRACO, al prezzo di qualche punto di punteggio](https://platform.claude.com/docs/it/images/cost-intel/time-awareness.svg)
</Frame>

Per pagare invece per la velocità, imposta `speed: "fast"` su Claude Fable 5.2 o Claude Opus 5.5. La [modalità veloce](https://platform.claude.com/docs/it/build-with-claude/fast-mode) offre fino a 2,5 volte più token di output al secondo al doppio dei prezzi standard dei token. Cambiare la velocità a metà conversazione comporta un mancato riscontro nella cache dei prompt.

## Combina i modelli

Ottimizza un modello prima di aggiungerne un secondo: esplora prima i livelli di effort sul tuo modello attuale, perché la maggior parte dei carichi di lavoro si ferma lì, e se l’esplorazione mostra un divario, calcola il prezzo del modello più potente da solo con effort basso. Costruisci un abbinamento solo se batte l’intera curva del punteggio rispetto alla spesa del singolo modello. Sul tuo carico di lavoro, valuta un abbinamento rispetto allo stesso modello con effort più basso e rispetto al modello immediatamente inferiore eseguito da solo.

La tabella seguente confronta le due strategie:

| Strategia         | Flusso di controllo                                                | Ruolo del modello di frontiera       | Adatta a                                                                                                                    | Il costo di frontiera cresce con            |
| ----------------- | ------------------------------------------------------------------ | ------------------------------------ | --------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------- |
| **Advisor**       | Il modello più piccolo esegue il ciclo, scala su richiesta         | Consultato per piani e correzioni    | Lavoro seriale difficile in alcuni punti, come i molti turni di un agente di programmazione tra poche decisioni reali       | Quanto spesso l’esecutore si blocca         |
| **Orchestratore** | Il modello di frontiera esegue il ciclo, delega il lavoro di massa | Pianifica, distribuisce e sintetizza | Lavoro che si dirama su file, documenti o casi realmente indipendenti, specialmente più di una finestra di contesto di essi | Quanto sono difficili da coordinare i pezzi |

### Strategia advisor: scala le decisioni difficili

Un advisor può aiutare solo quando l’esecutore lo consulta.

Nelle misurazioni di Anthropic, l’unico abbinamento il cui esecutore consultava spesso, su un benchmark di coding, ha ottenuto 1,7 punti in più rispetto all’esecutore da solo con lo stesso effort, al limite del rumore tra esecuzioni, per circa 2,1 volte il costo. Dove l’esecutore consultava raramente o mai, l’abbinamento ha ottenuto un punteggio entro il rumore tra esecuzioni rispetto all’esecutore da solo, o inferiore.

Per attivarlo, aggiungi alla tua richiesta lo [strumento advisor](https://platform.claude.com/docs/it/agents-and-tools/tool-use/advisor-tool), una funzionalità beta. Su Claude Managed Agents, [assegna un advisor alla sessione](https://platform.claude.com/docs/it/managed-agents/multiagent-orchestration#give-the-session-an-advisor). Per Claude Code, consulta [escalation delle decisioni difficili con lo strumento advisor](https://code.claude.com/docs/it/advisor).

<Frame>
  ![Diagramma della strategia advisor: un modello esecutore gestisce il ciclo principale e chiama su richiesta un advisor Claude Fable 5.1](https://platform.claude.com/docs/it/images/model-routing-advisor-strategy.svg)
</Frame>

La tabella seguente confronta ciascun abbinamento con il suo esecutore da solo con lo stesso effort:

| Benchmark                                                                                                                                              | Punteggio                                                                       | Costo                                                                         | Advisor consultato                                                                                        |
| ------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------- | ----------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------- |
| Benchmark interno di coding agentico<sup>[11](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup> | 90,1%, 1,7 punti sopra l’esecutore da solo, al limite del rumore tra esecuzioni | $2,92 USD per tentativo, circa 2,1 volte l’esecutore da solo                  | Circa 1,4 volte per tentativo; il 4% dei tentativi non ha ricevuto consigli                               |
| GPQA Diamond<sup>[9](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup>                          | Entro il rumore tra esecuzioni rispetto all’esecutore da solo                   | 12% in più per domanda per Claude Haiku 5.5, 25% in più per Claude Sonnet 5.5 | Su nessuna delle 198 domande, in due esecuzioni ciascuna; nessun prompt di sistema chiedeva consultazioni |
| Chartography<sup>[13](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup>                         | 61,7, 7 punti sotto l’esecutore da solo e oltre il rumore tra esecuzioni        | Circa lo stesso dell’esecutore da solo                                        | Su 1 attività su 300                                                                                      |

* **Benchmark interno di coding agentico.** Claude Opus 5.5 con `high`, con un advisor Claude Fable 5.1.
* **GPQA Diamond.** Claude Haiku 5.5 o Claude Sonnet 5.5 al valore predefinito di ciascun modello (`medium` e `high`), con un advisor Claude Opus 5.5.
* **Chartography.** Claude Opus 5.5 con `low`, con un advisor Claude Fable 5.1.

L’advisor può trasferire solo capacità che mancano all’esecutore: su GPQA Diamond, Claude Sonnet 5.5 da solo ha pareggiato Claude Opus 5.5 da solo al 91% contando i rifiuti come errori, ma solo perché Opus 5.5 ha rifiutato sei domande di biologia per esecuzione rispetto a una di Sonnet 5.5. Sulle domande a cui ciascuno ha risposto, Opus 5.5 era in vantaggio di circa 2 punti.

Sul benchmark di coding, il guadagno dell’abbinamento è al limite del rumore tra esecuzioni, e si colloca circa sulla curva dell’effort di Claude Opus 5.5 stesso, quindi l’advisor ha comprato circa quanto fa un effort maggiore. Il grafico seguente mostra l’abbinamento rispetto a quella curva e a quella di Claude Fable 5.1 di agosto:

<Frame>
  ![Benchmark di coding: Opus 5.5 a high con un advisor Fable 5.1 guadagna 1,7 punti per 2,1 volte il costo, vicino alla sua curva di effort](https://platform.claude.com/docs/it/images/cost-intel/internal-coding-advisor-opus-5-5.svg)
</Frame>

**Cosa fare.**

* Misura il tasso di consultazione sulle tue attività. La definizione dello strumento advisor, circa 1.000 token di prompt per richiesta, aggiunge costo anche quando l’esecutore non consulta mai. Con la [cache dei prompt](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#cache-repeated-context), un ciclo agentico multi-turno paga la definizione al prezzo di lettura dalla cache dopo la prima richiesta, quindi questo sovraccarico conta soprattutto per attività brevi a richiesta singola.
* Se l’esecutore consulta raramente, consulta [Prompt per compiti di programmazione e agentici](https://platform.claude.com/docs/it/agents-and-tools/tool-use/advisor-tool#prompting-for-coding-and-agent-tasks) per prompt di sistema che chiedono consultazioni, e misura di nuovo dopo averne aggiunto uno. Su 20 problemi di SWE-bench Pro<sup>[3](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup>, il prompt suggerito non ha fatto una differenza chiara per Claude Sonnet 5.5.
* Ripristina l’effort dell’esecutore se il tasso di consultazione crolla. In misurazioni su modelli precedenti, un abbinamento che consultava sulla maggior parte delle attività con l’effort predefinito consultava su poche quando l’effort veniva abbassato, e poi otteneva un punteggio inferiore all’esecutore da solo al suo effort predefinito (SWE-bench Pro<sup>[3](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup>).
* Ricontrolla a ogni rilascio di modello, perché i rilasci spostano sia il divario di capacità sia il rapporto di prezzo.

### Strategia orchestratore: delega il lavoro di massa

Nelle misurazioni di Anthropic, la delega è risultata in vantaggio solo in due situazioni:

* Lavoro di routine con una lunga coda di costo (una porzione facile di BrowseComp<sup>[4](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup>, su modelli precedenti)
* Lavoro più grande di una finestra di contesto (un benchmark interno di ricerca di difetti<sup>[8](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup>)

Quando il lavoro è un’unica catena dipendente, o rientra in un singolo contesto senza una lunga coda di costo, il modello dell’orchestratore da solo con effort più basso è risultato in vantaggio in ogni caso misurato su modelli precedenti (il set più difficile di BrowseComp, e DeepWideSearch<sup>[6](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup>); lavori esterni indipendenti riportano lo stesso schema<sup>[5](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup>.

Per costruire un orchestratore, usa l’[orchestrazione multiagente](https://platform.claude.com/docs/it/managed-agents/multiagent-orchestration) in Claude Managed Agents: configura un agente orchestratore e i subagent che può chiamare, ciascuno con il proprio modello.

<Frame>
  ![Diagramma della strategia orchestratore: un modello di frontiera distribuisce sottoattività a tre modelli worker a costo inferiore](https://platform.claude.com/docs/it/images/model-routing-orchestrator-strategy.svg)
</Frame>

Il grafico seguente mostra nove delle diciassette configurazioni del benchmark di ricerca di difetti per costo e punteggio (nessuna delle cinque di Claude Fable 5.2):

<Frame>
  ![Grafico a dispersione, ricerca di difetti: Opus 5.5 con subagent Sonnet 5.5 eguaglia Opus 5.5 da solo a medium, per circa un terzo in meno](https://platform.claude.com/docs/it/images/cost-intel/corpus-pareto.svg)
</Frame>

**Cosa fare.**

* **Lavoro di routine con una lunga coda di costo:** misura prima questo caso, sia per l’accuratezza sia per il costo. La misurazione alla base copre solo i problemi a cui la configurazione con delega ha risposto correttamente in ogni esecuzione (riferimento 4).
* **Lavoro più grande di una finestra di contesto:** dividilo in parti, una sessione o un subagent per parte. Sul benchmark di ricerca di difetti<sup>[8](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup>, Claude Opus 5.5 con subagent Claude Sonnet 5.5 è costato circa un terzo in meno rispetto a una sessione di Claude Opus 5.5 per parte al suo effort predefinito, e ha ottenuto più o meno lo stesso punteggio. Usare Claude Fable 5.2 come orchestratore al posto di Claude Opus 5.5 è costato il 19% in più e ha ottenuto più o meno lo stesso punteggio. Da solo, da `low` a `high`, Claude Fable 5.2 ha ottenuto da 1,6 a 5,9 punti in più di Claude Opus 5.5 da solo a `high`, a un costo da 1,5 a 2,4 volte superiore, e da 3,2 a 7,5 punti in più rispetto a quando usa subagent Claude Sonnet 5.5, a un costo da 2,2 a 3,4 volte superiore. Ha anche ottenuto un punteggio più alto di Claude Fable 5.1 da solo a ciascun livello di effort: 3,6 punti a `low`, per il 32% in meno; 3,8 a `medium`, per il 37% in meno; e 6,1 a `high`, per il 21% in meno.
* **Subagent di Claude Haiku 5.5 nelle attività di coding:** confrontali prima con l’abbassamento dell’effort. Su un benchmark interno di coding su Claude Managed Agents, i subagent sono stati un’alternativa all’abbassamento dell’effort, non un miglioramento. Aggiungerli a Claude Opus 5.5 a `medium`, con un breve prompt di delega, ha ridotto il costo per tentativo del 32% e il tasso di successo di circa 4 punti percentuali (intervallo al 95% da 1,3 a 7,1), più o meno quanto darebbe a quel costo una combinazione di `low` e `medium` senza subagent<sup>[29](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup>.

## Misura sul tuo carico di lavoro

Misura sul tuo carico di lavoro: i numeri in questa pagina riflettono i prezzi di listino al momento della misurazione e cambieranno man mano che modelli e prezzi cambiano; anche il tuo tasso di escalation, la pulizia con cui le attività si suddividono e la lunghezza delle trascrizioni li influenzano. Il metodo resta lo stesso:

1. Preleva alcune attività dai log di produzione, ponderate come il traffico reale, e [scrivi controlli sui risultati](https://platform.claude.com/docs/it/test-and-evaluate/develop-tests) per ciascuna: test superati, ticket chiuso, numero di righe corretto. Registra il costo per attività accanto al punteggio.
2. Stabilisci una baseline per i livelli di modello su tutti i livelli di effort, non solo su quello predefinito, e traccia il punteggio rispetto alla spesa. Una configurazione multi-modello deve battere l’intera curva del singolo modello.
3. Se la curva mostra un divario che l’effort non riesce a colmare, aggiungi la strategia multi-modello adatta ed esegui di nuovo la suite.
4. Esegui la configurazione vincente in modalità shadow su una porzione del traffico prima del passaggio definitivo, poi mantieni la suite in esecuzione.

**Come calcolare il prezzo di un’attività.** Calcola il prezzo di ciascuno dei cinque conteggi di token nell’`usage` di una risposta alla propria tariffa: input non in cache, scritture in cache da 5 minuti e da 1 ora a 1,25x e 2x il prezzo di input, letture dalla cache e output. Sommali su tutte le richieste dell’attività (l’[API Usage and Cost Analytics](https://platform.claude.com/docs/it/manage-claude/usage-cost-analytics-api) riporta il totale aggregato). Su Claude Haiku 5.5, usa le tariffe corrispondenti alla lunghezza del prompt di ogni richiesta, contando le letture e le scritture in cache (vedi [Prezzi del contesto lungo](https://platform.claude.com/docs/it/about-claude/pricing#long-context-pricing)). Quando `usage.speed` è `"fast"`, usa le [tariffe della modalità veloce](https://platform.claude.com/docs/it/about-claude/pricing#fast-mode-pricing).

L’esempio seguente calcola il costo di una richiesta ai prezzi di listino di Claude Opus 5.5. Modifica i tre prezzi per un altro modello:

<CodeGroup exclude="shell:cURL, shell:CLI">
  <CodeGroupItem language="cURL">
    Questo calcolo richiede più logica di un singolo comando shell. Usa l’[Anthropic SDK](https://platform.claude.com/docs/it/cli-sdks-libraries/overview) per eseguirlo.
  </CodeGroupItem>

  <CodeGroupItem language="CLI">
    Questo calcolo richiede più logica di un singolo comando shell. Usa l’[Anthropic SDK](https://platform.claude.com/docs/it/cli-sdks-libraries/overview) per eseguirlo.
  </CodeGroupItem>

  ```python Python
  INPUT_PER_MTOK = 4.00  # Claude Opus 5.5
  # 0,05x il prezzo di input su Claude Opus 5.5; il moltiplicatore varia in base al modello
  CACHE_READ_PER_MTOK = 0.20
  OUTPUT_PER_MTOK = 20.00

  client = anthropic.Anthropic()
  response = client.messages.create(
      model="claude-opus-5-5",
      max_tokens=1024,
      messages=[{"role": "user", "content": "Hello, Claude"}],
  )
  usage = response.usage
  cache_writes = usage.cache_creation
  writes_1h = cache_writes.ephemeral_1h_input_tokens if cache_writes else 0
  writes_5m = cache_writes.ephemeral_5m_input_tokens if cache_writes else 0
  cost = (
      usage.input_tokens * INPUT_PER_MTOK
      # Le scritture in cache da 1 ora costano 2x il prezzo di input, quelle da 5 minuti 1,25x; le letture al prezzo di lettura cache.
      + writes_1h * INPUT_PER_MTOK * 2.0
      + writes_5m * INPUT_PER_MTOK * 1.25
      + (usage.cache_read_input_tokens or 0) * CACHE_READ_PER_MTOK
      + usage.output_tokens * OUTPUT_PER_MTOK
  ) / 1_000_000
  print(f"Request cost: ${cost:.6f}")
  ```

  ```typescript TypeScript
  const INPUT_PER_MTOK = 4.0; // Claude Opus 5.5
  const CACHE_READ_PER_MTOK = 0.2; // 0.05x the input price on Claude Opus 5.5; the multiplier differs by model
  const OUTPUT_PER_MTOK = 20.0;

  const client = new Anthropic();
  const response = await client.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 1024,
    messages: [{ role: "user", content: "Hello, Claude" }]
  });
  const usage = response.usage;
  const cost =
    (usage.input_tokens * INPUT_PER_MTOK +
      (usage.cache_creation?.ephemeral_1h_input_tokens ?? 0) * INPUT_PER_MTOK * 2 + // 1-hour cache write
      (usage.cache_creation?.ephemeral_5m_input_tokens ?? 0) * INPUT_PER_MTOK * 1.25 + // 5-minute cache write
      (usage.cache_read_input_tokens ?? 0) * CACHE_READ_PER_MTOK + // cache read
      usage.output_tokens * OUTPUT_PER_MTOK) /
    1_000_000;
  console.log(`Request cost: $${cost.toFixed(6)}`);
  ```

  ```csharp C#
  const double InputPerMtok = 4.00; // Claude Opus 5.5
  const double CacheReadPerMtok = 0.20; // 0.05x the input price on Claude Opus 5.5; the multiplier differs by model
  const double OutputPerMtok = 20.00;

  AnthropicClient client = new();
  var response = await client.Messages.Create(
      new MessageCreateParams
      {
          Model = Model.ClaudeOpus5_5,
          MaxTokens = 1024,
          Messages = [new UserMessageParam { Content = "Hello, Claude" }],
      }
  );
  var usage = response.Usage;
  double cost =
      (
          usage.InputTokens * InputPerMtok
          + (usage.CacheCreation?.Ephemeral1hInputTokens ?? 0) * InputPerMtok * 2.00 // 1-hour cache write
          + (usage.CacheCreation?.Ephemeral5mInputTokens ?? 0) * InputPerMtok * 1.25 // 5-minute cache write
          + (usage.CacheReadInputTokens ?? 0) * CacheReadPerMtok // cache read
          + usage.OutputTokens * OutputPerMtok
      ) / 1_000_000;
  Console.WriteLine($"Request cost: ${cost:F6}");
  ```

  ```go Go
  const (
  	inputPerMTok     = 4.00 // Claude Opus 5.5
  	cacheReadPerMTok = 0.20 // 0.05x the input price on Claude Opus 5.5; the multiplier differs by model
  	outputPerMTok    = 20.00
  )

  // ...
  	client := anthropic.NewClient()

  	response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
  		Model:     anthropic.ModelClaudeOpus5_5,
  		MaxTokens: 1024,
  		Messages: []anthropic.MessageParam{
  			anthropic.NewUserMessage(anthropic.NewTextBlock("Hello, Claude")),
  		},
  	})
  	if err != nil {
  		log.Fatal(err)
  	}

  	usage := response.Usage
  	cost := (float64(usage.InputTokens)*inputPerMTok +
  		float64(usage.CacheCreation.Ephemeral1hInputTokens)*inputPerMTok*2.00 + // 1-hour cache write
  		float64(usage.CacheCreation.Ephemeral5mInputTokens)*inputPerMTok*1.25 + // 5-minute cache write
  		float64(usage.CacheReadInputTokens)*cacheReadPerMTok + // cache read
  		float64(usage.OutputTokens)*outputPerMTok) / 1_000_000
  	fmt.Printf("Request cost: $%.6f\n", cost)
  ```

  ```java Java
  static final double INPUT_PER_MTOK = 4.00; // Claude Opus 5.5
  static final double CACHE_READ_PER_MTOK = 0.20; // 0.05x the input price on Claude Opus 5.5; the multiplier differs by model
  static final double OUTPUT_PER_MTOK = 20.00;

  void main() {
      AnthropicClient client = AnthropicOkHttpClient.fromEnv();

      Message response = client.messages().create(MessageCreateParams.builder()
          .model(Model.CLAUDE_OPUS_5_5)
          .maxTokens(1024)
          .addUserMessage("Hello, Claude")
          .build());

      Usage usage = response.usage();
      long writes1h = usage.cacheCreation().map(CacheCreation::ephemeral1hInputTokens).orElse(0L);
      long writes5m = usage.cacheCreation().map(CacheCreation::ephemeral5mInputTokens).orElse(0L);
      double cost = (usage.inputTokens() * INPUT_PER_MTOK
          + writes1h * INPUT_PER_MTOK * 2.00 // 1-hour cache write
          + writes5m * INPUT_PER_MTOK * 1.25 // 5-minute cache write
          + usage.cacheReadInputTokens().orElse(0L) * CACHE_READ_PER_MTOK // cache read
          + usage.outputTokens() * OUTPUT_PER_MTOK) / 1_000_000;
      IO.println("Request cost: $%.6f".formatted(cost));
  }
  ```

  ```php PHP
  const INPUT_PER_MTOK = 4.00; // Claude Opus 5.5
  const CACHE_READ_PER_MTOK = 0.20; // 0.05x the input price on Claude Opus 5.5; the multiplier differs by model
  const OUTPUT_PER_MTOK = 20.00;

  $client = new Client();
  $response = $client->messages->create(
      model: Model::CLAUDE_OPUS_5_5,
      maxTokens: 1024,
      messages: [['role' => 'user', 'content' => 'Hello, Claude']],
  );
  $usage = $response->usage;
  $cost = (
      $usage->inputTokens * INPUT_PER_MTOK
      + ($usage->cacheCreation?->ephemeral1hInputTokens ?? 0) * INPUT_PER_MTOK * 2.00 // 1-hour cache write
      + ($usage->cacheCreation?->ephemeral5mInputTokens ?? 0) * INPUT_PER_MTOK * 1.25 // 5-minute cache write
      + ($usage->cacheReadInputTokens ?? 0) * CACHE_READ_PER_MTOK // cache read
      + $usage->outputTokens * OUTPUT_PER_MTOK
  ) / 1_000_000;
  printf("Request cost: \$%.6f\n", $cost);
  ```

  ```ruby Ruby
  INPUT_PER_MTOK = 4.00 # Claude Opus 5.5
  CACHE_READ_PER_MTOK = 0.20 # 0.05x the input price on Claude Opus 5.5; the multiplier differs by model
  OUTPUT_PER_MTOK = 20.00

  client = Anthropic::Client.new
  response = client.messages.create(
    model: Anthropic::Model::CLAUDE_OPUS_5_5,
    max_tokens: 1024,
    messages: [{ role: "user", content: "Hello, Claude" }]
  )
  usage = response.usage
  cost = (
    usage.input_tokens * INPUT_PER_MTOK +
    usage.cache_creation&.ephemeral_1h_input_tokens.to_i * INPUT_PER_MTOK * 2.00 + # 1-hour cache write
    usage.cache_creation&.ephemeral_5m_input_tokens.to_i * INPUT_PER_MTOK * 1.25 + # 5-minute cache write
    usage.cache_read_input_tokens.to_i * CACHE_READ_PER_MTOK + # cache read
    usage.output_tokens * OUTPUT_PER_MTOK
  ) / 1_000_000
  puts format("Request cost: $%.6f", cost)
  ```
</CodeGroup>

**Cosa controllare.**

* **Quota di letture dalla cache.** Nei loop degli agenti la maggior parte dei token di input dovrebbe essere costituita da letture dalla cache. Se `cache_read_input_tokens` è piccolo rispetto a `input_tokens` più `cache_creation_input_tokens`, verifica che la cache sia attiva e che il prefisso rimanga lo stesso tra una richiesta e l’altra.
* **Strumento advisor e compattazione.** Quando lo [strumento advisor](https://platform.claude.com/docs/it/agents-and-tools/tool-use/advisor-tool#usage-and-billing) o la [compattazione](https://platform.claude.com/docs/it/build-with-claude/compaction-threshold#understanding-usage) è abilitato, alcuni token vengono riportati solo in `usage.iterations` e non nei totali di primo livello. Somma invece su `usage.iterations` e calcola il prezzo delle voci `advisor_message` alle tariffe del modello advisor.

La tabella seguente elenca le leve nell’ordine in cui provarle. I dati provengono dai test di Anthropic, dai post di lancio e dai prezzi e dalle velocità pubblicati:

| Leva                                             | Risparmio                                                                                                                                                                                                                                 | Costo in qualità                                                                                                                                                                                | Latenza                                                                                                                                                                 | Dove                                                                                                                                                                                  |
| ------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Cache dei prompt                                 | Costo ridotto di un fattore da 4,8 a 7,2 su un agente di ricerca, e di una percentuale compresa tra l’83% e l’86% su un piccolo agente di triage                                                                                          | Nessuno                                                                                                                                                                                         | Più veloce                                                                                                                                                              | [Metti in cache il contesto ripetuto](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#cache-repeated-context)                            |
| Durata della cache di 1 ora                      | Con 1 turno su 10 dopo una pausa, il valore predefinito di 5 minuti è costato il 54% in più; con 1 su 20, circa lo stesso                                                                                                                 | Nessuno                                                                                                                                                                                         | Sui modelli precedenti, rimasta attiva dopo una pausa<sup>[16](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup> | [Scegli la durata della cache](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#pick-the-cache-duration)                                  |
| Riduzione dell’input                             | Un ulteriore 21%-26% in meno sulla fattura di un piccolo agente di triage                                                                                                                                                                 | Con la ricerca degli strumenti, accuratezza nello stesso intervallo che senza<sup>[27](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup> | Neutra                                                                                                                                                                  | [Taglia i token di input e di contesto](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#trim-input-and-context-tokens)                   |
| Ricerca degli strumenti                          | 45% con 500 definizioni di strumenti allegate; 20% differendo il set di strumenti di un server MCP di GitHub                                                                                                                              | Nessuno per gli strumenti di cui l’attività non ha mai bisogno                                                                                                                                  | Neutra                                                                                                                                                                  | [Taglia i token di input e di contesto](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#trim-input-and-context-tokens)                   |
| File di dati tramite esecuzione del codice       | 92% su un’attività sui dati con 25 domande, con la cache dei prompt disattivata                                                                                                                                                           | Un guadagno: 25 su 25 corrette invece di 7                                                                                                                                                      | Più veloce                                                                                                                                                              | [Taglia i token di input e di contesto](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#trim-input-and-context-tokens)                   |
| Batch API                                        | 50%                                                                                                                                                                                                                                       | Nessuno                                                                                                                                                                                         | Risultati entro 24 ore                                                                                                                                                  | [Metti in batch il lavoro che può attendere](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#batch-work-that-can-wait)                   |
| Revisione dei prompt rispetto al modello attuale | 14% su entrambi gli aggiornamenti di modello testati                                                                                                                                                                                      | Nessuno; un guadagno in una delle due                                                                                                                                                           | Più veloce (meno round di chiamate agli strumenti)                                                                                                                      | [Verifica i prompt rispetto al modello attuale](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#audit-prompts-against-the-current-model) |
| Aggiornamento del modello                        | Di solito meno: fino al 40% in meno sui carichi di lavoro tipici, e fino all’87% in meno per attività risolta su un benchmark di coding                                                                                                   | Nessuno nel coding, un guadagno sulla maggior parte; inferiore su un benchmark di ricerca per Claude Fable 5.2                                                                                  | Neutra                                                                                                                                                                  | [Aggiorna il modello](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#upgrade-the-model)                                                 |
| Effort più basso                                 | Sulle attività di coding lunghe, `medium` è costato circa dal 30% al 52% in meno rispetto a `high`, e `low` circa due terzi in meno                                                                                                       | Fino a 34 punti in meno, a seconda dell’attività e del modello; 3,3 su un agente di ricerca                                                                                                     | Più veloce                                                                                                                                                              | [Regola l’effort](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#tune-effort)                                                           |
| Riesecuzione dei fallimenti                      | Circa il 40% in meno rispetto all’esecuzione di tutto a `high`, con lo stesso tasso di successo o leggermente migliore                                                                                                                    | Nessuno                                                                                                                                                                                         | Un secondo tentativo sulle attività che falliscono                                                                                                                      | [Riesegui i fallimenti con un effort più alto](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#re-run-failures-at-higher-effort)         |
| Richiesta di risposte più brevi                  | Circa il 13% in meno, grazie al 39% di token di output in meno                                                                                                                                                                            | Nessuno                                                                                                                                                                                         | Più veloce                                                                                                                                                              | [Imposta budget e limiti di output](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#set-budgets-and-output-caps)                         |
| Aumento di `max_tokens`                          | Nessuno: il costo per attività risolta non è aumentato a 64.000                                                                                                                                                                           | Un guadagno: fino a 57 punti in più di attività risolte a 64.000 su un benchmark di coding; nessuno su un altro                                                                                 | Neutra                                                                                                                                                                  | [Imposta budget e limiti di output](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#set-budgets-and-output-caps)                         |
| Advisor                                          | Nessuno: circa 2,1 volte il costo del solo modello, su un benchmark di coding                                                                                                                                                             | Nel coding, un piccolo guadagno che potrebbe essere casuale; sulla lettura di grafici, una perdita                                                                                              | Circa 1,4 chiamate extra per tentativo, nel coding                                                                                                                      | [Strategia advisor](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#advisor-strategy-escalate-hard-decisions)                            |
| Orchestratore                                    | Con subagent sul modello immediatamente inferiore, circa un terzo in meno rispetto al modello dell’orchestratore da solo al suo effort predefinito, su lavori più grandi di una finestra di contesto; sul lavoro di routine, misura prima | Nessuna perdita misurabile su quel lavoro                                                                                                                                                       | Fino a 25 subagent alla volta                                                                                                                                           | [Strategia orchestratore](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#orchestrator-strategy-delegate-bulk-work)                      |
| Modalità veloce                                  | Nessuno: il doppio dei prezzi standard dei token                                                                                                                                                                                          | Nessuno                                                                                                                                                                                         | Fino a 2,5 volte più token di output al secondo                                                                                                                         | [Mostra al modello il tempo trascorso](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#show-the-model-elapsed-time)                      |

### Automatizza la ricerca con la skill Claude API

Esegui il comando `cost-optimize` della [skill Claude API](https://platform.claude.com/docs/it/agents-and-tools/agent-skills/claude-api-skill) prima di cercare risparmi. Profila dove vanno i tuoi token e applica le leve in ordine, iniziando dalla cache:

Lascia che Claude Code trovi i risparmi per te

```text
/claude-api cost-optimize
```

Poi esegui il comando `hillclimb` nella directory che contiene la tua valutazione:

Lascia che Claude Code esegua la ricerca per te

```text
/claude-api hillclimb
```

Anthropic ha misurato la prima leva di `cost-optimize` e due ricerche su tau2-bench retail<sup>[24](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#refs)</sup>, tutte su modelli precedenti. I breakpoint della cache prodotti da `cost-optimize` hanno ridotto il costo per attività, e il tasso di successo è sceso di meno della variabilità tra esecuzioni identiche.

Una ricerca ha trovato una configurazione più economica abbassando l’effort e scendendo di un livello di modello. Il suo tasso di successo è rimasto all’interno della fascia stabilita prima della ricerca per una frazione di attività, e si è attestato al di sotto della soglia più rigorosa che la ricerca usava per i propri verdetti. Una seconda ricerca, avviata dal modello a costo inferiore con il suo effort predefinito, non ha mantenuto nulla. Il riferimento 24 riporta i dati e quanto è costata l’esecuzione di ciascuna ricerca.

Il grafico seguente mostra ogni passaggio della prima ricerca:

<Frame caption="Una ricerca su modelli precedenti, passo dopo passo. Le modifiche di effort e di modello hanno prodotto i risparmi; le modifiche ai prompt non hanno portato alcun guadagno duraturo.">
  ![Grafico a dispersione, tau2-bench retail: ogni passaggio della ricerca a partire da Claude Opus 5; Sonnet 5 a low è più economico del 61% entro 2 punti](https://platform.claude.com/docs/it/images/cost-intel/hillclimb.svg)
</Frame>

Due impostazioni determinano se puoi fidarti della risposta della ricerca:

* **Tieni da parte una suddivisione che la ricerca non legge mai.** La ricerca valuta l’adozione lì, quindi la conferma intercetta una modifica che si adatta solo alle attività che la ricerca ha visto, come è successo con le modifiche ai prompt (riferimento 24).
* **Ripeti la baseline prima della prima modifica.** In queste misurazioni, esecuzioni identiche di una stessa configurazione iniziale differivano di diverse attività (riferimento 24). Le ripetizioni forniscono al criterio di adozione della ricerca una soglia di rumore.

## Benchmark citati

Salvo dove un riferimento indichi diversamente, le misurazioni sono esecuzioni interne di Anthropic di questi benchmark. Salvo diversa indicazione, i costi sono in USD ai prezzi di listino in vigore al momento dell’esecuzione di ciascun benchmark; i dati di Claude Sonnet 5 usano $2 USD e $10 USD per milione di token di input e di output. I dati di Claude Sonnet 5.5 delle esecuzioni del 24 settembre 2026 usano gli stessi prezzi di input e output e il suo attuale prezzo di lettura dalla cache, $0,10 USD per milione di token, anziché il prezzo di lancio di $0,20 USD, applicati ai conteggi di token registrati in ciascuna esecuzione. Quelle esecuzioni hanno usato una build pre-release di Claude Sonnet 5.5, e a nessun tentativo in esse ha risposto un modello di fallback. I grafici etichettati “notional USD” (USD nozionali) calcolano il prezzo dei conteggi di token di ciascuna richiesta a quelle tariffe anziché riportare fatture.

1. **WideSearch:** Wong et al., “WideSearch: Benchmarking Agentic Broad Info-Seeking,” arXiv:2508.07999, 2025. Attività di ricerca web ampia valutate sulla completezza e sull’accuratezza di una tabella con molte righe; 200 problemi, 3 esecuzioni per configurazione, eseguite dal 1° al 2 agosto 2026. Con Claude Fable 5 su questo benchmark, DeepWideSearch (riferimento 6), BrowseComp (riferimento 4) e GDPval (riferimento 2), l’effort `low` ha ceduto da 1 a 3 punti in cambio di un costo per attività ridotto da un terzo alla metà, `medium` ha eguagliato l’accuratezza del valore predefinito a circa il 70%-87% del suo costo, e il valore predefinito non ha portato nulla di misurabile rispetto a `medium` su nessuno dei quattro. Il grafico della concentrazione dei costi è un’esecuzione separata su 20 problemi, 3 esecuzioni per problema, eseguita dal 3 al 4 agosto 2026, con costi calcolati dai record di fatturazione per richiesta. Copre 59 delle 60 esecuzioni. La sessantesima, fatturata $10,91 USD dei $432,31 USD totali, non ha alcun costo registrato con il suo risultato e non è inclusa.

2. **GDPval:** OpenAI, “GDPval: Evaluating AI Model Performance on Real-World Economically Valuable Tasks,” 2025. Deliverable di lavoro intellettuale valutati rispetto a rubriche specifiche per attività; un’esecuzione su 210 attività del gold set rilasciato, un tentativo per attività, eseguita il 2 agosto 2026. La valutazione è affidata a un modello Claude, quindi i punteggi assoluti possono differire dai risultati pubblicati.

3. **SWE-bench Pro:** Scale AI, “SWE-Bench Pro: Can AI Agents Solve Long-Horizon Software Engineering Tasks?”, 2025.

   * **Cosa è stato misurato:** Un sottoinsieme di 482 problemi selezionato per la compatibilità con l’harness di valutazione di Anthropic; i punteggi non sono confrontabili con la classifica pubblica. Non sono confrontabili nemmeno con i risultati di SWE-bench Pro nella system card di Claude Opus 5.5, che provengono da esecuzioni con effort `max` su un diverso insieme di problemi.
   * **Come sono stati calcolati i prezzi:** I costi su questo sottoinsieme sono calcolati come viene misurato l’uso dell’organizzazione di un cliente: il prompt precedente di ciascuna richiesta come lettura dalla cache e i suoi nuovi token come scrittura nella cache a 5 minuti, dai registri di utilizzo delle esecuzioni stesse, verificati rispetto al registro contabile di un cliente.
   * **Esecuzioni di Claude Opus 5.5:** I dati di Claude Opus 5.5 sono la media di due esecuzioni a `low`, `medium` (il suo valore predefinito) e `high`, e usano un’esecuzione a `xhigh`, tutte eseguite dal 19 al 20 settembre 2026, con lo stesso limite di 16.384 token per turno delle esecuzioni di agosto di Claude Opus 5; il limite ha interrotto 2 tentativi a `xhigh` e nessuno alle altre impostazioni. Rispetto a `high`, Claude Opus 5.5 ha ottenuto circa 2,5 punti in meno al suo valore predefinito, `medium`, per circa il 70% del costo per attività, e circa 8 punti in meno a `low` per circa un terzo del costo; `xhigh` ha ottenuto circa 1,4 punti in più per 2,5 volte il costo di `high`. I rapporti derivano da costi non arrotondati.
   * **I 478 problemi:** Le esecuzioni di Opus 5.5 hanno usato una versione del benchmark i cui container di valutazione possono raggiungere solo mirror interni dei pacchetti. Quella versione esclude un problema il cui test richiede un sito web attivo, e su altri tre la soluzione di riferimento lì fallisce, quindi i confronti con Opus 5.5, e i dati di Claude Fable 5.1 affiancati a essi, usano i restanti 478 problemi.
   * **Esecuzioni di Claude Sonnet 5.5:** Claude Sonnet 5.5 ha eseguito la stessa versione del benchmark: due esecuzioni al suo valore predefinito, `high`, e due a `medium`, tutte il 24 settembre 2026, con lo stesso limite di 16.384 token per turno, che non ha interrotto nessuno dei suoi tentativi. I suoi dati usano i 478 problemi, e così anche i dati di Claude Sonnet 5 affiancati a essi, conteggiati su quei problemi dalle esecuzioni di agosto.
   * **Esecuzioni di Claude Opus 5:** I dati di SWE-bench Pro di Claude Opus 5 in [Aggiorna il modello](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#upgrade-the-model) e in questo riferimento sono la media di due esecuzioni al suo effort predefinito e usano un’esecuzione a `low`, tutte eseguite il 4 agosto 2026.
   * **Advisor, abbinamenti con Claude Sonnet 5:** Gli abbinamenti con esecutore Claude Sonnet 5 e advisor Claude Opus 5 alla base degli esempi sul tasso di consultazione in [Strategia advisor](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#advisor-strategy-escalate-hard-decisions) sono stati eseguiti su questo sottoinsieme con la stessa configurazione di test: l’abbinamento all’effort predefinito è stato eseguito due volte (7 e 8 agosto 2026, un’esecuzione e una replica esatta), l’abbinamento a effort basso una volta (8 agosto 2026), e, dieci giorni dopo, Claude Sonnet 5 da solo due volte al suo effort predefinito (77,4%, la baseline per entrambi gli abbinamenti).
   * **Advisor, verifica delle consultazioni di Claude Sonnet 5.5:** La verifica delle consultazioni di Claude Sonnet 5.5 citata in [Strategia advisor](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#advisor-strategy-escalate-hard-decisions) ha eseguito un tentativo su ciascuno di 20 dei 478 problemi, il 24 settembre 2026, con un advisor Claude Opus 5.5 tramite lo strumento advisor. Sono state eseguite quattro configurazioni: `high` e `xhigh`, ciascuna con e senza il prompt di sistema suggerito dalla documentazione dello strumento advisor per le attività di coding. Al suo effort predefinito, `high`, Claude Sonnet 5.5 non ha consultato l’advisor su nessuno dei 20 problemi, con o senza il prompt. A `xhigh`, lo ha consultato su 3 dei 20 problemi senza il prompt e su 4 con esso, ogni volta nei suoi tentativi con il maggior numero di turni.
   * **Dati sull’escalation:** I dati sull’escalation derivano attività per attività dalle esecuzioni di Opus 5.5: prima `low`, poi `high` sui suoi fallimenti, ha risolto dal 96,4% al 97,5% tra gli abbinamenti di esecuzioni per circa $0,17 USD; prima `medium`, dal 96,0% al 97,1% per circa $0,24 USD; `high` rieseguito sui propri fallimenti, 96,9% per $0,31 USD; tutto a `high`, dal 94,8% al 95,8% per $0,29 USD.
   * **Confronta i modelli:** Il dato di Claude Fable 5.1 in [Confronta i modelli](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#compare-models-on-cost-per-task) proviene da un’esecuzione sullo stesso sottoinsieme all’effort predefinito, eseguita il 26 agosto 2026: conteggiato sui 478 problemi, ha risolto il 92,3% per $1,19 USD per attività risolta. Il grafico di quella sezione e i dati della sua tabella di Claude Opus 5.5 e Claude Sonnet 5.5 aggregano le due esecuzioni a ciascuna impostazione rappresentata, tutte conteggiate sui 478 problemi: Claude Opus 5.5 a `low`, `medium` e `high`, e Claude Sonnet 5.5 a `medium` e `high`. I dati di Claude Fable 5.2 sono un’esecuzione ciascuno a `low` e a `high` (il suo valore predefinito sulla Messages API), entrambe con lo stesso limite di 16.384 token per turno, che ha interrotto 8 dei 463 tentativi a `high` e nessuno a `low`; i tentativi interrotti contano come fallimenti. Un altro tentativo a `high` è stato fermato da un monitor di sicurezza nell’ambiente di valutazione prima di terminare e conta anch’esso come fallimento, sebbene le modifiche che aveva apportato fino a quel momento superassero i test; escluderlo darebbe il 96,5% per `high`. Quelle esecuzioni hanno usato una versione del benchmark i cui container di valutazione non hanno accesso alla rete. Dei 478 problemi usati per i confronti con Opus 5.5, la soluzione di riferimento fallisce senza accesso alla rete su 15, quindi i confronti con Fable 5.2 usano i restanti 463. In quei confronti, i dati di Claude Opus 5.5 sono le stesse esecuzioni conteggiate sui 463 problemi: due esecuzioni ciascuna a `medium` e `high`, e una a `xhigh`. I dati di Claude Fable 5.1 e Claude Opus 5.5 affiancati a essi sono stati valutati con accesso alla rete, quindi corrisponde solo l’insieme di problemi, non la configurazione di valutazione. I costi di Claude Fable 5.2 usano la misurazione descritta in Come sono stati calcolati i prezzi, applicata ai totali di token di ciascun tentativo anziché a ciascuna richiesta separatamente, quindi sono stime.
   * **Confronta i modelli, lavoro per attività:** In quei dati, Claude Opus 5.5 a `low` ha svolto meno lavoro su ciascuna attività rispetto a Claude Sonnet 5.5 al suo valore predefinito: poco più della metà dei token di output di Sonnet 5.5 e poco più di un terzo delle sue letture dalla cache. Ai rispettivi valori predefiniti, Opus 5.5 a `medium` ha risolto circa 5 punti percentuali in più di Sonnet 5.5 per circa il doppio del costo. A quell’impostazione ha svolto leggermente più lavoro per attività rispetto a Sonnet 5.5.
   * **Aggiorna il modello, esecuzioni:** Il punto di Claude Fable 5 in Aggiorna il modello aggrega tre esecuzioni all’effort predefinito, eseguite il 26 agosto 2026, con prezzi calcolati come viene misurato l’uso dell’organizzazione di un cliente. La scala degli aggiornamenti conteggia ogni modello sui 478 problemi, ciascuno con i valori predefiniti con cui è distribuito. Usa un’esecuzione per modello tranne Opus 5, Opus 5.5, Sonnet 5 e Sonnet 5.5 (due esecuzioni ciascuno) e Fable 5 (le tre esecuzioni descritte sopra). Le esecuzioni di Opus 4.7, Opus 4.8, Sonnet 4.6 e Sonnet 5 si sono svolte dal 17 al 19 agosto 2026, e quelle di Opus 5 il 4 agosto, tutte nello stesso harness e nella stessa organizzazione; le esecuzioni di Opus 5.5 e Sonnet 5.5 sono quelle descritte in precedenza in questo riferimento.
   * **Aggiorna il modello, costo per attività risolta:** Claude Opus 5 costa il 21% in più per attività risolta rispetto a Claude Opus 4.8 quando quelle esecuzioni di Claude Opus 5 vengono confrontate con un’esecuzione di Claude Opus 4.8 ai valori predefiniti con cui è distribuito, della serie dal 17 al 19 agosto, conteggiata sugli stessi 478 problemi; il pannello SWE-bench Pro del grafico non mostra né Claude Opus 4.7 né Claude Opus 4.8. Nelle stesse misurazioni, con prezzi calcolati come viene fatturato un cliente, Claude Opus 5 risolve 12 punti in più di attività rispetto a Claude Opus 4.8 a quel 21% in più per attività risolta, Claude Opus 4.8 risolve la stessa quota di attività di Claude Opus 4.7 per il 14% in meno per attività risolta, e Claude Opus 5 con effort `low` supera il valore predefinito di Claude Opus 4.8 su questo benchmark per circa il 30% del suo costo per attività risolta.
   * **Aggiorna il modello, prezzi:** Il risparmio di Claude Sonnet 5 rispetto a Claude Sonnet 4.6 in Aggiorna il modello deriva dal suo prezzo per token più basso, che compensa ampiamente i token aggiuntivi che usa per attività. Claude Sonnet 5.5 costa quanto Claude Sonnet 5 per tutto tranne le letture dalla cache, che costano la metà. I prezzi per token di Claude Opus 5.5 sono inferiori a quelli di Claude Opus 5, soprattutto per le letture dalla cache. Come Claude Sonnet 5, il livello di frontiera ha guadagnato grazie al prezzo: la maggior parte del risparmio di Claude Fable 5.1 è il prezzo più basso delle letture dalla cache.
   * **Costo senza cache, calcolato dai conteggi di token registrati:** Anthropic ha ricalcolato i prezzi dei conteggi di token registrati delle esecuzioni di Claude Opus 5.5 e Claude Sonnet 5.5, sui 478 problemi, per i fattori sulla cache in [Perché la cache viene prima](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#why-caching-comes-first).
   * **I fattori, per modello:** Ciascun fattore è il costo in token con ogni token di input al prezzo di input, token di output invariati, diviso per il costo calcolato come viene misurato l’uso dell’organizzazione di un cliente: per Claude Opus 5.5, 3,3 a `medium`, 2,4 a `low`, 3,8 a `high` e 5,4 a `xhigh` (un’esecuzione); per Claude Sonnet 5.5, con letture dalla cache a $0,10 USD per milione di token, 3,1 a `high` e 2,4 a `medium`, oppure 2,8 a `high` al prezzo di lancio di $0,20 USD. La prima richiesta di un’attività è calcolata come scrittura nella cache.

4. **BrowseComp:** Wei et al., “BrowseComp: A Simple Yet Challenging Benchmark for Browsing Agents,” OpenAI, 2025. I dati sull’effort usano un taglio di 500 problemi, da una a tre esecuzioni per impostazione, eseguite il 3 agosto 2026, con il punto predefinito che aggrega due esecuzioni dal 26 al 27 luglio 2026. La misurazione del lavoro di routine con una lunga coda di costo in [Strategia orchestratore](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#orchestrator-strategy-delegate-bulk-work) usa 10 problemi che il modello risolveva in modo affidabile da solo quando il protocollo è stato fissato, da una porzione di 26 problemi, 50 esecuzioni delegate (5 per problema; dal 1° al 2 agosto 2026) e 70 esecuzioni del modello da solo (50 dal 2 al 3 agosto 2026; 20 archiviate dal 12 al 13 luglio e del 1° agosto 2026), $6,45 USD rispetto a $11,99 USD per esecuzione in valore atteso; i dati delegati hanno una banda di misurazione di circa il 20%. I 10 problemi sono quelli su cui la configurazione delegata, un orchestratore Claude Fable 5 con un worker Claude Sonnet 5, ha risposto correttamente in tutte e 5 le esecuzioni e Claude Fable 5 da solo in entrambe le esecuzioni archiviate; le esecuzioni delegate sono quelle stesse esecuzioni, e solo Claude Fable 5 da solo è stato eseguito di nuovo sui dieci. Sulle sue 70 esecuzioni, archiviate e nuove, Claude Fable 5 da solo ha risposto correttamente in 68. Su quei problemi la configurazione delegata è costata in media circa la metà di Claude Fable 5 da solo (i $6,45 USD e $11,99 USD indicati in precedenza) e circa un terzo al 90° percentile ($12 USD rispetto a $33 USD per esecuzione), e la sua esecuzione più costosa è costata $42 USD rispetto a $84 USD; anche quell’esecuzione da $84 USD era errata. Sull’insieme BrowseComp completo e più difficile, Claude Fable 5 da solo ha raggiunto l’accuratezza della configurazione con orchestratore misurata su quell’insieme a un costo inferiore dal 22% al 30%.

5. **Scalabilità delle architetture di agenti:** Kim et al., “Towards a Science of Scaling Agent Systems,” arXiv:2512.08296, 2025. Studio esterno indipendente, citato solo per la direzione del risultato su quando la delega non conviene, non per alcun dato.

6. **DeepWideSearch:** “DeepWideSearch: Benchmarking Depth and Width in Agentic Information Seeking,” arXiv:2510.20168, 2025. Le 220 domande coprono 15 domini, ciascuna combinando la raccolta di molte righe con il recupero multi-hop; misurato sull’insieme di righe standard del benchmark, 3 esecuzioni per configurazione, eseguite il 2 agosto 2026 (il punto del team con un singolo worker è stato eseguito dal 26 al 27 luglio 2026). Con Claude Fable 5, l’effort `low` ha eguagliato un orchestratore con un worker Claude Sonnet 5 a un costo inferiore del 29%, e ha impiegato 4,5 minuti per problema, rispetto a 7,9 minuti con il valore predefinito.

7. **DeepResearch Bench II:** Li et al., “DeepResearch Bench II: Diagnosing Deep Research Agents via Rubrics from Expert Report,” arXiv:2601.08536, 2026.

   * **Cosa è stato misurato:** Le sue 132 attività di ricerca in 22 domini sono valutate rispetto a rubriche binarie derivate da esperti. Misurato il 3 novembre 2026, su un sottoinsieme di 50 attività tratto da tutti i suoi temi, metà in inglese e metà in cinese, un tentativo per attività, 3 esecuzioni per impostazione: Claude Sonnet 5.5 a `high`, Claude Opus 5.5 a `medium`, e Claude Fable 5.1 e Claude Fable 5.2 a `low`, `medium` e `high`. Ogni impostazione è stata eseguita sulla Messages API con il ragionamento adattivo, e i tre modelli rilasciati con i classificatori di sicurezza di produzione attivi. Claude Fable 5.2 è stato eseguito prima del suo rilascio, su 46 delle 50 attività, senza le quattro attività di biologia.
   * **Strumenti:** L’agente ha usato strumenti di ricerca e recupero che l’harness di valutazione ospita su un indice web di Anthropic senza nulla datato dopo il 17 marzo 2026, e non aveva una shell. Una query di ricerca oltre i 120 caratteri veniva troncata all’ultima parola intera, e l’agente ne era informato: dal 57% al 59% delle ricerche su Claude Fable 5.2, il 49% su Claude Sonnet 5.5, e dal 26% al 31% nelle altre impostazioni. All’interno di un’attività, le esecuzioni di Claude Fable 5.2 con più ricerche troncate non hanno ottenuto punteggi inferiori. Ulteriori esecuzioni di Claude Fable 5.2 e Claude Opus 5.5 sono seguite il 6 e il 7 novembre 2026, tre per modello in ciascuna di due serie. Lo strumento ha troncato le query più lunghe come in precedenza in una serie e le ha rifiutate nell’altra. Sulle 43 attività valutate in entrambe le serie, Claude Fable 5.2 a `high` ha ottenuto 0,9 punti in meno di Claude Opus 5.5 con il troncamento (intervallo al 95% da 1,0 in più a 2,7 in meno). Quell’intervallo include il divario di 1,9 punti misurato il 3 novembre, su 44 attività. Con il rifiuto ha ottenuto 1,9 punti in meno (da 0,0 a 3,7). Quel divario è stato di 1,0 punti più ampio che con il troncamento (da 0,8 più stretto a 2,8 più ampio), non una variazione misurabile. Circa un quarto dei recuperi ha restituito un errore. L’articolo di origine di ciascuna attività e l’articolo e il dataset del benchmark stesso sono stati esclusi tramite filtro.
   * **Come è stato assegnato il punteggio:** Claude Opus 4.6 fa da giudice secondo il protocollo di rubrica del benchmark; l’originale usa un giudice diverso, e un giudice Anthropic potrebbe favorire lo stile della casa. I punteggi sono medie sulle 44 attività a cui ogni impostazione ha risposto e che il giudice ha valutato completamente. Le altre sei: quattro attività di biologia a cui Claude Sonnet 5.5 ha risposto in ogni esecuzione, e su cui i classificatori di sicurezza hanno fermato ogni tentativo di Claude Fable 5.1 (36) e 11 dei 12 di Claude Opus 5.5; un’attività, una rassegna della ricerca sulla sicurezza informatica, su cui i classificatori hanno fermato un tentativo di Claude Fable 5.1 a `low` e due dei tre di Claude Fable 5.2 a `high`; e una su cui un controllo di sicurezza che Anthropic aggiunge alle proprie valutazioni ha fermato un tentativo di Claude Sonnet 5.5.
   * **Punteggi:** Sulle 44 attività, e su tutte le 50, con un tentativo rifiutato o fermato contato come 0 e un tentativo con risposta che il giudice non ha valutato completamente mantenuto al suo punteggio parziale: Claude Sonnet 5.5, 57,2% e 56,8%; Claude Opus 5.5, 59,6% e 54,6%; Claude Fable 5.1, 60,2% e 54,7% a `low`, 62,1% e 56,6% a `medium`, e 62,5% e 57,0% a `high`. Claude Fable 5.2, sulle 44 attività: 54,5% a `low`, 55,0% a `medium` e 57,7% a `high`. Differenze attività per attività sulle 44 attività, calcolate prima dell’arrotondamento, con intervalli al 95%: Claude Fable 5.1 a `high` rispetto a `low`, 2,3 punti (da 1,3 a 3,3); Claude Opus 5.5 rispetto a Claude Sonnet 5.5, 2,4 (da 1,0 a 3,8); Claude Fable 5.1 a `high` rispetto a Claude Opus 5.5, 2,8 (da 1,4 a 4,3), e rispetto a Claude Sonnet 5.5, 5,2 punti (da 4,0 a 6,5); Claude Fable 5.1 a `medium` rispetto a `low`, 1,9 (da 0,6 a 3,1); Claude Fable 5.2 a `high` rispetto a `low`, 3,3 (da 1,7 a 4,9), e a `medium` rispetto a `low`, 0,6 (da -0,6 a 1,8); Claude Fable 5.2 a `high` rispetto a Claude Sonnet 5.5, 0,5 (da -1,2 a 2,2), e rispetto a Claude Opus 5.5, -1,9 (da -3,6 a -0,2); Claude Fable 5.2 rispetto a Claude Fable 5.1, -5,8 (da -8,0 a -3,5) a `low`, -7,0 (da -9,3 a -4,8) a `medium` e -4,7 (da -6,4 a -3,1) a `high`. Su tutte le 50 attività: Claude Opus 5.5 rispetto a Claude Sonnet 5.5, -2,2 (da -7,6 a 3,2); Claude Fable 5.1 a `high` rispetto a Claude Sonnet 5.5, 0,2 (da -5,5 a 5,9).
   * **Come sono stati calcolati i prezzi:** Ciascun costo per attività è il costo dei token del modello stesso ai prezzi di listino, dai registri di utilizzo dei tentativi, su tutte le 50 attività e ogni tentativo, mediato sulle tre esecuzioni: $1,11 USD su Claude Sonnet 5.5, $1,61 USD su Claude Opus 5.5, e $3,55 USD, $4,44 USD e $5,69 USD su Claude Fable 5.1. I costi di Claude Fable 5.2 si riferiscono alle sue 46 attività: $1,49 USD, $2,16 USD e $4,82 USD; sulle stesse 46 attività le altre cinque impostazioni costano $1,13 USD, $1,69 USD, $3,85 USD, $4,82 USD e $6,18 USD. Sulle quattro attività di biologia, ogni tentativo di Claude Fable 5.1 è stato fermato alla sua prima richiesta, e i tentativi sono costati in media circa un centesimo su Claude Fable 5.1 e $0,74 USD su Claude Opus 5.5. Sulle sole 44 attività i costi sono $1,13 USD, $1,68 USD, $3,85 USD, $4,77 USD e $6,10 USD, e $1,50 USD, $2,20 USD e $4,86 USD su Claude Fable 5.2. I confronti di costo in [Confronta i modelli](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#compare-models-on-cost-per-task) (1,5, 4,3 e 2,9 volte; il 61%, il 54% e il 20% in meno di Claude Fable 5.1 a `low`, `medium` e `high`) e in [Regola l’effort](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#tune-effort) (3,2 volte) si riferiscono a quelle 44 attività, come i punteggi accanto a essi. I costi coprono solo i token del modello; gli strumenti dell’harness non aggiungono costi. L’agente ha effettuato da 12 a 33 ricerche per attività, inclusi i tentativi rifiutati.
   * **Grafici:** Il grafico sulla cache e il grafico sull’effort mostrano esecuzioni del 22 ottobre 2026 di Claude Fable 5.1, Claude Opus 5.5 e Claude Sonnet 5.5 agli stessi livelli di effort. Il grafico sulla cache ricalcola il prezzo delle richieste di quelle esecuzioni con ogni token di input alla tariffa senza cache. L’harness di valutazione ha impostato i breakpoint della cache.
   * **Comparabilità:** Questi punteggi non sono confrontabili con la classifica del benchmark.

8. **Benchmark interno di ricerca di difetti:**

   * **Cosa è stato misurato:** Interno ad Anthropic, per lavori più grandi di una finestra di contesto: un corpus di circa 22 milioni di token da 14 sorgenti di pacchetti Python pubblici, in 201 parti, con 130 difetti inseriti e valutazione deterministica. Dieci esecuzioni per configurazione, su [Claude Managed Agents](https://platform.claude.com/docs/it/managed-agents/overview): 51 delle 170 dal 27 al 29 ottobre 2026, 69 dal 2 al 3 novembre 2026 e le 50 di Claude Fable 5.2 dal 3 al 4 novembre 2026, prima del suo rilascio.
   * **Configurazioni:** Da solo, ciascun modello ha eseguito una sessione per parte, e ogni sessione riceveva i rilevamenti fatti fino a quel momento: Claude Fable 5.2, Claude Fable 5.1 e Claude Opus 5.5 a `low`, `medium` e `high`, e Claude Sonnet 5.5 e Claude Haiku 5.5 al valore predefinito di ciascun modello (`high` e `medium`). Con i subagent, Claude Fable 5.2, Claude Fable 5.1 o Claude Opus 5.5 è stato eseguito a `high` come orchestratore, tramite l’[orchestrazione multiagente](https://platform.claude.com/docs/it/managed-agents/multiagent-orchestration) (il tipo `multiagent_20261001`): un agente predefinito come subagent, all’effort predefinito del suo modello, chiamato una volta per ciascuna parte, fino a 25 alla volta, con disattivati sia gli agenti inline sia i workflow dinamici. Ogni configurazione si è conclusa con un’ulteriore sessione, senza subagent, che ha assemblato i rilevamenti. Il ragionamento è stato eseguito con il valore predefinito della piattaforma: attivo, con il modello che sceglie quando ragionare.
   * **Strumenti:** Ogni agente ha usato gli strumenti di shell e di file propri del benchmark, in una macchina virtuale isolata. Prima dell’avvio di qualsiasi agente, la valutazione ha rimosso da quella macchina le copie installate dei pacchetti del corpus e ha verificato che nessuna connessione da essa andasse a buon fine.
   * **Risultati:** F1 medio (campo di variazione) e costo medio per esecuzione. Claude Haiku 5.5 da solo: 0,577 (da 0,550 a 0,606), $25 USD. Claude Sonnet 5.5 da solo: 0,760 (da 0,669 a 0,788), $103 USD. Claude Opus 5.5 da solo a `low`: 0,489 (da 0,437 a 0,551), $38 USD; a `medium`: 0,827 (da 0,797 a 0,850), $200 USD; a `high`: 0,850 (da 0,829 a 0,876), $236 USD. Claude Fable 5.1 da solo a `low`: 0,829 (da 0,807 a 0,841), $527 USD; a `medium`: 0,839 (da 0,817 a 0,856), $603 USD; a `high`: 0,847 (da 0,829 a 0,861), $716 USD. Claude Fable 5.2 da solo a `low`: 0,866 (da 0,852 a 0,884), $357 USD; a `medium`: 0,877 (da 0,863 a 0,884), $378 USD; a `high`: 0,909 (da 0,896 a 0,925), $563 USD. Claude Opus 5.5 con subagent Claude Sonnet 5.5: 0,831 (da 0,814 a 0,850), $139 USD; con subagent Claude Haiku 5.5: 0,677 (da 0,640 a 0,718), $47 USD. Claude Fable 5.1 con subagent Claude Sonnet 5.5: 0,825 (da 0,812 a 0,858), $172 USD; con subagent Claude Haiku 5.5: 0,687 (da 0,660 a 0,723), $88 USD. Claude Fable 5.2 con subagent Claude Sonnet 5.5: 0,833 (da 0,795 a 0,856), $165 USD; con subagent Claude Haiku 5.5: 0,716 (da 0,683 a 0,773), $85 USD. Tra le configurazioni degli altri modelli che superano 0,80, i campi di variazione di ogni coppia si sovrappongono. Differenze di F1 medio, con intervalli al 95%: Claude Opus 5.5 con subagent Claude Sonnet 5.5 ha ottenuto 0,4 punti in più di Claude Opus 5.5 da solo a `medium` (da 1,1 in meno a 1,9 in più), 1,9 in meno che da solo a `high` (da 0,6 a 3,2) e 7,1 in più di Claude Sonnet 5.5 da solo (da 4,6 a 9,7). Da solo, Claude Opus 5.5 ha ottenuto 2,3 punti in più a `high` che a `medium` (da 0,7 a 3,9). Claude Fable 5.1 da solo ha ottenuto 1,8 punti in meno a `low` che a `high` (da 0,8 a 2,8); a `high` ha ottenuto 2,0 punti in più di Claude Opus 5.5 da solo a `medium` (da 0,7 a 3,4) e 0,3 in meno di Claude Opus 5.5 da solo a `high` (da 1,5 in meno a 1,0 in più). Con subagent Claude Sonnet 5.5, Claude Fable 5.1 ha ottenuto 0,6 punti in meno di Claude Opus 5.5 (da 1,9 in meno a 0,6 in più). Rispetto a Claude Opus 5.5 da solo a `medium` e a `high`, Claude Fable 5.2 da solo ha ottenuto un punteggio più alto a ciascun livello, differenze calcolate prima dell’arrotondamento: a `low`, di 3,9 punti (da 2,4 a 5,3) e 1,6 (da 0,3 a 2,9), per 1,8 e 1,5 volte il costo; a `medium`, di 5,0 (da 3,6 a 6,3) e 2,7 (da 1,5 a 3,8), per 1,9 e 1,6 volte; a `high`, di 8,2 (da 6,8 a 9,6) e 5,9 (da 4,7 a 7,1), per 2,8 e 2,4 volte. Ha ottenuto un punteggio più alto di Claude Fable 5.1 da solo allo stesso livello: di 3,6 punti a `low` (da 2,6 a 4,7), 3,8 a `medium` (da 2,8 a 4,8) e 6,1 a `high` (da 5,3 a 7,0), per il 32%, il 37% e il 21% in meno. Ha ottenuto 4,3 punti in meno a `low` che a `high` (da 3,3 a 5,3), per il 37% in meno. Con subagent Claude Sonnet 5.5, Claude Fable 5.2 ha ottenuto 0,2 punti in più di Claude Opus 5.5 (da 1,3 in meno a 1,7 in più), per il 19% in più, e 3,2 punti in meno di Claude Fable 5.2 da solo a `low` (da 1,8 a 4,7), 4,3 in meno che a `medium` (da 3,0 a 5,7) e 7,5 in meno che a `high` (da 6,1 a 9,0), per il 54%, il 56% e il 71% in meno. Un’esecuzione di Claude Fable 5.2 da solo a `high` è terminata in anticipo, senza punteggio, ed è stata sostituita. L’abbinamento di Claude Opus 5.5 è costato il 31% in meno di Claude Opus 5.5 da solo a `medium` e il 41% in meno di Claude Opus 5.5 da solo a `high`. Da solo, Claude Opus 5.5 è costato il 15% in meno a `medium` che a `high`. Tutte e sette le esecuzioni di novembre di Claude Sonnet 5.5 da solo hanno ottenuto un punteggio inferiore alle tre di ottobre (da 0,669 a 0,775, rispetto ai valori da 0,783 a 0,788); la causa non è nota, e ogni esecuzione è conteggiata. Claude Fable 5.1 con subagent Claude Haiku 5.5 è costato $85,77 USD per esecuzione a ottobre e $89,06 USD a novembre.
   * **Come sono stati calcolati i prezzi:** Il costo delle sessioni di ciascuna esecuzione ai prezzi di listino della piattaforma: token con cache dei prompt, più il tempo di esecuzione della sessione. Per cinque delle esecuzioni di Claude Opus 5.5 a `high`, il prezzo è calcolato solo in base al numero di token, ai prezzi della cache a 5 minuti, perché ciascuna è stata eseguita in parte con la durata della cache di 1 ora, con la quale le scritture in cache costano di più. Il prezzo dei token propri di Claude Fable 5.2 è calcolato in base al loro numero, ai prezzi di listino con scritture nella cache a 5 minuti; nelle sue esecuzioni da solo, il tempo di esecuzione delle sue sessioni, meno dello 0,2% del costo di un’esecuzione, non è incluso. Il costo di un controllo aggiuntivo sulle chiamate agli strumenti, parte della configurazione di sicurezza della valutazione, non è incluso.

9. **GPQA Diamond:** Rein et al., “GPQA: A Graduate-Level Google-Proof Q\&A Benchmark,” 2023. Il sottoinsieme Diamond di 198 domande, valutato da un modello rispetto alle risposte di riferimento, con i token dell’advisor misurati per richiesta. Claude Haiku 5.5 e Claude Sonnet 5.5, ciascuno da solo e con un advisor Claude Opus 5.5, e Claude Opus 5.5 da solo hanno eseguito due esecuzioni per configurazione il 7 ottobre 2026, tutte con il [fallback lato server](https://platform.claude.com/docs/it/build-with-claude/refusals-and-fallback#server-side-fallback) disattivato, all’effort predefinito di ciascun modello, e con i rifiuti conteggiati come errori. Un controllo di sicurezza della piattaforma ha rifiutato una domanda di biologia per esecuzione su Claude Haiku 5.5 e Claude Sonnet 5.5 da soli, una in due esecuzioni su Haiku 5.5 con l’advisor, nessuna su Sonnet 5.5 con l’advisor, e sei per esecuzione su Opus 5.5, che ha ottenuto il 91% con queste conteggiate come errori e il 93,5% sulle domande a cui ha risposto. Claude Haiku 5.5 da solo ha ottenuto l’85%, 6 punti sotto Opus 5.5. Le configurazioni con advisor hanno aggiunto lo strumento senza un prompt che chiedesse consultazioni, e nessuno dei due esecutori ha chiamato l’advisor su alcuna domanda. Gli abbinamenti hanno ottenuto 0,5 punti (Claude Haiku 5.5) e 1,0 punti (Claude Sonnet 5.5) in più rispetto all’esecutore da solo, entrambi entro il rumore tra esecuzioni.

10. **DeepSWE:** Datacurve, “DeepSWE: Measuring Frontier Coding Agents on Original, Long-Horizon Engineering Tasks,” arXiv:2607.07946, 2026. L’insieme ha 113 attività originali in cinque linguaggi con verificatori basati su programmi. Gli abbinamenti sono due esecuzioni ciascuno, eseguite il 7 agosto 2026, con i token dell’advisor misurati per richiesta, e hanno usato un ciclo advisor lato client anziché lo strumento advisor, con contabilità identica. Le variazioni di effort a modello singolo sono esecuzioni singole con prezzi calcolati dai conteggi di token, un’approssimazione che tiene conto della cache. I costi per attività sono i totali delle esecuzioni divisi per 113. Su questo benchmark un esecutore Claude Sonnet 5 a effort basso con un advisor ha ottenuto 23 punti in più dello stesso esecutore da solo.

11. **Benchmark interno di coding agentico:**

    * **Cosa è stato misurato:** Interno ad Anthropic: 370 attività su repository valutate dai test dei repository stessi. I dati API sono stati misurati con un semplice agente API e un limite di output di 128.000 token, un’esecuzione per configurazione: Opus 5 da solo all’effort predefinito dal 9 al 10 agosto 2026, e a `low` e `medium` il 10 agosto 2026; Claude Fable 5.1 da solo a cinque valori di effort impostati esplicitamente il 20 agosto 2026 (il grafico ne mostra tre); e l’abbinamento dal 24 al 25 agosto 2026.
    * **Esecuzioni di agosto:** Le esecuzioni di agosto avevano cinque tentativi per attività per l’abbinamento e per il controllo Claude Opus 5 e uno per gli altri punti.
    * **Come sono stati calcolati i prezzi:** I costi sono per tentativo. I costi sono calcolati come viene misurato l’uso dell’organizzazione di un cliente: il prompt precedente di ciascuna richiesta del ciclo dell’agente come lettura dalla cache e i suoi nuovi token come scrittura nella cache a 5 minuti, dai registri di utilizzo delle esecuzioni stesse, e ciascuna chiamata all’advisor, che non usa la cache, dai suoi token registrati, tutto ai prezzi di listino.
    * **Claude Opus 5.5 da solo:** Claude Opus 5.5 da solo è stato eseguito su tutte le 370 attività, dal 19 al 20 settembre 2026: al suo effort predefinito (`medium`) e a `high` con cinque tentativi per attività, e a `low` e `xhigh` con uno (369 su 370 valutate per ciascuno, dopo un fallimento del controllo di configurazione). Claude Opus 5.5 da solo ha risolto il 74,8% dei tentativi a `low` per $0,35 USD per tentativo, l’86,6% a `medium` per $0,84 USD, l’88,4% a `high` per $1,38 USD e il 91,1% a `xhigh` per $4,11 USD.
    * **Claude Opus 5.5 con un advisor Claude Fable 5.1, esecuzioni:** L’esecutore Claude Opus 5.5 a `high` con il Claude Fable 5.1 rilasciato come advisor (le esecuzioni di agosto usavano uno snapshot pre-release) ha eseguito cinque tentativi per attività nelle stesse date; un’attività non ha superato il controllo di configurazione, quindi sono stati valutati 1.845 tentativi. I 279 tentativi in cui l’advisor è stato respinto per carico sono stati rieseguiti, e i tentativi le cui consultazioni sono andate in timeout sono stati mantenuti, come ad agosto.
    * **Claude Fable 5.1 e Claude Fable 5.2 da solo:** Per confronto, il Claude Fable 5.1 rilasciato da solo a `high`, il suo valore predefinito, ha ottenuto l’85,7% (317 attività su 370), un tentativo per attività il 7 ottobre 2026. Claude Fable 5.2 da solo è stato eseguito su tutte le 370 attività, un tentativo per attività a `low`, `medium` e `high` (369 su 370 valutate a `medium`, dopo un fallimento del controllo di configurazione).
    * **Consultazioni:** L’abbinamento di agosto ha registrato in media circa due consultazioni dell’advisor per tentativo; l’abbinamento con Claude Opus 5.5 ne ha richieste 1,39 e ricevute 1,35.
    * **Claude Opus 5.5 con un advisor Claude Fable 5.1, risultati:** L’abbinamento con Claude Opus 5.5 ha ottenuto il 90,1% a $2,92 USD per tentativo: rispetto a Claude Opus 5.5 al suo valore predefinito, `medium`, si tratta di 3,5 punti per circa 3,5 volte la spesa. Il costo in latenza sono le consultazioni stesse: circa una o due chiamate aggiuntive a un modello di frontiera per attività, ciascuna sul percorso critico dell’attività. Con l’esecutore Claude Opus 5.5, i consigli non hanno fatto risparmiare quasi nulla sul costo dell’esecutore: $1,36 USD per tentativo rispetto a $1,38 USD per Claude Opus 5.5 da solo a `high`, mentre le consultazioni sono costate $1,55 USD.
    * **Abbinamento di agosto:** Ad agosto, con un esecutore Claude Opus 5 e un advisor Claude Fable 5.1, l’esecutore ha speso $1,26 USD in meno per tentativo rispetto a Claude Opus 5 da solo al suo valore predefinito, e le consultazioni sono costate $2,47 USD, quindi quel risparmio ha coperto circa la metà dei consigli. Quell’abbinamento di agosto era la configurazione più accurata misurata all’epoca, a $6,21 USD per tentativo.
    * **Claude Sonnet 5.5 da solo, esecuzioni:** Claude Sonnet 5.5 da solo è stato eseguito su tutte le 370 attività il 24 settembre 2026, al suo effort predefinito (`high`) e a `medium`, un tentativo per attività, con lo stesso limite di output di 128.000 token, che non ha interrotto nessuno dei suoi tentativi. Tutte le 370 sono state valutate a `medium`, e 369 su 370 a `high`, dopo un fallimento del controllo di configurazione. I suoi costi sono calcolati come viene misurato l’uso dell’organizzazione di un cliente.
    * **Claude Sonnet 5.5 da solo, risultati:** Senza advisor, Claude Sonnet 5.5 ha ottenuto il 77,8% al suo valore predefinito, `high`, per $0,33 USD per tentativo, circa 9 punti sotto Claude Opus 5.5 al suo valore predefinito per circa due quinti del costo; a `medium`, ha ottenuto il 62,7% per $0,16 USD. A `medium`, Claude Sonnet 5.5 ha ottenuto circa 15 punti in meno rispetto al suo valore predefinito, `high`, per circa il 48% del costo per tentativo.
    * **Confronta i modelli:** In [Confronta i modelli](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#compare-models-on-cost-per-task), Claude Opus 5.5 al suo valore predefinito costa per tentativo meno di due terzi di Claude Fable 5.2 a `medium`, che è un’esecuzione singola. Con `low`, Fable 5.2 ha ottenuto anch’esso l’88,9%, per $1,05 USD per tentativo. Con `high`, il suo valore predefinito sulla Messages API, ha ottenuto il 93,5% per $5,39 USD per tentativo.

12. **Benchmark interno di attività su repository (misurazione del limite):**

    * **Cosa è stato misurato:** Un insieme separato interno ad Anthropic di circa 130 attività su repository, eseguito il 20 agosto 2026 (Claude Fable 5.1) e il 19 settembre 2026 (Claude Opus 5.5, al suo effort predefinito, `medium`), con un semplice ciclo di agente API, un tentativo per attività. Le esecuzioni di Claude Fable 5.2 hanno usato lo stesso ciclo, un tentativo per attività; in esse, come nelle esecuzioni di Claude Opus 5.5, un turno che raggiungeva il limite terminava il suo tentativo.
    * **Come sono stati calcolati i prezzi:** Il costo per attività risolta è calcolato come viene fatturato un cliente, con una cache dei prompt a 5 minuti, per Claude Fable 5.1, e ai prezzi di listino dai conteggi di token registrati nelle sue esecuzioni per Claude Opus 5.5.
    * **Esecuzioni di Claude Fable 5.1 e Claude Fable 5.2:** Le esecuzioni di Claude Fable 5.1 sono 135 attività per limite all’effort predefinito impostato esplicitamente. Le esecuzioni di Claude Fable 5.2 sono 134 attività per limite a `high`, il suo valore predefinito sulla Messages API, impostato esplicitamente; un’attività è stata ritirata dall’insieme dopo le esecuzioni di Claude Fable 5.1 e Claude Opus 5.5. Un’ulteriore attività non ha superato il controllo della soluzione di riferimento del benchmark stesso prima dell’avvio del modello, in ogni esecuzione, quindi è esclusa e vengono valutate 133 attività per limite. Il dato a 16.384 token è la media di due esecuzioni (19,5% e 21,1%); i dati a 64.000 e 128.000 sono esecuzioni singole (77,4% e 78,2%). A 64.000, un’attività non ha superato quel controllo alla prima esecuzione ed è stata eseguita di nuovo; ha superato il controllo ed è valutata. Nessun tentativo di Fable 5.2 a 16.384 o 64.000 ha ricevuto un rifiuto di sicurezza. A 128.000, un tentativo ha ricevuto un rifiuto di sicurezza e uno è stato fermato da un monitor di sicurezza nell’ambiente di valutazione prima di terminare; entrambi contano come fallimenti. Le modifiche che il tentativo fermato aveva apportato fino a quel momento superavano i test; escluderlo darebbe il 78,8% a 128.000. I costi di Claude Fable 5.2 e Claude Opus 5.5 nella tabella calcolano il prezzo dell’utilizzo di token registrato di ciascun tentativo ai prezzi di listino del modello. I risultati dei due modelli sono stati valutati da versioni diverse del codice di valutazione del benchmark.
    * **Esecuzioni di Claude Opus 5.5:** Il dato di Claude Opus 5.5 a 16.384 token è la media di due esecuzioni (134 e 135 attività valutate), e i suoi dati a 64.000 e 128.000 sono esecuzioni singole (135 attività ciascuna); due tentativi in ciascuna esecuzione a 16.384 token e uno in ciascuna delle esecuzioni a 64.000 e 128.000 token si sono conclusi con un rifiuto di sicurezza e contano come fallimenti. Claude Opus 5.5 ha risolto il 57,6% a 16.384 (58,2% e 57,0%), il 75,6% a 64.000 e il 68,9% a 128.000. Nessuno dei suoi tentativi è stato interrotto a 64.000 o 128.000, quindi il limite non spiega la differenza tra quelle due esecuzioni.
    * **Tentativi terminati dal limite:** Solo 1 dei 66 tentativi di Claude Opus 5.5 terminati dal limite di 16.384 token, e 9 dei 117 tentativi di Claude Fable 5.1, hanno comunque superato i test. Lo stesso vale per 20 dei 226 tentativi di Claude Fable 5.2.
    * **Costo per tentativo:** Il costo per tentativo è stato di $3 USD a 16.384 e $4 USD a 64.000 per Claude Opus 5.5, ai prezzi di listino, e di $8 USD e $13 USD per Claude Fable 5.1, come viene fatturato un cliente. Per Claude Fable 5.2 è stato di $6 USD e $19 USD, ai prezzi di listino.
    * **Dati sul limite di SWE-bench Pro:** I dati sul limite di SWE-bench Pro sono un’esecuzione di Claude Fable 5.1 per limite all’effort predefinito, eseguita il 26 agosto 2026, su un sottoinsieme di 100 problemi stratificato dall’insieme di 482 problemi del riferimento 3, non confrontabile con i suoi punteggi; all’effort predefinito le esecuzioni a 16.384 e a 64.000 hanno risolto ciascuna 94 dei 100 problemi.
    * **Lunghezza dei turni:** Le distribuzioni per turno nel grafico a punti della sezione provengono dalle esecuzioni di Claude Opus 5.5 e Claude Fable 5.1 a 128.000: nessun turno di Opus 5.5 ha raggiunto il limite (il più lungo era di circa 61.000 token, e lo 0,56% dei suoi turni ha superato 16.384), e un turno di Fable 5.1 ha raggiunto 128.000 (lo 0,46% dei suoi turni ha superato 16.384). Con il limite a 128.000, 2 dei 14.331 turni di Claude Fable 5.1 erano più lunghi di 64.000 token, e nessun turno di Claude Opus 5.5 lo era. Con il limite a 128.000, 303 dei 17.750 turni di Claude Fable 5.2 (1,7%) erano più lunghi di 16.384 token e 7 erano più lunghi di 64.000, contando i turni dei tentativi annullati ed eseguiti di nuovo.

13. **Chartography:** Surge AI, “Chartography,” 2026.

    * **Cosa è stato misurato:** L’insieme completo rilasciato di 100 domande, misurato il 6 e il 9 agosto 2026 (Claude Opus 5 da solo) e il 20 settembre 2026 (Claude Opus 5.5), con l’implementazione di Anthropic su Claude Managed Agents (sandbox cloud standard; le configurazioni con advisor usano l’advisor di Managed Agents).
    * **Come è stato assegnato il punteggio:** Claude Sonnet 4.6 valuta al posto del giudice di riferimento e il benchmark viene eseguito con strumenti, quindi i punteggi sono confrontabili tra configurazioni qui ma non con la classifica pubblicata. Non sono confrontabili nemmeno con i risultati di Chartography nella system card di Claude Opus 5.5, che usano un valutatore diverso e vengono eseguiti con effort `max`. Due esecuzioni per configurazione (tre per Claude Opus 5.5), aggregate; le differenze tra esecuzioni arrivavano fino a 10 punti.
    * **Come sono stati calcolati i prezzi:** I costi sono ciò che viene fatturato a un cliente che esegue l’agente abitualmente: la prima richiesta di ciascun grafico legge dalla cache il prompt di sistema e gli strumenti condivisi dell’agente, come accade quando un’altra sessione dello stesso agente è stata eseguita nei 5 minuti precedenti. Un grafico eseguito da solo costa circa $0,03 USD in più con Claude Opus 5 o Claude Opus 5.5 e circa $0,12 USD in più con Claude Fable 5.1. I dati di agosto sono ricalcolati in questo modo dai registri di utilizzo delle esecuzioni. I costi escludono il tempo della sandbox, che ha aggiunto meno dell’1% alle esecuzioni di agosto.
    * **Claude Fable 5.1 da solo, esecuzioni di agosto:** Le esecuzioni di Claude Fable 5.1 da solo sono del 24 agosto 2026, con le impostazioni di servizio di lancio della piattaforma, due esecuzioni per impostazione; sei tentativi hanno raggiunto il limite di sessione di 15 minuti e ottengono 0, e a due grafici per esecuzione ha risposto Claude Opus 5 dopo un rifiuto di sicurezza.
    * **Claude Opus 5 con un advisor Claude Fable 5.1:** L’esecutore Claude Opus 5 a effort basso con un advisor Claude Fable 5.1 è stato eseguito due volte il 30 agosto 2026, con le stesse impostazioni (63,0 e 67,0, media 65,0, a $0,47 USD per grafico; l’advisor è stato consultato sull’88% delle attività in ciascuna esecuzione, e 4 delle sue 219 risposte sono arrivate invece da Claude Opus 5, ciascuna dopo che un filtro di sicurezza di produzione aveva fermato la risposta dell’advisor stesso). Quell’abbinamento ha eguagliato Claude Fable 5.1 da solo a `medium` entro il rumore tra esecuzioni (65,0 rispetto a 67,5) a circa 1,8 volte il costo per attività: una consultazione che scatta sulla maggior parte delle attività costa più che eseguire direttamente il modello più potente.
    * **Esecuzioni di Claude Opus 5.5:** Claude Opus 5.5 è stato eseguito a `low`, con il fallback lato server disattivato e un classificatore di sicurezza che valutava ogni chiamata a strumento: tre esecuzioni da solo (70, 68 e 68) e tre con un advisor Claude Fable 5.1 configurato (59, 63 e 63), in cui ha consultato l’advisor su 1 attività su 300.
    * **Risultati con effort `low`:** Su questo benchmark di lettura di grafici, Claude Opus 5.5 a `low` ha ottenuto 68,7 per circa $0,03 USD per grafico, contro 62,5 per $0,15 USD di Claude Fable 5.1 a `low` e 49 per $0,16 USD di Claude Opus 5 a `low`.
    * **Claude Fable 5.1 da solo, esecuzioni di ottobre:** Per il confronto con l’abbinamento di Claude Opus 5.5, Claude Fable 5.1 da solo a `high`, il suo valore predefinito, è stato eseguito tre volte il 7 ottobre 2026, con la stessa implementazione e le stesse impostazioni della piattaforma delle esecuzioni di Claude Opus 5.5: 82, 79 e 79, una media di 80,0.
    * **Tasso di consultazione:** Il confronto del tasso di consultazione per gli abbinamenti precedenti deriva dalla riesecuzione delle stesse configurazioni sulla Messages API con un set di strumenti container, dal 10 all’11 agosto 2026.

14. **Valutazione della revisione dei prompt per l’help desk di supporto:**

    * **Cosa è stato misurato:** Un insieme costruito da Anthropic di 44 ticket di supporto con valutazione deterministica, eseguito all’inizio di agosto 2026 e riportato l’8 agosto 2026, con sei prompt di sistema, ciascuno dei quali aggiunge allo stesso prompt pulito un pattern comune nei prompt scritti per Claude Opus 4.8 e Claude Sonnet 4.6.
    * **Il grafico:** Ciascun punto del grafico è uno di tre casi (modello precedente, modello più recente sullo stesso prompt, modello più recente dopo la revisione) mediato sui sei prompt e sui 44 ticket.
    * **Risultati, Claude Opus 5:** Su Claude Opus 5, i prompt scritti per Claude Opus 4.8 sono costati il 36% in più per ticket rispetto a Claude Opus 4.8, senza variazioni di accuratezza. Dopo la revisione sono costati il 14% in meno su Claude Opus 5 rispetto a prima (dalle medie non arrotondate; i costi arrotondati del grafico, 3,43 e 2,93 centesimi di dollaro USA per ticket, danno il 14,6%), e Claude Opus 5 ha risolto correttamente il 97% dei ticket, rispetto al 92%. Per pattern, su Claude Opus 5: rimuovere “verifica due volte” ha ridotto il costo per ticket di un terzo, e rimuovere “sii il più accurato possibile” lo ha ridotto quasi altrettanto; rimuovere l’impostazione di ragionamento ritirata, le regole contraddittorie e lo scratchpad fatto a mano ha ripristinato ciascuno da 7 a 11 punti di accuratezza.
    * **Risultati, Claude Sonnet 5:** Nella migrazione da Claude Sonnet 4.6 a Claude Sonnet 5, la revisione ha ridotto del 14% il costo per ticket a parità di accuratezza.
    * **Avvertenze:** Il guadagno di accuratezza di Opus 5 ha un intervallo di confidenza al 95% da 3 a 8 punti; le differenze di accuratezza di Sonnet rientrano nel rumore.

15. **Insieme di domande su file di dati:** Un insieme costruito da Anthropic di 25 domande aggregate su una porzione di 1.862 righe di un CSV pubblico sulle vendite di liquori, con verità di riferimento calcolata con pandas e valutazione a corrispondenza esatta, eseguito su Claude Sonnet 5 e Claude Opus 5 con il ragionamento disattivato (il ramo in contesto non può completare con il valore predefinito), un limite di output di 4.000 token e nessuna cache dei prompt, tre esecuzioni per configurazione, eseguite il 19 agosto 2026. Il ramo con file carica il CSV tramite la Files API e usa lo strumento `code_execution_20260120`. Le tre esecuzioni di Claude Sonnet 5 del ramo in contesto hanno risposto correttamente a 6, 7 e 7 delle 25 domande; l’etichetta del grafico e il testo riportano la loro media, 6,67, arrotondata alla domanda più vicina, e il punto del grafico è disegnato alla media, 26,7%.

16. **Misurazione della durata della cache:**

    * **Cosa è stato misurato:** Il job di triage di 20 issue da [Taglia i token di input e di contesto](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#trim-input-and-context-tokens), eseguito su Claude Sonnet 5 il 23 agosto 2026, e su Claude Opus 5.5 il 19 e 20 settembre 2026, al suo effort predefinito (`medium`) e a `high`, sulla Messages API con lo stesso harness (per Claude Opus 5.5, un suo porting che invia gli stessi corpi di richiesta), le celle di Claude Opus 5.5 con `max_tokens` aumentato a 4.096, con pause inserite prima di una quota di turni scelta casualmente (nessuna, 5%, 10% e ogni turno a 6 minuti su tutte le 20 issue su entrambi i modelli, più ogni turno a 2 minuti su Claude Sonnet 5; pause di 20 e 45 minuti su un sottoinsieme di 5 issue su entrambi i modelli). I dati di Claude Opus 5.5 in questa pagina coprono entrambi i livelli di effort.
    * **Altri modelli e date:** I dati sul keep-alive di Claude Opus 5 riportati di seguito provengono dallo stesso job il 23 agosto 2026, con `max_tokens` aumentato a 4.096, con le stesse pianificazioni tranne le pause di 2 e 45 minuti. Claude Sonnet 5.5 ha eseguito la stessa misurazione di Claude Sonnet 5 (le stesse pianificazioni delle pause e le tre impostazioni della cache, tre esecuzioni per cella), con l’harness portato usato per Claude Opus 5.5, al suo effort predefinito, `high`, il 24 settembre 2026.
    * **Come sono stati assegnati punteggi e prezzi:** Tre esecuzioni per cella, costo calcolato dai campi `usage` di ciascuna risposta ai prezzi di listino (per Claude Opus 5.5, $4 USD input, $5 USD scrittura a 5 minuti, $8 USD scrittura a 1 ora, $0,20 USD lettura dalla cache e $20 USD output per milione di token; Claude Sonnet 5 è stato eseguito su un’organizzazione interna ad Anthropic il cui utilizzo è misurato allo stesso modo di quello di un’organizzazione cliente), accuratezza rispetto alle stesse etichette di riferimento.
    * **Come è stato eseguito e calcolato il prezzo, Claude Sonnet 5.5:** Claude Sonnet 5.5 ha impostato `max_tokens` a 4.096 nelle richieste di sessione e a 1 nelle richieste keep-alive, è stato eseguito su un’organizzazione interna ad Anthropic il cui utilizzo è misurato allo stesso modo di quello di un’organizzazione cliente, e i suoi prezzi sono calcolati ai prezzi di listino attuali ($2 USD input, $2,50 USD scrittura a 5 minuti, $4 USD scrittura a 1 ora, $0,10 USD lettura dalla cache e $10 USD output per milione di token). A parte il `max_tokens` più alto, che nessun turno ha raggiunto, un input differisce dalle esecuzioni di Claude Sonnet 5: l’unica GIF animata del job è stata inviata come PNG del suo primo fotogramma, l’unico fotogramma che l’API usa ([Visione](https://platform.claude.com/docs/it/build-with-claude/vision)), e le due contano come lo stesso numero di token di input.
    * **Punto di pareggio:** Il punto di pareggio è circa il 3,3% dei turni su Claude Sonnet 5 e dal 3,1% al 3,2% su Claude Opus 5.5: la mediana della quota di pareggio di ciascuna sessione, calcolata dal modello di costo a partire dalle dimensioni del contesto turno per turno di quella sessione, su tutte le 45 sessioni da venti issue di Claude Sonnet 5 e le 36 sessioni da venti issue di Claude Opus 5.5 a ciascun livello di effort (ogni pianificazione delle pause eseguita sul job completo, con tutte e tre le impostazioni della cache, tre esecuzioni ciascuna; le celle da 5 issue non sono incluse). Il punto di pareggio su Claude Sonnet 5.5 è circa il 3,1% dei turni, la mediana sulle sue 45 sessioni da venti issue. Il grafico sulla durata della cache rappresenta queste sessioni di Claude Sonnet 5.5, tre per punto.
    * **Impostazioni a 5 minuti e a 1 ora, Claude Sonnet 5 e Claude Opus 5.5:** Nella cella al 5% le impostazioni a 5 minuti e a 1 ora si sono equivalse su Claude Sonnet 5, perché le pause di quell’estrazione sono cadute su prefissi piccoli; su Claude Opus 5.5 si sono quasi equivalse. Su Claude Sonnet 5, al suo prezzo di lettura dalla cache di $0,20 USD per milione di token, una sessione è costata $0,60 USD, $0,69 USD e $0,99 USD con l’impostazione a 5 minuti senza pause, con il 5% e con il 10% dei turni in pausa, e $0,70 USD, $0,70 USD e $0,71 USD con l’impostazione a 1 ora.
    * **Richieste keep-alive, Claude Sonnet 5 e Claude Opus 5:** Anthropic ha misurato le richieste keep-alive che aggiornano la cache a 5 minuti su Claude Sonnet 5 e Claude Opus 5 il 23 agosto 2026, e su Claude Opus 5.5 nelle esecuzioni sopra, sempre inviate con `max_tokens: 1`. Su Claude Sonnet 5 sono costate il 7,7% in meno dell’impostazione a 1 ora con il 5% dei turni in pausa e circa lo stesso con il 10%; su Claude Opus 5 nessuna differenza era misurabile a nessuna delle due quote; su entrambi sono costate di più con una pausa di 6 minuti o più prima di ogni turno. Quindi su quei due modelli l’impostazione da usare è la durata di 1 ora, non le richieste keep-alive.
    * **Richieste keep-alive, Claude Opus 5.5:** Su Claude Opus 5.5 le richieste keep-alive sono costate dall’8% al 18% in meno dell’impostazione a 1 ora con il 5% e il 10% dei turni in pausa (dall’8% al 13% in meno al suo effort predefinito, `medium`, e dal 10% al 18% in meno a `high`; circa dal 10% al 15% una volta rimosso il rumore tra sessioni rifatturando i token di ciascuna sessione keep-alive ai prezzi della cache a 1 ora), e di più con una pausa prima di ogni turno: dal 4% al 6% in più a 6 minuti, dal 9% al 10% a 20 minuti e dal 56% al 58% a 45 minuti.
    * **Richieste con `max_tokens: 0`:** Misurato il 20 ottobre 2026, su Claude Fable 5.1, Claude Opus 5.5, Claude Sonnet 5.5 e Claude Haiku 5.5, tre volte per modello, su un prompt di sistema di 10.000 token con la cache a 5 minuti. Una richiesta con `max_tokens: 0` inviata 4 minuti dopo la scrittura della cache non ha restituito alcun output, ha letto l’intera voce e non ha scritto nulla. Una richiesta 4 minuti dopo, 8 minuti dopo la scrittura, ha ancora letto l’intera voce. Senza la richiesta con `max_tokens: 0`, la richiesta a 8 minuti non ha letto nulla e ha scritto di nuovo il prefisso, in tutte e 12 le volte.
    * **Impostazioni a 5 minuti e a 1 ora, Claude Sonnet 5.5:** Con il 5% dei turni in pausa l’impostazione a 5 minuti è costata in media il 5% in più dell’impostazione a 1 ora (dal 2% in meno al 12% in più nelle tre esecuzioni), il che rientra nella variazione tra esecuzioni: le pause di quell’estrazione sono cadute su prefissi piccoli, come su Claude Sonnet 5, e rifatturare i token di ciascuna sessione a 5 minuti ai prezzi della cache a 1 ora dà circa l’1% in più. Con il 10% in pausa è costata il 54% in più (dal 36% al 73% in più). Senza pause, l’impostazione a 5 minuti è costata in media il 19% in meno dell’impostazione a 1 ora (dal 3% al 32% in meno nelle tre esecuzioni; il prezzo di scrittura più alto dell’impostazione a 1 ora prevede circa il 20%), e dal 21% al 24% in meno in ogni esecuzione con pause di 2 minuti.
    * **Richieste keep-alive, Claude Sonnet 5.5:** Le richieste keep-alive sono costate in media il 16% in meno dell’impostazione a 1 ora con il 5% dei turni in pausa (dal 13% al 20% in meno nelle tre esecuzioni) e l’8% in meno con il 10% (dal 3% al 10% in meno), e sono costate di più con una pausa di 6 minuti o più prima di ogni turno. Con il 5% e il 10% dei turni in pausa, le pause sono durate da 6 a 32 minuti su Claude Sonnet 5.5 e su Claude Opus 5.5. Rifatturare i token di ciascuna sessione keep-alive ai prezzi della cache a 1 ora, come per Claude Opus 5.5 sopra, dà dal 15% al 16% in meno al 5% in pausa e circa il 10% in meno al 10%, e con una pausa prima di ogni turno il 7% in più a 6 minuti, dal 9% al 10% in più a 20 minuti e dal 66% al 73% in più a 45 minuti. I dati a 6 minuti escludono l’esecuzione 3, in cui 2 delle 39 richieste keep-alive di quella sessione sono andate in timeout: la cache è scaduta prima di quei due turni, la sessione ha scritto 214.000 token nella cache contro 80.000-85.000 nelle esecuzioni 1 e 2, ed è costata il 38% in più della sessione a 1 ora dell’esecuzione 3.
    * **Richieste keep-alive, Claude Sonnet 5.5, per esecuzione:** Confrontando invece la sessione keep-alive di ciascuna esecuzione con la sessione a 1 ora della stessa esecuzione, il keep-alive è costato da circa lo stesso al 10% in più a 6 minuti (esecuzioni 1 e 2; il 4% in più sulla loro media), da circa lo stesso al 16% in più a 20 minuti e dal 64% all’80% in più a 45 minuti.
    * **Richieste keep-alive, Claude Sonnet 5.5, dimensione del campione:** I punti a 6 minuti del grafico sul keep-alive sono la media delle esecuzioni 1 e 2 per tutte e tre le impostazioni. Ciascuna cella è composta da tre sessioni (due per i dati a 6 minuti sopra). Senza pause, il keep-alive non invia richieste aggiuntive e quindi corrisponde all’impostazione a 5 minuti, eppure le due differivano fino al 23% all’interno di una singola esecuzione, quindi una differenza di pochi punti percentuali in una media su tre esecuzioni non è un effetto chiaro.
    * **Cache disattivata e attivata, Claude Sonnet 5:** Su Claude Sonnet 5, lo stesso job è stato eseguito con la cache disattivata e con la cache attivata, tre esecuzioni ciascuna il 19 agosto 2026, con `max_tokens` a 700: $3,36 USD contro $0,57 USD per sessione in media, un risparmio dell’83%.
    * **Calcolato dai conteggi di token registrati, Claude Sonnet 5.5:** Anthropic ha anche ricalcolato i prezzi dei conteggi di token registrati delle tre sessioni di Claude Sonnet 5.5 con la cache a 5 minuti e senza pause per il dato sulla cache in [Perché la cache viene prima](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#why-caching-comes-first). Ciascuna di queste tre sessioni è una conversazione di 40 richieste sulle 20 issue del job. Ai prezzi di listino al 12 ottobre 2026, le sessioni sono costate in media $0,51 USD ciascuna, dai campi di utilizzo, contro $3,70 USD con ogni token di input al prezzo di input e token di output invariati: un risparmio dell’86% (dall’86% all’87% nelle tre sessioni), ovvero un fattore di 7,3. Al prezzo di lancio della lettura dalla cache di $0,20 USD il risparmio è dell’82%, quindi l’aumento rispetto al dato di Claude Sonnet 5 deriva dal prezzo più basso della lettura dalla cache.
    * **Calcolato dai conteggi di token registrati, Claude Opus 5.5:** Ricalcolate allo stesso modo, le tre sessioni di Claude Opus 5.5 al suo effort predefinito, `medium`, con la cache a 5 minuti e senza pause sono costate in media $1,02 USD ciascuna contro $6,93 USD, un risparmio dell’85%, ovvero un fattore di 6,8; il modello ha usato il ragionamento nel 79% delle richieste.
    * **Come è stato impostato il ragionamento, solo due serie di esecuzioni:** Le richieste delle tre sessioni di Claude Sonnet 5.5 con la cache a 5 minuti e senza pause non impostavano alcuna opzione di ragionamento, quindi il ragionamento è stato lasciato al valore predefinito del modello, e il modello lo ha usato nel 38% delle richieste. Anche le richieste delle esecuzioni di Claude Sonnet 5 con la cache disattivata e con la cache attivata non impostavano alcuna opzione di ragionamento, quindi il ragionamento è stato lasciato al valore predefinito del modello, e il modello lo ha usato in 41 richieste su 121 con la cache disattivata e in 40 su 120 con la cache attivata.
    * **Latenza dopo una pausa:** Su Claude Sonnet 5 e Claude Opus 5, il turno dopo una pausa ha mantenuto la latenza con cache calda con l’impostazione a 1 ora.
    * **Cambiare la durata a metà conversazione:** Misurato il 21 ottobre 2026, su Claude Fable 5.1, Claude Opus 5.5, Claude Sonnet 5.5 e Claude Haiku 5.5, sulla Messages API senza strumenti, con ragionamento adattivo, effort `high`, un breakpoint della cache sul prompt di sistema e la [cache automatica](https://platform.claude.com/docs/it/build-with-claude/prompt-caching#automatic-caching) o un breakpoint esplicito sull’ultimo blocco. Le conversazioni contenevano circa 5.000 o 100.000 token di testo di riempimento, con turni dell’assistente fissi di una parola e nessun blocco di ragionamento. In una conversazione con la cache di 5 minuti, la prima richiesta con la cache di 1 ora che aggiungeva un turno non ha letto nulla e ha scritto l’intero prompt al prezzo della cache di 1 ora (55 su 55). La richiesta successiva con la cache di 1 ora ha letto tutto (36 su 36). Un prompt di sistema in cache con la durata di 1 ora fin dalla prima richiesta è stato comunque letto (12 su 12). Una richiesta con la cache di 1 ora che non aggiungeva nulla ha letto le voci a 5 minuti (31 su 31) e non le ha estese: 8 minuti dopo, la stessa richiesta non ha letto nulla (12 su 12). In una conversazione con la cache di 1 ora, una richiesta con la cache di 5 minuti ha letto tutto e ha scritto solo il suo nuovo turno (12 su 12). Le richieste sono state eseguite in un’unica organizzazione interna ad Anthropic sulla Claude API.
    * **Cambiare la durata a metà conversazione, come sono stati calcolati i prezzi:** Dai campi `usage` ai prezzi di listino, a poco più di 100.000 token, con `max_tokens` a 16, la prima richiesta con la cache di 1 ora che aggiungeva un turno è costata $2,01 USD, $0,80 USD, $0,40 USD e $0,10 USD sui quattro modelli nell’ordine indicato. Un turno che leggeva la cache è costato $0,026 USD, $0,020 USD, $0,010 USD e $0,005 USD. Claude Haiku 5.5 è ai suoi [prezzi del contesto lungo](https://platform.claude.com/docs/it/about-claude/pricing#long-context-pricing).

17. **Quota di letture dalla cache in produzione:** Utilizzo aggregato della Claude API di prima parte per i 14 giorni terminati il 23 agosto 2026, solo prodotto API diretto, escluse le organizzazioni interne ad Anthropic, nessuna organizzazione identificata. Un giorno-organizzazione conta come ciclo di agente quando le sue richieste contengono definizioni di strumenti e risultati di strumenti, i suoi prompt contengono in media 9 o più chiamate a strumenti precedenti, è stata usata la cache, e ha effettuato almeno 10 richieste di questo tipo (l’API non ha un identificatore di conversazione, quindi questo fa le veci della lunghezza della conversazione): 303.003 giorni-organizzazione su 106.487 organizzazioni, quota mediana di letture dalla cache dell’84,2% di tutti i token di input, quartile superiore 91,7%. Le etichette dei casi d’uso (il caso d’uso dichiarato dall’organizzazione, o altrimenti quello classificato) coprono il 74% di quei giorni-organizzazione e il 99% dei loro token; circa il 72% dei giorni-organizzazione di coding legge l’80% o più. Il decile superiore dei giorni-organizzazione legge il 95,9% o più per il coding e dal 94,2% al 94,8% per supporto, ricerca, dati e altri agenti. La suddivisione a livello di richiesta a 25 o più chiamate a strumenti precedenti proviene da un campione di sei ore: coding 92% letto, 7% scritto, meno dell’1% senza cache.

18. **Misurazioni sulla rottura della cache, sulla tempistica della compattazione e sulla riga di stato:**

    * **Test di ottobre 2026, una modifica a una conversazione lunga:** Misurato il 20 ottobre 2026, su Claude Fable 5.1, Claude Opus 5.5, Claude Sonnet 5.5 e Claude Haiku 5.5, sulla Messages API senza strumenti, con ragionamento adattivo, l’effort predefinito di ciascun modello, la cache a 5 minuti, un breakpoint della cache sul prompt di sistema e la [cache automatica](https://platform.claude.com/docs/it/build-with-claude/prompt-caching#automatic-caching). La conversazione conteneva circa 101.000 token: un prompt di sistema di 20.000 token, 13 turni utente di testo di riempimento, la risposta del modello stesso al primo turno con il suo blocco di ragionamento e risposte di una parola ai restanti. Una volta che una richiesta aveva messo in cache la conversazione, una seconda aggiungeva un breve turno, e ciascuna richiesta misurata inviava quella conversazione più lunga con una modifica. Due conversazioni per modello hanno dato lo stesso risultato.
    * **Test di ottobre 2026, token letti e scritti:** Senza modifiche, e con una modifica dell’effort per messaggio, la richiesta ha letto tutti i 101.000 token e non ne ha scritto nessuno. Con un messaggio di sistema di 25 token a metà conversazione, o una riga di stato di 25 token alla fine del turno utente più recente, li ha letti tutti e ha scritto solo il nuovo testo. Una modifica dell’effort di primo livello (a `low` su Claude Fable 5.1 e Claude Sonnet 5.5, a `high` su Claude Opus 5.5 e Claude Haiku 5.5) ha letto il prompt di sistema di 20.000 token e ha scritto 81.000 token. Gli stessi 25 token all’inizio o alla fine del prompt di sistema non hanno letto nulla e hanno scritto tutti i 101.000. La richiesta successiva a un messaggio di sistema a metà conversazione, a una modifica dell’effort di primo livello o a 25 token aggiunti alla fine del prompt di sistema ha letto il nuovo prefisso; una nuova riga di stato all’inizio ha scritto di nuovo tutto. Un ulteriore test il 21 ottobre 2026, sugli stessi quattro modelli con conversazioni di 5.000 token, e su tutti tranne Claude Fable 5.1 con conversazioni di 100.000 token, tutte con risposte di una parola, ha inviato un header beta per la prima volta a metà conversazione, come può fare una prima modifica dell’effort per messaggio: quella richiesta ha letto tutto ciò che la richiesta precedente aveva messo in cache, in tutte e 54 le volte. Un messaggio di sistema inviato senza header beta ha fatto lo stesso, in tutte e 15 le volte.
    * **Test di ottobre 2026, come sono stati calcolati i prezzi:** Il grafico riporta il lato prompt di una richiesta, dai suoi campi `usage` ai prezzi di listino. I valori del grafico, nell’ordine modifica del prompt di sistema, messaggio di sistema, modifica dell’effort di primo livello e modifica dell’effort per messaggio: Claude Fable 5.1 $1,26 USD, $0,026 USD, $1,02 USD e $0,025 USD; Claude Opus 5.5 $0,50 USD, $0,020 USD, $0,41 USD e $0,020 USD; Claude Sonnet 5.5 $0,25 USD, $0,010 USD, $0,20 USD e $0,010 USD. La richiesta invariata ripeteva byte per byte una richiesta precedente; un nuovo turno di circa 25 token aggiunge meno di $0,001 USD. Su Claude Haiku 5.5, le cui richieste superavano i 100.000 token di prompt e quindi erano ai suoi [prezzi del contesto lungo](https://platform.claude.com/docs/it/about-claude/pricing#long-context-pricing): $0,063 USD per la modifica del prompt di sistema, $0,052 USD per la modifica dell’effort e $0,005 USD per la lettura. Le richieste sono state eseguite su un’organizzazione interna ad Anthropic il cui utilizzo viene misurato allo stesso modo di quello di un’organizzazione cliente. Le richieste hanno lasciato `prefix_mismatch_behavior` non impostato, e l’API ha lasciato passare i loro blocchi di ragionamento che non superavano il controllo del prefisso, quindi ha accettato le modifiche del prompt di sistema in questi test. Ogni richiesta rinviava un blocco di ragionamento precedente. Sulla Claude API, la stessa modifica può ricevere un errore 400 su tutti e quattro i modelli. Vedi [Controlli del prefisso sui blocchi di ragionamento](https://platform.claude.com/docs/it/build-with-claude/preserved-thinking/prefix-checks).
    * **Test di novembre 2026, modifiche dopo una compattazione:** Eseguito il 9 novembre 2026, su Claude Opus 5.5 e Claude Fable 5.2, sulla Messages API con ragionamento adattivo, effort `high`, nessuna cache, uno strumento definito, `tool_choice` impostato su `none`, [`prefix_mismatch_behavior`](https://platform.claude.com/docs/it/build-with-claude/preserved-thinking/prefix-checks#mismatch-behavior) impostato su `"error"` e la [compattazione a una soglia di token](https://platform.claude.com/docs/it/build-with-claude/compaction-threshold) con un trigger di 50.000 token. Una prima richiesta di circa 55.700 token ha attivato una compattazione, e la sua risposta conteneva un blocco di compattazione seguito da un blocco di ragionamento. La richiesta successiva ha rinviato quella risposta con un nuovo turno utente. Invariata, è andata a buon fine. Con uno strumento aggiunto a `tools`, o con il prompt di sistema riformulato, ha ricevuto l’errore 400. In una conversazione senza compattazione, le stesse due modifiche hanno ricevuto l’errore 400, e lo stesso è accaduto rimuovendo un blocco di testo da un turno utente precedente. Una conversazione di ciascun tipo per modello. Su Claude Fable 5.2, la risposta della prima conversazione ampia non conteneva alcun blocco di ragionamento. Una seconda conversazione ha sostituito la prima, con una domanda più difficile, un `max_tokens` più alto e `instructions` di compattazione personalizzate, e conta solo la seconda. Le richieste sono state eseguite sulla Claude API.
    * **Cosa è stato misurato:** La variante lunga dell’agente di triage da [Taglia i token di input e di contesto](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#trim-input-and-context-tokens), eseguita il 24 agosto 2026, su Claude Sonnet 5 con la cache a 5 minuti, costo dai campi di utilizzo ai prezzi di listino, cinque sessioni per ramo: un ramo senza modifiche all’effort predefinito per tutto il tempo ($0,81 USD per sessione), e due rami che iniziano con effort basso e apportano le stesse due modifiche che invalidano la cache, un passaggio all’effort predefinito e uno strumento aggiunto, o a metà sessione alle richieste 12 e 17 ($0,95 USD) o insieme alla prima richiesta dopo la prima compattazione ($0,75 USD).
    * **Quarto ramo:** Un quarto ramo di sei sessioni, eseguito il 25 agosto 2026, ha apportato le stesse due modifiche alla richiesta che ha attivato la prima compattazione ($0,92 USD per sessione): il passaggio di riassunto di quella richiesta ha scritto nella cache il contesto di 81.000 token invece di leggerlo, quindi quel passaggio è costato $0,21 USD contro $0,04 USD per lo stesso passaggio nel ramo al confine.
    * **Compattazione:** Le sessioni si sono compattate per la prima volta tra la richiesta 21 e la 25 (16 delle 21 sessioni alla richiesta 22), una volta che il prompt ha superato la soglia di compattazione di 80.000 token, e due sessioni senza modifiche si sono compattate una seconda volta verso la fine. Il totale più basso del ramo al confine rispetto al ramo senza modifiche riflette le sue richieste a effort basso prima della modifica e quelle seconde compattazioni piuttosto che la cache: i costi di riscrittura dei due rami differiscono di meno di $0,01 USD.
    * **Ramo a metà sessione:** Il ramo a metà sessione ha pagato $0,23 USD per sessione in riscritture della cache; la differenza tra il ramo a metà sessione e quello al confine è stata di $0,20 USD con un intervallo di confidenza al 95% da $0,11 USD a $0,29 USD. Nel ramo a metà sessione, la modifica dell’effort e lo strumento aggiunto hanno riscritto 39.000 e 60.000 token in cache. Una delle sue sessioni è risultata economica ($0,82 USD) dopo che il suo modello ha chiamato in modo errato lo strumento di ricerca dopo la compattazione e ha ottenuto risultati vuoti; è inclusa, e senza di essa il ramo ha una media di $0,98 USD.
    * **Accuratezza e letture dalla cache:** L’accuratezza è stata in media di 14,2 etichette su 20 in ciascun ramo del 24 agosto e di 14,7 nel ramo del 25 agosto; le letture dalla cache sono state il 91% dei token del prompt senza modifiche, l’85% a metà sessione, il 91% al confine e l’86% con le modifiche sulla richiesta di attivazione.
    * **Misurazione separata, riga di stato:** Una misurazione separata sul job di triage di 20 issue da [Taglia i token di input e di contesto](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#trim-input-and-context-tokens), eseguita il 18 agosto 2026, anch’essa su Claude Sonnet 5 con la cache a 5 minuti, con prezzi calcolati allo stesso modo, tre esecuzioni per ramo: con una riga di stato di 25 token all’inizio del prompt di sistema, un’esecuzione è costata in media $4,24 USD (da $4,12 USD a $4,47 USD nelle tre esecuzioni) e non ha letto nulla dalla cache; con la stessa riga alla fine del turno utente più recente, dopo l’ultimo breakpoint della cache, un’esecuzione è costata $0,59 USD (da $0,55 USD a $0,61 USD). Il primo caso costa più di quanto sia costato lo stesso job con la cache disattivata. Una successiva riesecuzione con la stessa configurazione ha dato $4,28 USD e $0,61 USD.
    * **Trigger di compattazione su Claude Haiku 5.5:** Misurato il 21 ottobre 2026, sulla Messages API con la [compattazione a una soglia di token](https://platform.claude.com/docs/it/build-with-claude/compaction-threshold), senza strumenti, con ragionamento adattivo, l’effort predefinito (`medium`), la cache a 5 minuti, un breakpoint della cache sul prompt di sistema e la [cache automatica](https://platform.claude.com/docs/it/build-with-claude/prompt-caching#automatic-caching). Ogni sessione era una conversazione di 45 richieste: un prompt di sistema di 5.000 token, 10.000 token di testo di riempimento con ogni turno utente e turni dell’assistente di una parola, tranne che una risposta con un blocco di compattazione veniva rinviata per intero. Quattro impostazioni hanno eseguito tre sessioni ciascuna: trigger di 150.000 token (il valore predefinito), 90.000 e 50.000 (il minimo consentito), e nessuna compattazione. I costi all’interno di un’impostazione concordavano entro il 4%. Con il trigger predefinito, 15 delle 45 risposte di ciascuna sessione e tutti e 3 i riassunti avevano prompt superiori a 100.000 token. Con un trigger di 90.000, il prompt più grande conteneva 97.269 token. La compattazione è stata eseguita alla prima richiesta il cui prompt complessivo aveva raggiunto il trigger, contando il prompt di sistema, le letture della cache e le scritture della cache. Il riassunto è stato scritto a partire da quel prompt più 44 token, che insieme superavano il trigger al massimo di 7.269 token. Altre tre sessioni, con un prompt di sistema di 22.000 token e un trigger di 50.000, hanno mostrato che il prompt di sistema conta. I riassunti erano brevi (da 184 a 640 token di output) perché il testo era di riempimento. Le richieste sono state eseguite in un’unica organizzazione interna ad Anthropic sulla Claude API.
    * **Trigger di compattazione su Claude Haiku 5.5, come sono stati calcolati i prezzi:** Dai campi `usage` ai prezzi di listino, una sessione è costata $0,272 USD con il trigger predefinito, $0,082 USD a 90.000, $0,075 USD a 50.000 e $0,729 USD senza compattazione. Per richiesta, dalla richiesta successiva alla prima compattazione fino all’ultima compattazione, i tre trigger sono costati $0,00605 USD, $0,00181 USD e $0,00166 USD. Con ogni prompt ai prezzi per i prompt fino a 100.000 token, il valore predefinito costerebbe $0,00206 USD per richiesta, e un trigger di 90.000 farebbe risparmiare il 12%. Il riassunto e la risposta di una compattazione hanno ciascuno un prezzo calcolato in base alla dimensione del proprio prompt.

19. **Misurazione della durata della cache su Claude Fable 5.1 e Claude Fable 5.2:** Lo stesso job di triage di 20 issue e lo stesso harness del riferimento 16, con `max_tokens` aumentato a 4.096, eseguito il 23 e il 26 agosto 2026, sullo snapshot di lancio di Claude Fable 5.1 ai suoi prezzi di lancio ($10 USD input, $12,50 USD scrittura a 5 minuti, $20 USD scrittura a 1 ora, $0,25 USD lettura dalla cache, $50 USD output per milione di token), tre impostazioni per pianificazione: la cache a 5 minuti, la cache a 1 ora e la cache a 5 minuti mantenuta attiva da una richiesta con `max_tokens: 0` sul prefisso invariato ogni 4 minuti, cronometrata dall’inizio della richiesta precedente (le esecuzioni del 23 agosto inviavano richieste keep-alive con `max_tokens: 1`; nelle celle del 26 agosto riportate qui, ogni richiesta keep-alive che ha ricevuto risposta ha aggiornato la cache e la sua risposta non ha riportato token di output). Pianificazioni: nessuna pausa, 10% dei turni e ogni turno a 6 minuti su tutte le 20 issue, e pause di 45 minuti sul sottoinsieme di 5 issue; tre esecuzioni per cella (sei per la cella keep-alive del 26 agosto con pause di 45 minuti), costo calcolato dai campi `usage` di ciascuna risposta ai prezzi di listino, accuratezza rispetto alle stesse etichette di riferimento (da 12 a 18 etichette esatte su 20). Medie per sessione del 26 agosto per le impostazioni a 5 minuti, a 1 ora e keep-alive: nessuna pausa $2,42 USD, $3,09 USD, $2,29 USD; 10% in pausa $4,50 USD, $2,96 USD, $2,36 USD; ogni turno $22,89 USD, $3,01 USD, $2,62 USD; le celle del 23 agosto concordano entro il 6%. I dati a 45 minuti ($1,68 USD, $0,59 USD e $0,71 USD per sessione da 5 issue) provengono da sessioni successive del 26 agosto: la prima serie di sessioni di quel giorno è stata interrotta quando la sua macchina è stata spenta, e la seconda è stata interessata da un guasto del servizio ed è stata scartata. La terza serie fornisce i dati a 5 minuti e a 1 ora; le sue tre sessioni keep-alive hanno inviato ciascuna richiesta keep-alive una sola volta, hanno perso richieste a causa di rifiuti per limite di velocità e non sono incluse nella media. Il dato keep-alive è la media di sei ulteriori sessioni che hanno reinviato entro due secondi qualsiasi richiesta keep-alive rifiutata. Le esecuzioni del 23 agosto hanno dato $1,67 USD, $0,58 USD e $0,70 USD. Il punto di pareggio tra le impostazioni a 5 minuti e a 1 ora è il 3,1% dei turni, la stessa misura del riferimento 16. La lettura dalla cache di Claude Fable 5.1 costa 0,025x il prezzo di input mentre le sue scritture nella cache mantengono i moltiplicatori standard, quindi una richiesta keep-alive che rilegge il prefisso è economica e il sovrapprezzo di scrittura della durata di 1 ora è la voce più alta, tranne con pause di 45 minuti, dove le richieste keep-alive costano più del sovrapprezzo. Claude Fable 5.2 ha eseguito lo stesso job a `high`, il suo valore predefinito sulla Messages API, e ai prezzi di listino ($8 USD input, $10 USD scrittura a 5 minuti, $16 USD scrittura a 1 ora, $0,20 USD lettura dalla cache, $40 USD output per milione di token). Come le celle di Claude Opus 5.5 nel riferimento 16, ha usato un porting dell’harness che invia gli stessi corpi di richiesta, con `max_tokens` aumentato a 4.096. Pianificazioni: nessuna pausa, 5% e 10% dei turni e ogni turno a 6 minuti su tutte le 20 issue, e pause di 20 e 45 minuti sul sottoinsieme di 5 issue, tre esecuzioni per cella. Le celle a 45 minuti sono state misurate due volte; i loro dati aggregano entrambe le serie di tre sessioni e, come per Claude Fable 5.1, escludono le sessioni keep-alive che hanno perso richieste keep-alive (qui, a causa di timeout; una in ciascuna serie), quindi il dato keep-alive a 45 minuti è la media di quattro sessioni e i dati a 5 minuti e a 1 ora la media di sei. Per tutto il tempo, le richieste keep-alive sono state inviate con `max_tokens: 0`. Il client di test attende 30 secondi una richiesta keep-alive e non riprova. Nelle pianificazioni elencate sopra, ha smesso di attendere per 3 delle 886 richieste keep-alive, tutte nelle celle a 45 minuti, e ogni volta la cache è scaduta e la richiesta keep-alive successiva ha scritto di nuovo il prefisso. Medie per sessione per le impostazioni a 5 minuti, a 1 ora e keep-alive: nessuna pausa $2,18 USD, $2,66 USD, $2,23 USD; 10% in pausa $4,16 USD, $2,82 USD, $2,29 USD; ogni turno a 6 minuti $20,36 USD, $2,61 USD, $2,50 USD; e $1,43 USD, $0,53 USD e $0,65 USD per sessione da 5 issue con pause di 45 minuti. I risparmi di Claude Fable 5.2 in [Scegli la durata della cache](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#pick-the-cache-duration) sono calcolati prima dell’arrotondamento. Includendo le due sessioni che hanno perso richieste keep-alive, la media keep-alive a 45 minuti era di $0,73 USD, $0,20 USD in più rispetto all’impostazione a 1 ora.

20. **Terminal-Bench 3:** le 74 attività del benchmark pubblico per agenti da terminale, eseguite su [Claude Managed Agents](https://platform.claude.com/docs/it/managed-agents/overview) con due strumenti personalizzati, una shell e un editor di file che l’harness di valutazione esegue nel container di ciascuna attività, al posto degli strumenti integrati della piattaforma, e per il resto con le impostazioni predefinite della piattaforma per gli account esterni, due esecuzioni per modello con effort `high`, dal 27 al 28 agosto 2026. Queste esecuzioni hanno usato la versione 3.0 di Terminal-Bench, e i loro punteggi non sono confrontabili con la classifica pubblica di Terminal-Bench né con i risultati di Terminal-Bench 4.0 nella system card di Claude Opus 5.5, che provengono da esecuzioni in Claude Code con effort `max`. I limiti di tempo di ciascuna attività sono 2,5 volte quelli del benchmark, il che concede all’agente tra 75 minuti e 20 ore per attività (5 ore per l’attività mediana), e ogni attività riceve il triplo della memoria che specifica, da 6 GiB a 96 GiB, con memoria aggiuntiva per le 12 attività che eseguono servizi ausiliari. L’agente non aveva accesso generale a internet: i suoi container potevano raggiungere un mirror interno dei pacchetti, un breve elenco di siti di download tra cui GitHub e il Python Package Index, e alcuni siti specifici di determinate attività, e otto delle attività non avevano alcun accesso alla rete. I punteggi sono tassi di superamento grezzi sui 148 tentativi per modello; le singole esecuzioni oscillano da 5 a 11 punti. I costi sono quelli che verrebbero fatturati a un cliente ai prezzi di listino, ricalcolati richiesta per richiesta dai registri di utilizzo delle esecuzioni con la durata della cache di 5 minuti. Claude Opus 4.7, Claude Opus 4.8 e Claude Opus 5 spendono ciascuno da $8 USD a $15 USD per attività. Claude Opus 4.7 ha terminato 11 dei suoi 148 tentativi al suo limite di output.

21. **DRACO:** Perplexity, “DRACO: a Cross-Domain Benchmark for Deep Research Accuracy, Completeness, and Objectivity,” arXiv:2602.11685, 2026.

    * **Cosa è stato misurato:** Le sue 100 attività di ricerca in 10 domini sono valutate rispetto a rubriche scritte da esperti di circa 40 criteri ponderati ciascuna, e il punteggio è la quota ponderata di criteri soddisfatti, da 0 a 100.
    * **Configurazioni:** Ogni configurazione è stata eseguita sulla Claude API con Claude Opus 5.5, il ragionamento adattivo predefinito, i classificatori di sicurezza di produzione attivi e `max_tokens` a 128.000 con streaming: un singolo agente con effort `medium` (il valore predefinito del modello) e a `low`, il singolo agente a `medium` con la frase e l’orologio, e un team a `medium` con e senza di essi. Il team è un agente principale che può avviare agenti ausiliari dello stesso modello tramite uno strumento, senza limite al loro numero.
    * **La frase:** Le due modifiche sono una frase e un orologio. La frase, “Time matters here: do not spend time that can be avoided, and the earlier a correct result is obtained, the better.”, va alla fine dell’attività nel primo messaggio `user` dell’agente, dopo una riga vuota, e alla fine del brief di ciascun agente ausiliario.
    * **L’orologio:** L’orologio è il tempo trascorso in secondi interi, come `[elapsed 252s]`, aggiunto prima di ogni richiesta, inclusa la prima, alla fine del messaggio `user` più recente: in un proprio blocco di testo dopo l’attività nella prima richiesta, e alla fine del testo dell’ultimo risultato di strumento, dopo una riga vuota, quando il messaggio contiene risultati di strumenti. Gli orologi precedenti restano al loro posto, quindi il prefisso in cache corrisponde ancora alla richiesta successiva. Ogni agente di un team legge lo stesso orologio, e il prompt di sistema non cambia.
    * **Nelle esecuzioni misurate:** Le esecuzioni misurate hanno usato questa formulazione e questo formato. Il loro orologio partiva dal primo token della prima risposta anziché dall’inizio dell’attività. Nelle esecuzioni di team misurate, il rapporto di un agente ausiliario raggiungeva l’agente principale in un messaggio separato dopo l’orologio, non all’interno dell’ultimo risultato di strumento.
    * **Quando:** Ciascuna configurazione ha effettuato tre tentativi per ciascuna attività, con un limite di quattro ore per tentativo, eseguiti il 24 settembre 2026, e tutte le configurazioni di una serie sono partite insieme.
    * **Strumenti:** Gli agenti hanno usato strumenti di ricerca e recupero che l’harness di valutazione ospita su un indice web di Anthropic, e Python e una shell in una sandbox senza accesso alla rete. Quegli strumenti determinano parte del tempo, e i tuoi funzioneranno a una velocità diversa, quindi la pagina indica il tempo come rapporto tra configurazioni, non in minuti.
    * **Come è stato misurato il tempo:** Il tempo è il tempo reale di un tentativo, dalla sua prima richiesta alla fine dell’ultima richiesta di qualsiasi agente, incluse le esecuzioni degli strumenti, mediato sui tentativi di un’attività. Un dato per l’attività tipica è la mediana, sulle attività, del rapporto di ciascuna attività tra due configurazioni.
    * **Come sono stati calcolati i prezzi:** Il costo di ciascuna attività è il prezzo delle sue richieste ai prezzi di listino pubblici di Claude Opus 5.5, con la cache dei prompt fatturata come lo sarebbe per un cliente che imposta un breakpoint della cache alla fine di ogni richiesta e usa la durata della cache di 5 minuti. Ciascuna richiesta legge dalla cache il prompt della richiesta precedente e scrive il resto. La prima richiesta di un tentativo, e qualsiasi richiesta che inizi più di 5 minuti dopo quella precedente, scrive l’intero prompt. I costi coprono solo i token del modello; gli strumenti dell’harness non aggiungono costi.
    * **Come è stato assegnato il punteggio:** Tutti gli intervalli sono intervalli bootstrap al 95% sulle attività, e le variazioni di punteggio sono differenze appaiate sulle attività. Claude Opus 5 valuta le risposte, quindi Claude Opus 5.5 non valuta il proprio lavoro, e il punteggio di ciascuna risposta è la media di cinque esecuzioni di valutazione.
    * **Avvertenze:** Un classificatore di sicurezza di produzione ha fermato tre tentativi in ciascuna configurazione, tutti su un’unica attività, e quei tentativi ottengono 0; escludere quell’attività non cambia alcun risultato. Le esecuzioni hanno anche fatto passare l’uso degli strumenti di ciascun agente attraverso un controllo di sicurezza interno ad Anthropic che le richieste dei clienti non hanno, il che aggiunge tempo a ciascuna richiesta in ogni configurazione. Su DRACO, il singolo agente senza le modifiche ha effettuato circa il doppio delle richieste, e il team circa un terzo in più, quindi il controllo probabilmente fa apparire leggermente maggiori i risparmi di tempo su DRACO.
    * **Risultati, singolo agente:** Risultati per [Mostra al modello il tempo trascorso](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#show-the-model-elapsed-time): con le modifiche, il singolo agente ha impiegato il 47% di tempo in meno a un costo inferiore del 60% sull’attività tipica, il suo costo medio è sceso da $1,13 USD a $0,44 USD per attività, e il suo punteggio è stato inferiore di 4,1 punti (intervallo al 95% da 2,9 a 5,2 in meno).
    * **Risultati, effort più basso:** Abbassare l’effort del singolo agente ha fatto risparmiare più tempo e costi rispetto alle modifiche, e ha perso più punteggio. Con effort `low`, ha ottenuto 13,3 punti in meno su DRACO, 3,4 su HLE e 14,0 sull’insieme di fisica rispetto a `medium`, e l’attività tipica ha richiesto l’84%, il 30% e il 47% di tempo in meno. Con le modifiche con effort `medium`, ha ottenuto 9,2, 2,5 e 11,0 punti in più rispetto a `low`, e l’attività tipica ha richiesto più tempo che a `low` di un fattore da 1,2 a 3,2.
    * **Risultati, team, agenti ausiliari:** L’agente principale del team ha avviato raramente agenti ausiliari. Senza le modifiche, ha avviato un agente ausiliario solo in 5 tentativi su 300 su DRACO, 13 su 1.479 su HLE e nessuno su 280 sull’insieme di fisica.
    * **Risultati, team:** Quindi i risultati del team mostrano per lo più l’agente principale che lavora da solo, con le istruzioni e gli strumenti propri del team. Senza le modifiche, il team impiegava già circa la metà del tempo del singolo agente sull’attività tipica di DRACO, e ha ottenuto 3,3 punti in meno (intervallo al 95% da 2,1 a 4,6 in meno). Con le modifiche, il team ha impiegato il 17% di tempo in meno a un costo inferiore del 20% sull’attività tipica di DRACO, e ha ottenuto 1,6 punti in meno (intervallo al 95% da 0,3 a 2,8 in meno).

22. **HLE:** Phan et al., “Humanity’s Last Exam,” arXiv:2501.14249, 2025. Domande scritte da esperti con risposte esatte, valutate rispetto alle risposte di riferimento. Misurato sulle prime 500 domande della release del 10 settembre 2025, immagini incluse, con le fonti del benchmark stesso bloccate dalla ricerca, e la stessa configurazione del riferimento 21. Ciascuna configurazione ha effettuato tre tentativi per ciascuna domanda, eseguiti il 24 settembre 2026. Claude Opus 5 confronta ciascuna risposta con la risposta di riferimento, usando il prompt del giudice pubblicato dal benchmark, e conta la maggioranza di tre valutazioni. I punteggi coprono 493 domande in ogni configurazione. Per cinque delle altre, la richiesta di valutazione superava il limite di 1M di token del giudice, e le altre due sono escluse perché l’esecuzione del singolo agente senza le modifiche si è fermata prima che tre dei suoi tentativi su di esse terminassero. I rapporti di tempo e costo coprono 492 domande per il singolo agente e 491 per il team, perché una o due domande non hanno tempistiche. Un classificatore di sicurezza di produzione ha fermato dal 3% al 4% dei tentativi di ciascuna configurazione, e quei tentativi ottengono 0; escluderli non cambia alcun risultato. Risultati per [Mostra al modello il tempo trascorso](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#show-the-model-elapsed-time): con le modifiche, il singolo agente ha impiegato il 14% di tempo in meno a un costo inferiore del 9% sulla domanda tipica. Con il giudice Claude Opus 5, il suo punteggio non ha mostrato variazioni chiare (0,9 punti in meno, intervallo al 95% da 2,5 in meno a 0,7 in più). Con un secondo valutatore, Claude Opus 4.6, il suo punteggio è stato inferiore di 1,9 punti (intervallo al 95% da 0,2 a 3,7 in meno). Il tempo medio è sceso più di quello della domanda tipica: il tempo medio è sceso del 43% e il costo medio del 37%, perché le modifiche hanno accorciato alcune domande molto lunghe. Il tempo del team sulla domanda tipica è variato del 3% o meno, e il suo punteggio non è cambiato in modo chiaro.

23. **Insieme di fisica:** Un insieme interno di 70 problemi di fisica a livello di ricerca, adattato dal benchmark pubblico CritPt: Zhu et al., “Probing the Critical Point (CritPt) of AI Reasoning: a Frontier Physics Research Benchmark,” arXiv:2509.26574, 2025. Revisori esperti hanno corretto gli enunciati dei problemi. Claude Opus 4.6 valuta ciascuna risposta con credito parziale, usando il prompt di valutazione dell’insieme, rispetto a soluzioni di riferimento di esperti che non sono pubbliche, quindi i punteggi non possono essere confrontati con i risultati pubblicati. Il punteggio è il voto medio sui tentativi di un problema, mediato sui problemi, in punti su 100. Misurato su tutti i 70 problemi, quattro tentativi per problema, eseguiti il 24 settembre 2026. Ogni agente aveva uno strumento Python, una shell e un editor di file in un container sandbox senza accesso alla rete, e nessuno strumento di ricerca o recupero. Nessun classificatore di sicurezza ha fermato un tentativo sull’insieme di fisica. Per il resto la configurazione è quella del riferimento 21. Risultati per [Mostra al modello il tempo trascorso](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#show-the-model-elapsed-time): con le modifiche, il singolo agente ha impiegato il 7% di tempo in meno a un costo inferiore del 4% sul problema tipico, e il suo punteggio è stato inferiore di 3,0 punti (intervallo al 95% da 0,4 a 5,6 in meno). Il tempo del team sul problema tipico è variato del 3% o meno, e il suo punteggio non è cambiato in modo chiaro. Il tempo medio del singolo agente è sceso del 14%. L’intero risparmio di tempo medio del singolo agente deriva da un solo problema, su cui l’agente senza le modifiche ha eseguito codice per circa mezz’ora per tentativo; senza quel problema, il suo tempo medio è circa lo stesso con e senza le modifiche.

24. **tau2-bench retail:** Barres et al., "τ²-Bench: Evaluating Conversational Agents in a Dual-Control Environment," arXiv:2506.07982, 2025.

    * **Cosa è stato misurato:** Le 114 attività del dominio retail sono state eseguite sull’harness pubblico contro la Claude API, con Claude Haiku 4.5 come utente simulato, Claude Sonnet 5 come giudice in linguaggio naturale e la cache dei prompt attiva; le attività sono state suddivise in 57 di ricerca e 57 tenute da parte.
    * **Quando:** Le due ricerche sono state eseguite il 6 settembre 2026, guidate dal comando `hillclimb` della skill Claude API. La coppia prima-e-dopo sulla cache è stata eseguita l’8 settembre 2026.
    * **Come è stato assegnato il punteggio:** Nelle ricerche, i punti di partenza e la configurazione confermata sono la media di tre esecuzioni sulle attività tenute da parte, i passaggi mantenuti sono stati giudicati su due esecuzioni, e gli altri candidati sono stati valutati su una o due esecuzioni. La coppia sulla cache: tre esecuzioni ciascuna su tutte le 114 attività con solo i breakpoint della cache dell’harness attivati o disattivati, la configurazione che il comando `cost-optimize` aveva prodotto in un’esecuzione precedente. I numeri sulle attività tenute da parte si riferiscono a 57 attività che la ricerca non ha mai letto.
    * **Come sono stati calcolati i prezzi:** Il costo per attività calcola il prezzo dei conteggi di token dell’agente e dell’utente simulato ai prezzi di listino (Claude Opus 5 $5 USD e $25 USD, Claude Sonnet 5 $2 USD e $10 USD per milione di token di input e di output, letture e scritture nella cache alle tariffe pubblicate) ed esclude il giudice; le variazioni percentuali derivano da costi non arrotondati; il dato mensile riguarda solo i token dell’agente, $0,135 USD e $0,047 USD per attività, moltiplicati per 10.000. A 10.000 conversazioni al mese, si tratta di circa $1.350 USD prima della prima ricerca e $470 USD dopo.
    * **Avvertenze:** Queste misurazioni sono state eseguite sui modelli Claude Opus e Claude Sonnet precedenti: la coppia sulla cache è stata eseguita su Claude Sonnet 5, la seconda ricerca è partita da Claude Sonnet 5, e la prima ricerca è passata da Claude Opus 5 a Claude Sonnet 5.
    * **Coppia sulla cache:** La coppia è stata eseguita su Claude Sonnet 5 all’effort predefinito. L’harness pubblico, così come distribuito, invia l’intera conversazione senza cache a ogni turno. La configurazione con cache ha un breakpoint sul prompt di sistema e uno sull’ultimo messaggio. Entrambe le ricerche sono state eseguite con quella cache attiva. Il costo per attività è passato da $0,223 USD senza cache a $0,062 USD con cache, un risparmio del 72%, e il tasso di successo dal 79,2% al 76,0%. Esecuzioni identiche con cache di quella configurazione sono variate da 85 a 93 su 114 nei diversi giorni. Ogni esecuzione con cache ha ottenuto un punteggio pari o inferiore a ogni esecuzione senza cache, ma il divario di meno di 4 attività rientra nella dispersione delle esecuzioni identiche con cache, quindi la variazione di accuratezza è troppo piccola per essere misurata con questa dimensione del campione.
    * **Come si è svolta la ricerca.** Il comando `hillclimb` pone quattro domande, presenta un piano e attende l’approvazione prima di spendere qualsiasi cosa. Nella prima ricerca, il piano ha lasciato invariati il simulatore di utente, il valutatore, la cache, la temperatura e le attività. L’ultima delle quattro domande iniziava così: `One pass over the full set is 114 cases x 1 rep on claude-opus-5, roughly 22 minutes.` A ogni round, la ricerca propone una modifica ed esegue l’insieme completo. Mantiene la modifica solo quando il numero si è spostato e il meccanismo previsto si vede nei dati di utilizzo. Si ferma quando tre round consecutivi non portano nulla, poi conferma il vincitore su nuove esecuzioni.
    * **Prima ricerca, risultato.** La ricerca ha ridotto il costo per attività del 61% mantenendo il tasso di successo entro una banda di 2 punti fissata prima della ricerca: da Claude Opus 5 all’effort predefinito ($0,142 USD per attività, 76,0% superate) a Claude Sonnet 5 a `low` con una modifica al prompt neutra in termini di costo ($0,055 USD, 74,3%). La ricerca è costata $179 USD in esecuzioni di valutazione e $228 USD nei propri token.
    * **Prima ricerca, partenza: Claude Opus 5, effort predefinito.** 76,0% a $0,142 USD. Tre esecuzioni identiche hanno coperto da 43 a 44 su 57. La ricerca ha fissato la soglia minima 2 punti sotto, al 74,0%, e l’ha arrotondata a 43 su 57 (75,4%) per i suoi verdetti.
    * **Prima ricerca, passaggio 1, effort a `low`: mantenuto.** 77,2% sulle due esecuzioni che lo hanno mantenuto, 77,8% su una conferma di tre esecuzioni dopo la ricerca, a $0,119 USD, il 17% in meno. La riga di stato della ricerca stessa recita, in parte: `two runs held-out 42 and 46, mean 44.0 >= floor 43; cost mean $0.1187 <= gate $0.1208; mechanism confirmed (output tokens -34% with calls flat)`.
    * **Prima ricerca, passaggio 2, Claude Sonnet 5 a `low`: mantenuto.** 75,4% a $0,055 USD, il 61% in meno.
    * **Prima ricerca, passaggio 3, una modifica al prompt (cercare gli ordini del cliente dopo il login invece di chiedere un ID ordine): mantenuta in selezione, poi non ha retto.** 79,8% su due esecuzioni; 74,3% su tre nuove esecuzioni. La ricerca l’ha lasciata in quanto neutra in termini di costo: il turno liberato è diventato un altro turno di ricerca.
    * **Prima ricerca, passaggio 4, una modifica al prompt (trasferire a un operatore umano solo su richiesta): respinta e annullata.** 71,9%. Ha risolto i 3 casi a cui mirava e ne ha compromessi altri 10 con un template generico “di’ cosa puoi e non puoi fare”.
    * **Prima ricerca, passaggio 5, una modifica al prompt: non eseguita.** Il suo guadagno previsto di 0,5 attività era inferiore alla soglia di adozione di 2 attività della ricerca.
    * **Prima ricerca, conferma: Claude Sonnet 5 a `low` con il prompt del passaggio 3, tre nuove esecuzioni.** 74,3% a $0,055 USD, all’interno della banda di 2 punti per 0,14 di attività, 1 attività su 57 sotto la partenza, e sotto la soglia minima di 43 su 57 registrata dalla ricerca. Le cinque esecuzioni di questa configurazione hanno coperto da 42 a 46, un intervallo più ampio del 43-44 della partenza.
    * **Prima ricerca, cosa ha mostrato.** Le leve dell’effort e del modello hanno prodotto i risparmi, e il meccanismo di ciascuna lo ha confermato. La leva del prompt ha prodotto reali cambiamenti di comportamento ma nessun guadagno duraturo. Su questo carico di lavoro, il numero di turni e il prefisso in cache che ogni turno rilegge determinano il costo per attività, non la formulazione.
    * **Seconda ricerca.** È partita da Claude Sonnet 5 all’effort predefinito con la cache attiva: 79,5% a $0,062 USD sulla metà tenuta da parte, con tre esecuzioni che coprivano da 42 a 47 su 57, quindi la soglia minima era 45 su 57 (78,9%). Esecuzioni identiche di una configurazione di partenza differivano qui fino a 5 attività su 57. La seconda ricerca non ha mantenuto nulla. L’effort a `low`, due modifiche al prompt ed entrambe insieme hanno ottenuto ciascuna il 77,2%, sotto la soglia minima, e hanno fatto risparmiare dal 10% al 14%, al di sotto della soglia di costo del 15% della ricerca. Una modifica al prompt per l’accuratezza ha ottenuto il 79,8% su due esecuzioni e il 73,7% su tre nuove esecuzioni, ed è stata annullata. La ricerca ha richiesto circa 19 esecuzioni di valutazione e $120 USD.

25. **Set di attività di Claude Managed Agents:**

    * **Cosa è stato misurato:** Un insieme interno ad Anthropic di 79 attività di agente con script in otto aree, tra cui memoria, multiagente e lavoro con contesto lungo, eseguite come sessioni di [Claude Managed Agents](https://platform.claude.com/docs/it/managed-agents/overview) in cui il test risponde a ogni chiamata a strumento. Ciascuna attività è stata eseguita cinque volte per modello.
    * **Esecuzioni:** I dati provengono da un’esecuzione per modello il 7 ottobre 2026, valutata quel giorno. In altre tre esecuzioni delle stesse attività l’8 e il 9 ottobre 2026, Claude Haiku 5.5 ha superato dal 91% al 93% dei tentativi, e in un’ulteriore esecuzione l’8 ottobre, Claude Haiku 4.5 ha superato il 63%.
    * **Come è stato assegnato il punteggio:** Un tentativo è stato superato solo se il valutatore, Claude Sonnet 4.6, valutando una sola volta, ha segnato come soddisfatta ogni riga della checklist dell’attività, quindi i tassi di successo dipendono dal valutatore. Su tutte le attività tranne una, una chiamata separata, a cui venivano mostrati i risultati degli strumenti per intero, ha valutato la riga che verifica i file e i messaggi scritti dall’agente tramite i suoi strumenti rispetto a quei risultati.
    * **Come sono stati calcolati i prezzi:** I costi sono costi in token ai prezzi di listino con cache dei prompt a 5 minuti, calcolati richiesta per richiesta, ed escludono il tempo di esecuzione della sessione.
    * **Risultati, prezzi dei token e costo:** Claude Haiku 4.5 non ha messo in cache l’80% delle sue richieste: ciascuna aveva un prompt di circa 4.100 token o meno, e la sua lunghezza minima di prompt memorizzabile in cache è di 4.096 token (512 per Claude Haiku 5.5). Da Claude Haiku 4.5 a Claude Haiku 5.5, i prezzi dei token sono scesi fino al 90%, e il costo in token delle 79 attività è sceso di circa il 75%. Il costo in token è sceso meno dei prezzi perché circa il 5% delle richieste di Claude Haiku 5.5 aveva prompt superiori a 100.000 token, che pagano prezzi più alti ([Prezzi del contesto lungo](https://platform.claude.com/docs/it/about-claude/pricing#long-context-pricing)), e queste hanno rappresentato il 73% del suo costo.
    * **Ragionamento:** Anthropic ha impostato l’effort di Claude Haiku 5.5 a `medium` e non ha inviato alcuna impostazione di ragionamento né limite di output per nessuno dei due modelli, quindi il ragionamento è stato lasciato alle impostazioni proprie di Claude Managed Agents per ciascun modello. Claude Haiku 5.5 ha usato il ragionamento nel 59% delle richieste, e Claude Haiku 4.5 nel 22%. Il confronto riguarda ciascun modello così come servito, non a parità di impostazioni.
    * **Costo senza cache, calcolato dai conteggi di token registrati:** Anthropic ha anche ricalcolato i prezzi dei conteggi di token registrati dell’esecuzione del 7 ottobre di Claude Haiku 5.5 per il fattore sulla cache in [Perché la cache viene prima](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#why-caching-comes-first). Claude Managed Agents applica autonomamente la cache dei prompt, quindi il fattore confronta due prezzi per le stesse richieste, non due impostazioni.
    * **Il fattore:** Il fattore, 1,7, è il costo in token dell’esecuzione con ogni token di input al prezzo di input, token di output invariati, diviso per il suo costo in token con ciascuna sessione calcolata a sé: il prompt precedente di ciascuna richiesta come lettura dalla cache e i suoi nuovi token come scrittura nella cache a 5 minuti. Ciascuna richiesta è calcolata per la propria lunghezza di prompt in entrambi i costi, quindi le 87 richieste oltre i 100.000 token pagano i prezzi più alti in entrambi. Sui conteggi di token così come registrati, che i costi di questa guida per l’esecuzione usano, il fattore è 1,9, perché i cinque tentativi di un’attività sono stati eseguiti in parallelo e hanno letto le voci di cache l’uno dell’altro.
    * **Perché il fattore è basso:** Il fattore è basso perché le sessioni sono brevi, una mediana di 4 richieste: la maggior parte dei token di input arriva come risultati di strumenti alla seconda o terza richiesta e viene letta dalla cache solo una o due volte. Otto attività con contesto lungo rappresentano tre quarti del costo. Una seconda esecuzione, l’8 ottobre, dà anch’essa 1,7.

26. **Misurazione del formato della risposta:**

    * **Cosa è stato misurato:** Il job di triage di 20 issue da [Taglia i token di input e di contesto](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#trim-input-and-context-tokens), eseguito su Claude Sonnet 5 con la cache dei prompt attiva e nessuna impostazione di ragionamento nella richiesta, quindi il ragionamento è stato lasciato al valore predefinito del modello, con tre istruzioni diverse per la risposta finale, tre esecuzioni per istruzione.
    * **Istruzione a due righe:** L’originale chiedeva due righe: `4. Finish with exactly two lines: LABEL: <one of: bug-confirmed, needs-more-info, duplicate-candidate, feature-request, upstream-issue, perf, ui-polish> SUMMARY: <one or two sentences for the engineering team>`
    * **Istruzione a una riga:** La variante più breve ne chiedeva una: `4. Finish with exactly one line in this form: DECISION | LABEL | REASON where DECISION is one of: triage-now, needs-info, close-duplicate; LABEL is one of: bug-confirmed, needs-more-info, duplicate-candidate, feature-request, upstream-issue, perf, ui-polish; REASON is one clause under 15 words. Output nothing after that line.`
    * **Istruzione memo:** La variante più lunga chiedeva un memo con sei sezioni intitolate: riepilogo del problema, evidenze, verifica dei duplicati, etichetta consigliata, passi successivi e confidenza.
    * **Presente anche nelle istruzioni così come inviate:** Così come inviata, l’istruzione a due righe diceva anche “Be concise.” e l’istruzione memo “Be thorough and explicit.”
    * **Quando:** Le istruzioni a due righe e a una riga sono state eseguite il 18 agosto 2026, con `max_tokens` a 700, e l’istruzione memo il 19 agosto 2026, con `max_tokens` a 3.000. Nessuna risposta ha raggiunto il proprio limite.
    * **Come sono stati assegnati punteggi e prezzi:** I dati sono la media delle tre esecuzioni ai prezzi di listino di Claude Sonnet 5, e l’accuratezza è la corrispondenza esatta con le etichette di riferimento.
    * **Risultati:** La risposta a una riga ha usato il 39% di token di output in meno rispetto all’originale a due righe ed è costata il 13% in meno per esecuzione (dalle medie non arrotondate; i costi arrotondati del grafico, $0,49 USD e $0,57 USD, danno il 14%). Il memo ha usato sei volte i token di output dell’originale a due righe ed è costato 2,8 volte la risposta a una riga.
    * **Ragionamento:** Circa la metà delle risposte includeva il ragionamento, e i suoi token sono conteggiati nei token di output.

27. **Misurazione della ricerca degli strumenti:**

    * **Cosa è stato misurato:** Il job di triage di 20 issue da [Taglia i token di input e di contesto](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#trim-input-and-context-tokens), eseguito su Claude Sonnet 5 il 19 agosto 2026, con la cache dei prompt attiva e nessuna impostazione di ragionamento nella richiesta, quindi il ragionamento è stato lasciato al valore predefinito del modello, tre esecuzioni per configurazione. L’agente aveva i propri due strumenti più definizioni di strumenti reali da server MCP pubblici, per un totale di 7, 17, 52, 102, 252 o 502 strumenti, con ogni definizione caricata oppure con quelle aggiunte contrassegnate con `defer_loading` dietro la ricerca degli strumenti.
    * **Come sono stati assegnati punteggi e prezzi:** I dati sono la media delle tre esecuzioni ai prezzi di listino di Claude Sonnet 5, e l’accuratezza è la corrispondenza esatta con le etichette di riferimento.
    * **Risultati:** Con ogni definizione caricata, il costo dell’esecuzione è salito da $0,55 USD con 7 strumenti a $1,02 USD con 502 strumenti, quasi il doppio. Con la ricerca degli strumenti era da $0,55 USD a $0,56 USD a ogni dimensione del catalogo, il 45% in meno con 502 strumenti (dai costi arrotondati del grafico, $0,56 USD e $1,02 USD; le medie non arrotondate danno il 45,6%). Ogni esecuzione ha risposto correttamente da 15 a 18 delle 20 issue, con o senza la ricerca degli strumenti.
    * **Avvertenze:** Nessuna esecuzione ha chiamato uno strumento del catalogo o lo strumento di ricerca strumenti: i due strumenti propri dell’agente erano sempre caricati, e ogni chiamata a strumento è andata a uno di essi. La misurazione mostra quanto costa portarsi dietro definizioni inutilizzate.
    * **Misurazione separata:** In una misurazione separata sullo stesso modello e nella stessa data, con un server MCP pubblico di GitHub collegato tramite il connettore MCP e nessun catalogo, tre esecuzioni con il set di strumenti del server differito sono costate il 20% in meno di tre esecuzioni senza ($0,56 USD e $0,70 USD per esecuzione), e le tre esecuzioni di ciascun ramo hanno risposto correttamente a 17, 16 e 16 issue. Le richieste in questa misurazione separata non includevano alcuno strumento di ricerca strumenti. Con il set di strumenti caricato, ciascuna esecuzione ha chiamato uno degli strumenti del server, `issue_read`, 3 o 4 volte; con il set differito, nessuna esecuzione ha chiamato alcuno degli strumenti del server.

28. **Misurazioni sulla riduzione dell’input e sul ciclo di vita del contesto:**

    * **Cosa è stato misurato:** Il job di triage di 20 issue da [Taglia i token di input e di contesto](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#trim-input-and-context-tokens) e la sua variante lunga, eseguiti su Claude Sonnet 5 il 19 agosto 2026 (data in UTC), tre esecuzioni per impostazione, senza alcuna impostazione di ragionamento nella richiesta, quindi il ragionamento è stato lasciato al valore predefinito del modello; circa 3 risposte su 10 includevano il ragionamento.
    * **Il grafico:** Il grafico in [Gestisci il ciclo di vita del contesto](https://platform.claude.com/docs/it/about-claude/models/optimizing-for-cost-and-intelligence#manage-the-context-lifecycle) confronta quattro impostazioni su ciascun job: il job con la cache dei prompt e la riduzione dell’input (ridimensionamento delle immagini e ricerca degli strumenti) attive, e lo stesso con una leva aggiunta, che è la modifica del contesto, la compattazione o la potatura. Il grafico considera una variazione inferiore al 10% come nessuna variazione.
    * **Impostazioni delle leve:** Le impostazioni delle leve differivano tra i due job: la modifica del contesto ha eliminato almeno 2.000 token una volta che il prompt superava 20.000 sul job da 20 issue, e almeno 40.000 una volta che superava 50.000 su quello lungo, mantenendo i tre usi di strumenti più recenti, e la compattazione si attivava a 50.000 token di input sul job da 20 issue e a 80.000 su quello lungo.
    * **Come sono stati calcolati i prezzi:** Ciascun costo è la media delle tre esecuzioni, dai campi di utilizzo delle risposte ai prezzi di listino di Claude Sonnet 5, con scritture nella cache a $2,50 USD e letture dalla cache a $0,20 USD per milione di token.
    * **Risultati, riduzione dell’input:** Una quinta impostazione, cache dei prompt senza riduzione dell’input, è costata $0,57 USD per esecuzione sul job da 20 issue e $1,38 USD su quello lungo, quindi la riduzione dell’input ha tolto il 26% al primo e il 21% al secondo. Rispetto allo stesso job da 20 issue con la cache disattivata, che costava $3,36 USD per esecuzione (riferimento 16), la cache dei prompt e la riduzione dell’input insieme hanno fatto risparmiare l’88% (le medie non arrotondate danno l’87,5%).
    * **Risultati, esecuzione da 20 issue:** Nell’esecuzione da 20 issue, dove il job senza leve costava $0,42 USD per esecuzione, la modifica del contesto è costata il 73% in più, la compattazione è stata eseguita una volta verso la fine di ciascuna esecuzione ed è costata il 7% in meno, e la potatura non ha riscritto nulla, perché nessun risultato di ricerca superava la sua soglia di 2.000 caratteri.
    * **Risultati, esecuzione lunga:** Nell’esecuzione lunga, dove il job senza leve costava $1,09 USD per esecuzione, la potatura è costata il 39% in meno, la compattazione il 32% in meno e la modifica del contesto il 4% in più.
    * **Letture dalla cache, esecuzioni lunghe:** Nelle esecuzioni lunghe con la potatura, l’89% dei token del prompt è stato letto dalla cache alla prima richiesta dopo un confine tra attività e l’81% nelle altre richieste. Sull’intero insieme delle esecuzioni lunghe, l’85% dei token del prompt è stato letto dalla cache con la potatura e l’85% con la modifica del contesto, contro il 95% senza leve.

29. **Benchmark interno di coding (misurazione dei subagenti):**

    * **Cosa è stato misurato:** 134 attività di coding su repository, ciascuna valutata come superata o fallita da test che l’agente non può vedere, cinque tentativi per attività in ciascuna di tre esecuzioni, dal 21 al 23 ottobre 2026, su [Claude Managed Agents](https://platform.claude.com/docs/it/managed-agents/overview) con la sua [orchestrazione multiagente](https://platform.claude.com/docs/it/managed-agents/multiagent-orchestration) (il tipo `multiagent_20261001`): un agente predefinito come subagente, con disattivati sia gli agenti inline sia i workflow dinamici.
    * **Configurazioni:** Claude Opus 5.5 da solo a `medium`, il suo valore predefinito, e a `low`; e Claude Opus 5.5 a `medium` con subagent Claude Haiku 5.5 a `medium`, una volta senza prompt aggiunto e una volta con un prompt di delega di 113 parole come prompt di sistema dell’orchestratore. Una quinta configurazione, con un prompt più lungo, non è riportata. La valutazione non ha impostato alcuna opzione di ragionamento, quindi il ragionamento è stato eseguito con il valore predefinito: attivo, con il modello che sceglie quando ragionare.
    * **Strumenti:** Ogni agente ha usato due strumenti personalizzati, una shell e un editor di file che la valutazione esegue nella sandbox propria di ciascun tentativo, al posto degli strumenti integrati della piattaforma. Come parte della configurazione di sicurezza della valutazione, le loro chiamate passavano attraverso un controllo aggiuntivo. Nella configurazione documentata, [le policy di autorizzazione non si applicano agli strumenti personalizzati](https://platform.claude.com/docs/it/managed-agents/permission-policies#custom-tools).
    * **Risultati:** I tentativi superati e il costo per tentativo sono stati 72,1% e $4,78 USD per Claude Opus 5.5 da solo a `medium`; 68,8% e $3,35 USD con subagent e senza prompt aggiunto; 67,9% e $3,27 USD con subagent e il prompt; e 63,0% e $1,84 USD da solo a `low`.
    * **Confronto con Claude Opus 5.5 da solo a `medium`:** Con il prompt, costo inferiore del 32% (intervallo al 95% dal 29% al 35%) e 4,2 punti percentuali in meno di tentativi superati (da 1,3 a 7,1). Senza prompt aggiunto, il 30% in meno (dal 27% al 33%) e 3,3 in meno (da 0,8 a 5,8). Da solo a `low`, il 62% in meno (dal 59% al 64%) e 9,1 in meno (da 5,0 a 13,3), un confronto aggiunto dopo le esecuzioni. Le differenze sono appaiate per attività all’interno di ciascuna esecuzione, e gli intervalli sono intervalli bootstrap sulle 134 attività.
    * **Confronto con un effort più basso:** Inviare una quota delle attività a `low` e il resto a `medium` dà una linea retta tra quei due risultati, un calcolo e non un’esecuzione. Al loro stesso costo, le configurazioni con subagent hanno superato, con il prompt, 0,5 punti percentuali in più rispetto a quella linea (da 2,3 in meno a 3,2 in più) e, senza prompt aggiunto, 1,1 in più (da 1,2 in meno a 3,3 in più): né sopra né sotto di essa. Il costo per tentativo superato è stato $6,63 USD da solo a `medium`, $4,86 USD con subagent e senza prompt aggiunto, $4,81 USD con il prompt e $2,92 USD a `low`.
    * **Come sono stati calcolati i prezzi:** I costi sono costi in token ai prezzi di listino con cache dei prompt a 5 minuti, con ciascuna richiesta calcolata sulla propria lunghezza di prompt ([Prezzi del contesto lungo](https://platform.claude.com/docs/it/about-claude/pricing#long-context-pricing)), ed escludono il tempo di esecuzione della sessione. I costi non includono il controllo aggiuntivo della valutazione sulle chiamate agli strumenti; includendolo, il risparmio con il prompt è del 27% (dal 25% al 30%).
    * **Cosa conta come fallimento:** Un tentativo conta come fallimento se un controllo di sicurezza lo ha interrotto, se la salvaguardia della piattaforma ha rifiutato un turno, o se la valutazione lo ha annullato perché non poteva confermare che i suoi controlli di sicurezza avessero visto ogni passaggio. I tentativi annullati hanno riguardato solo le configurazioni con subagent: 72 su 2.010 con il prompt, 57 dei quali in un’unica esecuzione. Rieseguendo la parte dell’esecuzione relativa a quella configurazione, ha superato 3,6 punti percentuali in meno rispetto a Claude Opus 5.5 da solo (da 1,0 a 6,3). Escludendo invece da entrambi i lati ogni tentativo che un controllo di sicurezza ha interrotto o che la valutazione ha annullato, ha superato 1,7 in meno (da 4,4 in meno a 1,1 in più). Quindi parte della perdita, ma non tutta, deriva dalle regole proprie della valutazione. Un tentativo di Claude Opus 5.5 da solo a `medium`, interrotto al limite di tre ore, non ha risultato ed è escluso; con i subagent, la stessa interruzione conta come fallimento.

## Prossimi passi

<CardGroup cols={2}>
  <Card title="Cache dei prompt" icon="database" href="https://platform.claude.com/docs/it/build-with-claude/prompt-caching">
    Il più grande vantaggio gratuito di questa pagina: configurazione, durate e diagnostica.
  </Card>

  <Card title="Effort" icon="gauge" href="https://platform.claude.com/docs/it/build-with-claude/effort">
    Scambia intelligenza con latenza e costo all’interno di un singolo modello.
  </Card>

  <Card title="Scegliere il modello giusto" icon="settings" href="https://platform.claude.com/docs/it/about-claude/models/choosing-a-model">
    Valuta capacità, velocità e costo nella famiglia di modelli Claude.
  </Card>

  <Card title="Budget di sessione" icon="coins" href="https://platform.claude.com/docs/it/managed-agents/budgets">
    Imposta un limite rigido in dollari su una sessione di Managed Agents.
  </Card>

  <Card title="Prezzi" icon="dollar-sign" href="https://platform.claude.com/docs/it/about-claude/pricing">
    Consulta i prezzi attuali per token di ogni modello Claude.
  </Card>

  <Card title="Cookbook: ottimizzazione dei costi sulla Claude API" icon="book" href="https://platform.claude.com/cookbook/cost-optimization-cost-optimization">
    Applica queste leve una alla volta a un agente funzionante in un notebook eseguibile, con il costo per attività dopo ogni passaggio.
  </Card>

  <Card title="Webinar: sviluppare sulla Claude Platform" icon="play" href="https://www.anthropic.com/webinars/building-on-the-claude-platform-claude-fable-5-and-model-orchestration-patterns">
    Guarda una presentazione guidata dei pattern advisor e orchestratore.
  </Card>
</CardGroup>
