Come utilizzare la modalità di ragionamento in claude 4.5

“Modalità di pensiero” (nota anche come pensiero esteso, pensiero o blocchi di pensiero) in Claude 4.5 è una modalità operativa esplicita e configurabile che istruisce il modello a dedicare un numero di token separato e con budget a generare un ragionamento interno, passo dopo passo (una “catena di pensiero”), prima di emettere la risposta finale. È progettata per migliorare le prestazioni in ragionamenti multi-step, coding complesso, workflow agentici e attività di ricerca, scambiando latenza e costo in token per una deliberazione interna più profonda. Claude 4.5 espone questa capacità a livello di Messages API con parametri espliciti (ad es., thinking / budget_tokens o un header di effort/“interleaved-thinking”), preserva e opzionalmente cifra i blocchi di pensiero per una successiva verifica o uso con strumenti, e introduce comportamenti di cache e contabilizzazione dei token che devi gestire quando costruisci carichi di lavoro in produzione.

Che cos’è Claude 4.5? (E quali modelli mi interessano?)

Claude 4.5 è l’ultimo set di modelli Claude rilasciati come aggiornamenti incrementali “4.5” (per esempio, Sonnet 4.5 e Opus 4.5). Sonnet 4.5 è posizionato come il miglior equilibrio tra intelligenza, coding e prestazioni agentiche per la maggior parte degli sviluppatori; Opus 4.5 si concentra su ragionamenti ad altissimo effort e preserva i blocchi di pensiero per migliorare la continuità multi-turn. Entrambi i modelli supportano le capacità di extended thinking di Claude, sebbene alcuni comportamenti (ad es., pensiero riassunto vs completo) varino in base al modello.

I miglioramenti prestazionali in Claude 4.5, in particolare in Sonnet 4.5, sono più evidenti nel benchmark SWE-bench Verified, che misura la capacità di un’IA di risolvere problemi reali su GitHub.

Questi numeri indicano che Claude 4.5 non è solo migliore nello scrivere snippet; è significativamente più capace di navigare interi file system ed eseguire attività autonome senza intervento umano.

Perché conta

• Coding & agenti: Sonnet 4.5 mostra forti miglioramenti nei task software reali e nel lavoro di coding a lungo raggio—rendendolo una scelta naturale per generazione di codice, editing e flussi di agenti autonomi.
• Extended thinking & contesto: I modelli della famiglia Claude 4.5 sono costruiti per ragionare con grandi scratchpad interni (decine di migliaia di token o più), abilitando ragionamenti multi-step più profondi. Ciò cambia come progetti prompt, budget di token e interazioni con strumenti.

Che cos’è la Thinking Mode in Claude 4.5?

La Thinking Mode (formalmente “Extended Thinking”) è una funzionalità che consente al modello di “mostrare il proprio lavoro” a sé stesso prima di fornire un output finale. A differenza dei modelli standard che si impegnano immediatamente su una risposta, Claude 4.5 utilizza uno spazio di ragionamento dedicato per esplorare ipotesi multiple, identificare potenziali errori nella logica e affinare la strategia.

Anatomia di una risposta

In un’interazione standard, il modello riceve un prompt e inizia a generare la risposta. In Thinking Mode, la risposta è suddivisa in due blocchi distinti:

Proprietà chiave della thinking mode

• Abilitazione su richiesta: Passi un oggetto thinking nella chiamata API come {"type":"enabled","budget_tokens":10000} per attivarla e dare al modello un budget di token interno per il ragionamento.
• Budgeting: budget_tokens limita i token di ragionamento interni del modello. Più budget => potenziale di ragionamento più profondo ma costi e latenza maggiori. Nei modelli Claude 4, i token di pensiero vengono fatturati anche se ricevi solo una vista riassunta.
• Riassunto e redazione: Per molti modelli Claude 4 l’utente vede una versione riassunta del contenuto di pensiero; alcuni ragionamenti interni possono essere redatti (crittografati) dai sistemi di safety e restituiti come redacted_thinking.
• Firme e verifica: I blocchi di pensiero includono una signature opaca utilizzata per la verifica quando si restituiscono blocchi di pensiero all’API (soprattutto necessario quando si usano strumenti). Tratta la firma come opaca — non tentare di analizzarla.
• Pensiero interleaved con strumenti: Claude 4 supporta l’interleaving dei blocchi di pensiero con esecuzioni di strumenti (beta e flag-based in alcuni casi). Questo è potente per il lavoro agentico (esegui uno strumento, pensa, esegui un altro strumento, ecc.).

