---
title: Guide de migration vers Claude Fable 5.1 et Claude Mythos 5.1
url: https://platform.claude.com/docs/fr/models/fable-5-1/migration-guide
description: Passez à Claude Fable 5.1 et Claude Mythos 5.1 depuis Claude Fable 5, Claude Mythos 5, Claude Opus 5 ou Claude Opus 4.8 grâce à ce guide de migration. Les instructions pour activer Claude Fable 5.1 et Claude Mythos 5.1 comprennent les identifiants de modèle, les changements incompatibles et des listes de contrôle de migration.
---

<Note>
  Ce guide couvre la migration du code de la [Messages API](https://platform.claude.com/docs/fr/build-with-claude/working-with-messages). Si vous utilisez [Claude Managed Agents](https://platform.claude.com/docs/fr/managed-agents/overview), aucune modification n'est requise au-delà de la mise à jour du nom du modèle.
</Note>

<Tip>
  **Automatisez votre migration avec la skill Claude API.** Dans Claude Code, exécutez `/claude-api migrate` pour invoquer la [skill Claude API](https://platform.claude.com/docs/fr/agents-and-tools/agent-skills/claude-api-skill#migrating-to-a-newer-claude-model) intégrée. Elle fonctionne avec n'importe quel modèle Claude actuel comme cible :

  Laissez Claude Code migrer votre code pour vous

  ```text
  /claude-api migrate ce projet vers claude-fable-5-1
  ```

  La skill applique le remplacement de l'identifiant du modèle et, si nécessaire, les changements de paramètres non rétrocompatibles, le remplacement du préremplissage (prefill) et le calibrage de l'effort pour votre modèle cible dans l'ensemble de votre base de code, puis produit une liste de contrôle des éléments à vérifier manuellement. Elle vous demande de confirmer la portée de la migration (répertoire de travail entier, un sous-répertoire ou une liste de fichiers spécifique) avant de modifier le moindre fichier. La skill détecte également les clients Amazon Bedrock et Claude Platform on AWS, et ajuste les formats d'identifiants de modèle ainsi que les changements de fonctionnalités pour ces plateformes.
</Tip>

[Claude Fable 5.1](https://platform.claude.com/docs/fr/models/fable-5-1/whats-new-fable-5-1) succède à Claude Fable 5 aux mêmes prix d'entrée et de sortie, avec des lectures de cache au quart du coût. Il est disponible sur l'API Claude, [Amazon Bedrock](https://platform.claude.com/docs/fr/build-with-claude/claude-in-amazon-bedrock), [Claude Platform on AWS](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws), [Google Cloud](https://platform.claude.com/docs/fr/build-with-claude/claude-on-vertex-ai) et [Microsoft Foundry](https://platform.claude.com/docs/fr/build-with-claude/claude-in-microsoft-foundry). [Claude Mythos 5.1](https://platform.claude.com/docs/fr/models/mythos-5-1/overview) partage les mêmes capacités et n'est disponible que pour les organisations vérifiées par le biais des programmes de vérification d'Anthropic, tels que le [Cyber Verification Program](https://support.claude.com/en/articles/14604842). Pour les différences de comportement et les modèles de prompting, consultez [Rédiger des prompts pour Claude Fable 5.1](https://platform.claude.com/docs/fr/build-with-claude/prompt-engineering/prompting-claude-fable-5-1).

Les paramètres de base partagés par `claude-fable-5-1` et `claude-mythos-5-1` :

* **Réflexion :** l'« [adaptive thinking](https://platform.claude.com/docs/fr/build-with-claude/thinking) » (réflexion adaptative) est toujours activée, sans changement par rapport à Claude Fable 5. Le modèle détermine quand et combien réfléchir. Aucune configuration `thinking` n'est requise. `thinking: {type: "disabled"}` et la réflexion étendue manuelle (`thinking: {type: "enabled", budget_tokens: N}`) renvoient tous deux une erreur 400.
* **Préremplissage :** le préremplissage du message de l'assistant renvoie une erreur 400, sans changement par rapport à Claude Fable 5. Utilisez plutôt des instructions dans l'invite système.
* **Choix d'outil :** `{type: "auto"}` (la valeur par défaut) et `{type: "none"}` sont pris en charge. Forcer un appel d'outil avec `{type: "any"}` ou `{type: "tool", name: "..."}` renvoie une erreur 400. Consultez [Changements incompatibles](https://platform.claude.com/docs/fr/models/fable-5-1/migration-guide#fable-5-1-breaking-changes).
* **Réflexion préservée entre modèles :** Claude Fable 5.1 lit les blocs de réflexion de Claude Opus 5, Claude Fable 5, Claude Mythos 5 et des modèles Claude antérieurs. Aucun de ces modèles ne peut lire les blocs de Claude Fable 5.1. Consultez [Changements incompatibles](https://platform.claude.com/docs/fr/models/fable-5-1/migration-guide#fable-5-1-breaking-changes).
* **Fenêtre de contexte et sortie :** une [« context window » (fenêtre de contexte) de 1M de tokens](https://platform.claude.com/docs/fr/build-with-claude/context-windows) par défaut, et jusqu'à 128k tokens de sortie par requête.
* **Tarification :** 10 $ USD par million de tokens d'entrée et 50 $ USD par million de tokens de sortie, comme pour Claude Fable 5. Les lectures du cache de prompts coûtent 0,25 $ USD par million de tokens, soit un quart du tarif de Claude Fable 5. Consultez [Tarification de Claude](https://platform.claude.com/docs/fr/about-claude/pricing).
* **Conservation des données :** les deux modèles exigent une conservation des données de 30 jours, ne sont pas disponibles dans le cadre d'accords de « zero data retention » (conservation zéro des données), ou ZDR, sauf autorisation expresse d'Anthropic, et sont désignés comme Covered Models (modèles couverts), comme Claude Fable 5 et Claude Mythos 5. Sur la Claude API, une requête provenant d'une organisation ou d'un espace de travail sans conservation de 30 jours renvoie une erreur 400 `invalid_request_error`. Les organisations disposant d'un accord ZDR doivent contacter leur équipe de compte Anthropic, ou configurer la conservation par espace de travail. Consultez [Exigences de conservation des données spécifiques aux modèles](https://platform.claude.com/docs/fr/manage-claude/api-and-data-retention#model-specific-data-retention-requirements) pour les détails par plateforme.

Là où les deux modèles divergent :

* **Disponibilité :** Claude Fable 5.1 ne nécessite pas d'approbation d'accès. Claude Mythos 5.1 n'est disponible que pour les organisations vérifiées par le biais des programmes de vérification d'Anthropic, tels que le [Cyber Verification Program](https://support.claude.com/en/articles/14604842). Pour demander l'accès, postulez au programme qui couvre votre cas d'usage, ou contactez votre équipe de compte Anthropic.
* **Priority Tier :** aucun des deux modèles n'est pris en charge sur [Priority Tier](https://platform.claude.com/docs/fr/api/service-tiers#supported-models). Claude Fable 5 l'est.

## Migration vers Claude Fable 5.1 depuis Claude Fable 5

La migration est en grande partie transparente. La surface de l'API, les limites, la tarification par token, le tokenizer, la réflexion adaptative toujours activée, la gestion des refus et les catégories `stop_details` correspondent tous à Claude Fable 5. Ce qui change : le choix d'outil forcé renvoie une erreur 400 ; seuls Claude Fable 5.1 et Claude Mythos 5.1 lisent les blocs de réflexion de Claude Fable 5.1, et uniquement dans la conversation qui les a produits ; les lectures de cache coûtent moins cher ; et le comportement des boucles d'agent diffère de trois façons. Les mêmes changements s'appliquent à [Claude Mythos 5.1](https://platform.claude.com/docs/fr/models/fable-5-1/migration-guide#migrating-from-claude-mythos-5-to-claude-mythos-5-1), à l'exception de la vérification de conversation sur les blocs de réflexion, que Claude Mythos 5.1 n'effectue pas.

### Mettre à jour le nom de votre modèle

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

# Ou, pour Claude Mythos 5.1, qui offre les mêmes capacités aux organisations vérifiées :
model = "claude-mythos-5-1"  # After
```

### Changements incompatibles

1. **Le choix d'outil forcé n'est pas pris en charge :** Claude Fable 5 accepte les valeurs `tool_choice` `auto`, `none`, `any` et `tool`. Sur `claude-fable-5-1`, `{type: "any"}` et `{type: "tool", name: "..."}` renvoient une erreur 400 `invalid_request_error` :

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

   La vérification s'applique sur l'API Messages, l'API Message Batches et le point de terminaison de [comptage de tokens](https://platform.claude.com/docs/fr/build-with-claude/token-counting).

   Avant (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>

   Après (Claude Fable 5.1) : laissez `tool_choice` sur `auto`, nommez l'outil dans l'instruction et définissez `strict: true` pour que l'appel corresponde à votre schéma. (Dans une organisation [CMEK](https://platform.claude.com/docs/fr/manage-claude/cmek), où les [sorties structurées](https://platform.claude.com/docs/fr/build-with-claude/structured-outputs), y compris `strict: true`, ne sont pas disponibles sur les modèles Claude Fable, appuyez-vous uniquement sur l'instruction.) Par exemple :

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

   Consultez [Utilisation d'outils stricte](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/strict-tool-use) et [Forcer l'utilisation d'outils](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/define-tools#forcing-tool-use). Si vous forciez un outil uniquement pour obtenir du JSON conforme au schéma, utilisez plutôt les [sorties JSON](https://platform.claude.com/docs/fr/build-with-claude/structured-outputs#usage) (`output_config.format`).

   Si votre application, plutôt que l'utilisateur, exige un appel d'outil spécifique au tour actuel d'une conversation multi-tours, ajoutez un [message système en cours de conversation](https://platform.claude.com/docs/fr/build-with-claude/mid-conversation-system-messages) après le dernier tour `user`. Nommez l'outil, indiquez que l'appel est requis pour ce tour et demandez à Claude d'ouvrir sa réponse avec celui-ci. Comme le message est ajouté plutôt qu'écrit dans le prompt `system` de niveau supérieur, les tours précédents restent identiques à l'octet près et conservent leurs succès de [cache de prompts](https://platform.claude.com/docs/fr/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'application exige une consultation du centre d'aide avant toute réponse
             # sur les politiques. Ajouter cette exigence sous forme de message système laisse
             # les tours précédents inchangés.
             {
                 "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'application exige une consultation du centre d'aide avant toute réponse
         // relative aux politiques. Ajouter cette exigence sous forme de message système laisse
         // les tours précédents inchangés.
         {
           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'application exige une recherche dans le centre d'aide avant toute
             // réponse sur une politique. Ajouter cette exigence comme « system message » (message système) laisse
             // les tours précédents inchangés.
             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'application exige une consultation du centre d'aide avant toute réponse
     		// sur une politique. Ajouter cette exigence sous forme de message système laisse
     		// les tours précédents inchangés.
     		{
     			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'application exige une recherche dans le centre d'aide avant toute
             // réponse sur une politique. Ajouter cette exigence en tant que message système laisse
             // les tours précédents inchangés.
             .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'application exige une recherche dans le centre d'aide avant toute
             // réponse sur une politique. Ajouter l'exigence sous forme de message système laisse
             // les tours précédents inchangés.
             ['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'application exige une recherche dans le centre d'aide avant toute
         # réponse sur une politique. Ajouter cette exigence comme message système laisse
         # les tours précédents inchangés.
         {
           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>

   Conservez le message `role: "system"` dans l'historique lors des requêtes ultérieures, comme pour tout autre tour. Les messages système en cours de conversation ne nécessitent aucun en-tête bêta. `tool_choice: {"type": "none"}` fonctionne toujours pour un tour qui ne doit pas appeler d'outils.

2. **Seuls Claude Fable 5.1 et Claude Mythos 5.1 lisent les blocs de réflexion de Claude Fable 5.1 :** chaque bloc `thinking` enregistre le modèle qui l'a produit. Claude Fable 5.1 lit ses propres blocs ainsi que ceux de Claude Mythos 5.1, Claude Opus 5, Claude Fable 5, Claude Mythos 5 et des modèles Claude antérieurs. Une conversation qui passe à `claude-fable-5-1` depuis l'un de ces modèles conserve son raisonnement antérieur. La condition est à sens unique : à l'exception de Claude Mythos 5.1, aucun de ces modèles ne peut lire les blocs de Claude Fable 5.1.

   Une conversation qui s'est déroulée sur Claude Fable 5.1 peut aboutir sur un autre modèle, plus ancien ou plus récent, via un changement de routeur, une nouvelle tentative côté client ou un [repli après refus du classificateur](https://platform.claude.com/docs/fr/build-with-claude/refusals-and-fallback), y compris un [repli côté serveur](https://platform.claude.com/docs/fr/build-with-claude/refusals-and-fallback#server-side-fallback). L'API supprime les blocs que ce modèle ne peut pas lire avant qu'il ne les voie, la requête réussit et les tokens d'entrée supprimés ne vous sont pas facturés. Le modèle cible replanifie sans ce raisonnement, ce qui peut augmenter le coût et la latence au premier tour après le changement. Pour voir ce qui a été supprimé, envoyez l'[en-tête bêta](https://platform.claude.com/docs/fr/api/beta-headers) `thinking-binding-controls-2026-08-01` : les réponses contiennent alors un tableau `input_transformations` qui nomme chaque bloc supprimé avec `reason: "model_binding_mismatch"`. Consultez [Changer de modèle en cours de conversation](https://platform.claude.com/docs/fr/build-with-claude/preserved-thinking#switching-models).

3. **La modification des tours précédents invalide les blocs de réflexion :** chaque bloc `thinking` de Claude Fable 5.1 n'est valide que par rapport au prompt `system`, aux `tools` et à l'historique de conversation qui l'ont précédé. Si Claude Code, claude.ai, [Claude Managed Agents](https://platform.claude.com/docs/fr/managed-agents/overview) ou le [Claude Agent SDK](https://code.claude.com/docs/fr/agent-sdk/overview) gère votre historique de conversation, il conserve déjà ce préfixe intact. Si votre code construit lui-même le tableau `messages`, ce point vous concerne, et [Réflexion préservée](https://platform.claude.com/docs/fr/build-with-claude/preserved-thinking) constitue le guide d'intégration complet. Là où la vérification est appliquée, une requête qui renvoie le bloc après que l'un de ces éléments a changé est rejetée avec une erreur 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 applique la vérification pour les nouveaux comptes créés à partir du 31 août 2026. Pour les comptes créés auparavant, l'API enregistre la non-correspondance mais n'agit pas en conséquence, sauf si la requête définit `thinking.block_binding.prefix_mismatch_behavior`, ce qui active l'application. Sur ces comptes, si vous envoyez l'en-tête bêta `thinking-binding-controls-2026-08-01` et laissez ce champ non défini, la réponse liste chaque bloc ayant échoué à la vérification dans `input_transformations` sous forme d'entrée `thinking_mismatch_allowed`. Rendez votre application compatible avec la vérification quel que soit l'âge de votre compte : les mêmes pratiques maintiennent le cache de prompts chaud, et vous pouvez tester la vérification depuis n'importe quel compte en envoyant `prefix_mismatch_behavior`. Si vous distribuez un outil ou un framework que des personnes exécutent avec leur propre clé API, testez de cette façon avant le lancement : votre clé est probablement associée à un compte plus ancien, et vos utilisateurs disposant de nouveaux comptes rencontreront la vérification avant vous. Pour savoir si la vérification est appliquée par défaut sur votre propre compte, envoyez une requête qui modifie l'historique sans l'en-tête bêta : une erreur 400 qui mentionne l'en-tête signifie que c'est le cas.

   L'erreur est permanente pour ce corps de requête : une boucle de nouvelles tentatives automatiques ne la résoudra pas. Pour continuer sans le raisonnement invalidé au lieu d'échouer, retirez les blocs `thinking` de l'historique et réessayez une fois, ou envoyez l'[en-tête bêta](https://platform.claude.com/docs/fr/api/beta-headers) `thinking-binding-controls-2026-08-01` et définissez `prefix_mismatch_behavior` sur `"drop_block"` (la valeur par défaut est `"error"`). Avec `"drop_block"`, l'API supprime le bloc non correspondant et tous les blocs de réflexion qui le suivent dans la conversation, et signale chacun avec `reason: "prefix_binding_mismatch"` dans le tableau `input_transformations` de la réponse :

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

   Le point de terminaison de [comptage de tokens](https://platform.claude.com/docs/fr/build-with-claude/token-counting) exécute la même vérification. Consultez [Contrôles pour les blocs qui ne sont pas préservés (bêta)](https://platform.claude.com/docs/fr/build-with-claude/thinking#preserved-thinking-controls) pour la forme de la réponse et le placement en streaming.

   Modèles qui invalident les blocs de réflexion ultérieurs, et ce qu'il faut faire à la place :

   * Modifier, réordonner ou supprimer des tours précédents. Cela inclut la suppression d'anciens résultats d'outils, le retrait de tours au milieu de la transcription, et la compaction côté client qui conserve les tours récents et leurs blocs de réflexion tels quels derrière un résumé (y compris la compaction en arrière-plan qui insère son résumé quelques tours plus tard). Utilisez plutôt la [compaction](https://platform.claude.com/docs/fr/build-with-claude/compaction) côté serveur ou l'[édition de contexte](https://platform.claude.com/docs/fr/build-with-claude/context-editing) ([effacement des résultats d'outils](https://platform.claude.com/docs/fr/build-with-claude/context-editing#tool-result-clearing) pour les anciens résultats d'outils), ou l'une des formes de compaction côté client décrites dans [Réduire le contexte sur le serveur](https://platform.claude.com/docs/fr/models/fable-5-1/migration-guide#fable-5-1-trim-context).
   * Injecter du contenu que vous ne conservez pas, par exemple un rappel par tour ajouté après les blocs `tool_result` et retiré à la requête suivante. Envoyez plutôt le rappel sous forme de [message système limité au tour](https://platform.claude.com/docs/fr/build-with-claude/mid-conversation-system-messages#turn-scoped-system-messages) et laissez-le dans l'historique.
   * Reconstruire le prompt `system` de niveau supérieur ou le tableau `tools` entre les requêtes d'une même conversation, par exemple pour mettre à jour la date actuelle ou pour ajouter ou retirer un outil. Ajoutez plutôt un [message système en cours de conversation](https://platform.claude.com/docs/fr/build-with-claude/mid-conversation-system-messages) qui contient la nouvelle instruction (« La date actuelle est le 2026-09-14. ») ou des blocs `tool_addition` et `tool_removal`. Un outil qui n'était pas déclaré dans `tools` au départ peut être [défini dans le bloc `tool_addition`](https://platform.claude.com/docs/fr/build-with-claude/mid-conversation-system-messages#define-tools-in-a-message-beta) (en-tête bêta `inline-tools-2026-09-15`).
   * Une URL d'image ou de document qui sert des octets différents lors d'une requête ultérieure. La vérification porte sur les octets, pas sur la chaîne d'URL ; une URL signée rotative pour le même fichier ne pose donc pas de problème. Pour le contenu que vous référencez sur plusieurs tours, téléversez-le une fois avec l'[API Files](https://platform.claude.com/docs/fr/build-with-claude/files) et envoyez le `file_id`, ou envoyez-le en base64.

   Chaque remplacement maintient également les tours précédents identiques à l'octet près et préserve les succès de [cache de prompts](https://platform.claude.com/docs/fr/build-with-claude/prompt-caching) que la modification de l'historique, du prompt `system` ou du tableau `tools` ferait perdre.

   Modèles qui continuent de fonctionner :

   * Historiques en ajout seul : ajouter des tours et renvoyer les tours précédents exactement tels qu'envoyés et reçus, y compris les messages `role: "system"` ajoutés.
   * Retirer les blocs de réflexion des tours d'assistant précédents, les plus anciens en premier.
   * Modifier `effort`, `max_tokens` ou tout autre paramètre de requête en dehors de `system`, `tools` et `messages`, et ajouter ou déplacer des marqueurs `cache_control`.
   * La compaction côté serveur et l'édition de contexte, y compris l'[effacement des blocs de réflexion](https://platform.claude.com/docs/fr/build-with-claude/context-editing#thinking-block-clearing). Elles ne comptent pas comme des modifications, car la vérification compare la conversation telle que vous l'avez envoyée.

   Pour vérifier une intégration existante :

   1. Capturez les corps de requête exacts qu'elle envoie sur quelques tours normaux, y compris une compaction ou un changement d'outil si votre produit en comporte. Pour chaque paire de requêtes consécutives, comparez le prompt `system`, le tableau `tools` et le préfixe commun de `messages`. Ils doivent être identiques octet par octet jusqu'aux tours nouvellement ajoutés. Une exception attendue est une requête qui insère un bloc `compaction` signé issu de la [compaction à la demande](https://platform.claude.com/docs/fr/build-with-claude/compaction-on-demand) : le bloc remplace les messages qu'il résume au début de `messages`, et tout ce qui suit doit toujours correspondre.
   2. Exécutez une session multi-tours normale sur `claude-fable-5-1` avec l'en-tête bêta `thinking-binding-controls-2026-08-01` et `prefix_mismatch_behavior: "drop_block"`, et journalisez `input_transformations` pour chaque réponse. Un tableau vide à chaque tour signifie que l'historique est intact. Une entrée avec `reason: "prefix_binding_mismatch"` signifie qu'un élément situé avant le bloc à `path` a changé depuis la requête précédente. Une entrée avec `reason: "model_binding_mismatch"` signifie que la conversation a changé de modèle, ce qui n'est pas un bogue de votre code. Cela fonctionne depuis n'importe quel compte, car la définition du champ active l'application pour la requête. En CI, définissez plutôt `"error"` afin qu'une modification fasse échouer l'exécution.
   3. Choisissez un paramètre de production. Conservez la valeur par défaut `"error"` si une non-correspondance de préfixe ne peut signifier qu'un bogue dans votre code, ou définissez `"drop_block"` pour supprimer les blocs concernés au lieu d'échouer, et surveillez dans tous les cas les erreurs 400 ou les entrées `input_transformations`.

   Supprimer les blocs de réflexion une seule fois, à une frontière de compaction par exemple, a peu d'effet. Une intégration qui invalide la réflexion antérieure à chaque requête redémarre le cache de prompts à chaque fois, ce qui peut augmenter le coût par tâche (consultez [Conserver l'historique de conversation en ajout seul](https://platform.claude.com/docs/fr/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#keep-the-conversation-history-append-only)).

### Changements de comportement

1. **Moins d'appels d'outils parallèles dans les longues boucles d'agent :** dans les boucles de longue durée où les prochaines lectures indépendantes ne sont qu'implicites dans la tâche (agents de codage personnalisés, harnais bash-et-éditeur, utilisation de l'ordinateur), Claude Fable 5.1 peut émettre un seul appel d'outil par tour. Chaque tour supplémentaire coûte des tokens, un aller-retour et du temps réel. Ajoutez une instruction de regroupement d'une phrase après chaque message utilisateur sous forme de [message système limité au tour](https://platform.claude.com/docs/fr/build-with-claude/mid-conversation-system-messages#turn-scoped-system-messages) (`clear_at: "next_user_message"`, bêta), ou, sans la bêta, dans un bloc de texte après les blocs `tool_result`, et laissez les copies précédentes dans l'historique lors des requêtes ultérieures. Consultez [Regrouper les appels d'outils indépendants dans les boucles d'agent](https://platform.claude.com/docs/fr/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#batch-independent-tool-calls-in-agent-loops).

2. **Moins de messages de progression entre les appels d'outils :** Claude Fable 5.1 écrit moins de mises à jour de statut pendant les longues séquences d'outils que Claude Fable 5, et ses résumés de codage agentique sont plus courts. Si votre interface affiche ces mises à jour, définissez `thinking.display` sur `"updates"` (bêta) ou `"summarized"` et demandez-les explicitement dans le prompt. Consultez [Mises à jour de progression entre les appels d'outils](https://platform.claude.com/docs/fr/build-with-claude/thinking#progress-updates) et [Demander des mises à jour de progression destinées à l'utilisateur](https://platform.claude.com/docs/fr/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#ask-for-user-facing-progress-updates).

3. **Moins d'appels de recherche et de récupération à faible effort :** Avec l'effort `low`, Claude Fable 5.1 répond de mémoire plus souvent que Claude Fable 5 au lieu d'appeler un outil de recherche ou de récupération. Si votre produit dépend de la récupération à faible effort, augmentez l'effort pour ces requêtes ou indiquez au modèle quand effectuer une recherche. Consultez [Déclenchement de la recherche à faible effort](https://platform.claude.com/docs/fr/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#search-triggering-at-low-effort).

Pour les différences de densité de prose, de formatage en chat, de citation dans les résumés et de modifications de fichiers, qui n'affectent pas l'intégration de l'API, consultez [Changements par rapport à Claude Fable 5](https://platform.claude.com/docs/fr/models/fable-5-1/whats-new-fable-5-1#changed-from-claude-fable-5).

### Changements recommandés

Ces changements ne sont pas obligatoires, mais chacun réduit le coût ou la latence, ou élimine un mode de défaillance :

1. **Modifier l'effort en cours de conversation (bêta) :** sur Claude Fable 5, `output_config.effort` est défini au niveau de la requête, et le modifier entre les requêtes fait perdre les préfixes mis en cache des tours précédents. Sur `claude-fable-5-1`, un message `role: "system"` ne portant que `output_config` augmente l'effort pour une étape difficile ou le réduit pour les étapes routinières sans invalider le [cache de prompts](https://platform.claude.com/docs/fr/build-with-claude/prompt-caching) :

   <CodeGroup>
     ```bash cURL
     # Message système ne modifiant que l'effort : le nouveau niveau s'applique à partir du prochain tour de l'utilisateur.
     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."
       # Message système portant uniquement sur l'effort : le nouveau niveau s'applique à partir du prochain tour de l'utilisateur.
       - 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.",
             },
             # Message système portant uniquement sur l'effort : le nouveau niveau s'applique à partir du prochain tour de l'utilisateur.
             {"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."
         },
         // Message système portant uniquement sur l'effort : le nouveau niveau prend effet au prochain tour de l'utilisateur.
         { 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." },
             // Message système portant uniquement sur l'effort : le nouveau niveau s'applique à partir du prochain tour de l'utilisateur.
             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.")},
     		},
     		// Message système ne modifiant que l'effort : le nouveau niveau s'applique dès le prochain tour de l'utilisateur.
     		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.")
             // Message système portant uniquement sur l'effort : le nouveau niveau s'applique dès le prochain tour de l'utilisateur.
             .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.'),
             // Message système limité à l'effort : le nouveau niveau s'applique à partir du prochain tour de l'utilisateur.
             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."},
         # Message système ne contenant que l'effort : le nouveau niveau s'applique dès le prochain tour de l'utilisateur.
         {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>

   Placé entre un tour `assistant` et le tour `user` suivant, comme ici, le message prend effet à partir de ce tour `user`. Placé directement après un tour `user` contenant une nouvelle entrée, il définit le niveau de la réponse de Claude à ce tour. Un tour `user` qui ne contient que des résultats d'outils ne compte pas comme une nouvelle entrée : le changement attend le prochain tour `user` contenant une nouvelle entrée. Le niveau reste ensuite en vigueur jusqu'à ce qu'un autre message `role: "system"` le modifie. Seuls les niveaux nommés sont acceptés (`low`, `medium`, `high`, `xhigh`, `max`), et l'en-tête bêta `mid-conversation-output-config-2026-07-01` est requis. Consultez [Effort par message](https://platform.claude.com/docs/fr/build-with-claude/effort#change-effort-mid-conversation-beta).

2. **Modifier les instructions et les outils avec des messages système en cours de conversation :** Pour modifier des instructions ou des outils en cours de session, ajoutez un [message `role: "system"`](https://platform.claude.com/docs/fr/build-with-claude/mid-conversation-system-messages), avec des blocs `tool_addition` et `tool_removal` pour les changements d'outils (en-tête bêta `inline-tools-2026-09-15` sur l'API Claude). Un bloc `tool_addition` peut nommer un outil déclaré dans `tools` au début de la session ou [contenir la définition complète de l'outil](https://platform.claude.com/docs/fr/build-with-claude/mid-conversation-system-messages#define-tools-in-a-message-beta), de sorte qu'un outil inconnu au début de la session n'a pas besoin de figurer dans `tools`. Cela préserve les succès de cache de prompts sur les tours précédents et maintient l'historique de conversation en ajout seul. L'ancien en-tête `mid-conversation-tool-changes-2026-07-01` fonctionne toujours pour les changements qui nomment un outil par référence, sur l'API Claude, Amazon Bedrock et Google Cloud. Le même message remplace le `tool_choice` forcé lorsqu'un outil spécifique doit s'exécuter au tour actuel (consultez [Changements incompatibles](https://platform.claude.com/docs/fr/models/fable-5-1/migration-guide#fable-5-1-breaking-changes)). Pour un rappel qui ne s'applique qu'à un seul tour, envoyez-le sous forme de message `role: "system"` distinct contenant uniquement du texte avec `clear_at: "next_user_message"` ([messages système limités au tour](https://platform.claude.com/docs/fr/build-with-claude/mid-conversation-system-messages#turn-scoped-system-messages), en-tête bêta `mid-conversation-system-clear-at-2026-08-21`) et laissez-le dans l'historique : il cesse d'être rendu après le message utilisateur suivant et ne coûte aucun token une fois effacé. Un message qui contient des blocs `tool_addition` ou `tool_removal` ne peut pas être limité au tour.

3. **Utiliser `fallbacks: "default"` pour les refus :** continuez à gérer `stop_reason: "refusal"` et à lire `stop_details.category` avant le contenu de la réponse. Pour réexécuter automatiquement les requêtes refusées sur un autre modèle, définissez `fallbacks: "default"` (bêta, en-tête `server-side-fallback-2026-07-01`). `"default"` relance une requête refusée sur le modèle recommandé par Anthropic pour cette catégorie. Les cibles de repli autorisées pour Claude Fable 5.1 sont Claude Opus 4.8 (`claude-opus-4-8`) et Claude Opus 5 (`claude-opus-5`). Une liste `fallbacks` explicite peut nommer l'un ou l'autre. Le modèle de repli ne reçoit pas les blocs de réflexion de Claude Fable 5.1. Le paramètre `fallbacks` n'est pas disponible sur Amazon Bedrock, Google Cloud ou Microsoft Foundry. Sur ces plateformes, utilisez plutôt le [repli côté client](https://platform.claude.com/docs/fr/build-with-claude/refusals-and-fallback#client-side-fallback). Si vous construisez vous-même la nouvelle tentative, le [crédit de repli](https://platform.claude.com/docs/fr/build-with-claude/fallback-credit) s'applique aux mêmes conditions que pour Claude Fable 5. Consultez [Refus et repli](https://platform.claude.com/docs/fr/build-with-claude/refusals-and-fallback).

4. **Commencer à l'effort `high` et balayer :** la valeur par défaut du [paramètre effort](https://platform.claude.com/docs/fr/build-with-claude/effort) est `high`, et les cinq niveaux sont pris en charge. Conservez les recommandations de Claude Fable 5 : `high` pour la plupart des travaux, et `medium` comme contrôle des coûts qui mérite d'être testé. Les gains de Claude Fable 5.1 par rapport à Claude Fable 5 sont les plus importants à `xhigh` et `max`, mais ces niveaux ajoutent également du temps de réflexion et du temps avant la première réponse, alors passez à ces niveaux pour les tâches les plus sensibles aux capacités et là où vos évaluations montrent le gain. Effectuez un nouveau balayage sur vos propres évaluations plutôt que de reprendre un réglage ajusté pour Claude Fable 5. Consultez [Niveaux d'effort recommandés pour Claude Fable 5.1](https://platform.claude.com/docs/fr/build-with-claude/effort#recommended-effort-levels-for-claude-fable-5-1).

5. **Réduire le contexte sur le serveur, ou compacter sous une forme qui ne transporte aucune réflexion obsolète :** Si votre code tronque ou résume les tours plus anciens côté client, la solution la plus simple consiste à déplacer ce travail vers la [compaction](https://platform.claude.com/docs/fr/build-with-claude/compaction) ou l'[édition de contexte](https://platform.claude.com/docs/fr/build-with-claude/context-editing) côté serveur. Aucune des deux ne compte comme une modification, car la [vérification de l'historique](https://platform.claude.com/docs/fr/models/fable-5-1/migration-guide#fable-5-1-preserved-thinking) compare la conversation telle que vous l'avez envoyée ; rien de ce qu'elles suppriment n'invalide donc les blocs de réflexion ultérieurs, et le [paramètre `instructions`](https://platform.claude.com/docs/fr/build-with-claude/compaction-threshold#custom-summarization-instructions) de la compaction accepte votre propre prompt de résumé. Si vous conservez les tours récents tels quels derrière le résumé, ou si vous résumez en arrière-plan pendant que la conversation se poursuit, utilisez la [compaction à la demande](https://platform.claude.com/docs/fr/build-with-claude/compaction-on-demand) (en-tête bêta `compact-2026-09-04`) plutôt qu'un résumé rédigé côté client. L'API rédige un bloc de résumé signé que vous placez à la place des messages qu'il résume. Les blocs de réflexion des tours que vous conservez peuvent rester valides, dans les conditions décrites dans [Compaction et réflexion préservée](https://platform.claude.com/docs/fr/build-with-claude/compaction-thinking-blocks#conditions-for-kept-thinking-to-stay-valid). Si vous conservez la compaction côté client, choisissez l'une des trois formes suivantes :

   * **Compaction simple (recommandée) :** remplacez l'historique entier par un seul message de résumé plus le nouveau tour utilisateur et ne rejouez rien d'autre. Aucun bloc de réflexion n'est reporté, donc rien n'échoue. Les modèles Claude sont entraînés sur des tâches à long horizon avec ce schéma, et il offre des performances comparables à des schémas plus élaborés pour la plupart des charges de travail.
   * **Compaction avec conservation de la fin :** si vous conservez les tours les plus récents tels quels derrière un résumé, retirez les blocs `thinking` et `redacted_thinking` de ces tours (le texte et les appels d'outils peuvent rester), ou définissez `prefix_mismatch_behavior: "drop_block"`. Leur réflexion a été produite par rapport à l'historique complet et échoue derrière le résumé dans le cas contraire.
   * **Compaction en arrière-plan :** si vous construisez le résumé hors du chemin critique et l'insérez plus tard, chaque tour produit entre-temps porte une réflexion antérieure à l'insertion. Envoyez `"drop_block"` sur chaque requête qui porte encore des blocs de réflexion produits avant l'insertion (ou retirez ces blocs vous-même ; `input_transformations` sur la première réponse après l'insertion liste exactement lesquels), ou compactez de manière synchrone.

   Ne retirez pas de tours individuels au milieu de la transcription : cela invalide tous les blocs de réflexion ultérieurs et aucune forme côté client ne permet de l'éviter. Utilisez un [message système en cours de conversation](https://platform.claude.com/docs/fr/build-with-claude/mid-conversation-system-messages) pour le changement d'instruction que vous effectuiez, ou l'[édition de contexte](https://platform.claude.com/docs/fr/build-with-claude/context-editing) côté serveur pour une suppression sélective. Consultez [Renvoyer les blocs de compaction](https://platform.claude.com/docs/fr/build-with-claude/compaction-threshold#passing-compaction-blocks-back).

### Liste de contrôle de migration

* Mettez à jour le nom du modèle de `claude-fable-5` vers `claude-fable-5-1` (ou de `claude-mythos-5` vers `claude-mythos-5-1`).
* Remplacez le `tool_choice` forcé (`{type: "any"}` ou `{type: "tool", ...}`). Il renvoie une erreur 400. Utilisez `{type: "auto"}` avec une instruction explicite et des outils `strict: true`, ou les sorties JSON. Placez l'instruction dans le tour `user`, ou dans un message `role: "system"` en cours de conversation lorsque votre application exige l'appel.
* Continuez à renvoyer les blocs `thinking` sans modification à chaque tour, y compris les blocs vides. Claude Fable 5.1 lit les blocs de Claude Opus 5, Claude Fable 5, Claude Mythos 5 et des modèles antérieurs. Déplacer une conversation de Claude Fable 5.1 vers tout modèle autre que Claude Mythos 5.1 supprime ses blocs.
* Si votre code construit lui-même le tableau `messages`, vérifiez s'il [modifie les tours précédents](https://platform.claude.com/docs/fr/models/fable-5-1/migration-guide#fable-5-1-preserved-thinking) : exécutez une session avec l'en-tête bêta `thinking-binding-controls-2026-08-01` et `prefix_mismatch_behavior: "drop_block"`, journalisez `input_transformations` et corrigez chaque `prefix_binding_mismatch`. Les entrées `model_binding_mismatch` après un changement de modèle sont attendues.
* Gardez l'historique de conversation en ajout seul : figez `system` et `tools` au début de la session et déplacez les changements en cours de session vers des messages `role: "system"` et des blocs `tool_addition` / `tool_removal`, envoyez les rappels par tour sous forme de messages système limités au tour que vous ne supprimez jamais, réduisez le contexte côté serveur ou supprimez les blocs de réflexion de tous les tours que vous reportez au-delà d'un résumé côté client, et référencez les fichiers utilisés sur plusieurs tours par `file_id`.
* Choisissez un `prefix_mismatch_behavior` de production (`"error"` par défaut, ou `"drop_block"`) et surveillez-le. Si vous maintenez un outil que d'autres exécutent avec leur propre clé API, testez avec le champ défini : les nouveaux comptes sont soumis à l'application par défaut, même si le vôtre ne l'est pas.
* Examinez les boucles d'agent pour détecter le comportement d'un seul appel d'outil par tour et ajoutez l'instruction de regroupement.
* Si votre interface affiche du texte de progression entre les appels d'outils, définissez `thinking.display` sur `"updates"` (bêta) ou `"summarized"` et demandez des mises à jour dans le prompt.
* Si vous modifiez l'effort entre les requêtes, déplacez le changement vers un message `role: "system"` d'[effort par message](https://platform.claude.com/docs/fr/build-with-claude/effort#change-effort-mid-conversation-beta) (bêta) pour conserver les succès de cache.
* Gérez `stop_reason: "refusal"` et lisez `stop_details.category`. Envisagez `fallbacks: "default"` (bêta).
* Réévaluez `effort` avec un nouveau balayage, en commençant à `high`, et réétablissez les références de coût et de latence sur vos propres charges de travail. Le tokenizer est inchangé. Les lectures du cache de prompts coûtent un quart du tarif de Claude Fable 5.

## Migration vers Claude Fable 5.1 depuis Claude Opus 5

Claude Fable 5.1 utilise les mêmes modèles d'[API Messages](https://platform.claude.com/docs/fr/build-with-claude/working-with-messages) et d'[utilisation d'outils](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/overview) que Claude Opus 5. Il conserve par défaut la [fenêtre de contexte de 1M de tokens](https://platform.claude.com/docs/fr/build-with-claude/context-windows), les [128k tokens de sortie maximum](https://platform.claude.com/docs/fr/models/overview), le minimum de 512 tokens pour la mise en cache des prompts et la prise en charge des [messages système en milieu de conversation](https://platform.claude.com/docs/fr/build-with-claude/mid-conversation-system-messages). La restriction sur le préremplissage, la restriction sur les paramètres d'échantillonnage et la valeur par défaut `"omitted"` pour `thinking.display` sont également conservées. Appliquez tout ce qui figure dans [Migration vers Claude Fable 5.1 depuis Claude Fable 5](https://platform.claude.com/docs/fr/models/fable-5-1/migration-guide#migrating-from-claude-fable-5-to-claude-fable-5-1), plus ce qui suit.

### Mettez à jour le nom de votre modèle

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

# Ou, pour Claude Mythos 5.1, qui offre les mêmes capacités aux organisations vérifiées :
model = "claude-mythos-5-1"  # After
```

### Ce qui a changé

1. **La réflexion ne peut plus être désactivée :** Claude Opus 5 accepte `thinking: {type: "disabled"}` à un niveau d'[effort](https://platform.claude.com/docs/fr/build-with-claude/effort) de `high` ou inférieur. Sur `claude-fable-5-1` et `claude-mythos-5-1`, la [réflexion adaptative](https://platform.claude.com/docs/fr/build-with-claude/thinking) est toujours activée, et `thinking: {type: "disabled"}` renvoie une erreur 400 à n'importe quel niveau d'effort. Supprimez le champ, contrôlez la dépense de tokens avec des niveaux d'effort inférieurs et réexaminez `max_tokens` pour les charges de travail qui s'exécutaient avec la réflexion désactivée.

2. **Le choix d'outil forcé n'est pas pris en charge :** Claude Opus 5 accepte `tool_choice` `any` et `tool`. `claude-fable-5-1` renvoie une erreur 400. Consultez [Changements incompatibles](https://platform.claude.com/docs/fr/models/fable-5-1/migration-guide#fable-5-1-breaking-changes).

3. **Réflexion préservée entre les modèles :** Claude Fable 5.1 lit les blocs de réflexion de Claude Opus 5 : les conversations passant de `claude-opus-5` à `claude-fable-5-1` conservent leur raisonnement. Claude Opus 5 ne peut pas lire les blocs de Claude Fable 5.1. Les blocs de Claude Fable 5.1 [cessent également d'être valides lorsque des tours antérieurs changent](https://platform.claude.com/docs/fr/models/fable-5-1/migration-guide#fable-5-1-preserved-thinking) : si votre code modifie des messages antérieurs, reconstruit `system` ou `tools`, ou compacte côté client entre les requêtes, Claude Opus 5 ne s'y opposait pas, mais `claude-fable-5-1` rejette ou supprime chaque bloc de réflexion ultérieur. Exécutez la vérification en trois étapes de cette section avant de basculer le trafic. Consultez [Changements incompatibles](https://platform.claude.com/docs/fr/models/fable-5-1/migration-guide#fable-5-1-breaking-changes).

4. **Le texte entre les appels d'outils est renvoyé dans des blocs de réflexion :** Sur Claude Opus 5, le texte que le modèle écrit entre les appels d'outils est renvoyé sous forme de blocs `text`. Sur `claude-fable-5-1`, comme sur Claude Fable 5, cette narration est renvoyée sous forme de blocs `thinking` de mise à jour de progression, un avant chaque appel d'outil. Avec la valeur par défaut `"omitted"` de `thinking.display`, ils ne contiennent aucun texte lisible. Si votre interface affiche cette narration, définissez `display: "updates"` (bêta) pour recevoir les mises à jour de progression sous forme de texte tout en gardant le raisonnement masqué, ou `"summarized"` pour recevoir les deux. Affichez ensuite les blocs `thinking` non vides entre les blocs `tool_use`. Consultez [Mises à jour de progression entre les appels d'outils](https://platform.claude.com/docs/fr/build-with-claude/thinking#progress-updates).

5. **Classificateurs de sécurité et routage de repli :** Claude Fable 5.1 exécute des classificateurs de sécurité couvrant les mêmes catégories `stop_details` que Claude Fable 5, un ensemble plus large que celui des classificateurs de Claude Opus 5. Attendez-vous à des valeurs `stop_details.category` supplémentaires, telles que `"bio"` ; consultez le [tableau des catégories de refus](https://platform.claude.com/docs/fr/build-with-claude/refusals-and-fallback#refusal-response) pour l'ensemble complet. Pour la configuration de `fallbacks` et les cibles autorisées, consultez [Utiliser `fallbacks: "default"` pour les refus](https://platform.claude.com/docs/fr/models/fable-5-1/migration-guide#fable-5-1-recommended-changes).

6. **Tarification :** 10 $ USD par million de tokens d'entrée et 50 $ USD par million de tokens de sortie, contre 5 $ USD et 25 $ USD pour Claude Opus 5. Les lectures du cache de prompts coûtent 0,25 $ USD par million de tokens, soit la moitié du tarif de Claude Opus 5. Consultez [Tarification de Claude](https://platform.claude.com/docs/fr/about-claude/pricing).

7. **Conservation des données :** Claude Fable 5.1 et Claude Mythos 5.1 exigent une conservation des données de 30 jours, ne sont pas disponibles dans le cadre d'accords de « zero data retention » (conservation zéro des données), ou ZDR, sauf autorisation expresse d'Anthropic, et sont désignés comme Modèles Couverts. Claude Opus 5 est disponible sous ZDR. Consultez [Exigences de conservation des données spécifiques aux modèles](https://platform.claude.com/docs/fr/manage-claude/api-and-data-retention#model-specific-data-retention-requirements).

### Liste de contrôle de migration

* Si votre organisation dispose d'un accord de « zero data retention » (conservation zéro des données), ou ZDR, confirmez d'abord votre éligibilité : ces modèles ne sont pas disponibles sous ZDR sauf autorisation expresse d'Anthropic. Consultez [Exigences de conservation des données spécifiques aux modèles](https://platform.claude.com/docs/fr/manage-claude/api-and-data-retention#model-specific-data-retention-requirements).
* Remplacez le nom du modèle `claude-opus-5` par `claude-fable-5-1` (ou `claude-mythos-5-1`).
* Supprimez toute configuration `thinking: {type: "disabled"}` : elle renvoie une erreur 400 sur `claude-fable-5-1`. Contrôlez la consommation de tokens avec des niveaux d'[effort](https://platform.claude.com/docs/fr/build-with-claude/effort) plus bas, et réexaminez `max_tokens`.
* Remplacez le `tool_choice` forcé (`any` ou `tool`) par `auto`, accompagné d'une instruction explicite (tour `user` ou message système en cours de conversation) et d'outils `strict: true`, ou par des sorties JSON.
* Si votre interface affiche le texte entre les appels d'outils, définissez `display: "updates"` (bêta) ou `"summarized"` et affichez les blocs `thinking` non vides.
* Appliquez les éléments relatifs à la « preserved thinking » (réflexion préservée), à la modification de l'historique, au comportement, à l'effort et au « fallback » (repli) de la [liste de vérification de Claude Fable 5](https://platform.claude.com/docs/fr/models/fable-5-1/migration-guide#migration-checklist-fable-5-1-from-fable-5).
* Réétablissez votre référence de coût sur vos propres charges de travail. Le « tokenizer » (tokeniseur) est inchangé. La tarification par token diffère.

## Migration vers Claude Fable 5.1 depuis Claude Opus 4.8 ou antérieur

Suivez la liste de contrôle ci-dessous. Si vous utilisez Claude Opus 4.7 ou une version antérieure, commencez par la section correspondante du [guide de migration vers Claude Opus 5.5](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide).

### Mettez à jour le nom de votre modèle

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

# Ou, pour Claude Mythos 5.1, qui offre les mêmes capacités aux organisations vérifiées :
model = "claude-mythos-5-1"  # After
```

### Liste de contrôle de migration

* Si votre organisation dispose d'un accord de conservation zéro des données (ZDR), confirmez d'abord votre éligibilité : ces modèles ne sont pas disponibles sous ZDR sauf autorisation expresse d'Anthropic. Claude Opus 4.8 est disponible sous ZDR.
* Mettez à jour le nom du modèle de `claude-opus-4-8` vers `claude-fable-5-1` (ou `claude-mythos-5-1`).
* Supprimez toute configuration `thinking: {type: "disabled"}` et réexaminez `max_tokens`. Les requêtes sans champ `thinking` s'exécutent avec la réflexion adaptative.
* Mettez à jour l'analyse des réponses qui lit le contenu par position, comme `content[0].text` : une réponse peut désormais commencer par des blocs `thinking`, sélectionnez donc plutôt les blocs de contenu par `type`.
* Remplacez le `tool_choice` forcé (`any` ou `tool`) par `auto` accompagné d'une instruction explicite (tour `user` ou message système en milieu de conversation) et d'outils `strict: true`, ou par des sorties JSON.
* Renvoyez les blocs `thinking` inchangés et traitez leur texte comme destiné uniquement à l'affichage. Claude Fable 5.1 lit les blocs de réflexion de Claude Opus 4.8 : une conversation qui passe sur `claude-fable-5-1` conserve son raisonnement antérieur. Claude Opus 4.8 ne peut pas lire les blocs de Claude Fable 5.1.
* Si votre code construit lui-même le tableau `messages`, vérifiez s'il [modifie des tours antérieurs](https://platform.claude.com/docs/fr/models/fable-5-1/migration-guide#fable-5-1-preserved-thinking). Les intégrations écrites pour Claude Opus 4.8 et antérieur tronquent souvent les anciens tours, retirent ou reconstruisent des messages antérieurs, ou actualisent le prompt `system` à chaque requête, et Claude Opus 4.8 ne s'y est jamais opposé. Sur `claude-fable-5-1`, chacune de ces opérations invalide les blocs de réflexion ultérieurs.
* Gérez `stop_reason: "refusal"`, lisez `stop_details.category` et envisagez `fallbacks: "default"` (bêta).
* Appliquez les éléments relatifs à la réflexion préservée, à la modification de l'historique, au comportement, à l'effort par message et aux mises à jour de progression de la [liste de contrôle Claude Fable 5](https://platform.claude.com/docs/fr/models/fable-5-1/migration-guide#migration-checklist-fable-5-1-from-fable-5).
* Réévaluez `effort` (commencez à `high`), examinez les prompts proches du [minimum de mise en cache](https://platform.claude.com/docs/fr/build-with-claude/prompt-caching#cache-limitations) de 512 tokens (1 024 tokens sur Claude Opus 4.8), et réétablissez une référence de coût et de latence. La tarification par token diffère, et les tokens de réflexion sont facturés comme des tokens de sortie, de sorte que les charges de travail qui s'exécutaient sans réflexion sur Claude Opus 4.8 peuvent produire davantage de tokens de sortie par requête.

## Migration vers Claude Mythos 5.1 depuis Claude Mythos 5

[Claude Mythos 5.1](https://platform.claude.com/docs/fr/models/mythos-5-1/overview) est l'équivalent de Claude Fable 5.1 pour les organisations vérifiées par le biais des programmes de vérification d'Anthropic, tels que le [Cyber Verification Program](https://support.claude.com/en/articles/14604842). Confirmez que votre organisation a accès à Claude Mythos 5.1 avant de changer d'identifiant de modèle.

Les différences au niveau de l'API correspondent à celles de [Migration vers Claude Fable 5.1 depuis Claude Fable 5](https://platform.claude.com/docs/fr/models/fable-5-1/migration-guide#migrating-from-claude-fable-5-to-claude-fable-5-1) : le choix d'outil forcé renvoie une erreur 400, et seuls Claude Mythos 5.1 et Claude Fable 5.1 lisent les blocs de réflexion de Claude Mythos 5.1 (Claude Mythos 5.1 lit les blocs de Claude Mythos 5, mais pas l'inverse). Contrairement à Claude Fable 5.1, Claude Mythos 5.1 n'exécute pas la vérification de conversation, de sorte que la modification des tours précédents n'[invalide pas les blocs de réflexion](https://platform.claude.com/docs/fr/models/fable-5-1/migration-guide#fable-5-1-preserved-thinking), bien qu'elle redémarre tout de même le cache de prompts.

### Mettez à jour le nom de votre modèle

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

### Liste de contrôle de migration

* Mettez à jour le nom du modèle de `claude-mythos-5` vers `claude-mythos-5-1`.
* Remplacez le `tool_choice` forcé (`any` ou `tool`) par `auto` accompagné d'une instruction explicite (tour `user` ou message système en milieu de conversation) et d'outils `strict: true`, ou par des sorties JSON.
* Gérez `stop_reason: "refusal"` et lisez `stop_details.category` avant le contenu de la réponse. Consultez [Refus et repli](https://platform.claude.com/docs/fr/build-with-claude/refusals-and-fallback).
* Continuez à renvoyer les blocs `thinking` inchangés à chaque tour, y compris les blocs vides.
* Si votre code construit lui-même le tableau `messages`, conservez un historique de conversation en ajout seul afin de garder le cache de prompts chaud. Claude Mythos 5.1 n'exécute pas la [vérification de conversation](https://platform.claude.com/docs/fr/build-with-claude/thinking#preserved-in-conversation), de sorte que les modifications n'invalident pas ses blocs de réflexion.
* Appliquez les changements de comportement et les changements recommandés de la [section Claude Fable 5](https://platform.claude.com/docs/fr/models/fable-5-1/migration-guide#migrating-from-claude-fable-5-to-claude-fable-5-1), à l'exception des éléments relatifs à la modification de l'historique, qui ne s'appliquent pas à Claude Mythos 5.1.
* Réévaluez `effort` avec un nouveau balayage et réétablissez une référence de coût et de latence. Les lectures du cache de prompts coûtent un quart du tarif de Claude Mythos 5.