---
title: Effort
url: https://platform.claude.com/docs/it/build-with-claude/effort
description: Controlla quanti token Claude usa quando risponde tramite il parametro effort, bilanciando la completezza della risposta e l'efficienza dei token.
featureMetadata:
  status: ga
  zdr:
    eligibility: eligible
    note: Excludes [Covered Models](https://platform.claude.com/docs/en/manage-claude/api-and-data-retention#model-specific-data-retention-requirements).
  supportedModels:
    - claude-fable-5-1
    - claude-mythos-5-1
    - claude-fable-5
    - claude-mythos-5
    - claude-mythos-preview
    - claude-opus-5-5
    - claude-opus-5
    - claude-opus-4-8
    - claude-opus-4-7
    - claude-opus-4-6
    - claude-opus-4-5-20251101
    - claude-sonnet-5-5
    - claude-sonnet-5
    - claude-sonnet-4-6
    - claude-haiku-5-5
  supportedPlatforms:
    Claude API: ga
    Claude Platform on AWS: ga
    Amazon Bedrock: ga
    Google Cloud: ga
    Microsoft Foundry: ga
---

Il parametro "effort" (impegno) ti consente di controllare quanti token Claude spende quando risponde alle richieste. Puoi bilanciare tra completezza della risposta ed efficienza dei token con un singolo modello. Il parametro effort di primo livello è disponibile su tutti i modelli supportati senza necessità di header beta. L'[effort per messaggio](https://platform.claude.com/docs/it/build-with-claude/effort#change-effort-mid-conversation-beta) è in beta.

<Tip>
  Per scoprire come l'effort interagisce con il thinking e quale controllo utilizzare, consulta [Ragionamento ed effort](https://platform.claude.com/docs/it/build-with-claude/thinking#thinking-and-effort). Dove è disponibile l'adaptive thinking, l'effort è il modo consigliato per controllare la profondità del thinking.
</Tip>

## Imposta il livello di effort

Imposta `output_config.effort` nella richiesta. L'esempio seguente esegue una richiesta con effort `medium` e stampa il testo della risposta.

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "content-type: application/json" \
    -d '{
      "model": "claude-opus-5-5",
      "max_tokens": 4096,
      "messages": [{
        "role": "user",
        "content": "Analyze the trade-offs between microservices and monolithic architectures"
      }],
      "output_config": {
        "effort": "medium"
      }
    }'
  ```

  ```bash CLI
  ant messages create \
    --model claude-opus-5-5 \
    --max-tokens 4096 \
    --output-config '{effort: medium}' \
    --message '{role: user, content: "Analyze the trade-offs between microservices and monolithic architectures"}' \
    --transform 'content.#(type=="text").text' \
    --raw-output
  ```

  ```python Python
  client = anthropic.Anthropic()

  response = client.messages.create(
      model="claude-opus-5-5",
      max_tokens=4096,
      messages=[
          {
              "role": "user",
              "content": "Analyze the trade-offs between microservices and monolithic architectures",
          }
      ],
      output_config={"effort": "medium"},
  )

  for block in response.content:
      if block.type == "text":
          print(block.text)
  ```

  ```typescript TypeScript
  const client = new Anthropic();

  const response = await client.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 4096,
    messages: [
      {
        role: "user",
        content: "Analyze the trade-offs between microservices and monolithic architectures"
      }
    ],
    output_config: {
      effort: "medium"
    }
  });

  const textBlock = response.content.find(
    (block): block is Anthropic.TextBlock => block.type === "text"
  );
  console.log(textBlock?.text);
  ```

  ```csharp C#
  AnthropicClient client = new();

  var parameters = new MessageCreateParams
  {
      Model = Model.ClaudeOpus5_5,
      MaxTokens = 4096,
      Messages = [
          new() {
              Role = Role.User,
              Content = "Analyze the trade-offs between microservices and monolithic architectures"
          }
      ],
      OutputConfig = new OutputConfig
      {
          Effort = Effort.Medium
      }
  };

  var message = await client.Messages.Create(parameters);
  Console.WriteLine(message);
  ```

  ```go Go
  client := anthropic.NewClient()

  response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeOpus5_5,
  	MaxTokens: 4096,
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock("Analyze the trade-offs between microservices and monolithic architectures")),
  	},
  	OutputConfig: anthropic.OutputConfigParam{
  		Effort: anthropic.OutputConfigEffortMedium,
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }
  for _, block := range response.Content {
  	if textBlock, ok := block.AsAny().(anthropic.TextBlock); ok {
  		fmt.Println(textBlock.Text)
  	}
  }
  ```

  ```java Java
  import com.anthropic.models.messages.OutputConfig;

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

      MessageCreateParams params = MessageCreateParams.builder()
          .model(Model.CLAUDE_OPUS_5_5)
          .maxTokens(4096L)
          .addUserMessage("Analyze the trade-offs between microservices and monolithic architectures")
          .outputConfig(OutputConfig.builder()
              .effort(OutputConfig.Effort.MEDIUM)
              .build())
          .build();

      Message response = client.messages().create(params);
      response.content().stream()
          .flatMap(block -> block.text().stream())
          .forEach(textBlock -> IO.println(textBlock.text()));
  }
  ```

  ```php PHP
  $client = new Client();

  $message = $client->messages->create(
      maxTokens: 4096,
      messages: [
          ['role' => 'user', 'content' => 'Analyze the trade-offs between microservices and monolithic architectures']
      ],
      model: 'claude-opus-5-5',
      outputConfig: ['effort' => 'medium'],
  );

  foreach ($message->content as $block) {
      if ($block->type === 'text') {
          echo $block->text, PHP_EOL;
      }
  }
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  message = client.messages.create(
    model: "claude-opus-5-5",
    max_tokens: 4096,
    messages: [
      { role: "user", content: "Analyze the trade-offs between microservices and monolithic architectures" }
    ],
    output_config: {
      effort: "medium"
    }
  )

  message.content.each do |block|
    puts block.text if block.type == :text
  end
  ```
</CodeGroup>

## Come funziona l'effort

La maggior parte dei modelli Claude utilizza per impostazione predefinita un effort alto, spendendo tutti i token necessari per ottenere risultati eccellenti; Claude Opus 5.5 e Claude Haiku 5.5 utilizzano per impostazione predefinita il livello medium. Puoi aumentare il livello di effort a `max` per ottenere la massima capacità in assoluto, oppure abbassarlo per essere più parsimonioso nell'uso dei token, ottimizzando velocità e costi e accettando una certa riduzione delle capacità.

<Tip>
  Impostare `effort` sul valore predefinito del modello (`"medium"` su Claude Opus 5.5 e Claude Haiku 5.5, `"high"` sugli altri modelli) produce esattamente lo stesso comportamento dell'omissione completa del parametro `effort`.
</Tip>

Il parametro effort influisce su **tutti i token** della risposta, inclusi:

* Risposte testuali e spiegazioni
* Chiamate agli strumenti e argomenti delle funzioni
* Il "thinking" (ragionamento), quando attivo

Poiché l'effort si applica a ogni token di output, funziona indipendentemente dal fatto che il ragionamento sia abilitato o meno. Un effort più basso comporta anche chiamate agli strumenti meno numerose e più concise.

### Livelli di effort

| Livello  | Descrizione                                                                                                                                                                                                                                                                                                                            | Caso d'uso tipico                                                                                                    |
| -------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------- |
| `max`    | Capacità massima assoluta senza vincoli sulla spesa di token. Disponibile su Claude Fable 5.1, Claude Mythos 5.1, Claude Fable 5, Claude Mythos 5, Claude Mythos Preview, Claude Opus 5.5, Claude Opus 5, Claude Opus 4.8, Claude Opus 4.7, Claude Opus 4.6, Claude Sonnet 5.5, Claude Sonnet 5, Claude Sonnet 4.6 e Claude Haiku 5.5. | Attività che richiedono il ragionamento più profondo possibile e l'analisi più approfondita                          |
| `xhigh`  | Capacità estesa per lavori a lungo orizzonte. Disponibile su Claude Fable 5.1, Claude Mythos 5.1, Claude Fable 5, Claude Mythos 5, Claude Opus 5.5, Claude Opus 5, Claude Opus 4.8, Claude Opus 4.7, Claude Sonnet 5.5, Claude Sonnet 5 e Claude Haiku 5.5.                                                                            | Attività agentiche e di programmazione di lunga durata (oltre 30 minuti) con budget di token nell'ordine dei milioni |
| `high`   | Spende tutti i token di cui l'attività ha bisogno per ottenere risultati eccellenti. Il valore predefinito su ogni modello che supporta l'effort, eccetto Claude Opus 5.5 e Claude Haiku 5.5.                                                                                                                                          | Ragionamento complesso, problemi di programmazione difficili, attività agentiche                                     |
| `medium` | Approccio bilanciato con un risparmio moderato di token. Il valore predefinito su Claude Opus 5.5 e Claude Haiku 5.5.                                                                                                                                                                                                                  | Attività agentiche che richiedono un equilibrio tra velocità, costi e prestazioni                                    |
| `low`    | Il più efficiente. Risparmio significativo di token con una certa riduzione delle capacità.                                                                                                                                                                                                                                            | Attività più semplici che richiedono la massima velocità e i costi più bassi, come i subagenti                       |

Non tutti i modelli che supportano `max` supportano `xhigh`.

<Note>
  L'effort è un segnale comportamentale, non un budget di token rigoroso. A livelli di effort più bassi, Claude ragiona comunque su problemi sufficientemente difficili, ma ragiona meno di quanto farebbe a livelli di effort più alti per lo stesso problema.
</Note>

Le raccomandazioni per modello che seguono prevalgono su questa tabella laddove differiscono.

### Livelli di effort consigliati per Claude Fable 5.1

Claude Fable 5.1 supporta tutti e cinque i livelli di effort. **Inizia con `high`, il valore predefinito.** Sali a `xhigh` o `max` per i lavori agentici e di coding più sensibili alle capacità, e scendi a `medium` o `low` per lavori di routine o sensibili alla latenza una volta che le tue valutazioni mostrano che la qualità si mantiene. A `high` e oltre, imposta un `max_tokens` ampio. È un limite rigido sull'output totale (thinking più testo della risposta). Le stesse raccomandazioni si applicano a Claude Mythos 5.1. Consulta [Prompting per Claude Fable 5.1](https://platform.claude.com/docs/it/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#consider-all-effort-levels).

Claude Fable 5.1 supporta anche la [modifica dell'effort a metà conversazione](https://platform.claude.com/docs/it/build-with-claude/effort#change-effort-mid-conversation-beta) con un `output_config` per messaggio, che preserva la cache dei prompt.

### Livelli di effort consigliati per Claude Fable 5

L'effort è il controllo principale per bilanciare intelligenza, latenza e costo su Claude Fable 5. **Inizia con `high`, il valore predefinito, per la maggior parte delle attività**, usa `xhigh` per i carichi di lavoro più sensibili alle capacità e scendi a `medium` o `low` per i lavori di routine. Le impostazioni di effort più basse su Claude Fable 5 offrono comunque buone prestazioni e spesso superano le prestazioni di `xhigh` sui modelli precedenti. A `high` e `xhigh`, imposta un `max_tokens` ampio. È un limite rigido sull'output totale (thinking più testo della risposta). Consulta [Controllo dei costi](https://platform.claude.com/docs/it/build-with-claude/thinking-steering-and-cost#cost-control).

Riduci l'effort se un'attività viene completata ma richiede più tempo del necessario, o se desideri uno stile di lavoro più rapido e interattivo. Le stesse raccomandazioni si applicano a Claude Mythos 5. Per indicazioni più complete, consulta [Prompting per Claude Fable 5](https://platform.claude.com/docs/it/build-with-claude/prompt-engineering/prompting-claude-fable-5).

### Livelli di effort consigliati per Claude Opus 5.5

Claude Opus 5.5 supporta tutti e cinque i livelli di effort, e `medium` è il valore predefinito (Claude Opus 5 e i modelli Opus precedenti usano `high` come predefinito, quindi una richiesta che omette `effort` viene eseguita a un livello inferiore rispetto a Claude Opus 5). Il ragionamento adattivo è sempre attivo e non può essere disattivato, quindi l'effort è il controllo principale per stabilire quanto il modello ragiona e quanto costa una richiesta. Esegui una scansione dei livelli di effort sulle tue valutazioni invece di riportare le impostazioni da un modello precedente, e imposta un valore elevato di `max_tokens` ai livelli più alti: si tratta di un limite rigido sull'output totale (ragionamento più testo della risposta). Le richieste che impostano `thinking: {"type": "disabled"}` restituiscono un errore 400 a qualsiasi livello di effort. Claude Opus 5.5 supporta anche la [modifica dell'effort a metà conversazione](https://platform.claude.com/docs/it/build-with-claude/effort#change-effort-mid-conversation-beta) con un `output_config` per messaggio, che preserva la cache dei prompt. Consulta [Prompting di Claude Opus 5.5](https://platform.claude.com/docs/it/build-with-claude/prompt-engineering/prompting-claude-opus-5-5).

### Livelli di effort consigliati per Claude Opus 5

Claude Opus 5 supporta tutti e cinque i livelli di effort. **Inizia con `high`, il valore predefinito**, e regola in base alle tue valutazioni: passa a `xhigh` per il lavoro di coding e agentico impegnativo, o a `max` quando un'attività giustifica una spesa di token senza vincoli, e usa liberamente `low` e `medium` come controllo principale per il costo dei token e il tempo di risposta ovunque le tue valutazioni mostrino che la qualità si mantiene. Se hai riportato le impostazioni di effort da un modello precedente, esegui una nuova scansione dei livelli di effort sulle tue valutazioni invece di riutilizzarle.

L'effort controlla il volume del ragionamento, non la lunghezza visibile della risposta: su Claude Opus 5, modificare l'effort non accorcia in modo affidabile le risposte, quindi [specifica la lunghezza nel prompt](https://platform.claude.com/docs/it/build-with-claude/prompt-engineering/prompting-claude-opus-5#response-length-and-verbosity).

Il valore predefinito dell'API è `high`. Imposta `effort` esplicitamente per usare un livello diverso. Il valore che passi prevale su quello predefinito.

Su Claude Opus 5, il ragionamento non può essere disabilitato con effort `xhigh` o `max`: le richieste che impostano `thinking: {"type": "disabled"}` a quei livelli restituiscono un errore 400. Consulta [Effort con il thinking](https://platform.claude.com/docs/it/build-with-claude/effort#effort-with-thinking).

Quando esegui Claude Opus 5 con effort `xhigh` o `max`, imposta un `max_tokens` elevato in modo che il modello abbia spazio per ragionare e agire attraverso subagenti e chiamate agli strumenti. Iniziare da 64k token e regolare da lì è un valore predefinito ragionevole.

Claude Opus 5 supporta anche la [modifica dell'effort a metà conversazione](https://platform.claude.com/docs/it/build-with-claude/effort#change-effort-mid-conversation-beta) con un `output_config` per messaggio, che preserva la cache dei prompt. L'effort per messaggio non è disponibile per Claude Opus 5 su Amazon Bedrock.

### Livelli di effort consigliati per Claude Opus 4.8

Le indicazioni per Claude Opus 4.7 si applicano anche a Claude Opus 4.8. **Inizia con `xhigh` per i casi d'uso di coding e agentici**, usa `high` per la maggior parte degli altri carichi di lavoro sensibili all'intelligenza e scendi a `medium` o `low` solo quando hai misurato che il livello inferiore mantiene la qualità sulle tue valutazioni.

Il valore predefinito dell'API è `high`. Imposta `effort` esplicitamente per usare un livello diverso. Il valore che passi sovrascrive quello predefinito.

Quando esegui Claude Opus 4.8 con effort `xhigh` o `max`, imposta un `max_tokens` ampio in modo che il modello abbia spazio per pensare e agire attraverso subagenti e chiamate agli strumenti. Partire da 64k token e regolare da lì è un valore predefinito ragionevole.

### Livelli di effort consigliati per Claude Opus 4.7

**Inizia con `xhigh` per i casi d'uso di coding e agentici**, e usa `high` come minimo per la maggior parte dei carichi di lavoro sensibili all'intelligenza. Scendi a `medium` per i carichi di lavoro sensibili ai costi, o sali a `max` solo quando le tue valutazioni mostrano un margine di miglioramento misurabile rispetto a `xhigh`.

Il valore predefinito dell'API è `high`. Per usare `xhigh`, imposta `effort` esplicitamente. Il valore che passi prevale su quello predefinito.

| Effort   | Indicazioni per Claude Opus 4.7                                                                                                                                                                                                                                                        |
| -------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `low`    | Efficiente, ma ideale per attività brevi e circoscritte. Abbina `low` a checklist esplicite se la tua attività ha più sezioni.                                                                                                                                                         |
| `medium` | La scelta immediata per il flusso di lavoro medio in cui desideri buoni risultati riducendo i costi.                                                                                                                                                                                   |
| `high`   | Casi d'uso avanzati che richiedono comunque un equilibrio tra intelligenza e consumo di token. Questo è spesso il miglior equilibrio tra qualità ed efficienza dei token.                                                                                                              |
| `xhigh`  | Il punto di partenza consigliato per il lavoro di coding e agentico, e per attività esplorative come chiamate ripetute agli strumenti, ricerche web dettagliate e ricerche nella knowledge base. Aspettati un uso di token significativamente più elevato rispetto a `high`.           |
| `max`    | Riservalo ai problemi di frontiera. Sulla maggior parte dei carichi di lavoro `max` aggiunge costi significativi per guadagni di qualità relativamente piccoli, e su alcune attività con output strutturato o meno sensibili all'intelligenza può portare a un ragionamento eccessivo. |

Claude Opus 4.7 rispetta inoltre i livelli di effort in modo più rigoroso rispetto a Claude Opus 4.6, specialmente a `low` e `medium`. A livelli di effort più bassi, il modello limita il proprio lavoro a ciò che è stato richiesto invece di fare più del necessario. Se osservi un ragionamento superficiale su problemi complessi con Claude Opus 4.7, aumenta l'effort invece di aggirare il problema tramite il prompt. Se devi mantenere l'effort basso per motivi di latenza, aggiungi indicazioni mirate come "Questa attività comporta un ragionamento in più passaggi. Pensa attentamente prima di rispondere."

Quando esegui Claude Opus 4.7 con effort `xhigh` o `max`, imposta un `max_tokens` elevato in modo che il modello abbia spazio per ragionare e agire attraverso subagenti e chiamate agli strumenti. Iniziare da 64k token e regolare da lì è un valore predefinito ragionevole.

### Livelli di effort consigliati per Claude Sonnet 5.5

Claude Sonnet 5.5 supporta tutti e cinque i livelli di effort, e `high` è il valore predefinito sulla Claude API. I suoi livelli sono ricalibrati, quindi un livello non produce la stessa quantità di ragionamento dello stesso livello su Claude Sonnet 5. Esegui una nuova scansione dei livelli di effort sulle tue valutazioni invece di riportare l'impostazione che usavi su Claude Sonnet 5. Inizia con `high` a meno che il tuo carico di lavoro non sia agentico o sensibile alla latenza. Per la programmazione agentica e l'uso degli strumenti in più passaggi, inizia con `medium` per attività ben specificate e passa a `high` per quelle più difficili o più lunghe. Per la chat e altri lavori sensibili alla latenza, inizia con `medium` o `low`. Usa `xhigh` o `max` solo dove le tue valutazioni mostrano un guadagno di qualità. Imposta `max_tokens` lasciando spazio per il ragionamento e la risposta. Il ragionamento conta ai fini di `max_tokens` anche quando il contenuto del ragionamento non viene restituito. Per la programmazione agentica, imposta `max_tokens` a 128.000, il massimo del modello, e usa lo [streaming](https://platform.claude.com/docs/it/build-with-claude/streaming) per la risposta.

Per disattivare il ragionamento iniziale, invia `thinking: {"type": "between_tools"}` invece di `"disabled"`. È l'impostazione di ragionamento più bassa su Claude Sonnet 5.5 e funziona con effort `low`, `medium` e `high`. A `xhigh` o `max`, una richiesta con questa impostazione restituisce un errore 400, quindi usa il ragionamento adattivo a quei livelli: ometti il campo `thinking` o invia `thinking: {"type": "adaptive"}`. Consulta [Esecuzione senza ragionamento iniziale](https://platform.claude.com/docs/it/build-with-claude/prompt-engineering/prompting-claude-sonnet-5-5#running-without-up-front-thinking).

Claude Sonnet 5.5 supporta anche la [modifica dell'effort a metà conversazione](https://platform.claude.com/docs/it/build-with-claude/effort#change-effort-mid-conversation-beta) con un `output_config` per messaggio, che preserva la cache dei prompt. Con `between_tools`, l'effort non può cambiare a metà conversazione: un `output_config.effort` per messaggio che differisce dal livello in vigore restituisce un errore 400. Per variare l'effort a ogni turno, usa il ragionamento adattivo. Consulta [Scrivere prompt per Claude Sonnet 5.5](https://platform.claude.com/docs/it/build-with-claude/prompt-engineering/prompting-claude-sonnet-5-5#calibrate-effort).

### Livelli di effort consigliati per Claude Sonnet 5

Claude Sonnet 5 usa per impostazione predefinita l'effort `high` sulla Claude API e su Claude Code.

* **Effort high (predefinito):** Adatto per ragionamento complesso, coding e attività agentiche in cui la qualità conta più della velocità o del costo.
* **Effort xhigh:** Per le attività di coding e agentiche più difficili. Consulta [Prompting per Claude Sonnet 5](https://platform.claude.com/docs/it/build-with-claude/prompt-engineering/prompting-claude-sonnet-5#calibrating-effort-and-thinking-depth).
* **Effort medium:** Riduzione rispetto al valore predefinito per risparmiare sui costi. Paragonabile a Claude Sonnet 4.6 con effort high.
* **Effort low:** Per carichi di lavoro ad alto volume o sensibili alla latenza. Adatto per chat e casi d'uso non di coding in cui si privilegiano tempi di risposta più rapidi.
* **Effort max:** Per attività che richiedono la capacità assolutamente più elevata senza vincoli sulla spesa di token.

### Livelli di effort consigliati per Claude Sonnet 4.6

Sonnet 4.6 utilizza per impostazione predefinita l'effort `high`. Imposta esplicitamente l'effort quando usi Sonnet 4.6 per evitare latenze impreviste:

* **Effort medium** (valore predefinito consigliato): Il miglior equilibrio tra velocità, costi e prestazioni per la maggior parte delle applicazioni. Adatto per il coding agentico, i flussi di lavoro con uso intensivo di strumenti e la generazione di codice.
* **Effort low:** Per carichi di lavoro ad alto volume o sensibili alla latenza. Adatto per chat e casi d'uso non di coding in cui si privilegiano tempi di risposta più rapidi.
* **Effort high:** Per ragionamento complesso e attività in cui la qualità conta più della velocità o dei costi.
* **Effort max:** Per attività che richiedono la massima capacità in assoluto senza vincoli sulla spesa di token.

### Livelli di effort consigliati per Claude Haiku 5.5

Claude Haiku 5.5 supporta tutti e cinque i livelli di effort, e `medium` è il valore predefinito. L'effort è il controllo principale per quanto il modello ragiona e, di conseguenza, per qualità, latenza e costi. **Inizia con `medium`** per la maggior parte del lavoro, inclusa la programmazione agentica. Usa `low`, il livello più economico e veloce, per la chat, le attività brevi con strumenti e le richieste semplici ad alto volume. Nei prompt lunghi per agenti, a `low` è più probabile che il modello salti una ricerca, si fermi prima del tempo o salti una verifica. Usa `high` per il lavoro di conoscenza, le attività agentiche più lunghe e il rispetto rigoroso delle istruzioni. Usa `xhigh` o `max` solo dove le tue valutazioni mostrano un guadagno di qualità, e confrontali con Claude Sonnet 5.5 in termini di prestazioni, costi e velocità. Il ragionamento è attivo per impostazione predefinita e conta ai fini di `max_tokens`, quindi lascia spazio per esso. Consulta [Prompting per Claude Haiku 5.5](https://platform.claude.com/docs/it/build-with-claude/prompt-engineering/prompting-claude-haiku-5-5#use-effort-to-control-thinking).

Per ottenere meno ragionamento, abbassa il livello di effort. Puoi anche inviare `thinking: {"type": "disabled"}` con effort `high` o inferiore. A `xhigh` o `max`, restituisce un errore 400, quindi usa il ragionamento adattivo a quei livelli: ometti il campo `thinking` o invia `thinking: {"type": "adaptive"}`.

Sulla Claude API e su Google Cloud, Claude Haiku 5.5 supporta anche la [modifica dell'effort a metà conversazione](https://platform.claude.com/docs/it/build-with-claude/effort#change-effort-mid-conversation-beta) con un `output_config` per messaggio, che preserva la cache dei prompt. Con `thinking: {"type": "disabled"}`, l'effort non può cambiare a metà conversazione: un `output_config.effort` per messaggio che differisce dal livello in vigore restituisce un errore 400. Per variare l'effort a ogni turno, usa il ragionamento adattivo.

## Effort con l'uso degli strumenti

Quando si usano strumenti, il parametro effort influisce sia sulle spiegazioni attorno alle chiamate agli strumenti sia sulle chiamate stesse. I livelli di effort più bassi tendono a:

* Combinare più operazioni in meno chiamate agli strumenti
* Effettuare meno chiamate agli strumenti
* Procedere direttamente all'azione senza preamboli
* Usare messaggi di conferma concisi dopo il completamento

I livelli di effort più alti possono:

* Effettuare più chiamate agli strumenti
* Spiegare il piano prima di agire
* Fornire riepiloghi dettagliati delle modifiche
* Includere commenti al codice più completi

## Effort con il thinking

Il parametro `thinking` controlla se Claude riflette in [blocchi di ragionamento](https://platform.claude.com/docs/it/build-with-claude/thinking) prima di rispondere; il parametro `effort` controlla quanto lavoro Claude dedica all'intera risposta, il che in modalità adattiva include quanto spesso e quanto profondamente riflette. Non passare `adaptive` come valore di `effort`: `adaptive` è una modalità di ragionamento, non un livello di effort.

A livelli di effort più alti, Claude pensa più facilmente e più a lungo. In un ciclo di uso degli strumenti, le richieste successive che elaborano solo i risultati degli strumenti possono comunque saltare il ragionamento a qualsiasi livello. A livelli più bassi, Claude può saltare completamente il ragionamento per i problemi più semplici. Consulta [Ragionamento ed effort](https://platform.claude.com/docs/it/build-with-claude/thinking#thinking-and-effort) per indicazioni complete su come i due controlli funzionano insieme.

Su Claude Opus 4.5, l'unico modello con solo "extended thinking" (ragionamento esteso) che supporta l'effort, questo funziona insieme a [`budget_tokens`](https://platform.claude.com/docs/it/build-with-claude/extended-thinking): imposta il livello di effort per la tua attività, quindi imposta il budget di token per il thinking in base alla profondità di ragionamento richiesta dall'attività.

Per la disponibilità del thinking per modello, consulta la [tabella di configurazione per modello](https://platform.claude.com/docs/it/build-with-claude/thinking-troubleshooting#supported-models). L'effort funziona con o senza thinking. Consulta [Come funziona l'effort](https://platform.claude.com/docs/it/build-with-claude/effort#how-effort-works).

## Cambiare l'effort a metà conversazione

Puoi eseguire i turni successivi di una conversazione a un livello di effort diverso in due modi. Su Claude Fable 5.1, Claude Mythos 5.1, Claude Opus 5.5, Claude Opus 5, Claude Sonnet 5.5 e Claude Haiku 5.5, usa una modifica dell'effort per messaggio, che mantiene la cache dei prompt. Sugli altri modelli, imposta un nuovo valore di primo livello nella richiesta successiva, il che fa ripartire la cache da zero.

### Effort per messaggio (beta)

L'effort per messaggio è in beta. Sulla Claude API e su [Google Cloud](https://platform.claude.com/docs/it/build-with-claude/claude-on-vertex-ai), è disponibile su Claude Fable 5.1, Claude Mythos 5.1, Claude Opus 5.5, Claude Opus 5, Claude Sonnet 5.5 e Claude Haiku 5.5. Su [Amazon Bedrock](https://platform.claude.com/docs/it/build-with-claude/claude-in-amazon-bedrock), è disponibile su Claude Fable 5.1, Claude Mythos 5.1 e Claude Opus 5.5. Richiede l'[header beta](https://platform.claude.com/docs/it/api/beta-headers) `mid-conversation-output-config-2026-07-01`. Con l'[API InvokeModel](https://platform.claude.com/docs/it/build-with-claude/claude-on-amazon-bedrock-legacy) di Amazon Bedrock, è disponibile su Claude Fable 5.1 e Claude Opus 5.5, e in questo caso invii quel valore nell'array `anthropic_beta` del corpo della richiesta.

Senza il valore beta, un `output_config` per messaggio restituisce un errore 400: `messages.N.output_config: Extra inputs are not permitted`, dove `N` è l'indice del messaggio `system` in `messages`. Con il valore beta, i modelli senza effort per messaggio, incluso Claude Fable 5, restituiscono un errore 400: `output_config.effort requires a model that supports per-turn effort; this model does not`. Su Amazon Bedrock, quei modelli e Claude Opus 5 restituiscono invece l'errore `Extra inputs are not permitted`. Su Claude Sonnet 5.5 con `thinking: {"type": "between_tools"}` e su Claude Haiku 5.5 con `thinking: {"type": "disabled"}`, l'effort non può cambiare a metà conversazione: un `output_config.effort` per messaggio che differisce dal livello in vigore restituisce un errore 400. Per variare l'effort a ogni turno, usa il ragionamento adattivo.

Aggiungi un messaggio `role: "system"` con `content` vuoto e il nuovo livello in `output_config.effort`. Posizionato direttamente dopo un turno `user` con un nuovo input, imposta il livello per la risposta di Claude a quel turno. Posizionato altrove, ad esempio tra un turno `assistant` e il turno `user` successivo come nell'esempio seguente, ha effetto a partire dal turno `user` successivo con un nuovo input. Un turno `user` che contiene solo blocchi `tool_result` non conta come nuovo input, quindi una modifica posizionata dopo di esso in un ciclo di uso degli strumenti attende il turno `user` successivo con un nuovo input. Il nuovo livello rimane poi in vigore finché un messaggio successivo non lo modifica. Tutto ciò che precede quel messaggio rimane invariato, quindi il prefisso in cache corrisponde ancora.

L'esempio seguente inizia con `high`, poi scende a `low` per una domanda di follow-up di routine:

<CodeGroup>
  ```bash cURL
  # Messaggio di sistema solo per l'effort: il nuovo livello ha effetto dal prossimo turno utente.
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: mid-conversation-output-config-2026-07-01" \
    -H "content-type: application/json" \
    -d '{
      "model": "claude-fable-5-1",
      "max_tokens": 4096,
      "output_config": {"effort": "high"},
      "messages": [
        {"role": "user", "content": "Plan a migration from SQLite to PostgreSQL in three short steps."},
        {"role": "assistant", "content": "1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts."},
        {"role": "system", "content": [], "output_config": {"effort": "low"}},
        {"role": "user", "content": "Summarize the plan in one sentence."}
      ]
    }'
  ```

  ```bash CLI
  ant beta:messages create --beta mid-conversation-output-config-2026-07-01 \
    --transform 'content.#(type=="text").text' --raw-output <<'YAML'
  model: claude-fable-5-1
  max_tokens: 4096
  output_config:
    effort: high
  messages:
    - role: user
      content: Plan a migration from SQLite to PostgreSQL in three short steps.
    - role: assistant
      content: "1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts."
    # Messaggio di sistema solo per l'effort: il nuovo livello ha effetto dal prossimo turno utente.
    - role: system
      content: []
      output_config:
        effort: low
    - role: user
      content: Summarize the plan in one sentence.
  YAML
  ```

  ```python Python
  client = anthropic.Anthropic()

  response = client.beta.messages.create(
      model="claude-fable-5-1",
      max_tokens=4096,
      output_config={"effort": "high"},
      messages=[
          {
              "role": "user",
              "content": "Plan a migration from SQLite to PostgreSQL in three short steps.",
          },
          {
              "role": "assistant",
              "content": "1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts.",
          },
          # Messaggio di sistema solo per l'effort: il nuovo livello si applica dal prossimo turno utente.
          {"role": "system", "content": [], "output_config": {"effort": "low"}},
          {"role": "user", "content": "Summarize the plan in one sentence."},
      ],
      betas=["mid-conversation-output-config-2026-07-01"],
  )

  for block in response.content:
      if block.type == "text":
          print(block.text)
  ```

  ```typescript TypeScript
  const client = new Anthropic();

  const response = await client.beta.messages.create({
    model: "claude-fable-5-1",
    max_tokens: 4096,
    output_config: { effort: "high" },
    messages: [
      {
        role: "user",
        content: "Plan a migration from SQLite to PostgreSQL in three short steps."
      },
      {
        role: "assistant",
        content:
          "1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts."
      },
      // Messaggio di sistema solo per l'effort: il nuovo livello ha effetto dal prossimo turno utente.
      { role: "system", content: [], output_config: { effort: "low" } },
      { role: "user", content: "Summarize the plan in one sentence." }
    ],
    betas: ["mid-conversation-output-config-2026-07-01"]
  });

  for (const block of response.content) {
    if (block.type === "text") {
      console.log(block.text);
    }
  }
  ```

  ```csharp C#
  using Anthropic.Models.Beta;
  using Anthropic.Models.Beta.Messages;
  using Model = Anthropic.Models.Messages.Model;

  AnthropicClient client = new();

  var response = await client.Beta.Messages.Create(new MessageCreateParams
  {
      Model = Model.ClaudeFable5_1,
      MaxTokens = 4096,
      OutputConfig = new() { Effort = Effort.High },
      Messages =
      [
          new() { Role = Role.User, Content = "Plan a migration from SQLite to PostgreSQL in three short steps." },
          new() { Role = Role.Assistant, Content = "1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts." },
          // Messaggio di sistema solo per l'effort: il nuovo livello ha effetto dal prossimo turno dell'utente.
          new()
          {
              Role = Role.System,
              Content = new([]),
              OutputConfig = new() { Effort = BetaSystemMessageOutputConfigEffort.Low },
          },
          new() { Role = Role.User, Content = "Summarize the plan in one sentence." },
      ],
      Betas = [AnthropicBeta.MidConversationOutputConfig2026_07_01],
  });

  foreach (var block in response.Content)
  {
      if (block.TryPickText(out var textBlock))
      {
          Console.WriteLine(textBlock.Text);
      }
  }
  ```

  ```go Go
  client := anthropic.NewClient()

  response, err := client.Beta.Messages.New(context.Background(), anthropic.BetaMessageNewParams{
  	Model:     anthropic.ModelClaudeFable5_1,
  	MaxTokens: 4096,
  	OutputConfig: anthropic.BetaOutputConfigParam{
  		Effort: anthropic.BetaOutputConfigEffortHigh,
  	},
  	Messages: []anthropic.BetaMessageParam{
  		anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Plan a migration from SQLite to PostgreSQL in three short steps.")),
  		{
  			Role:    anthropic.BetaMessageParamRoleAssistant,
  			Content: []anthropic.BetaContentBlockParamUnion{anthropic.NewBetaTextBlock("1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts.")},
  		},
  		// Messaggio di sistema solo per l'effort: il nuovo livello ha effetto dal prossimo turno utente.
  		anthropic.NewBetaSystemMessage(anthropic.BetaSystemMessageOutputConfigParam{
  			Effort: anthropic.BetaSystemMessageOutputConfigEffortLow,
  		}),
  		anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Summarize the plan in one sentence.")),
  	},
  	Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaMidConversationOutputConfig2026_07_01},
  })
  if err != nil {
  	log.Fatal(err)
  }

  for _, block := range response.Content {
  	if textBlock, ok := block.AsAny().(anthropic.BetaTextBlock); ok {
  		fmt.Println(textBlock.Text)
  	}
  }
  ```

  ```java Java
  import com.anthropic.models.beta.AnthropicBeta;
  import com.anthropic.models.beta.messages.BetaMessage;
  import com.anthropic.models.beta.messages.BetaMessageParam;
  import com.anthropic.models.beta.messages.BetaOutputConfig;
  import com.anthropic.models.beta.messages.BetaSystemMessageOutputConfig;
  import com.anthropic.models.beta.messages.MessageCreateParams;
  import com.anthropic.models.messages.Model;

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

      MessageCreateParams params = MessageCreateParams.builder()
          .model(Model.CLAUDE_FABLE_5_1)
          .maxTokens(4096L)
          .addBeta(AnthropicBeta.MID_CONVERSATION_OUTPUT_CONFIG_2026_07_01)
          .outputConfig(BetaOutputConfig.builder()
              .effort(BetaOutputConfig.Effort.HIGH)
              .build())
          .addUserMessage("Plan a migration from SQLite to PostgreSQL in three short steps.")
          .addAssistantMessage("1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts.")
          // Messaggio di sistema solo per l'effort: il nuovo livello ha effetto dal prossimo turno utente.
          .addMessage(BetaMessageParam.builder()
              .role(BetaMessageParam.Role.SYSTEM)
              .contentOfBetaContentBlockParams(List.of())
              .outputConfig(BetaSystemMessageOutputConfig.builder()
                  .effort(BetaSystemMessageOutputConfig.Effort.LOW)
                  .build())
              .build())
          .addUserMessage("Summarize the plan in one sentence.")
          .build();

      BetaMessage response = client.beta().messages().create(params);
      response.content().stream()
          .flatMap(block -> block.text().stream())
          .forEach(textBlock -> IO.println(textBlock.text()));
  }
  ```

  ```php PHP
  use Anthropic\Beta\AnthropicBeta;
  use Anthropic\Beta\Messages\BetaMessageParam;
  use Anthropic\Beta\Messages\BetaOutputConfig;
  use Anthropic\Beta\Messages\BetaSystemMessageOutputConfig;
  use Anthropic\Client;

  $client = new Client();

  $response = $client->beta->messages->create(
      model: 'claude-fable-5-1',
      maxTokens: 4096,
      outputConfig: BetaOutputConfig::with(effort: 'high'),
      messages: [
          BetaMessageParam::with(role: 'user', content: 'Plan a migration from SQLite to PostgreSQL in three short steps.'),
          BetaMessageParam::with(role: 'assistant', content: '1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts.'),
          // Messaggio di sistema solo per l'effort: il nuovo livello ha effetto dal prossimo turno utente.
          BetaMessageParam::with(
              role: 'system',
              content: [],
              outputConfig: BetaSystemMessageOutputConfig::with(effort: 'low'),
          ),
          BetaMessageParam::with(role: 'user', content: 'Summarize the plan in one sentence.'),
      ],
      betas: [AnthropicBeta::MID_CONVERSATION_OUTPUT_CONFIG_2026_07_01],
  );

  foreach ($response->content as $block) {
      if ($block->type === 'text') {
          echo $block->text, PHP_EOL;
      }
  }
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  response = client.beta.messages.create(
    model: "claude-fable-5-1",
    max_tokens: 4096,
    output_config: {effort: :high},
    messages: [
      {role: "user", content: "Plan a migration from SQLite to PostgreSQL in three short steps."},
      {role: "assistant", content: "1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts."},
      # Messaggio di sistema solo per l'effort: il nuovo livello ha effetto dal prossimo turno utente.
      {role: "system", content: [], output_config: {effort: :low}},
      {role: "user", content: "Summarize the plan in one sentence."}
    ],
    betas: [Anthropic::AnthropicBeta::MID_CONVERSATION_OUTPUT_CONFIG_2026_07_01]
  )

  response.content.each do |block|
    puts block.text if block.type == :text
  end
  ```
</CodeGroup>

Un messaggio di sistema con solo l'effort non contiene testo, quindi le [regole di posizionamento per i messaggi di sistema a metà conversazione](https://platform.claude.com/docs/it/build-with-claude/mid-conversation-system-messages#limitations) non si applicano. Può comparire in qualsiasi punto di `messages`, anche come prima voce o tra un turno `assistant` e il turno `user` successivo. I valori sono i nomi dei livelli (`low`, `medium`, `high`, `xhigh` e `max`).

Preferisci questa forma alla modifica del valore di primo livello tra una richiesta e l'altra. Una modifica di primo livello fa ripartire la cache e, su Claude Fable 5.1, orienta anche il modello in modo meno affidabile: le sue risposte precedenti sono state scritte al livello precedente e il modello tende a rimanere coerente con esse.

### Effort di primo livello nella richiesta successiva

L'`output_config.effort` di primo livello si applica all'intera richiesta. Per eseguire una parte successiva di una conversazione a un livello diverso, imposta il nuovo valore nella richiesta successiva. Poiché l'effort di primo livello modella il prompt renderizzato, modificarlo tra le richieste non preserva i prefissi in cache dei turni precedenti. Se fai affidamento sulla [cache dei prompt](https://platform.claude.com/docs/it/build-with-claude/prompt-caching) in una sessione lunga e il tuo modello non supporta l'effort per messaggio, scegli un livello di effort all'inizio e mantienilo costante.

## Best practice

1. **Imposta l'effort esplicitamente:** L'API utilizza per impostazione predefinita `high` (`medium` su Claude Opus 5.5 e Claude Haiku 5.5), ma il punto di partenza giusto dipende dal tuo modello e dal tuo carico di lavoro.
2. **Usa low per attività sensibili alla velocità o semplici:** Quando la latenza è importante o le attività sono semplici, un effort basso può ridurre significativamente i tempi di risposta e i costi.
3. **Testa il tuo caso d'uso:** L'impatto dei livelli di effort varia in base al tipo di attività. Valuta le prestazioni sui tuoi casi d'uso specifici prima del deployment.
4. **Considera un effort dinamico:** Regola l'effort in base alla complessità dell'attività. Le query semplici possono giustificare un effort basso, mentre la programmazione agentica e il ragionamento complesso traggono vantaggio da un effort alto. Consulta il punto successivo prima di variarlo all'interno di una stessa conversazione.
5. **Mantieni costante l'effort di primo livello nelle conversazioni in cache:** Modificare il valore dell'effort di primo livello tra una richiesta e l'altra invalida la [cache dei prompt](https://platform.claude.com/docs/it/build-with-claude/prompt-caching), quindi varialo tra carichi di lavoro diversi anziché all'interno di una conversazione che si basa sugli hit della cache. Sui modelli che lo supportano, usa invece una [modifica dell'effort per messaggio](https://platform.claude.com/docs/it/build-with-claude/effort#change-effort-mid-conversation-beta), che preserva la cache. Consulta [Ragionamento e cache dei prompt](https://platform.claude.com/docs/it/build-with-claude/thinking#thinking-and-prompt-caching).

## Passaggi successivi

<CardGroup>
  <Card title="Budget delle attività" icon="gauge" href="https://platform.claude.com/docs/it/build-with-claude/task-budgets">
    Fornisci a Claude un budget di token indicativo per l'intero ciclo agentico, per aiutare il modello ad autoregolarsi nelle attività agentiche lunghe.
  </Card>

  <Card title="Orientare il ragionamento" icon="compass" href="https://platform.claude.com/docs/it/build-with-claude/thinking-steering-and-cost">
    Comprendi il ragionamento adattivo, in cui Claude determina quando e quanto ragionare, e orientalo con l'effort e il prompting.
  </Card>

  <Card title="Ragionamento" icon="brain" href="https://platform.claude.com/docs/it/build-with-claude/thinking">
    Comprendi come funziona il ragionamento, quando Claude ragiona per impostazione predefinita e come il ragionamento interagisce con l'effort.
  </Card>
</CardGroup>