Per esempi pratici e i parametri più aggiornati, la documentazione Messages/Extended Thinking di Anthropic è il riferimento canonico.

Come la Messages API restituisce contenuti di pensiero

Pensiero riassunto vs completo; crittografia e firme

Diverse versioni dei modelli Claude gestiscono il pensiero in modo diverso: i modelli Claude 4 più recenti (come Sonnet/Opus 4.5) spesso restituiscono una vista pubblica riassunta del ragionamento interno mentre lo scratchpad completo può essere crittografato e disponibile solo tramite un campo signature (o blocchi redatti). Quando si utilizzano strumenti (o è necessario preservare lo stato interno tra chiamate a strumenti), devi passare i blocchi di pensiero all’API o utilizzare il meccanismo di firma descritto nei doc. Questo meccanismo aiuta a proteggere il ragionamento interno sensibile consentendo al contempo una sicura continuazione del processo di pensiero quando necessario.

Schema pratico di gestione

Uso di strumenti / continuazione: se la tua richiesta successiva deve continuare lo stesso stato interno (ad es., strumenti eseguiti sulla base del pensiero), includi il blocco di pensiero restituito o la firma quando richiami l’API, in modo che il modello possa decrittare e proseguire da dove si era fermato.

Request: invia thinking: {type: "enabled", budget_tokens: N}.

Response: potresti ricevere (a) un output pubblico riassunto, (b) una signature crittografata o un blocco redacted_thinking, oppure (c) entrambi.

CometAPI offre l’API di Claude 4.5 al 20% del prezzo ufficiale, e può anche essere chiamata usando le Anthropic Messages. Dovrai ottenere una chiave API prima di iniziare.

Esempio 1 — semplice curl (non in streaming) con thinking abilitata

curl https://api.cometapi.com/v1/messages \
  -H "x-api-key: $CometAPI_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-4-5",
    "max_tokens": 16000,
    "thinking": {
      "type": "enabled",
      "budget_tokens": 10000
    },
    "messages": [
      {"role": "user", "content": "Design a robust data validation strategy for CSV imports, show tests + code."}
    ]
  }'

La risposta conterrà blocchi content. Ispeziona ogni blocco e preferisci i blocchi text per l’output finale; i blocchi thinking contengono il riepilogo dell’analisi interna del modello.

Esempio 2 — Python: richiesta, parsing di blocchi di pensiero e testo

import os, requests

API_KEY = os.environ["CometAPI_API_KEY"]
URL = "https://api.cometapi.com/v1/messages"
HEADERS = {
    "x-api-key": API_KEY,
    "anthropic-version": "2023-06-01",
    "content-type": "application/json"
}

payload = {
    "model": "claude-sonnet-4-5",
    "max_tokens": 16000,
    "thinking": {"type": "enabled", "budget_tokens": 8000},
    "messages": [{"role": "user", "content": "Explain how to do property-based testing in Python; include example code."}]
}

r = requests.post(URL, headers=HEADERS, json=payload)
r.raise_for_status()
resp = r.json()

# Parse blocks
for block in resp.get("content", []):
    if block.get("type") == "thinking":
        thinking_summary = block.get("thinking")
        print("=== THINKING (summary) ===")
        print(thinking_summary[:1000])  # truncate for logs
        print("signature:", block.get("signature")[:64], "...")
    elif block.get("type") == "text":
        print("=== FINAL TEXT ===")
        print(block.get("text"))

Questo codice estrae e stampa il pensiero riassunto e la risposta finale. Se devi preservare la continuità nei flussi agentici multi-turn, includi i blocchi di pensiero non modificati nella successiva richiesta nell’array messages (vedi esempio successivo).

