---
title: Guida alla migrazione a Claude Fable 5.1 e Claude Mythos 5.1
url: https://platform.claude.com/docs/it/models/fable-5-1/migration-guide
description: Passa a Claude Fable 5.1 e Claude Mythos 5.1 da Claude Fable 5, Claude Mythos 5, Claude Opus 5 o Claude Opus 4.8 con questa guida alla migrazione. Le indicazioni per abilitare Claude Fable 5.1 e Claude Mythos 5.1 includono ID dei modelli, modifiche incompatibili e checklist di migrazione.
---

<Note>
  Questa guida copre la migrazione del codice della [Messages API](https://platform.claude.com/docs/it/build-with-claude/working-with-messages). Se usi [Claude Managed Agents](https://platform.claude.com/docs/it/managed-agents/overview), non sono necessarie modifiche oltre all'aggiornamento del nome del modello.
</Note>

<Tip>
  **Automatizza la tua migrazione con la skill Claude API.** In Claude Code, esegui `/claude-api migrate` per invocare la [skill Claude API](https://platform.claude.com/docs/it/agents-and-tools/agent-skills/claude-api-skill#migrating-to-a-newer-claude-model) inclusa. Funziona con qualsiasi modello Claude attuale come destinazione:

  Lascia che Claude Code migri il tuo codice per te

  ```text
  /claude-api migrate questo progetto a claude-fable-5-1
  ```

  La skill applica la sostituzione dell'ID del modello e, se necessario, le modifiche incompatibili ai parametri, la sostituzione del prefill e la calibrazione dell'effort per il modello di destinazione in tutta la tua base di codice, quindi produce una checklist di elementi da verificare manualmente. Ti chiede di confermare l'ambito della migrazione (l'intera directory di lavoro, una sottodirectory o un elenco specifico di file) prima di modificare qualsiasi file. La skill rileva inoltre i client Amazon Bedrock e Claude Platform su AWS e adatta i formati degli ID dei modelli e le modifiche alle funzionalità per tali piattaforme.
</Tip>

[Claude Fable 5.1](https://platform.claude.com/docs/it/models/fable-5-1/whats-new-fable-5-1) succede a Claude Fable 5 agli stessi prezzi di input e output, con letture dalla cache a un quarto del costo. È disponibile sulla Claude API, su [Amazon Bedrock](https://platform.claude.com/docs/it/build-with-claude/claude-in-amazon-bedrock), [Claude Platform on AWS](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws), [Google Cloud](https://platform.claude.com/docs/it/build-with-claude/claude-on-vertex-ai) e [Microsoft Foundry](https://platform.claude.com/docs/it/build-with-claude/claude-in-microsoft-foundry). [Claude Mythos 5.1](https://platform.claude.com/docs/it/models/mythos-5-1/overview) condivide le stesse capacità ed è disponibile solo per le organizzazioni verificate tramite i programmi di verifica di Anthropic, come il [Cyber Verification Program](https://support.claude.com/en/articles/14604842). Per le differenze di comportamento e i pattern di prompting, consulta [Prompting per Claude Fable 5.1](https://platform.claude.com/docs/it/build-with-claude/prompt-engineering/prompting-claude-fable-5-1).

Le impostazioni di base condivise da `claude-fable-5-1` e `claude-mythos-5-1`:

* **Ragionamento:** L'[adaptive thinking](https://platform.claude.com/docs/it/build-with-claude/thinking) (ragionamento adattivo) è sempre attivo, invariato rispetto a Claude Fable 5. Il modello determina quando e quanto ragionare. Non è richiesta alcuna configurazione `thinking`. Sia `thinking: {type: "disabled"}` sia il ragionamento esteso manuale (`thinking: {type: "enabled", budget_tokens: N}`) restituiscono un errore 400.
* **Prefill:** Il prefill del messaggio dell'assistente restituisce un errore 400, invariato rispetto a Claude Fable 5. Usa invece istruzioni nel "system prompt" (prompt di sistema).
* **Tool choice:** `{type: "auto"}` (il valore predefinito) e `{type: "none"}` sono supportati. Forzare una chiamata a uno strumento con `{type: "any"}` o `{type: "tool", name: "..."}` restituisce un errore 400. Consulta [Modifiche incompatibili](https://platform.claude.com/docs/it/models/fable-5-1/migration-guide#fable-5-1-breaking-changes).
* **Thinking preservato tra modelli:** Claude Fable 5.1 legge i blocchi di thinking di Claude Opus 5, Claude Fable 5, Claude Mythos 5 e dei modelli Claude precedenti. Nessuno di questi modelli può leggere i blocchi di Claude Fable 5.1. Consulta [Modifiche incompatibili](https://platform.claude.com/docs/it/models/fable-5-1/migration-guide#fable-5-1-breaking-changes).
* **Finestra di contesto e output:** Una ["context window" (finestra di contesto) da 1M di token](https://platform.claude.com/docs/it/build-with-claude/context-windows) per impostazione predefinita, e fino a 128k token di output per richiesta.
* **Prezzi:** $10 USD per milione di token di input e $50 USD per milione di token di output, come Claude Fable 5. Le letture dalla cache dei prompt costano $0,25 USD per milione di token, un quarto della tariffa di Claude Fable 5. Consulta [Prezzi di Claude](https://platform.claude.com/docs/it/about-claude/pricing).
* **Conservazione dei dati:** Entrambi i modelli richiedono una conservazione dei dati di 30 giorni, non sono disponibili con accordi di zero data retention (ZDR) salvo espressa autorizzazione di Anthropic, e sono designati come Covered Models, come Claude Fable 5 e Claude Mythos 5. Sulla Claude API, una richiesta proveniente da un'organizzazione o un workspace senza conservazione di 30 giorni restituisce un errore 400 `invalid_request_error`. Le organizzazioni con un accordo ZDR devono contattare il proprio team account Anthropic, oppure configurare la conservazione per singolo workspace. Consulta [Requisiti di conservazione dei dati specifici per modello](https://platform.claude.com/docs/it/manage-claude/api-and-data-retention#model-specific-data-retention-requirements) per i dettagli per piattaforma.

Dove i due modelli divergono:

* **Disponibilità:** Claude Fable 5.1 non richiede l'approvazione dell'accesso. Claude Mythos 5.1 è disponibile solo per le organizzazioni verificate tramite i programmi di verifica di Anthropic, come il [Cyber Verification Program](https://support.claude.com/en/articles/14604842). Per richiedere l'accesso, candidati al programma che copre il tuo caso d'uso oppure contatta il tuo team account di Anthropic.
* **Priority Tier:** Nessuno dei due modelli è supportato su [Priority Tier](https://platform.claude.com/docs/it/api/service-tiers#supported-models). Claude Fable 5 lo è.

## Migrazione a Claude Fable 5.1 da Claude Fable 5

La migrazione è per lo più drop-in. La superficie dell'API, i limiti, i prezzi per token, il tokenizer, il ragionamento adattivo sempre attivo, la gestione dei rifiuti e le categorie `stop_details` corrispondono tutti a Claude Fable 5. Cosa cambia: la scelta forzata dello strumento restituisce un errore 400; solo Claude Fable 5.1 e Claude Mythos 5.1 leggono i blocchi di ragionamento di Claude Fable 5.1, e solo nella conversazione che li ha prodotti; le letture dalla cache costano meno; e il comportamento nei loop agentici differisce in tre modi. Le stesse modifiche si applicano a [Claude Mythos 5.1](https://platform.claude.com/docs/it/models/fable-5-1/migration-guide#migrating-from-claude-mythos-5-to-claude-mythos-5-1), tranne il controllo della conversazione sui blocchi di ragionamento, che Claude Mythos 5.1 non esegue.

### Aggiorna il nome del modello

```python
model = "claude-fable-5"  # Before
model = "claude-fable-5-1"  # After

# Oppure, per Claude Mythos 5.1, che offre le stesse funzionalità alle organizzazioni verificate:
model = "claude-mythos-5-1"  # After
```

### Modifiche incompatibili

1. **Il tool choice forzato non è supportato:** Claude Fable 5 accetta `tool_choice` `auto`, `none`, `any` e `tool`. Su `claude-fable-5-1`, `{type: "any"}` e `{type: "tool", name: "..."}` restituiscono un errore 400 `invalid_request_error`:

   ```text wrap
   tool_choice: type "tool" and "any" are not supported for this model.
   ```

   Il controllo si applica alla Messages API, alla Message Batches API e all'endpoint di [conteggio dei token](https://platform.claude.com/docs/it/build-with-claude/token-counting).

   Prima (Claude Fable 5):

   <CodeGroup>
     ```bash cURL
     curl -sS https://api.anthropic.com/v1/messages \
       -H "content-type: application/json" \
       -H "x-api-key: $ANTHROPIC_API_KEY" \
       -H "anthropic-version: 2023-06-01" \
       -d '{
         "model": "claude-fable-5",
         "max_tokens": 16000,
         "tools": [
           {
             "name": "record_summary",
             "description": "Record the structured summary of the document.",
             "input_schema": {
               "type": "object",
               "properties": {"summary": {"type": "string"}},
               "required": ["summary"]
             }
           }
         ],
         "tool_choice": {"type": "tool", "name": "record_summary"},
         "messages": [
           {"role": "user", "content": "Summarize: The meeting moved to Thursday."}
         ]
       }'
     ```

     ```bash CLI
     ant messages create <<'YAML'
     model: claude-fable-5
     max_tokens: 16000
     tools:
       - name: record_summary
         description: Record the structured summary of the document.
         input_schema:
           type: object
           properties:
             summary:
               type: string
           required: [summary]
     tool_choice:
       type: tool
       name: record_summary
     messages:
       - role: user
         content: "Summarize: The meeting moved to Thursday."
     YAML
     ```

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

     record_summary_tool = {
         "name": "record_summary",
         "description": "Record the structured summary of the document.",
         "input_schema": {
             "type": "object",
             "properties": {"summary": {"type": "string"}},
             "required": ["summary"],
         },
     }

     response = client.messages.create(
         model="claude-fable-5",
         max_tokens=16000,
         tools=[record_summary_tool],
         tool_choice={"type": "tool", "name": "record_summary"},
         messages=[{"role": "user", "content": "Summarize: The meeting moved to Thursday."}],
     )
     print(response.content)
     ```

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

     const response = await client.messages.create({
       model: "claude-fable-5",
       max_tokens: 16000,
       tools: [
         {
           name: "record_summary",
           description: "Record the structured summary of the document.",
           input_schema: {
             type: "object",
             properties: { summary: { type: "string" } },
             required: ["summary"]
           }
         }
       ],
       tool_choice: { type: "tool", name: "record_summary" },
       messages: [{ role: "user", content: "Summarize: The meeting moved to Thursday." }]
     });

     console.log(response.content);
     ```

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

     var parameters = new MessageCreateParams
     {
         Model = Model.ClaudeFable5,
         MaxTokens = 16000,
         Tools = [
             new ToolUnion(new Tool()
             {
                 Name = "record_summary",
                 Description = "Record the structured summary of the document.",
                 InputSchema = new InputSchema()
                 {
                     Properties = new Dictionary<string, JsonElement>
                     {
                         ["summary"] = JsonSerializer.SerializeToElement(new { type = "string" }),
                     },
                     Required = ["summary"],
                 },
             }),
         ],
         ToolChoice = new ToolChoiceTool { Name = "record_summary" },
         Messages = [
             new() { Role = Role.User, Content = "Summarize: The meeting moved to Thursday." }
         ]
     };

     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.ModelClaudeFable5,
     	MaxTokens: 16000,
     	Tools: []anthropic.ToolUnionParam{
     		{OfTool: &anthropic.ToolParam{
     			Name:        "record_summary",
     			Description: anthropic.String("Record the structured summary of the document."),
     			InputSchema: anthropic.ToolInputSchemaParam{
     				Properties: map[string]any{
     					"summary": map[string]any{"type": "string"},
     				},
     				Required: []string{"summary"},
     			},
     		}},
     	},
     	ToolChoice: anthropic.ToolChoiceUnionParam{OfTool: &anthropic.ToolChoiceToolParam{Name: "record_summary"}},
     	Messages: []anthropic.MessageParam{
     		anthropic.NewUserMessage(anthropic.NewTextBlock("Summarize: The meeting moved to Thursday.")),
     	},
     })
     if err != nil {
     	log.Fatal(err)
     }
     fmt.Println(response.RawJSON())
     ```

     ```java Java

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

         MessageCreateParams params = MessageCreateParams.builder()
             .model(Model.CLAUDE_FABLE_5)
             .maxTokens(16000L)
             .addTool(Tool.builder()
                 .name("record_summary")
                 .description("Record the structured summary of the document.")
                 .inputSchema(InputSchema.builder()
                     .properties(JsonValue.from(Map.of("summary", Map.of("type", "string"))))
                     .required(List.of("summary"))
                     .build())
                 .build())
             .toolChoice(ToolChoice.ofTool(ToolChoiceTool.builder()
                 .name("record_summary")
                 .build()))
             .addUserMessage("Summarize: The meeting moved to Thursday.")
             .build();

         Message response = client.messages().create(params);
         IO.println(response);
     }
     ```

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

     $message = $client->messages->create(
         maxTokens: 16000,
         messages: [
             ['role' => 'user', 'content' => 'Summarize: The meeting moved to Thursday.']
         ],
         model: 'claude-fable-5',
         toolChoice: ['type' => 'tool', 'name' => 'record_summary'],
         tools: [
             [
                 'name' => 'record_summary',
                 'description' => 'Record the structured summary of the document.',
                 'input_schema' => [
                     'type' => 'object',
                     'properties' => [
                         'summary' => ['type' => 'string']
                     ],
                     'required' => ['summary']
                 ]
             ]
         ],
     );

     echo $message;
     ```

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

     message = client.messages.create(
       model: Anthropic::Model::CLAUDE_FABLE_5,
       max_tokens: 16000,
       tools: [
         {
           name: "record_summary",
           description: "Record the structured summary of the document.",
           input_schema: {
             type: "object",
             properties: { summary: { type: "string" } },
             required: ["summary"]
           }
         }
       ],
       tool_choice: { type: "tool", name: "record_summary" },
       messages: [
         { role: "user", content: "Summarize: The meeting moved to Thursday." }
       ]
     )
     puts message
     ```
   </CodeGroup>

   Dopo (Claude Fable 5.1): lascia `tool_choice` su `auto`, nomina lo strumento nell'istruzione e imposta `strict: true` in modo che la chiamata corrisponda al tuo schema. (In un'organizzazione [CMEK](https://platform.claude.com/docs/it/manage-claude/cmek), dove gli [output strutturati](https://platform.claude.com/docs/it/build-with-claude/structured-outputs), incluso `strict: true`, non sono disponibili sui modelli Claude Fable, affidati alla sola istruzione.) Per esempio:

   <CodeGroup>
     ```bash cURL
     curl -sS https://api.anthropic.com/v1/messages \
       -H "content-type: application/json" \
       -H "x-api-key: $ANTHROPIC_API_KEY" \
       -H "anthropic-version: 2023-06-01" \
       -d '{
         "model": "claude-fable-5-1",
         "max_tokens": 16000,
         "tools": [
           {
             "name": "record_summary",
             "description": "Record the structured summary of the document.",
             "strict": true,
             "input_schema": {
               "type": "object",
               "properties": {"summary": {"type": "string"}},
               "required": ["summary"],
               "additionalProperties": false
             }
           }
         ],
         "tool_choice": {"type": "auto"},
         "messages": [
           {"role": "user", "content": "Summarize: The meeting moved to Thursday. Call the record_summary tool with your result."}
         ]
       }'
     ```

     ```bash CLI
     ant messages create <<'YAML'
     model: claude-fable-5-1
     max_tokens: 16000
     tools:
       - name: record_summary
         description: Record the structured summary of the document.
         strict: true
         input_schema:
           type: object
           properties:
             summary:
               type: string
           required: [summary]
           additionalProperties: false
     tool_choice:
       type: auto
     messages:
       - role: user
         content: "Summarize: The meeting moved to Thursday. Call the record_summary tool with your result."
     YAML
     ```

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

     record_summary_tool = {
         "name": "record_summary",
         "description": "Record the structured summary of the document.",
         "strict": True,
         "input_schema": {
             "type": "object",
             "properties": {"summary": {"type": "string"}},
             "required": ["summary"],
             "additionalProperties": False,
         },
     }

     response = client.messages.create(
         model="claude-fable-5-1",
         max_tokens=16000,
         tools=[record_summary_tool],
         tool_choice={"type": "auto"},
         messages=[
             {
                 "role": "user",
                 "content": "Summarize: The meeting moved to Thursday. Call the record_summary tool with your result.",
             }
         ],
     )
     print(response.content)
     ```

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

     const response = await client.messages.create({
       model: "claude-fable-5-1",
       max_tokens: 16000,
       tools: [
         {
           name: "record_summary",
           description: "Record the structured summary of the document.",
           strict: true,
           input_schema: {
             type: "object",
             properties: { summary: { type: "string" } },
             required: ["summary"],
             additionalProperties: false
           }
         }
       ],
       tool_choice: { type: "auto" },
       messages: [
         {
           role: "user",
           content:
             "Summarize: The meeting moved to Thursday. Call the record_summary tool with your result."
         }
       ]
     });

     console.log(response.content);
     ```

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

     var parameters = new MessageCreateParams
     {
         Model = Model.ClaudeFable5_1,
         MaxTokens = 16000,
         Tools = [
             new ToolUnion(new Tool()
             {
                 Name = "record_summary",
                 Description = "Record the structured summary of the document.",
                 Strict = true,
                 InputSchema = new InputSchema(new Dictionary<string, JsonElement>
                 {
                     ["properties"] = JsonSerializer.SerializeToElement(new Dictionary<string, object>
                     {
                         ["summary"] = new { type = "string" },
                     }),
                     ["required"] = JsonSerializer.SerializeToElement(new[] { "summary" }),
                     ["additionalProperties"] = JsonSerializer.SerializeToElement(false),
                 }),
             }),
         ],
         ToolChoice = new ToolChoiceAuto(),
         Messages = [
             new() { Role = Role.User, Content = "Summarize: The meeting moved to Thursday. Call the record_summary tool with your result." }
         ]
     };

     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.ModelClaudeFable5_1,
     	MaxTokens: 16000,
     	Tools: []anthropic.ToolUnionParam{
     		{OfTool: &anthropic.ToolParam{
     			Name:        "record_summary",
     			Description: anthropic.String("Record the structured summary of the document."),
     			Strict:      anthropic.Bool(true),
     			InputSchema: anthropic.ToolInputSchemaParam{
     				Properties: map[string]any{
     					"summary": map[string]any{"type": "string"},
     				},
     				Required: []string{"summary"},
     				ExtraFields: map[string]any{
     					"additionalProperties": false,
     				},
     			},
     		}},
     	},
     	ToolChoice: anthropic.ToolChoiceUnionParam{OfAuto: &anthropic.ToolChoiceAutoParam{}},
     	Messages: []anthropic.MessageParam{
     		anthropic.NewUserMessage(anthropic.NewTextBlock("Summarize: The meeting moved to Thursday. Call the record_summary tool with your result.")),
     	},
     })
     if err != nil {
     	log.Fatal(err)
     }
     fmt.Println(response.RawJSON())
     ```

     ```java Java

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

         MessageCreateParams params = MessageCreateParams.builder()
             .model(Model.CLAUDE_FABLE_5_1)
             .maxTokens(16000L)
             .addTool(Tool.builder()
                 .name("record_summary")
                 .description("Record the structured summary of the document.")
                 .inputSchema(InputSchema.builder()
                     .properties(JsonValue.from(Map.of("summary", Map.of("type", "string"))))
                     .putAdditionalProperty("required", JsonValue.from(List.of("summary")))
                     .putAdditionalProperty("additionalProperties", JsonValue.from(false))
                     .build())
                 .strict(true)
                 .build())
             .toolChoice(ToolChoice.ofAuto(ToolChoiceAuto.builder().build()))
             .addUserMessage("Summarize: The meeting moved to Thursday. Call the record_summary tool with your result.")
             .build();

         Message response = client.messages().create(params);
         IO.println(response);
     }
     ```

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

     $message = $client->messages->create(
         maxTokens: 16000,
         messages: [
             ['role' => 'user', 'content' => 'Summarize: The meeting moved to Thursday. Call the record_summary tool with your result.']
         ],
         model: 'claude-fable-5-1',
         toolChoice: ['type' => 'auto'],
         tools: [
             [
                 'name' => 'record_summary',
                 'description' => 'Record the structured summary of the document.',
                 'strict' => true,
                 'input_schema' => [
                     'type' => 'object',
                     'properties' => [
                         'summary' => ['type' => 'string']
                     ],
                     'required' => ['summary'],
                     'additionalProperties' => false
                 ]
             ]
         ],
     );

     echo $message;
     ```

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

     message = client.messages.create(
       model: "claude-fable-5-1",
       max_tokens: 16000,
       tools: [
         {
           name: "record_summary",
           description: "Record the structured summary of the document.",
           strict: true,
           input_schema: {
             type: "object",
             properties: { summary: { type: "string" } },
             required: ["summary"],
             additionalProperties: false
           }
         }
       ],
       tool_choice: { type: "auto" },
       messages: [
         { role: "user", content: "Summarize: The meeting moved to Thursday. Call the record_summary tool with your result." }
       ]
     )
     puts message
     ```
   </CodeGroup>

   Consulta [Uso rigoroso degli strumenti](https://platform.claude.com/docs/it/agents-and-tools/tool-use/strict-tool-use) e [Forzare l'uso degli strumenti](https://platform.claude.com/docs/it/agents-and-tools/tool-use/define-tools#forcing-tool-use). Se forzavi uno strumento solo per ottenere JSON conforme allo schema, usa invece gli [output JSON](https://platform.claude.com/docs/it/build-with-claude/structured-outputs#usage) (`output_config.format`).

   Se la tua applicazione, anziché l'utente, richiede una chiamata a uno strumento specifico nel turno corrente di una conversazione multi-turno, aggiungi un [messaggio di sistema a metà conversazione](https://platform.claude.com/docs/it/build-with-claude/mid-conversation-system-messages) dopo l'ultimo turno `user`. Nomina lo strumento, indica che la chiamata è obbligatoria per questo turno e di' a Claude di aprire la sua risposta con essa. Poiché il messaggio viene aggiunto in coda anziché scritto nel prompt `system` di primo livello, i turni precedenti restano identici byte per byte e mantengono i loro hit nella ["prompt cache" (cache dei prompt)](https://platform.claude.com/docs/it/build-with-claude/prompt-caching):

   <CodeGroup>
     ```bash cURL
     curl -sS https://api.anthropic.com/v1/messages \
       -H "content-type: application/json" \
       -H "x-api-key: $ANTHROPIC_API_KEY" \
       -H "anthropic-version: 2023-06-01" \
       -d '{
         "model": "claude-fable-5-1",
         "max_tokens": 16000,
         "system": "You are a customer support assistant for an online electronics store.",
         "tools": [
           {
             "name": "search_help_center",
             "description": "Search the help center for policy and troubleshooting articles.",
             "strict": true,
             "input_schema": {
               "type": "object",
               "properties": {"query": {"type": "string"}},
               "required": ["query"],
               "additionalProperties": false
             }
           }
         ],
         "messages": [
           {"role": "user", "content": "My headphones from order A1234 arrived yesterday."},
           {"role": "assistant", "content": "Thanks for confirming. How can I help with order A1234?"},
           {"role": "user", "content": "I opened the box. Can I still return them?"},
           {
             "role": "system",
             "content": "Tool-use requirement for the current turn: the application requires a call to the search_help_center tool in your response to the latest message from the user. Begin your response with the search_help_center tool call. Do not reply with text only."
           }
         ]
       }'
     ```

     ```bash CLI
     ant messages create <<'YAML'
     model: claude-fable-5-1
     max_tokens: 16000
     system: You are a customer support assistant for an online electronics store.
     tools:
       - name: search_help_center
         description: Search the help center for policy and troubleshooting articles.
         strict: true
         input_schema:
           type: object
           properties:
             query:
               type: string
           required: [query]
           additionalProperties: false
     messages:
       - role: user
         content: My headphones from order A1234 arrived yesterday.
       - role: assistant
         content: Thanks for confirming. How can I help with order A1234?
       - role: user
         content: I opened the box. Can I still return them?
       - role: system
         content: >-
           Tool-use requirement for the current turn: the application requires a call
           to the search_help_center tool in your response to the user's latest message.
           Begin your response with the search_help_center tool call. Do not reply with
           text only.
     YAML
     ```

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

     search_help_center_tool = {
         "name": "search_help_center",
         "description": "Search the help center for policy and troubleshooting articles.",
         "strict": True,
         "input_schema": {
             "type": "object",
             "properties": {"query": {"type": "string"}},
             "required": ["query"],
             "additionalProperties": False,
         },
     }

     response = client.messages.create(
         model="claude-fable-5-1",
         max_tokens=16000,
         system="You are a customer support assistant for an online electronics store.",
         tools=[search_help_center_tool],
         messages=[
             {
                 "role": "user",
                 "content": "My headphones from order A1234 arrived yesterday.",
             },
             {
                 "role": "assistant",
                 "content": "Thanks for confirming. How can I help with order A1234?",
             },
             {"role": "user", "content": "I opened the box. Can I still return them?"},
             # L'applicazione richiede una ricerca nel centro assistenza prima di qualsiasi
             # risposta sulle policy. Aggiungere il requisito come messaggio di sistema lascia
             # invariati i turni precedenti.
             {
                 "role": "system",
                 "content": "Tool-use requirement for the current turn: the application requires a call to the search_help_center tool in your response to the user's latest message. Begin your response with the search_help_center tool call. Do not reply with text only.",
             },
         ],
     )
     print(response.content)
     ```

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

     const response = await client.messages.create({
       model: "claude-fable-5-1",
       max_tokens: 16000,
       system: "You are a customer support assistant for an online electronics store.",
       tools: [
         {
           name: "search_help_center",
           description: "Search the help center for policy and troubleshooting articles.",
           strict: true,
           input_schema: {
             type: "object",
             properties: { query: { type: "string" } },
             required: ["query"],
             additionalProperties: false
           }
         }
       ],
       messages: [
         { role: "user", content: "My headphones from order A1234 arrived yesterday." },
         { role: "assistant", content: "Thanks for confirming. How can I help with order A1234?" },
         { role: "user", content: "I opened the box. Can I still return them?" },
         // L'applicazione richiede una ricerca nel centro assistenza prima di qualsiasi
         // risposta sulle policy. Aggiungere il requisito come messaggio di sistema lascia
         // invariati i turni precedenti.
         {
           role: "system",
           content:
             "Tool-use requirement for the current turn: the application requires a call to the search_help_center tool in your response to the user's latest message. Begin your response with the search_help_center tool call. Do not reply with text only."
         }
       ]
     });

     console.log(response.content);
     ```

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

     var parameters = new MessageCreateParams
     {
         Model = Model.ClaudeFable5_1,
         MaxTokens = 16000,
         System = "You are a customer support assistant for an online electronics store.",
         Tools = [
             new ToolUnion(new Tool()
             {
                 Name = "search_help_center",
                 Description = "Search the help center for policy and troubleshooting articles.",
                 Strict = true,
                 InputSchema = new InputSchema(new Dictionary<string, JsonElement>
                 {
                     ["properties"] = JsonSerializer.SerializeToElement(new Dictionary<string, object>
                     {
                         ["query"] = new { type = "string" },
                     }),
                     ["required"] = JsonSerializer.SerializeToElement(new[] { "query" }),
                     ["additionalProperties"] = JsonSerializer.SerializeToElement(false),
                 }),
             }),
         ],
         Messages = [
             new() { Role = Role.User, Content = "My headphones from order A1234 arrived yesterday." },
             new() { Role = Role.Assistant, Content = "Thanks for confirming. How can I help with order A1234?" },
             new() { Role = Role.User, Content = "I opened the box. Can I still return them?" },
             // L'applicazione richiede una consultazione del centro assistenza prima di qualsiasi
             // risposta sulle policy. Aggiungere il requisito come messaggio di sistema lascia
             // invariati i turni precedenti.
             new()
             {
                 Role = Role.System,
                 Content = "Tool-use requirement for the current turn: the application requires a call to the search_help_center tool in your response to the user's latest message. Begin your response with the search_help_center tool call. Do not reply with text only."
             }
         ]
     };

     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.ModelClaudeFable5_1,
     	MaxTokens: 16000,
     	System: []anthropic.TextBlockParam{
     		{Text: "You are a customer support assistant for an online electronics store."},
     	},
     	Tools: []anthropic.ToolUnionParam{
     		{OfTool: &anthropic.ToolParam{
     			Name:        "search_help_center",
     			Description: anthropic.String("Search the help center for policy and troubleshooting articles."),
     			Strict:      anthropic.Bool(true),
     			InputSchema: anthropic.ToolInputSchemaParam{
     				Properties: map[string]any{
     					"query": map[string]any{"type": "string"},
     				},
     				Required: []string{"query"},
     				ExtraFields: map[string]any{
     					"additionalProperties": false,
     				},
     			},
     		}},
     	},
     	Messages: []anthropic.MessageParam{
     		anthropic.NewUserMessage(anthropic.NewTextBlock("My headphones from order A1234 arrived yesterday.")),
     		anthropic.NewAssistantMessage(anthropic.NewTextBlock("Thanks for confirming. How can I help with order A1234?")),
     		anthropic.NewUserMessage(anthropic.NewTextBlock("I opened the box. Can I still return them?")),
     		// L'applicazione richiede una ricerca nel centro assistenza prima di ogni risposta
     		// sulle policy. Aggiungendo il requisito come messaggio di sistema, i
     		// turni precedenti restano invariati.
     		{
     			Role: anthropic.MessageParamRoleSystem,
     			Content: []anthropic.ContentBlockParamUnion{
     				anthropic.NewTextBlock("Tool-use requirement for the current turn: the application requires a call to the search_help_center tool in your response to the user's latest message. Begin your response with the search_help_center tool call. Do not reply with text only."),
     			},
     		},
     	},
     })
     if err != nil {
     	log.Fatal(err)
     }
     fmt.Println(response.RawJSON())
     ```

     ```java Java

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

         MessageCreateParams params = MessageCreateParams.builder()
             .model(Model.CLAUDE_FABLE_5_1)
             .maxTokens(16000L)
             .system("You are a customer support assistant for an online electronics store.")
             .addTool(Tool.builder()
                 .name("search_help_center")
                 .description("Search the help center for policy and troubleshooting articles.")
                 .inputSchema(InputSchema.builder()
                     .properties(JsonValue.from(Map.of("query", Map.of("type", "string"))))
                     .putAdditionalProperty("required", JsonValue.from(List.of("query")))
                     .putAdditionalProperty("additionalProperties", JsonValue.from(false))
                     .build())
                 .strict(true)
                 .build())
             .addUserMessage("My headphones from order A1234 arrived yesterday.")
             .addAssistantMessage("Thanks for confirming. How can I help with order A1234?")
             .addUserMessage("I opened the box. Can I still return them?")
             // L'applicazione richiede una ricerca nel centro assistenza prima di qualsiasi
             // risposta sulle policy. Aggiungere il requisito come messaggio di sistema lascia
             // invariati i turni precedenti.
             .addMessage(MessageParam.builder()
                 .role(MessageParam.Role.SYSTEM)
                 .content("Tool-use requirement for the current turn: the application requires a call to the search_help_center tool in your response to the user's latest message. Begin your response with the search_help_center tool call. Do not reply with text only.")
                 .build())
             .build();

         Message response = client.messages().create(params);
         IO.println(response);
     }
     ```

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

     $message = $client->messages->create(
         maxTokens: 16000,
         messages: [
             ['role' => 'user', 'content' => 'My headphones from order A1234 arrived yesterday.'],
             ['role' => 'assistant', 'content' => 'Thanks for confirming. How can I help with order A1234?'],
             ['role' => 'user', 'content' => 'I opened the box. Can I still return them?'],
             // L'applicazione richiede una ricerca nel centro assistenza prima di ogni
             // risposta sulle policy. Aggiungere il requisito come messaggio di sistema lascia
             // invariati i turni precedenti.
             ['role' => 'system', 'content' => 'Tool-use requirement for the current turn: the application requires a call to the search_help_center tool in your response to the user\'s latest message. Begin your response with the search_help_center tool call. Do not reply with text only.']
         ],
         model: 'claude-fable-5-1',
         system: 'You are a customer support assistant for an online electronics store.',
         tools: [
             [
                 'name' => 'search_help_center',
                 'description' => 'Search the help center for policy and troubleshooting articles.',
                 'strict' => true,
                 'input_schema' => [
                     'type' => 'object',
                     'properties' => [
                         'query' => ['type' => 'string']
                     ],
                     'required' => ['query'],
                     'additionalProperties' => false
                 ]
             ]
         ],
     );

     echo $message;
     ```

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

     message = client.messages.create(
       model: "claude-fable-5-1",
       max_tokens: 16000,
       system: "You are a customer support assistant for an online electronics store.",
       tools: [
         {
           name: "search_help_center",
           description: "Search the help center for policy and troubleshooting articles.",
           strict: true,
           input_schema: {
             type: "object",
             properties: { query: { type: "string" } },
             required: ["query"],
             additionalProperties: false
           }
         }
       ],
       messages: [
         { role: "user", content: "My headphones from order A1234 arrived yesterday." },
         { role: "assistant", content: "Thanks for confirming. How can I help with order A1234?" },
         { role: "user", content: "I opened the box. Can I still return them?" },
         # L'applicazione richiede una ricerca nel centro assistenza prima di qualsiasi
         # risposta sulle policy. Aggiungere il requisito come messaggio di sistema lascia
         # invariati i turni precedenti.
         {
           role: "system",
           content: "Tool-use requirement for the current turn: the application requires a call to the search_help_center tool in your response to the user's latest message. Begin your response with the search_help_center tool call. Do not reply with text only."
         }
       ]
     )
     puts message
     ```
   </CodeGroup>

   Mantieni il messaggio `role: "system"` nella cronologia nelle richieste successive, come per qualsiasi altro turno. I messaggi di sistema a metà conversazione non richiedono alcun header beta. `tool_choice: {"type": "none"}` funziona ancora per un turno che non deve chiamare strumenti.

2. **Solo Claude Fable 5.1 e Claude Mythos 5.1 leggono i blocchi di ragionamento di Claude Fable 5.1:** Ogni blocco `thinking` registra quale modello lo ha prodotto. Claude Fable 5.1 legge i propri blocchi e quelli di Claude Mythos 5.1, Claude Opus 5, Claude Fable 5, Claude Mythos 5 e dei modelli Claude precedenti. Una conversazione che passa a `claude-fable-5-1` da uno qualsiasi di questi mantiene il ragionamento precedente. La condizione è unidirezionale: a parte Claude Mythos 5.1, nessuno di questi modelli può leggere i blocchi di Claude Fable 5.1.

   Una conversazione eseguita su Claude Fable 5.1 può finire su un altro modello, più vecchio o più recente, tramite un cambio di router, un nuovo tentativo lato client o un [fallback per rifiuto del classificatore](https://platform.claude.com/docs/it/build-with-claude/refusals-and-fallback), incluso un [fallback lato server](https://platform.claude.com/docs/it/build-with-claude/refusals-and-fallback#server-side-fallback). L'API rimuove i blocchi che quel modello non può leggere prima che li veda, la richiesta va a buon fine e non ti vengono addebitati i token di input scartati. Il modello di destinazione ripianifica senza quel ragionamento, il che può aumentare costi e latenza nel primo turno dopo il cambio. Per vedere cosa è stato scartato, invia l'[header beta](https://platform.claude.com/docs/it/api/beta-headers) `thinking-binding-controls-2026-08-01`: le risposte conterranno quindi un array `input_transformations` che nomina ogni blocco scartato con `reason: "model_binding_mismatch"`. Consulta [Cambiare modello a metà conversazione](https://platform.claude.com/docs/it/build-with-claude/preserved-thinking#switching-models).

3. **Modificare i turni precedenti invalida i blocchi di thinking:** Ogni blocco `thinking` di Claude Fable 5.1 è valido solo rispetto al prompt `system`, ai `tools` e alla cronologia della conversazione che lo hanno preceduto. Se Claude Code, claude.ai, [Claude Managed Agents](https://platform.claude.com/docs/it/managed-agents/overview) o il [Claude Agent SDK](https://code.claude.com/docs/it/agent-sdk/overview) gestiscono la cronologia della tua conversazione, mantengono già intatto quel prefisso. Se il tuo codice costruisce da sé l'array `messages`, questo punto ti riguarda, e [Thinking preservato](https://platform.claude.com/docs/it/build-with-claude/preserved-thinking) è la guida di integrazione completa. Dove il controllo è applicato, una richiesta che rimanda indietro il blocco dopo che uno qualsiasi di questi è cambiato viene rifiutata con un errore 400:

   ```text wrap
   messages.5.content.0: Invalid `signature` in `thinking` block. The block is bound to a different conversation. Remove the block, or set `thinking.block_binding.prefix_mismatch_behavior` to "drop_block". That setting requires the `thinking-binding-controls-2026-08-01` value in the `anthropic-beta` header.
   ```

   L'API applica il controllo per i nuovi account creati a partire dal 31 agosto 2026. Per gli account creati in precedenza, l'API registra la mancata corrispondenza ma non interviene, a meno che la richiesta non imposti `thinking.block_binding.prefix_mismatch_behavior`, che attiva l'applicazione del controllo. Su questi account, se invii l'header beta `thinking-binding-controls-2026-08-01` e lasci quel campo non impostato, la risposta elenca ogni blocco che non ha superato il controllo in `input_transformations` come voce `thinking_mismatch_allowed`. Rendi la tua applicazione compatibile con il controllo indipendentemente dall'età del tuo account: gli stessi pattern mantengono calda la cache dei prompt e puoi testare il controllo da qualsiasi account inviando `prefix_mismatch_behavior`. Se distribuisci uno strumento o un framework che le persone eseguono con la propria chiave API, testalo in questo modo prima del lancio: la tua chiave è probabilmente su un account più vecchio, e i tuoi utenti su account nuovi incontreranno il controllo prima di te. Per verificare se il controllo è applicato per impostazione predefinita al tuo account, invia una richiesta che modifica la cronologia senza l'header beta: un errore 400 che menziona l'header significa che lo è.

   L'errore è permanente per quel corpo di richiesta: un loop di tentativi automatici non lo risolverà. Per continuare senza il ragionamento invalidato invece di fallire, rimuovi i blocchi `thinking` dalla cronologia e riprova una volta, oppure invia l'[header beta](https://platform.claude.com/docs/it/api/beta-headers) `thinking-binding-controls-2026-08-01` e imposta `prefix_mismatch_behavior` su `"drop_block"` (il valore predefinito è `"error"`). Con `"drop_block"`, l'API scarta il blocco non corrispondente e ogni blocco di thinking successivo nella conversazione, e riporta ciascuno con `reason: "prefix_binding_mismatch"` nell'array `input_transformations` 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 "anthropic-beta: thinking-binding-controls-2026-08-01" \
       -H "content-type: application/json" \
       -d '{
         "model": "claude-fable-5-1",
         "max_tokens": 16000,
         "thinking": {
           "type": "adaptive",
           "block_binding": {
             "prefix_mismatch_behavior": "drop_block"
           }
         },
         "messages": [
           {
             "role": "user",
             "content": "What is the greatest common divisor of 1071 and 462?"
           }
         ]
       }'
     ```

     ```bash CLI
     ant beta:messages create \
       --beta thinking-binding-controls-2026-08-01 \
       --transform '{content.#(type=="text")#.text,input_transformations}' \
       --format yaml <<'YAML'
     model: claude-fable-5-1
     max_tokens: 16000
     thinking:
       type: adaptive
       block_binding:
         prefix_mismatch_behavior: drop_block
     messages:
       - role: user
         content: What is the greatest common divisor of 1071 and 462?
     YAML
     ```

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

     response = client.beta.messages.create(
         model="claude-fable-5-1",
         max_tokens=16000,
         thinking={
             "type": "adaptive",
             "block_binding": {"prefix_mismatch_behavior": "drop_block"},
         },
         messages=[
             {
                 "role": "user",
                 "content": "What is the greatest common divisor of 1071 and 462?",
             }
         ],
         betas=["thinking-binding-controls-2026-08-01"],
     )

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

     print(f"Input transformations: {len(response.input_transformations or [])}")
     ```

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

     const response = await client.beta.messages.create({
       model: "claude-fable-5-1",
       max_tokens: 16000,
       thinking: {
         type: "adaptive",
         block_binding: { prefix_mismatch_behavior: "drop_block" }
       },
       messages: [
         { role: "user", content: "What is the greatest common divisor of 1071 and 462?" }
       ],
       betas: ["thinking-binding-controls-2026-08-01"]
     });

     for (const block of response.content) {
       if (block.type === "text") {
         console.log(block.text);
       }
     }
     console.log(`Input transformations: ${response.input_transformations?.length ?? 0}`);
     ```

     ```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()
         {
             Model = Model.ClaudeFable5_1,
             MaxTokens = 16000,
             Thinking = new BetaThinkingConfigAdaptive
             {
                 BlockBinding = new()
                 {
                     PrefixMismatchBehavior = BetaThinkingPrefixMismatchBehavior.DropBlock,
                 },
             },
             Messages =
             [
                 new()
                 {
                     Role = Role.User,
                     Content = "What is the greatest common divisor of 1071 and 462?",
                 },
             ],
             Betas = [AnthropicBeta.ThinkingBindingControls2026_08_01],
         }
     );

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

     Console.WriteLine($"Input transformations: {response.InputTransformations?.Count ?? 0}");
     ```

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

     response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
     	Model:     anthropic.ModelClaudeFable5_1,
     	MaxTokens: 16000,
     	Thinking: anthropic.BetaThinkingConfigParamUnion{
     		OfAdaptive: &anthropic.BetaThinkingConfigAdaptiveParam{
     			BlockBinding: anthropic.BetaThinkingBlockBindingParam{
     				PrefixMismatchBehavior: anthropic.BetaThinkingPrefixMismatchBehaviorDropBlock,
     			},
     		},
     	},
     	Messages: []anthropic.BetaMessageParam{
     		anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("What is the greatest common divisor of 1071 and 462?")),
     	},
     	Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaThinkingBindingControls2026_08_01},
     })
     if err != nil {
     	log.Fatal(err)
     }

     for _, block := range response.Content {
     	if textBlock, ok := block.AsAny().(anthropic.BetaTextBlock); ok {
     		fmt.Println(textBlock.Text)
     	}
     }
     fmt.Printf("Input transformations: %d\n", len(response.InputTransformations))
     ```

     ```java Java
     import com.anthropic.models.beta.AnthropicBeta;
     import com.anthropic.models.beta.messages.BetaMessage;
     import com.anthropic.models.beta.messages.BetaThinkingBlockBinding;
     import com.anthropic.models.beta.messages.BetaThinkingConfigAdaptive;
     import com.anthropic.models.beta.messages.BetaThinkingPrefixMismatchBehavior;
     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(16000L)
             .addBeta(AnthropicBeta.THINKING_BINDING_CONTROLS_2026_08_01)
             .thinking(BetaThinkingConfigAdaptive.builder()
                 .blockBinding(BetaThinkingBlockBinding.builder()
                     .prefixMismatchBehavior(BetaThinkingPrefixMismatchBehavior.DROP_BLOCK)
                     .build())
                 .build())
             .addUserMessage("What is the greatest common divisor of 1071 and 462?")
             .build();

         BetaMessage response = client.beta().messages().create(params);

         response.content().stream()
             .flatMap(block -> block.text().stream())
             .forEach(textBlock -> IO.println(textBlock.text()));
         IO.println("Input transformations: "
             + response.inputTransformations().map(List::size).orElse(0));
     }
     ```

     ```php PHP
     use Anthropic\Beta\AnthropicBeta;
     use Anthropic\Beta\Messages\BetaThinkingBlockBinding;
     use Anthropic\Beta\Messages\BetaThinkingConfigAdaptive;
     use Anthropic\Beta\Messages\BetaThinkingPrefixMismatchBehavior;
     use Anthropic\Client;

     $client = new Client();

     $response = $client->beta->messages->create(
         model: 'claude-fable-5-1',
         maxTokens: 16000,
         thinking: BetaThinkingConfigAdaptive::with(
             blockBinding: BetaThinkingBlockBinding::with(
                 prefixMismatchBehavior: BetaThinkingPrefixMismatchBehavior::DROP_BLOCK,
             ),
         ),
         messages: [
             ['role' => 'user', 'content' => 'What is the greatest common divisor of 1071 and 462?'],
         ],
         betas: [AnthropicBeta::THINKING_BINDING_CONTROLS_2026_08_01],
     );

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

     echo 'Input transformations: ', count($response->inputTransformations ?? []), PHP_EOL;
     ```

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

     response = client.beta.messages.create(
       model: "claude-fable-5-1",
       max_tokens: 16_000,
       thinking: {
         type: "adaptive",
         block_binding: {prefix_mismatch_behavior: "drop_block"}
       },
       messages: [
         {role: "user", content: "What is the greatest common divisor of 1071 and 462?"}
       ],
       betas: [Anthropic::AnthropicBeta::THINKING_BINDING_CONTROLS_2026_08_01]
     )

     response.content.each do |block|
       puts block.text if block.type == :text
     end

     puts "Input transformations: #{response.input_transformations&.length || 0}"
     ```
   </CodeGroup>

   L'endpoint di [conteggio dei token](https://platform.claude.com/docs/it/build-with-claude/token-counting) esegue lo stesso controllo. Consulta [Controlli per i blocchi non preservati (beta)](https://platform.claude.com/docs/it/build-with-claude/thinking#preserved-thinking-controls) per la forma della risposta e il posizionamento nello streaming.

   Pattern che invalidano i blocchi di thinking successivi, e cosa fare invece:

   * Modificare, riordinare o rimuovere turni precedenti. Ciò include l'eliminazione di vecchi risultati degli strumenti, il taglio di turni dal centro della trascrizione e la compattazione lato client che mantiene alla lettera i turni recenti e i loro blocchi di ragionamento dietro un riepilogo (inclusa la compattazione in background che inserisce il suo riepilogo qualche turno dopo). Usa invece la ["compaction" (compattazione)](https://platform.claude.com/docs/it/build-with-claude/compaction) lato server o il ["context editing" (modifica del contesto)](https://platform.claude.com/docs/it/build-with-claude/context-editing) ([cancellazione dei risultati degli strumenti](https://platform.claude.com/docs/it/build-with-claude/context-editing#tool-result-clearing) per i vecchi risultati degli strumenti), oppure una delle forme di compattazione lato client descritte in [Riduci il contesto sul server](https://platform.claude.com/docs/it/models/fable-5-1/migration-guide#fable-5-1-trim-context).
   * Inserire contenuti che non persisti, ad esempio un promemoria per turno aggiunto dopo i blocchi `tool_result` e rimosso alla richiesta successiva. Invia invece il promemoria come ["turn-scoped system message" (messaggio di sistema limitato al turno)](https://platform.claude.com/docs/it/build-with-claude/mid-conversation-system-messages#turn-scoped-system-messages) e lascialo nella cronologia.
   * Ricostruire il prompt `system` di primo livello o l'array `tools` tra richieste della stessa conversazione, ad esempio per aggiornare la data corrente o per aggiungere o rimuovere uno strumento. Aggiungi invece un [messaggio di sistema a metà conversazione](https://platform.claude.com/docs/it/build-with-claude/mid-conversation-system-messages) che contenga la nuova istruzione ("La data corrente è 2026-09-14.") o blocchi `tool_addition` e `tool_removal`. Uno strumento che non era dichiarato in `tools` all'inizio può essere [definito all'interno del blocco `tool_addition`](https://platform.claude.com/docs/it/build-with-claude/mid-conversation-system-messages#define-tools-in-a-message-beta) (header beta `inline-tools-2026-09-15`).
   * Un URL di immagine o documento che restituisce byte diversi in una richiesta successiva. Il controllo riguarda i byte, non la stringa dell'URL, quindi un URL firmato a rotazione per lo stesso file va bene. Per i contenuti a cui fai riferimento in più turni, caricali una volta con la [Files API](https://platform.claude.com/docs/it/build-with-claude/files) e invia il `file_id`, oppure inviali in base64.

   Ogni sostituzione mantiene inoltre i turni precedenti identici byte per byte e preserva gli hit nella [cache dei prompt](https://platform.claude.com/docs/it/build-with-claude/prompt-caching) che la modifica della cronologia, del prompt `system` o dell'array `tools` farebbe perdere.

   Pattern che continuano a funzionare:

   * Cronologie append-only: aggiungere turni e rimandare i turni precedenti esattamente come inviati e ricevuti, inclusi i messaggi `role: "system"` aggiunti.
   * Rimuovere i blocchi di thinking dai turni precedenti dell'assistente, a partire dai più vecchi.
   * Cambiare `effort`, `max_tokens` o qualsiasi altro parametro della richiesta al di fuori di `system`, `tools` e `messages`, e aggiungere o spostare marcatori `cache_control`.
   * Compattazione lato server e context editing, inclusa la [cancellazione dei blocchi di thinking](https://platform.claude.com/docs/it/build-with-claude/context-editing#thinking-block-clearing). Non contano come modifiche, perché il controllo confronta la conversazione così come l'hai inviata.

   Per verificare un'integrazione esistente:

   1. Cattura i corpi esatti delle richieste che invia nel corso di alcuni turni normali, inclusa una compattazione o una modifica degli strumenti se il tuo prodotto le prevede. Per ogni coppia di richieste consecutive, confronta il prompt `system`, l'array `tools` e il prefisso condiviso di `messages`. Devono essere identici byte per byte fino ai turni appena aggiunti. Un'eccezione prevista è una richiesta che inserisce un blocco `compaction` firmato dalla [compattazione su richiesta](https://platform.claude.com/docs/it/build-with-claude/compaction-on-demand): il blocco sostituisce i messaggi che riassume all'inizio di `messages`, e tutto ciò che segue deve comunque corrispondere.
   2. Esegui una normale sessione a più turni su `claude-fable-5-1` con l'header beta `thinking-binding-controls-2026-08-01` e `prefix_mismatch_behavior: "drop_block"`, e registra `input_transformations` in ogni risposta. Un array vuoto in ogni turno significa che la cronologia è intatta. Una voce con `reason: "prefix_binding_mismatch"` significa che qualcosa prima del blocco in `path` è cambiato rispetto alla richiesta precedente. Una voce con `reason: "model_binding_mismatch"` significa che la conversazione ha cambiato modello, il che non è un bug nel tuo codice. Questo funziona da qualsiasi account, perché impostare il campo attiva l'applicazione del controllo per la richiesta. In CI, imposta invece `"error"` in modo che una modifica faccia fallire l'esecuzione.
   3. Scegli un'impostazione per la produzione. Lascia il valore predefinito `"error"` se una mancata corrispondenza del prefisso può significare solo un bug nel tuo codice, oppure imposta `"drop_block"` per scartare i blocchi interessati invece di fallire, e in entrambi i casi monitora gli errori 400 o le voci `input_transformations`.

   Scartare i blocchi di thinking una volta, per esempio a un confine di compattazione, ha poco effetto. Un'integrazione che invalida il thinking precedente a ogni richiesta riavvia la cache dei prompt ogni volta, il che può aumentare il costo per attività (consulta [Mantieni la cronologia della conversazione append-only](https://platform.claude.com/docs/it/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#keep-the-conversation-history-append-only)).

### Cambiamenti di comportamento

1. **Meno chiamate parallele a strumenti nei loop agentici lunghi:** Nei loop di lunga durata in cui le successive letture indipendenti sono solo implicite nell'attività (agenti di coding personalizzati, harness bash-and-editor, computer use), Claude Fable 5.1 può emettere una sola chiamata a strumento per turno. Ogni turno in più costa token, un round trip e tempo reale. Aggiungi un'istruzione di batching di una frase dopo ogni messaggio utente come [messaggio di sistema limitato al turno](https://platform.claude.com/docs/it/build-with-claude/mid-conversation-system-messages#turn-scoped-system-messages) (`clear_at: "next_user_message"`, beta), oppure, senza la beta, in un blocco di testo dopo i blocchi `tool_result`, e lascia le copie precedenti nella cronologia nelle richieste successive. Consulta [Raggruppa le chiamate a strumenti indipendenti nei loop agentici](https://platform.claude.com/docs/it/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#batch-independent-tool-calls-in-agent-loops).

2. **Meno messaggi di avanzamento tra le chiamate agli strumenti:** Claude Fable 5.1 scrive meno aggiornamenti di stato durante lunghe sequenze di strumenti rispetto a Claude Fable 5, e i suoi riepiloghi di coding agentico sono più brevi. Se la tua interfaccia mostra questi aggiornamenti, imposta `thinking.display` su `"updates"` (beta) o `"summarized"` e richiedili esplicitamente nel prompt. Consulta [Aggiornamenti di avanzamento tra le chiamate agli strumenti](https://platform.claude.com/docs/it/build-with-claude/thinking#progress-updates) e [Richiedi aggiornamenti di avanzamento rivolti all'utente](https://platform.claude.com/docs/it/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#ask-for-user-facing-progress-updates).

3. **Meno chiamate di ricerca e recupero con effort basso:** Con un "effort" (livello di impegno) `low`, Claude Fable 5.1 risponde a memoria più spesso di Claude Fable 5 invece di chiamare uno strumento di ricerca o recupero. Se il tuo prodotto si basa sul recupero con effort basso, aumenta l'effort per quelle richieste o indica al modello quando cercare. Consulta [Attivazione della ricerca con effort basso](https://platform.claude.com/docs/it/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#search-triggering-at-low-effort).

Per le differenze nella densità della prosa, nella formattazione della chat, nelle citazioni nei riassunti e nelle modifiche ai file, che non influiscono sull'integrazione API, consulta [Cambiato rispetto a Claude Fable 5](https://platform.claude.com/docs/it/models/fable-5-1/whats-new-fable-5-1#changed-from-claude-fable-5).

### Modifiche consigliate

Queste modifiche non sono obbligatorie, ma ciascuna riduce costo o latenza o elimina una modalità di errore:

1. **Cambia l'effort a metà conversazione (beta):** Su Claude Fable 5, `output_config.effort` è a livello di richiesta, e cambiarlo tra richieste fa perdere i prefissi in cache dei turni precedenti. Su `claude-fable-5-1`, un messaggio `role: "system"` che contiene solo `output_config` aumenta l'effort per un passaggio difficile o lo riduce per quelli di routine senza invalidare la [cache dei prompt](https://platform.claude.com/docs/it/build-with-claude/prompt-caching):

   <CodeGroup>
     ```bash cURL
     # Messaggio di sistema solo per l'effort: il nuovo livello si applica 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 si applica 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 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 (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 si applica 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 si applica 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 si applica dal prossimo turno dell'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 si applica 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>

   Posizionato tra un turno `assistant` e il turno `user` successivo, come qui, il messaggio ha effetto a partire da quel turno `user`. Posizionato subito dopo un turno `user` con nuovo input, imposta il livello per la risposta di Claude a quel turno. Un turno `user` che contiene solo risultati degli strumenti non conta come nuovo input: la modifica attende il successivo turno `user` con nuovo input. Il livello resta poi valido finché un altro messaggio `role: "system"` non lo modifica. Sono accettati solo i livelli nominati (`low`, `medium`, `high`, `xhigh`, `max`), ed è richiesto l'header beta `mid-conversation-output-config-2026-07-01`. Consulta [Effort per messaggio](https://platform.claude.com/docs/it/build-with-claude/effort#change-effort-mid-conversation-beta).

2. **Modifica istruzioni e strumenti con i messaggi di sistema a metà conversazione:** Per modificare istruzioni o strumenti durante una sessione, aggiungi un [messaggio `role: "system"`](https://platform.claude.com/docs/it/build-with-claude/mid-conversation-system-messages), con blocchi `tool_addition` e `tool_removal` per le modifiche agli strumenti (header beta `inline-tools-2026-09-15` sulla Claude API). Un blocco `tool_addition` può nominare uno strumento dichiarato in `tools` all'avvio della sessione o [contenere la definizione completa dello strumento](https://platform.claude.com/docs/it/build-with-claude/mid-conversation-system-messages#define-tools-in-a-message-beta), quindi uno strumento sconosciuto all'avvio della sessione non deve necessariamente trovarsi in `tools`. Questo preserva gli hit della cache dei prompt sui turni precedenti e mantiene la cronologia della conversazione di sola aggiunta. Il vecchio header `mid-conversation-tool-changes-2026-07-01` funziona ancora per le modifiche che nominano uno strumento per riferimento, sulla Claude API, su Amazon Bedrock e su Google Cloud. Lo stesso messaggio sostituisce il `tool_choice` forzato quando uno strumento specifico deve essere eseguito nel turno corrente (consulta [Modifiche incompatibili](https://platform.claude.com/docs/it/models/fable-5-1/migration-guide#fable-5-1-breaking-changes)). Per un promemoria che si applica a un solo turno, invialo come messaggio `role: "system"` separato di solo testo con `clear_at: "next_user_message"` ([messaggi di sistema limitati al turno](https://platform.claude.com/docs/it/build-with-claude/mid-conversation-system-messages#turn-scoped-system-messages), header beta `mid-conversation-system-clear-at-2026-08-21`) e lascialo nella cronologia: smette di essere renderizzato dopo il messaggio utente successivo e non costa token una volta cancellato. Un messaggio che contiene blocchi `tool_addition` o `tool_removal` non può essere limitato al turno.

3. **Usa `fallbacks: "default"` per i rifiuti:** Continua a gestire `stop_reason: "refusal"` e a leggere `stop_details.category` prima del contenuto della risposta. Per rieseguire automaticamente le richieste rifiutate su un altro modello, imposta `fallbacks: "default"` (beta, header `server-side-fallback-2026-07-01`). `"default"` riprova una richiesta rifiutata sul modello che Anthropic consiglia per quella categoria. I target di fallback consentiti per Claude Fable 5.1 sono Claude Opus 4.8 (`claude-opus-4-8`) e Claude Opus 5 (`claude-opus-5`). Un elenco `fallbacks` esplicito può nominare l'uno o l'altro. Il modello di fallback non riceve i blocchi di ragionamento di Claude Fable 5.1. Il parametro `fallbacks` non è disponibile su Amazon Bedrock, Google Cloud o Microsoft Foundry. Su queste piattaforme, usa invece il [fallback lato client](https://platform.claude.com/docs/it/build-with-claude/refusals-and-fallback#client-side-fallback). Se costruisci tu stesso il nuovo tentativo, il [credito di fallback](https://platform.claude.com/docs/it/build-with-claude/fallback-credit) si applica alle stesse condizioni di Claude Fable 5. Consulta [Rifiuti e fallback](https://platform.claude.com/docs/it/build-with-claude/refusals-and-fallback).

4. **Inizia a effort `high` ed esegui uno sweep:** Il valore predefinito del [parametro effort](https://platform.claude.com/docs/it/build-with-claude/effort) è `high`, e tutti e cinque i livelli sono supportati. Mantieni le indicazioni di Claude Fable 5: `high` per la maggior parte del lavoro, e `medium` come controllo dei costi che vale la pena testare. I miglioramenti di Claude Fable 5.1 rispetto a Claude Fable 5 sono maggiori a `xhigh` e `max`, ma questi livelli aggiungono anche tempo di thinking e tempo alla prima risposta, quindi passa a essi per le attività più sensibili alle capacità e dove le tue valutazioni mostrano il miglioramento. Esegui un nuovo sweep sulle tue valutazioni invece di riportare un'impostazione calibrata per Claude Fable 5. Consulta [Livelli di effort consigliati per Claude Fable 5.1](https://platform.claude.com/docs/it/build-with-claude/effort#recommended-effort-levels-for-claude-fable-5-1).

5. **Riduci il contesto sul server, oppure compatta in una forma che non contenga ragionamento obsoleto:** Se il tuo codice tronca o riassume i turni più vecchi sul client, la soluzione più semplice è spostare questo lavoro sulla [compattazione](https://platform.claude.com/docs/it/build-with-claude/compaction) lato server o sul [context editing](https://platform.claude.com/docs/it/build-with-claude/context-editing). Nessuno dei due conta come modifica, perché il [controllo della cronologia](https://platform.claude.com/docs/it/models/fable-5-1/migration-guide#fable-5-1-preserved-thinking) confronta la conversazione così come l'hai inviata, quindi nulla di ciò che rimuovono invalida i blocchi di ragionamento successivi, e il [parametro `instructions`](https://platform.claude.com/docs/it/build-with-claude/compaction-threshold#custom-summarization-instructions) della compattazione accetta il tuo prompt di riepilogo. Se mantieni i turni recenti alla lettera dietro il riepilogo, o riassumi in background mentre la conversazione prosegue, usa la [compattazione su richiesta](https://platform.claude.com/docs/it/build-with-claude/compaction-on-demand) (header beta `compact-2026-09-04`) invece di un riepilogo scritto dal client. L'API scrive un blocco di riepilogo firmato che inserisci al posto dei messaggi che riassume. I blocchi di ragionamento nei turni che mantieni possono restare validi, alle condizioni descritte in [Compattazione e ragionamento preservato](https://platform.claude.com/docs/it/build-with-claude/compaction-thinking-blocks#conditions-for-kept-thinking-to-stay-valid). Se mantieni la compattazione sul client, scegli una di queste tre forme:

   * **Compattazione semplice (consigliata):** sostituisci l'intera cronologia con un unico messaggio di riassunto più il nuovo turno utente e non riprodurre nient'altro. Nessun blocco di thinking viene riportato, quindi nulla fallisce. I modelli Claude sono addestrati su attività a lungo orizzonte con questo schema, che ha prestazioni paragonabili a schemi più elaborati per la maggior parte dei carichi di lavoro.
   * **Compattazione keep-tail:** se mantieni i turni più recenti alla lettera dietro un riassunto, rimuovi i blocchi `thinking` e `redacted_thinking` da quei turni (testo e chiamate a strumenti possono restare), oppure imposta `prefix_mismatch_behavior: "drop_block"`. Il loro thinking è stato prodotto rispetto alla cronologia completa e altrimenti fallisce dietro il riassunto.
   * **Compattazione in background:** se costruisci il riassunto fuori dal percorso critico e lo inserisci più tardi, ogni turno prodotto nel frattempo porta thinking che precede la sostituzione. Invia `"drop_block"` su ogni richiesta che porta ancora blocchi di thinking prodotti prima della sostituzione (oppure rimuovi tu stesso quei blocchi; `input_transformations` sulla prima risposta dopo la sostituzione elenca esattamente quali), oppure compatta in modo sincrono.

   Non tagliare singoli turni dal centro della trascrizione: ciò invalida ogni blocco di ragionamento successivo e nessuna forma lato client lo evita. Usa un [messaggio di sistema a metà conversazione](https://platform.claude.com/docs/it/build-with-claude/mid-conversation-system-messages) per la modifica delle istruzioni che stavi apportando, oppure il [context editing](https://platform.claude.com/docs/it/build-with-claude/context-editing) lato server per la rimozione selettiva. Consulta [Restituire i blocchi di compattazione](https://platform.claude.com/docs/it/build-with-claude/compaction-threshold#passing-compaction-blocks-back).

### Checklist di migrazione

* Aggiorna il nome del modello da `claude-fable-5` a `claude-fable-5-1` (o da `claude-mythos-5` a `claude-mythos-5-1`).
* Sostituisci il `tool_choice` forzato (`{type: "any"}` o `{type: "tool", ...}`). Restituisce un errore 400. Usa `{type: "auto"}` più un'istruzione esplicita e strumenti con `strict: true`, oppure gli output JSON. Inserisci l'istruzione nel turno `user`, oppure in un messaggio `role: "system"` a metà conversazione quando è la tua applicazione a richiedere la chiamata.
* Continua a restituire i blocchi `thinking` invariati a ogni turno, inclusi quelli vuoti. Claude Fable 5.1 legge i blocchi di Claude Opus 5, Claude Fable 5, Claude Mythos 5 e dei modelli precedenti. Spostare una conversazione da Claude Fable 5.1 a qualsiasi modello diverso da Claude Mythos 5.1 ne scarta i blocchi.
* Se il tuo codice costruisce autonomamente l'array `messages`, verifica se [modifica i turni precedenti](https://platform.claude.com/docs/it/models/fable-5-1/migration-guide#fable-5-1-preserved-thinking): esegui una sessione con l'header beta `thinking-binding-controls-2026-08-01` e `prefix_mismatch_behavior: "drop_block"`, registra `input_transformations` e correggi ogni `prefix_binding_mismatch`. Le voci `model_binding_mismatch` dopo un cambio di modello sono previste.
* Mantieni la cronologia della conversazione di sola aggiunta: congela `system` e `tools` all'inizio della sessione e sposta le modifiche a metà sessione in messaggi `role: "system"` e blocchi `tool_addition` / `tool_removal`, invia i promemoria per turno come messaggi di sistema limitati al turno che non rimuovi mai, riduci il contesto lato server o rimuovi i blocchi di ragionamento da tutti i turni che trasferisci oltre un riepilogo lato client, e fai riferimento ai file usati in più turni tramite `file_id`.
* Scegli un `prefix_mismatch_behavior` per la produzione (`"error"` per impostazione predefinita, oppure `"drop_block"`) e monitoralo. Se gestisci uno strumento che altri eseguono con la propria chiave API, testa con il campo impostato: ai nuovi account il controllo viene applicato per impostazione predefinita anche se al tuo no.
* Esamina i cicli dell'agente per individuare il comportamento di una sola chiamata a uno strumento per turno e aggiungi l'istruzione di raggruppamento.
* Se la tua interfaccia mostra testo di avanzamento tra le chiamate agli strumenti, imposta `thinking.display` su `"updates"` (beta) o `"summarized"` e richiedi gli aggiornamenti nel prompt.
* Se modifichi l'effort tra le richieste, sposta la modifica in un messaggio `role: "system"` di [effort per messaggio](https://platform.claude.com/docs/it/build-with-claude/effort#change-effort-mid-conversation-beta) (beta) per mantenere gli hit della cache.
* Gestisci `stop_reason: "refusal"` e leggi `stop_details.category`. Valuta `fallbacks: "default"` (beta).
* Rivaluta `effort` con un nuovo sweep, partendo da `high`, e ristabilisci la baseline di costo e latenza sui tuoi carichi di lavoro. Il tokenizer è invariato. Le letture dalla cache dei prompt costano un quarto della tariffa di Claude Fable 5.

## Migrazione a Claude Fable 5.1 da Claude Opus 5

Claude Fable 5.1 usa gli stessi pattern della [Messages API](https://platform.claude.com/docs/it/build-with-claude/working-with-messages) e di [uso degli strumenti](https://platform.claude.com/docs/it/agents-and-tools/tool-use/overview) di Claude Opus 5. Mantiene per impostazione predefinita la [finestra di contesto da 1M di token](https://platform.claude.com/docs/it/build-with-claude/context-windows), i [128k token massimi di output](https://platform.claude.com/docs/it/models/overview), il minimo di 512 token per la cache dei prompt e il supporto ai [messaggi di sistema a metà conversazione](https://platform.claude.com/docs/it/build-with-claude/mid-conversation-system-messages). Anche la restrizione sul prefill, la restrizione sui parametri di campionamento e il valore predefinito `"omitted"` per `thinking.display` vengono mantenuti. Applica tutto quanto indicato in [Migrazione a Claude Fable 5.1 da Claude Fable 5](https://platform.claude.com/docs/it/models/fable-5-1/migration-guide#migrating-from-claude-fable-5-to-claude-fable-5-1), più quanto segue.

### Aggiorna il nome del modello

```python
model = "claude-opus-5"  # Before
model = "claude-fable-5-1"  # After

# Oppure, per Claude Mythos 5.1, che offre le stesse funzionalità alle organizzazioni verificate:
model = "claude-mythos-5-1"  # After
```

### Cosa è cambiato

1. **Il ragionamento non può più essere disabilitato:** Claude Opus 5 accetta `thinking: {type: "disabled"}` a un livello di [effort](https://platform.claude.com/docs/it/build-with-claude/effort) pari a `high` o inferiore. Su `claude-fable-5-1` e `claude-mythos-5-1`, il [ragionamento adattivo](https://platform.claude.com/docs/it/build-with-claude/thinking) è sempre attivo e `thinking: {type: "disabled"}` restituisce un errore 400 a qualsiasi livello di effort. Rimuovi il campo, controlla la spesa di token con livelli di effort inferiori e rivedi `max_tokens` per i carichi di lavoro che venivano eseguiti con il ragionamento disabilitato.

2. **La scelta forzata dello strumento non è supportata:** Claude Opus 5 accetta `tool_choice` `any` e `tool`. `claude-fable-5-1` restituisce un errore 400. Consulta [Modifiche di rilievo](https://platform.claude.com/docs/it/models/fable-5-1/migration-guide#fable-5-1-breaking-changes).

3. **Ragionamento preservato tra modelli:** Claude Fable 5.1 legge i blocchi di ragionamento di Claude Opus 5: le conversazioni che passano da `claude-opus-5` a `claude-fable-5-1` mantengono il loro ragionamento. Claude Opus 5 non può leggere i blocchi di Claude Fable 5.1. I blocchi di Claude Fable 5.1 inoltre [cessano di essere validi quando i turni precedenti cambiano](https://platform.claude.com/docs/it/models/fable-5-1/migration-guide#fable-5-1-preserved-thinking): se il tuo codice modifica i messaggi precedenti, ricostruisce `system` o `tools`, oppure compatta sul client tra le richieste, Claude Opus 5 non obiettava, ma `claude-fable-5-1` rifiuta o scarta ogni blocco di ragionamento successivo. Esegui la verifica in tre passaggi di quella sezione prima di spostare il traffico. Consulta [Modifiche di rilievo](https://platform.claude.com/docs/it/models/fable-5-1/migration-guide#fable-5-1-breaking-changes).

4. **Il testo tra le chiamate agli strumenti viene restituito nei blocchi di ragionamento:** Su Claude Opus 5, il testo che il modello scrive tra le chiamate agli strumenti viene restituito come blocchi `text`. Su `claude-fable-5-1`, come su Claude Fable 5, quella narrazione viene restituita come blocchi `thinking` di aggiornamento sull'avanzamento, uno prima di ogni chiamata a uno strumento. Con il valore predefinito `"omitted"` di `thinking.display`, questi blocchi non contengono testo leggibile. Se la tua interfaccia mostra quella narrazione, imposta `display: "updates"` (beta) per ricevere gli aggiornamenti di avanzamento come testo mentre il ragionamento resta nascosto, oppure `"summarized"` per ricevere entrambi. Quindi mostra i blocchi `thinking` non vuoti tra i blocchi `tool_use`. Consulta [Aggiornamenti di avanzamento tra le chiamate agli strumenti](https://platform.claude.com/docs/it/build-with-claude/thinking#progress-updates).

5. **Classificatori di sicurezza e instradamento di fallback:** Claude Fable 5.1 esegue classificatori di sicurezza che coprono le stesse categorie `stop_details` di Claude Fable 5, un insieme più ampio rispetto ai classificatori di Claude Opus 5. Aspettati valori aggiuntivi di `stop_details.category`, come `"bio"`; consulta la [tabella delle categorie di rifiuto](https://platform.claude.com/docs/it/build-with-claude/refusals-and-fallback#refusal-response) per l'insieme completo. Per la configurazione di `fallbacks` e i target consentiti, consulta [Usa `fallbacks: "default"` per i rifiuti](https://platform.claude.com/docs/it/models/fable-5-1/migration-guide#fable-5-1-recommended-changes).

6. **Prezzi:** $10 USD per milione di token di input e $50 USD per milione di token di output, rispetto a $5 USD e $25 USD per Claude Opus 5. Le letture dalla cache dei prompt costano $0,25 USD per milione di token, la metà della tariffa di Claude Opus 5. Consulta [Prezzi di Claude](https://platform.claude.com/docs/it/about-claude/pricing).

7. **Conservazione dei dati:** Claude Fable 5.1 e Claude Mythos 5.1 richiedono una conservazione dei dati di 30 giorni, non sono disponibili con accordi di zero data retention (ZDR) salvo espressa autorizzazione di Anthropic, e sono designati come Covered Models. Claude Opus 5 è disponibile con ZDR. Consulta [Requisiti di conservazione dei dati specifici per modello](https://platform.claude.com/docs/it/manage-claude/api-and-data-retention#model-specific-data-retention-requirements).

### Checklist di migrazione

* Se la tua organizzazione ha un accordo di "zero data retention" (conservazione zero dei dati), o ZDR, verifica prima l'idoneità: questi modelli non sono disponibili in regime ZDR salvo espressa autorizzazione di Anthropic. Consulta [Requisiti di conservazione dei dati specifici per modello](https://platform.claude.com/docs/it/manage-claude/api-and-data-retention#model-specific-data-retention-requirements).
* Aggiorna il nome del modello da `claude-opus-5` a `claude-fable-5-1` (o `claude-mythos-5-1`).
* Rimuovi qualsiasi configurazione `thinking: {type: "disabled"}`: su `claude-fable-5-1` restituisce un errore 400. Controlla la spesa di token con livelli di [effort](https://platform.claude.com/docs/it/build-with-claude/effort) più bassi e rivedi `max_tokens`.
* Sostituisci il `tool_choice` forzato (`any` o `tool`) con `auto` più un'istruzione esplicita (turno `user` o messaggio di sistema a metà conversazione) e strumenti con `strict: true`, oppure con gli output JSON.
* Se la tua interfaccia mostra il testo tra le chiamate agli strumenti, imposta `display: "updates"` (beta) o `"summarized"` e mostra i blocchi `thinking` non vuoti.
* Applica le voci relative a ragionamento preservato, modifica della cronologia, comportamento, effort e fallback della [checklist di Claude Fable 5](https://platform.claude.com/docs/it/models/fable-5-1/migration-guide#migration-checklist-fable-5-1-from-fable-5).
* Ricalcola la baseline dei costi sui tuoi carichi di lavoro. Il tokenizer è invariato. Il prezzo per token è diverso.

## Migrazione a Claude Fable 5.1 da Claude Opus 4.8 o precedenti

Segui la checklist riportata di seguito. Se usi Claude Opus 4.7 o versioni precedenti, inizia dalla sezione corrispondente della [guida alla migrazione a Claude Opus 5.5](https://platform.claude.com/docs/it/models/opus-5-5/migration-guide).

### Aggiorna il nome del modello

```python
model = "claude-opus-4-8"  # Before
model = "claude-fable-5-1"  # After

# Oppure, per Claude Mythos 5.1, che offre le stesse funzionalità alle organizzazioni verificate:
model = "claude-mythos-5-1"  # After
```

### Checklist di migrazione

* Se la tua organizzazione ha un accordo di zero data retention (ZDR), verifica prima l'idoneità: questi modelli non sono disponibili con ZDR salvo espressa autorizzazione di Anthropic. Claude Opus 4.8 è disponibile con ZDR.
* Aggiorna il nome del modello da `claude-opus-4-8` a `claude-fable-5-1` (o `claude-mythos-5-1`).
* Rimuovi qualsiasi configurazione `thinking: {type: "disabled"}` e rivedi `max_tokens`. Le richieste senza un campo `thinking` vengono eseguite con il ragionamento adattivo.
* Aggiorna l'analisi delle risposte che legge il contenuto per posizione, come `content[0].text`: una risposta ora può iniziare con blocchi `thinking`, quindi seleziona i blocchi di contenuto in base al `type`.
* Sostituisci il `tool_choice` forzato (`any` o `tool`) con `auto` più un'istruzione esplicita (turno `user` o messaggio di sistema a metà conversazione) e strumenti con `strict: true`, oppure con output JSON.
* Restituisci i blocchi `thinking` invariati e tratta il loro testo come destinato alla sola visualizzazione. Claude Fable 5.1 legge i blocchi di ragionamento di Claude Opus 4.8: una conversazione che passa a `claude-fable-5-1` mantiene il suo ragionamento precedente. Claude Opus 4.8 non può leggere i blocchi di Claude Fable 5.1.
* Se il tuo codice costruisce da sé l'array `messages`, verifica se [modifica i turni precedenti](https://platform.claude.com/docs/it/models/fable-5-1/migration-guide#fable-5-1-preserved-thinking). Le integrazioni scritte per Claude Opus 4.8 e precedenti spesso troncano i turni vecchi, rimuovono o ricostruiscono i messaggi precedenti, oppure aggiornano il prompt `system` a ogni richiesta, e Claude Opus 4.8 non ha mai obiettato. Su `claude-fable-5-1` ciascuna di queste operazioni invalida i blocchi di ragionamento successivi.
* Gestisci `stop_reason: "refusal"`, leggi `stop_details.category` e valuta `fallbacks: "default"` (beta).
* Applica le voci relative a ragionamento preservato, modifica della cronologia, comportamento, effort per messaggio e aggiornamenti di avanzamento della [checklist di Claude Fable 5](https://platform.claude.com/docs/it/models/fable-5-1/migration-guide#migration-checklist-fable-5-1-from-fable-5).
* Rivaluta `effort` (inizia da `high`), rivedi i prompt vicini al [minimo per la cache](https://platform.claude.com/docs/it/build-with-claude/prompt-caching#cache-limitations) di 512 token (1.024 token su Claude Opus 4.8) e ricalcola la baseline di costo e latenza. I prezzi per token sono diversi e i token di ragionamento vengono fatturati come token di output, quindi i carichi di lavoro eseguiti senza ragionamento su Claude Opus 4.8 possono produrre più token di output per richiesta.

## Migrazione a Claude Mythos 5.1 da Claude Mythos 5

[Claude Mythos 5.1](https://platform.claude.com/docs/it/models/mythos-5-1/overview) è la controparte di Claude Fable 5.1 per le organizzazioni verificate tramite i programmi di verifica di Anthropic, come il [Cyber Verification Program](https://support.claude.com/en/articles/14604842). Verifica che la tua organizzazione abbia accesso a Claude Mythos 5.1 prima di cambiare gli ID del modello.

Le differenze a livello di API corrispondono a [Migrazione a Claude Fable 5.1 da Claude Fable 5](https://platform.claude.com/docs/it/models/fable-5-1/migration-guide#migrating-from-claude-fable-5-to-claude-fable-5-1): la scelta forzata dello strumento restituisce un errore 400, e solo Claude Mythos 5.1 e Claude Fable 5.1 leggono i blocchi di ragionamento di Claude Mythos 5.1 (Claude Mythos 5.1 legge i blocchi di Claude Mythos 5, non il contrario). A differenza di Claude Fable 5.1, Claude Mythos 5.1 non esegue il controllo della conversazione, quindi la modifica dei turni precedenti non [invalida i blocchi di ragionamento](https://platform.claude.com/docs/it/models/fable-5-1/migration-guide#fable-5-1-preserved-thinking), anche se riavvia comunque la cache dei prompt.

### Aggiorna il nome del modello

```python
model = "claude-mythos-5"  # Before
model = "claude-mythos-5-1"  # After
```

### Checklist di migrazione

* Aggiorna il nome del modello da `claude-mythos-5` a `claude-mythos-5-1`.
* Sostituisci il `tool_choice` forzato (`any` o `tool`) con `auto` più un'istruzione esplicita (turno `user` o messaggio di sistema a metà conversazione) e strumenti con `strict: true`, oppure con output JSON.
* Gestisci `stop_reason: "refusal"` e leggi `stop_details.category` prima del contenuto della risposta. Consulta [Rifiuti e fallback](https://platform.claude.com/docs/it/build-with-claude/refusals-and-fallback).
* Continua a restituire i blocchi `thinking` invariati a ogni turno, inclusi quelli vuoti.
* Se il tuo codice costruisce da sé l'array `messages`, mantieni la cronologia della conversazione in sola aggiunta per mantenere calda la cache dei prompt. Claude Mythos 5.1 non esegue la [verifica della conversazione](https://platform.claude.com/docs/it/build-with-claude/thinking#preserved-in-conversation), quindi le modifiche non invalidano i suoi blocchi di ragionamento.
* Applica le modifiche di comportamento e quelle consigliate della [sezione Claude Fable 5](https://platform.claude.com/docs/it/models/fable-5-1/migration-guide#migrating-from-claude-fable-5-to-claude-fable-5-1), eccetto le voci relative alla modifica della cronologia, che non si applicano a Claude Mythos 5.1.
* Rivaluta `effort` con una nuova esplorazione e ricalcola la baseline di costo e latenza. Le letture dalla cache dei prompt costano un quarto della tariffa di Claude Mythos 5.