Esempio 3 — riuso dei blocchi di pensiero in un flusso multi-turn (pseudo Python)

# After initial response (resp above):
# Add the assistant message including the thinking block back into the conversation
assistant_message = {
  "role": "assistant",
  "content": resp["content"]  # include raw content array (contains thinking + text blocks)
}

# Next user turn: ask follow-up and include previous assistant message
payload2 = {
  "model": "claude-opus-4-5",  # Opus preserves thinking blocks better across turns
  "max_tokens": 20000,
  "thinking": {"type": "enabled", "budget_tokens": 12000},
  "messages": [
    {"role": "user", "content": "Now adapt the validation logic for an avro pipeline."},
    assistant_message
  ]
}
r2 = requests.post(URL, headers=HEADERS, json=payload2)

Preservare esattamente i blocchi di pensiero non modificati è fondamentale quando si usano strumenti integrati o workflow agentici lunghi. Opus 4.5 ha impostazioni predefinite migliorate per la preservazione e caching dei blocchi di pensiero.

Come fare streaming degli output di pensiero e mostrare il progresso in una UI?

Best practice per lo streaming

• Usa gli endpoint di streaming degli SDK (gli SDK Python/TypeScript hanno helper di stream). Per lavori di ragionamento lunghi o ad alto budget, lo streaming evita timeout HTTP e ti dà testo parziale mentre il modello elabora. Il codice tipico usa un iteratore su text_stream (Python) o parsing di eventi (JS).
• Aspettati flussi in due fasi a volte: il modello può prima produrre frammenti di ragionamento visibile, poi finalizzare con la risposta. Progetta la UI per gestire contenuti suddivisi e per mostrare stati “sto pensando…” vs risposta finale.
• Se l’API restituisce un signature_delta o content_block_delta durante lo streaming, acquisiscilo e allegalo alle chiamate successive come richiesto dalla specifica.

Se devi mostrare avanzamenti di ragionamento intermedi in una UI, fai lo stream della risposta. Il server emetterà eventi thinking_delta seguiti da eventi text_delta.

curl https://api.cometapi.com/v1/messages \
  --header "x-api-key: $CometAPI_API_KEY" \
  --header "anthropic-version: 2023-06-01" \
  --header "content-type: application/json" \
  --data '{
    "model": "claude-sonnet-4-5",
    "max_tokens": 16000,
    "stream": true,
    "thinking": { "type": "enabled", "budget_tokens": 8000 },
    "messages": [ { "role": "user", "content": "Walk me through debugging this failing unit test and propose fixes." } ]
  }'

Quando si fa streaming, gestisci gli eventi content_block_start, content_block_delta (che includono thinking_delta e text_delta) e content_block_stop in ordine. Questo è il modo per mostrare il ragionamento passo dopo passo del modello mentre accade.

Come interagisce Claude Code con la thinking mode? (terminal + VS Code)

Claude Code è il terminale interattivo e agentico per il coding che integra la Messages API e i runner di strumenti. L’esperienza CLI/IDE espone il pensiero in due modi:

• Impostazioni globali / per sessione: Claude Code espone un pannello di impostazioni /config per regolare il comportamento (come l’agente chiede permessi, se preservare i blocchi di pensiero, ecc.). Usa quella UI piuttosto che riscrivere JSON grezzo se vuoi modifiche comportamentali persistenti.
• Selezione del modello e comandi CLI: Puoi scegliere claude-sonnet-4-5 o claude-opus-4-5 come modello attivo nel REPL; gli strumenti e il comportamento del pensiero seguono le semantiche della Messages API. Il CHANGELOG e le note di rilascio indicano che il pensiero ora è abilitato di default per alcune distribuzioni Opus 4.5 e che la configurazione del pensiero è visibile tramite /config.

Flusso pratico in Claude Code:

1. Avvia un progetto nel REPL.
2. Usa /config per ispezionare i flag relativi al pensiero (preservazione, verbosità, ecc.).
3. Chiedi all’agente di eseguire un compito lungo — produrrà contenuti di pensiero e, se necessario, chiederà il permesso di eseguire specifici passaggi bash. Preserva i blocchi di pensiero quando devi verificare o ri-eseguire decisioni in seguito.

Installazione e Setup

Claude Code richiede Node.js e può essere installato globalmente.

# Install Claude Code CLI
npm install -g @anthropic/claude-code

# Authenticate
claude-code --init

Attivare il Thinking nel terminale

Claude Code supporta vari flag e trigger in linguaggio naturale per controllare la profondità del ragionamento.

Suggerimenti:

• Usa "think"/"think harder" quando vuoi che l’agente esplori implementazioni alternative.
• Quando Claude Code esegue chiamate a strumenti (run tests, operazioni git), preserva eventuali blocchi thinking se la CLI/l’agente li restituisce; altrimenti l’agente può perdere contesto tra i passaggi.

Benefici del Thinking interleaved e della preservazione dei blocchi

Per workflow agentici avanzati, Claude 4.5 introduce due funzionalità beta che migliorano significativamente le interazioni multi-turn e l’uso di strumenti: Interleaved Thinking e Thinking Block Preservation.

Interleaved Thinking (Beta)

Il ragionamento standard avviene una volta prima dell’output. Interleaved Thinking (abilitato tramite l’header interleaved-thinking-2025-05-14) consente a Claude di “pensare” tra le chiamate agli strumenti.

Immagina Claude che stia facendo debug di un server:

1. Think: "Dovrei controllare prima i log."
2. Tool Call: read_file(logs.txt)
3. Think: "I log mostrano un timeout del database. Ora devo verificare le impostazioni del pool di connessione."
4. Tool Call: read_file(db_config.yml)

Questa “riflessione continua” garantisce che il modello adatti la propria strategia in base ai dati ricevuti dagli strumenti, piuttosto che seguire un piano rigido predefinito.

Thinking Block Preservation

Nelle conversazioni multi-turn, specialmente quelle che coinvolgono l’uso di strumenti, è fondamentale passare i precedenti blocchi thinking all’API.

• Continuità del ragionamento: Ricevendo i propri pensieri precedenti, Claude mantiene il contesto logico del suo percorso.
• Ottimizzazione Opus 4.5: In Claude Opus 4.5, questo comportamento è automatizzato. Il modello preserva di default tutti i blocchi di pensiero precedenti nel suo contesto, garantendo che anche in sessioni che durano 30+ ore il modello non “dimentichi” perché dieci turni fa ha preso determinate decisioni architetturali.

Best practice per usare la THINKING mode con Claude 4.5

Scegli il modello e il budget giusti per il task:

Usa Sonnet 4.5 per coding e workflow agentici quando ti serve il miglior compromesso tra velocità, costo e forti capacità di coding; usa Opus 4.5 per il ragionamento più profondo e le window di contesto maggiori o quando prevedi di eseguire sessioni autonome lunghe. Entrambi supportano l’extended thinking. Scegli budget_tokens proporzionalmente alla complessità del task (inizia in piccolo per esperimenti; aumenta il budget solo se osservi miglioramenti sostanziali di qualità).

Monitora e controlla costi e latenza

Vieni addebito per tutti i token di pensiero prodotti da Claude, non per il riassunto che ricevi. Ciò significa che lunghe deliberazioni interne aumentano il costo anche se vedi solo un breve riassunto. Traccia l’uso dei token e considera una messa a punto graduale (per esempio: 2k → 8k → 32k) quando si passa dall’esplorazione alla produzione.

Preserva i blocchi di pensiero solo quando necessario

I blocchi di pensiero possono essere firmati crittograficamente e preservati per successiva verifica e per uso interleaved con strumenti. Evita di fare echo dei blocchi di pensiero in ogni richiesta successiva a meno che il tuo workflow non richieda che il modello mantenga le deliberazioni interne precedenti (per esempio, quando un agente ri-eseguirà passaggi e necessita dei razionali preservati). La preservazione continua del pensiero aumenta il volume di contesto e può complicare la contabilizzazione dei token.

Quando effettuare lo streaming del pensiero agli utenti

Il pensiero in streaming è eccellente per strumenti per sviluppatori e UI educative (mostrando “lavoro in corso” mentre il modello delibera). Non fare streaming del pensiero grezzo agli utenti finali di app consumer di produzione senza considerare safety e redazione: il pensiero riassunto esiste proprio per questo. Se fai streaming, fornisci elementi UI che etichettino il ragionamento interno (ad es., “Ragionamento dell’assistente — interno”) e controlla se l’utente finale vede il pensiero riassunto o quello completo.

Uso degli strumenti e interleaving

Quando combini pensiero con strumenti (esecuzione di codice, fetch web, processi locali), usa il design di interleaved thinking quando ti serve che il modello selezioni strumenti, li esegua e ragioni sui risultati all’interno dello stesso turno. L’interleaving aumenta la complessità (e può richiedere flag di funzionalità) ma è potente per l’automazione agentica. Sii esplicito su quale pensiero preservi e testa come il modello seleziona gli strumenti con una run con thinking abilitata.

Note pratiche di troubleshooting e operative

Errori comuni e cosa significano

• Thinking non valido + scelta forzata dello strumento: Se richiedi il thinking ma forzi anche modalità di uso degli strumenti incompatibili con il thinking, l’API restituirà un errore — non mescolare l’imposizione di tool_choice: {"type":"tool","name":"..."} con thinking.
• Budget > max_tokens: Per scenari di thinking interleaved le regole effettive sui token differiscono — la piattaforma spiega quando budget_tokens può superare max_tokens. Leggi attentamente la sezione “interleaved thinking” prima di testare budget elevati.
• Validazione della firma: Se preservi blocchi di pensiero per chiamate successive, includi la signature restituita in modo che l’API possa verificare che provengano da Claude; questo previene manomissioni e mantiene la catena verificabile.

Osservabilità e strumentazione

Logga: (1) la selezione del model, (2) thinking.budget_tokens, (3) il consumo effettivo dei token di pensiero (vieni fatturato per questo), (4) le latenze di streaming (tempo al primo thinking_delta), e (5) i token di testo finali. Usa queste metriche per costruire budget e SLO per i flussi rivolti agli utenti.

Rollout progressivo e human-in-the-loop

Fai rollout dei modelli con thinking abilitato dietro flag di funzionalità. Inizia con una percentuale di traffico di sviluppatori o interno, raccogli failure o redazioni e itera su prompt e budget. Per domini sensibili, richiedi revisione umana sugli output che includono ragionamento interno sostanziale prima del rilascio.

Suggerimenti di debug

• Inizia in piccolo: abilita budget_tokens basso e scala per comprendere miglioramenti incrementali.
• Attiva lo streaming e logga gli eventi content_block_delta / di firma per capire quando il modello produce blocchi di pensiero.
• Se usi Claude Code: controlla /config e le impostazioni a livello di progetto; consulta il changelog di Claude Code se il comportamento non corrisponde alle predefinite attese.

Conclusione:

Claude 4.5, combinato con la potenza dell’Extended Thinking e la CLI di Claude Code, rappresenta il salto più significativo nella produttività degli sviluppatori dai tempi dell’invenzione dell’IDE. Consentendo al modello di “mostrare il proprio lavoro” e deliberare su problemi complessi, Anthropic è andata oltre l’era dei “chatbot” ed è entrata nell’era “agentica”.

Che tu stia integrando la Messages API in uno strumento per sviluppatori personalizzato o usando Claude Code per gestire i tuoi PR quotidiani, padroneggiare la Thinking Mode è essenziale. Offre la trasparenza necessaria per la fiducia e la profondità di ragionamento necessaria per l’eccellenza.

Gli sviluppatori possono accedere al modello Claude 4.5 (Claude Sonnet 4.5 , Claude Haiku 4.5, Claude Opus 4.5) tramite CometAPI. Per iniziare, esplora le capacità dei modelli di CometAPI nel Playground e consulta la guida all’API per istruzioni dettagliate. Prima di accedere, assicurati di aver effettuato l’accesso a CometAPI e ottenuto la chiave API. CometAPI offre un prezzo molto inferiore rispetto a quello ufficiale per aiutarti nell’integrazione.

Pronto a partire? → Prova gratuita di Claude 4.5!