---
title: Guía de migración a Claude Fable 5.1 y Claude Mythos 5.1
url: https://platform.claude.com/docs/es/models/fable-5-1/migration-guide
description: Cambia a Claude Fable 5.1 y Claude Mythos 5.1 desde Claude Fable 5, Claude Mythos 5, Claude Opus 5 o Claude Opus 4.8 con esta guía de migración. La guía para habilitar Claude Fable 5.1 y Claude Mythos 5.1 incluye los ID de modelo, los cambios incompatibles y las listas de verificación de migración.
---

<Note>
  Esta guía cubre la migración de código de la [Messages API](https://platform.claude.com/docs/es/build-with-claude/working-with-messages). Si usas [Claude Managed Agents](https://platform.claude.com/docs/es/managed-agents/overview), no se requieren cambios más allá de actualizar el nombre del modelo.
</Note>

<Tip>
  **Automatiza tu migración con la skill de Claude API.** En Claude Code, ejecuta `/claude-api migrate` para invocar la [skill de Claude API](https://platform.claude.com/docs/es/agents-and-tools/agent-skills/claude-api-skill#migrating-to-a-newer-claude-model) incluida. Funciona con cualquier modelo actual de Claude como destino:

  Deja que Claude Code migre tu código por ti

  ```text
  /claude-api migrate este proyecto a claude-fable-5-1
  ```

  La skill aplica el cambio de ID de modelo y, según sea necesario, los cambios de parámetros incompatibles, el reemplazo de prefill y la calibración de esfuerzo para tu modelo de destino en toda tu base de código, y luego produce una lista de verificación de elementos para revisar manualmente. Te pide que confirmes el alcance de la migración (todo el directorio de trabajo, un subdirectorio o una lista específica de archivos) antes de editar cualquier archivo. La skill también detecta clientes de Amazon Bedrock y Claude Platform on AWS y ajusta los formatos de ID de modelo y los cambios de funcionalidades para esas plataformas.
</Tip>

[Claude Fable 5.1](https://platform.claude.com/docs/es/models/fable-5-1/whats-new-fable-5-1) sucede a Claude Fable 5 con los mismos precios de entrada y salida, y con lecturas de caché a una cuarta parte del costo. Está disponible en la Claude API, [Amazon Bedrock](https://platform.claude.com/docs/es/build-with-claude/claude-in-amazon-bedrock), [Claude Platform on AWS](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws), [Google Cloud](https://platform.claude.com/docs/es/build-with-claude/claude-on-vertex-ai) y [Microsoft Foundry](https://platform.claude.com/docs/es/build-with-claude/claude-in-microsoft-foundry). [Claude Mythos 5.1](https://platform.claude.com/docs/es/models/mythos-5-1/overview) comparte las mismas capacidades y está disponible solo para organizaciones verificadas a través de los programas de verificación de Anthropic, como el [Cyber Verification Program](https://support.claude.com/en/articles/14604842). Para conocer las diferencias de comportamiento y los patrones de prompting, consulta [Prompts para Claude Fable 5.1](https://platform.claude.com/docs/es/build-with-claude/prompt-engineering/prompting-claude-fable-5-1).

La configuración base que comparten `claude-fable-5-1` y `claude-mythos-5-1`:

* **Pensamiento:** El ["adaptive thinking"](https://platform.claude.com/docs/es/build-with-claude/thinking) (pensamiento adaptativo) está siempre activado, sin cambios respecto a Claude Fable 5. El modelo determina cuándo y cuánto pensar. No se requiere ninguna configuración de `thinking`. Tanto `thinking: {type: "disabled"}` como el "extended thinking" (pensamiento extendido) manual (`thinking: {type: "enabled", budget_tokens: N}`) devuelven un error 400.
* **Prefill:** Prellenar el mensaje del asistente devuelve un error 400, sin cambios respecto a Claude Fable 5. Usa instrucciones en la indicación del sistema en su lugar.
* **Elección de herramienta:** Se admiten `{type: "auto"}` (el valor predeterminado) y `{type: "none"}`. Forzar una llamada a herramienta con `{type: "any"}` o `{type: "tool", name: "..."}` devuelve un error 400. Consulta [Cambios incompatibles](https://platform.claude.com/docs/es/models/fable-5-1/migration-guide#fable-5-1-breaking-changes).
* **Pensamiento preservado entre modelos:** Claude Fable 5.1 lee bloques de pensamiento de Claude Opus 5, Claude Fable 5, Claude Mythos 5 y modelos Claude anteriores. Ninguno de esos modelos puede leer los bloques de Claude Fable 5.1. Consulta [Cambios incompatibles](https://platform.claude.com/docs/es/models/fable-5-1/migration-guide#fable-5-1-breaking-changes).
* **Ventana de contexto y salida:** Una ["context window" (ventana de contexto) de 1M de tokens](https://platform.claude.com/docs/es/build-with-claude/context-windows) de forma predeterminada, y hasta 128k tokens de salida por solicitud.
* **Precios:** $10 USD por millón de tokens de entrada y $50 USD por millón de tokens de salida, igual que Claude Fable 5. Las lecturas de caché de prompts cuestan $0.25 USD por millón de tokens, una cuarta parte de la tarifa de Claude Fable 5. Consulta [Precios de Claude](https://platform.claude.com/docs/es/about-claude/pricing).
* **Retención de datos:** Ambos modelos requieren retención de datos de 30 días, no están disponibles bajo acuerdos de retención cero de datos (ZDR) a menos que Anthropic lo autorice expresamente, y están designados como Covered Models, igual que Claude Fable 5 y Claude Mythos 5. En la Claude API, una solicitud de una organización o espacio de trabajo sin retención de 30 días devuelve un `invalid_request_error` 400. Las organizaciones con un acuerdo ZDR deben contactar a su equipo de cuenta de Anthropic, o configurar la retención por espacio de trabajo. Consulta [Requisitos de retención de datos específicos por modelo](https://platform.claude.com/docs/es/manage-claude/api-and-data-retention#model-specific-data-retention-requirements) para obtener detalles por plataforma.

Dónde divergen los dos modelos:

* **Disponibilidad:** Claude Fable 5.1 no requiere aprobación de acceso. Claude Mythos 5.1 está disponible solo para organizaciones verificadas a través de los programas de verificación de Anthropic, como el [Cyber Verification Program](https://support.claude.com/en/articles/14604842). Para solicitar acceso, postúlate al programa que cubra tu caso de uso o contacta a tu equipo de cuenta de Anthropic.
* **Priority Tier:** Ninguno de los dos modelos es compatible con [Priority Tier](https://platform.claude.com/docs/es/api/service-tiers#supported-models). Claude Fable 5 sí lo es.

## Migración a Claude Fable 5.1 desde Claude Fable 5

La migración es en su mayoría directa. La superficie de la API, los límites, los precios por token, el tokenizador, el pensamiento adaptativo siempre activado, el manejo de rechazos y las categorías de `stop_details` coinciden con Claude Fable 5. Lo que cambia: la elección forzada de herramienta devuelve un error 400; solo Claude Fable 5.1 y Claude Mythos 5.1 leen los bloques de pensamiento de Claude Fable 5.1, y solo en la conversación que los produjo; las lecturas de caché cuestan menos; y el comportamiento en bucles de agente difiere de tres maneras. Los mismos cambios se aplican a [Claude Mythos 5.1](https://platform.claude.com/docs/es/models/fable-5-1/migration-guide#migrating-from-claude-mythos-5-to-claude-mythos-5-1), excepto la verificación de conversación en los bloques de pensamiento, que Claude Mythos 5.1 no ejecuta.

### Actualiza el nombre de tu modelo

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

# O bien, para Claude Mythos 5.1, que ofrece las mismas capacidades a organizaciones verificadas:
model = "claude-mythos-5-1"  # After
```

### Cambios incompatibles

1. **La elección forzada de herramienta no es compatible:** Claude Fable 5 acepta `tool_choice` `auto`, `none`, `any` y `tool`. En `claude-fable-5-1`, `{type: "any"}` y `{type: "tool", name: "..."}` devuelven un `invalid_request_error` 400:

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

   La verificación aplica en la Messages API, la Message Batches API y el endpoint de [conteo de tokens](https://platform.claude.com/docs/es/build-with-claude/token-counting).

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

   Después (Claude Fable 5.1): deja `tool_choice` en `auto`, nombra la herramienta en la instrucción y establece `strict: true` para que la llamada coincida con tu esquema. (En una organización [CMEK](https://platform.claude.com/docs/es/manage-claude/cmek), donde las [salidas estructuradas](https://platform.claude.com/docs/es/build-with-claude/structured-outputs), incluido `strict: true`, no están disponibles en los modelos Claude Fable, confía únicamente en la instrucción.) Por ejemplo:

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

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

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

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

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

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

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

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

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

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

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

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

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

     ```java Java

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

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

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

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

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

     echo $message;
     ```

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

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

   Consulta [Uso estricto de herramientas](https://platform.claude.com/docs/es/agents-and-tools/tool-use/strict-tool-use) y [Forzar el uso de herramientas](https://platform.claude.com/docs/es/agents-and-tools/tool-use/define-tools#forcing-tool-use). Si forzabas una herramienta solo para obtener JSON conforme al esquema, usa [salidas JSON](https://platform.claude.com/docs/es/build-with-claude/structured-outputs#usage) (`output_config.format`) en su lugar.

   Si tu aplicación, y no el usuario, requiere una llamada a herramienta específica en el turno actual de una conversación de varios turnos, agrega un [mensaje de sistema a mitad de conversación](https://platform.claude.com/docs/es/build-with-claude/mid-conversation-system-messages) después del último turno `user`. Nombra la herramienta, indica que la llamada es obligatoria para este turno y dile a Claude que abra su respuesta con ella. Como el mensaje se agrega en lugar de escribirse en la indicación `system` de nivel superior, los turnos anteriores permanecen idénticos byte a byte y conservan sus aciertos de ["prompt cache" (caché de prompts)](https://platform.claude.com/docs/es/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?"},
             # La aplicación requiere una consulta al centro de ayuda antes de cualquier
             # respuesta sobre políticas. Agregar el requisito como mensaje del sistema deja los
             # turnos anteriores sin cambios.
             {
                 "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?" },
         // La aplicación requiere consultar el centro de ayuda antes de cualquier
         // respuesta sobre políticas. Agregar el requisito como mensaje de sistema deja
         // los turnos anteriores sin cambios.
         {
           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?" },
             // La aplicación requiere una consulta al centro de ayuda antes de cualquier
             // respuesta sobre políticas. Agregar el requisito como system message (mensaje del sistema) deja
             // los turnos anteriores sin cambios.
             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?")),
     		// La aplicación requiere una consulta al centro de ayuda antes de cualquier
     		// respuesta sobre políticas. Añadir el requisito como mensaje del sistema deja los
     		// turnos anteriores sin cambios.
     		{
     			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?")
             // La aplicación exige consultar el centro de ayuda antes de dar cualquier
             // respuesta sobre políticas. Agregar el requisito como mensaje de sistema deja
             // los turnos anteriores sin cambios.
             .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?'],
             // La aplicación exige consultar el centro de ayuda antes de cualquier
             // respuesta sobre políticas. Agregar el requisito como mensaje de sistema deja
             // los turnos anteriores sin cambios.
             ['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?" },
         # La aplicación exige consultar el centro de ayuda antes de dar cualquier
         # respuesta sobre políticas. Añadir el requisito como mensaje del sistema deja
         # los turnos anteriores sin cambios.
         {
           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>

   Mantén el mensaje `role: "system"` en el historial en solicitudes posteriores, como con cualquier otro turno. Los mensajes de sistema a mitad de conversación no necesitan encabezado beta. `tool_choice: {"type": "none"}` sigue funcionando para un turno que no debe llamar herramientas.

2. **Solo Claude Fable 5.1 y Claude Mythos 5.1 leen los bloques de pensamiento de Claude Fable 5.1:** Cada bloque `thinking` registra qué modelo lo produjo. Claude Fable 5.1 lee sus propios bloques y los de Claude Mythos 5.1, Claude Opus 5, Claude Fable 5, Claude Mythos 5 y modelos Claude anteriores. Una conversación que pasa a `claude-fable-5-1` desde cualquiera de ellos conserva su razonamiento anterior. La condición es unidireccional: aparte de Claude Mythos 5.1, ninguno de esos modelos puede leer los bloques de Claude Fable 5.1.

   Una conversación que se ejecutó en Claude Fable 5.1 puede terminar en otro modelo, más antiguo o más nuevo, mediante un cambio de enrutador, un reintento del lado del cliente o un [fallback por rechazo del clasificador](https://platform.claude.com/docs/es/build-with-claude/refusals-and-fallback), incluido un [fallback del lado del servidor](https://platform.claude.com/docs/es/build-with-claude/refusals-and-fallback#server-side-fallback). La API elimina los bloques que ese modelo no puede leer antes de que los vea, la solicitud se completa correctamente y no se te cobran los tokens de entrada descartados. El modelo de destino vuelve a planificar sin ese razonamiento, lo que puede aumentar el costo y la latencia en el primer turno después del cambio. Para ver qué se descartó, envía el [encabezado beta](https://platform.claude.com/docs/es/api/beta-headers) `thinking-binding-controls-2026-08-01`: las respuestas incluirán entonces un arreglo `input_transformations` que nombra cada bloque descartado con `reason: "model_binding_mismatch"`. Consulta [Cambiar de modelo a mitad de la conversación](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking#switching-models).

3. **Editar turnos anteriores invalida los bloques de pensamiento:** Cada bloque `thinking` de Claude Fable 5.1 es válido solo frente a la indicación `system`, las `tools` y el historial de conversación que lo precedieron. Si Claude Code, claude.ai, [Claude Managed Agents](https://platform.claude.com/docs/es/managed-agents/overview) o el [Claude Agent SDK](https://code.claude.com/docs/es/agent-sdk/overview) administra tu historial de conversación, ya mantiene ese prefijo intacto. Si tu código construye el arreglo `messages` por sí mismo, este punto aplica a ti, y [Pensamiento preservado](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking) es la guía de integración completa. Donde se aplica la verificación, una solicitud que envía el bloque de vuelta después de que cualquiera de esos elementos cambió se rechaza con un error 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.
   ```

   La API aplica la verificación a las cuentas nuevas creadas a partir del 31 de agosto de 2026. En las cuentas creadas antes, la API registra la discrepancia pero no actúa sobre ella, a menos que la solicitud establezca `thinking.block_binding.prefix_mismatch_behavior`, lo que activa la aplicación de la verificación. En esas cuentas, si envías el encabezado beta `thinking-binding-controls-2026-08-01` y dejas ese campo sin establecer, la respuesta enumera cada bloque que no superó la verificación en `input_transformations` como una entrada `thinking_mismatch_allowed`. Haz que tu aplicación sea compatible con la verificación sin importar la antigüedad de tu cuenta: los mismos patrones mantienen la caché de prompts activa, y puedes probar contra la verificación desde cualquier cuenta enviando `prefix_mismatch_behavior`. Si distribuyes una herramienta o framework que las personas ejecutan con su propia clave de API, prueba de esa manera antes del lanzamiento: es probable que tu clave pertenezca a una cuenta más antigua, y tus usuarios con cuentas nuevas se toparán con la verificación antes que tú. Para saber si tu propia cuenta tiene la verificación aplicada de forma predeterminada, envía una solicitud que edite el historial sin el encabezado beta: un error 400 que nombre el encabezado significa que sí.

   El error es permanente para ese cuerpo de solicitud: un bucle de reintento automático no lo resolverá. Para continuar sin el razonamiento invalidado en lugar de fallar, elimina los bloques `thinking` del historial y reintenta una vez, o envía el [encabezado beta](https://platform.claude.com/docs/es/api/beta-headers) `thinking-binding-controls-2026-08-01` y establece `prefix_mismatch_behavior` en `"drop_block"` (el valor predeterminado es `"error"`). Con `"drop_block"`, la API descarta el bloque discrepante y cada bloque de pensamiento posterior en la conversación, e informa cada uno con `reason: "prefix_binding_mismatch"` en el arreglo `input_transformations` de la respuesta:

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

   El endpoint de [conteo de tokens](https://platform.claude.com/docs/es/build-with-claude/token-counting) ejecuta la misma verificación. Consulta [Controles para bloques que no se preservan (beta)](https://platform.claude.com/docs/es/build-with-claude/thinking#preserved-thinking-controls) para conocer la forma de la respuesta y la ubicación en streaming.

   Patrones que invalidan los bloques de pensamiento posteriores, y qué hacer en su lugar:

   * Editar, reordenar o eliminar turnos anteriores. Esto incluye borrar resultados de herramientas antiguos, recortar turnos de la mitad de la transcripción y la compactación del lado del cliente que conserva los turnos recientes y sus bloques de pensamiento textualmente detrás de un resumen (incluida la compactación en segundo plano que inserta su resumen unos turnos después). En su lugar, usa la [compactación](https://platform.claude.com/docs/es/build-with-claude/compaction) o la [edición de contexto](https://platform.claude.com/docs/es/build-with-claude/context-editing) del lado del servidor ([limpieza de resultados de herramientas](https://platform.claude.com/docs/es/build-with-claude/context-editing#tool-result-clearing) para resultados de herramientas antiguos), o una de las formas de compactación del lado del cliente descritas en [Recorta el contexto en el servidor](https://platform.claude.com/docs/es/models/fable-5-1/migration-guide#fable-5-1-trim-context).
   * Inyectar contenido que no persistes, por ejemplo, un recordatorio por turno agregado después de los bloques `tool_result` y eliminado en la siguiente solicitud. En su lugar, envía el recordatorio como un [mensaje del sistema con alcance de turno](https://platform.claude.com/docs/es/build-with-claude/mid-conversation-system-messages#turn-scoped-system-messages) y déjalo en el historial.
   * Reconstruir la indicación `system` de nivel superior o el arreglo `tools` entre solicitudes de la misma conversación, por ejemplo, para actualizar la fecha actual o para agregar o quitar una herramienta. En su lugar, agrega un [mensaje del sistema a mitad de la conversación](https://platform.claude.com/docs/es/build-with-claude/mid-conversation-system-messages) que contenga la nueva instrucción ("La fecha actual es 2026-09-14.") o bloques `tool_addition` y `tool_removal`. Una herramienta que no se declaró en `tools` al inicio puede [definirse dentro del bloque `tool_addition`](https://platform.claude.com/docs/es/build-with-claude/mid-conversation-system-messages#define-tools-in-a-message-beta) (encabezado beta `inline-tools-2026-09-15`).
   * Una URL de imagen o documento que sirve bytes diferentes en una solicitud posterior. La verificación cubre los bytes, no la cadena de la URL, por lo que una URL firmada rotativa para el mismo archivo no causa problemas. Para el contenido al que haces referencia en varios turnos, súbelo una vez con la [Files API](https://platform.claude.com/docs/es/build-with-claude/files) y envía el `file_id`, o envíalo en base64.

   Cada reemplazo también mantiene los turnos anteriores idénticos byte a byte y preserva los aciertos de [caché de prompts](https://platform.claude.com/docs/es/build-with-claude/prompt-caching) que editar el historial, la indicación `system` o el arreglo `tools` perdería.

   Patrones que siguen funcionando:

   * Historiales de solo agregar: añadir turnos y devolver los turnos anteriores exactamente como se enviaron y recibieron, incluidos los mensajes `role: "system"` agregados.
   * Eliminar bloques de pensamiento de turnos anteriores del asistente, empezando por los más antiguos.
   * Cambiar `effort`, `max_tokens` o cualquier otro parámetro de solicitud fuera de `system`, `tools` y `messages`, y agregar o mover marcadores `cache_control`.
   * Compactación del lado del servidor y edición de contexto, incluida la [limpieza de bloques de pensamiento](https://platform.claude.com/docs/es/build-with-claude/context-editing#thinking-block-clearing). No cuentan como ediciones, porque la verificación compara la conversación tal como la enviaste.

   Para verificar una integración existente:

   1. Captura los cuerpos de solicitud exactos que envía durante algunos turnos normales, incluida una compactación o un cambio de herramientas si tu producto los tiene. Para cada par de solicitudes consecutivas, compara la indicación `system`, el arreglo `tools` y el prefijo compartido de `messages`. Deben ser idénticos byte a byte hasta los turnos recién agregados. Una excepción esperada es una solicitud que inserta un bloque `compaction` firmado de la [compactación bajo demanda](https://platform.claude.com/docs/es/build-with-claude/compaction-on-demand): el bloque reemplaza los mensajes que resume al principio de `messages`, y todo lo que viene después debe seguir coincidiendo.
   2. Ejecuta una sesión normal de varios turnos contra `claude-fable-5-1` con el encabezado beta `thinking-binding-controls-2026-08-01` y `prefix_mismatch_behavior: "drop_block"`, y registra `input_transformations` en cada respuesta. Un arreglo vacío en cada turno significa que el historial está intacto. Una entrada con `reason: "prefix_binding_mismatch"` significa que algo anterior al bloque en `path` cambió desde la solicitud previa. Una entrada con `reason: "model_binding_mismatch"` significa que la conversación cambió de modelo, lo cual no es un error en tu código. Esto funciona desde cualquier cuenta, porque establecer el campo activa la aplicación de la verificación en la solicitud. En CI, establece `"error"` en su lugar para que una edición haga fallar la ejecución.
   3. Elige una configuración para producción. Deja el valor predeterminado `"error"` si una discrepancia de prefijo solo puede significar un error en tu código, o establece `"drop_block"` para descartar los bloques afectados en lugar de fallar, y supervisa los errores 400 o las entradas de `input_transformations` en cualquier caso.

   Descartar bloques de pensamiento una vez, en un límite de compactación por ejemplo, tiene poco efecto. Una integración que invalida el pensamiento previo en cada solicitud reinicia la caché de prompts cada vez, lo que puede aumentar el costo por tarea (consulta [Mantén el historial de conversación como solo agregar](https://platform.claude.com/docs/es/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#keep-the-conversation-history-append-only)).

### Cambios de comportamiento

1. **Menos llamadas a herramientas en paralelo en bucles de agente largos:** En bucles de larga duración donde las siguientes lecturas independientes solo están implícitas en la tarea (agentes de codificación personalizados, arneses de bash y editor, uso de computadora), Claude Fable 5.1 puede emitir una llamada a herramienta por turno. Cada turno adicional cuesta tokens, un viaje de ida y vuelta y tiempo de reloj. Agrega una instrucción de agrupación de una oración después de cada mensaje del usuario como un [mensaje de sistema con alcance de turno](https://platform.claude.com/docs/es/build-with-claude/mid-conversation-system-messages#turn-scoped-system-messages) (`clear_at: "next_user_message"`, beta), o, sin la beta, en un bloque de texto después de los bloques `tool_result`, y deja las copias anteriores en el historial en solicitudes posteriores. Consulta [Agrupa llamadas a herramientas independientes en bucles de agente](https://platform.claude.com/docs/es/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#batch-independent-tool-calls-in-agent-loops).

2. **Menos mensajes de progreso entre llamadas a herramientas:** Claude Fable 5.1 escribe menos actualizaciones de estado durante secuencias largas de herramientas que Claude Fable 5, y sus resúmenes de codificación agéntica son más cortos. Si tu interfaz muestra esas actualizaciones, establece `thinking.display` en `"updates"` (beta) o `"summarized"` y solicítalas explícitamente en el prompt. Consulta [Actualizaciones de progreso entre llamadas a herramientas](https://platform.claude.com/docs/es/build-with-claude/thinking#progress-updates) y [Pide actualizaciones de progreso orientadas al usuario](https://platform.claude.com/docs/es/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#ask-for-user-facing-progress-updates).

3. **Menos llamadas de búsqueda y recuperación con esfuerzo bajo:** Con esfuerzo `low`, Claude Fable 5.1 responde de memoria con más frecuencia que Claude Fable 5 en lugar de llamar a una herramienta de búsqueda o recuperación. Si tu producto depende de la recuperación con esfuerzo bajo, aumenta el esfuerzo para esas solicitudes o dile al modelo cuándo buscar. Consulta [Activación de búsqueda con esfuerzo bajo](https://platform.claude.com/docs/es/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#search-triggering-at-low-effort).

Para las diferencias en densidad de prosa, formato de chat, citas en resúmenes y ediciones de archivos, que no afectan la integración con la API, consulta [Cambios respecto a Claude Fable 5](https://platform.claude.com/docs/es/models/fable-5-1/whats-new-fable-5-1#changed-from-claude-fable-5).

### Cambios recomendados

Estos cambios no son obligatorios, pero cada uno reduce el costo o la latencia o elimina un modo de falla:

1. **Cambia el esfuerzo a mitad de conversación (beta):** En Claude Fable 5, `output_config.effort` es a nivel de solicitud, y cambiarlo entre solicitudes descarta los prefijos en caché de turnos anteriores. En `claude-fable-5-1`, un mensaje `role: "system"` que lleva solo `output_config` aumenta el esfuerzo para un paso difícil o lo reduce para los rutinarios sin invalidar la [caché de prompts](https://platform.claude.com/docs/es/build-with-claude/prompt-caching):

   <CodeGroup>
     ```bash cURL
     # Mensaje del sistema que solo cambia el esfuerzo: el nuevo nivel se aplica a partir del siguiente turno del usuario.
     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."
       # Mensaje del sistema solo de esfuerzo: el nuevo nivel se aplica a partir del siguiente turno del usuario.
       - 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.",
             },
             # Mensaje del sistema solo de esfuerzo: el nuevo nivel se aplica a partir del siguiente turno del usuario.
             {"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."
         },
         // Mensaje del sistema solo de esfuerzo: el nuevo nivel se aplica a partir del siguiente turno del usuario.
         { 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." },
             // Mensaje del sistema solo de esfuerzo: el nuevo nivel se aplica a partir del siguiente turno del usuario.
             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.")},
     		},
     		// Mensaje del sistema que solo cambia el esfuerzo: el nuevo nivel se aplica a partir del siguiente turno del usuario.
     		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.")
             // Mensaje del sistema solo de esfuerzo: el nuevo nivel se aplica a partir del siguiente turno del usuario.
             .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.'),
             // Mensaje del sistema solo con esfuerzo (effort): el nuevo nivel se aplica desde el siguiente turno del usuario.
             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."},
         # Mensaje del sistema que solo cambia el esfuerzo: el nuevo nivel se aplica a partir del siguiente turno del usuario.
         {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>

   Colocado entre un turno `assistant` y el siguiente turno `user`, como aquí, el mensaje surte efecto a partir de ese turno `user`. Colocado directamente después de un turno `user` con nueva entrada, establece el nivel para la respuesta de Claude a ese turno. Un turno `user` que contiene solo resultados de herramientas no cuenta como nueva entrada: el cambio espera al siguiente turno `user` con nueva entrada. El nivel se mantiene hasta que otro mensaje `role: "system"` lo cambie. Solo se aceptan los niveles con nombre (`low`, `medium`, `high`, `xhigh`, `max`), y se requiere el encabezado beta `mid-conversation-output-config-2026-07-01`. Consulta [Esfuerzo por mensaje](https://platform.claude.com/docs/es/build-with-claude/effort#change-effort-mid-conversation-beta).

2. **Cambia instrucciones y herramientas con mensajes del sistema a mitad de la conversación:** Para cambiar instrucciones o herramientas en medio de una sesión, agrega un [mensaje `role: "system"`](https://platform.claude.com/docs/es/build-with-claude/mid-conversation-system-messages), con bloques `tool_addition` y `tool_removal` para los cambios de herramientas (encabezado beta `inline-tools-2026-09-15` en la Claude API). Un bloque `tool_addition` puede nombrar una herramienta declarada en `tools` al inicio de la sesión o [contener la definición completa de la herramienta](https://platform.claude.com/docs/es/build-with-claude/mid-conversation-system-messages#define-tools-in-a-message-beta), por lo que una herramienta desconocida al inicio de la sesión no necesita estar en `tools`. Esto preserva los aciertos de caché de prompts en turnos anteriores y mantiene el historial de conversación en modo de solo anexado. El encabezado anterior `mid-conversation-tool-changes-2026-07-01` sigue funcionando para cambios que nombran una herramienta por referencia, en la Claude API, Amazon Bedrock y Google Cloud. El mismo mensaje reemplaza el `tool_choice` forzado cuando una herramienta específica debe ejecutarse en el turno actual (consulta [Cambios incompatibles](https://platform.claude.com/docs/es/models/fable-5-1/migration-guide#fable-5-1-breaking-changes)). Para un recordatorio que se aplica a un solo turno, envíalo como un mensaje `role: "system"` separado, solo de texto, con `clear_at: "next_user_message"` ([mensajes del sistema con alcance de turno](https://platform.claude.com/docs/es/build-with-claude/mid-conversation-system-messages#turn-scoped-system-messages), encabezado beta `mid-conversation-system-clear-at-2026-08-21`) y déjalo en el historial: deja de renderizarse después del siguiente mensaje del usuario y no cuesta tokens una vez limpiado. Un mensaje que contiene bloques `tool_addition` o `tool_removal` no puede tener alcance de turno.

3. **Usa `fallbacks: "default"` para los rechazos:** Sigue manejando `stop_reason: "refusal"` y leyendo `stop_details.category` antes del contenido de la respuesta. Para volver a ejecutar automáticamente las solicitudes rechazadas en otro modelo, establece `fallbacks: "default"` (beta, encabezado `server-side-fallback-2026-07-01`). `"default"` reintenta una solicitud rechazada en el modelo que Anthropic recomienda para esa categoría. Los destinos de fallback permitidos para Claude Fable 5.1 son Claude Opus 4.8 (`claude-opus-4-8`) y Claude Opus 5 (`claude-opus-5`). Una lista `fallbacks` explícita puede nombrar cualquiera de los dos. El modelo de fallback no recibe los bloques de pensamiento de Claude Fable 5.1. El parámetro `fallbacks` no está disponible en Amazon Bedrock, Google Cloud ni Microsoft Foundry. En esas plataformas, usa el [fallback del lado del cliente](https://platform.claude.com/docs/es/build-with-claude/refusals-and-fallback#client-side-fallback) en su lugar. Si construyes el reintento tú mismo, el [crédito de fallback](https://platform.claude.com/docs/es/build-with-claude/fallback-credit) se aplica en los mismos términos que para Claude Fable 5. Consulta [Rechazos y fallback](https://platform.claude.com/docs/es/build-with-claude/refusals-and-fallback).

4. **Comienza con esfuerzo `high` y haz un barrido:** El valor predeterminado del [parámetro effort](https://platform.claude.com/docs/es/build-with-claude/effort) es `high`, y los cinco niveles son compatibles. Mantén la guía de Claude Fable 5: `high` para la mayoría del trabajo, y `medium` como un control de costos que vale la pena probar. Las mejoras de Claude Fable 5.1 sobre Claude Fable 5 son mayores en `xhigh` y `max`, pero esos niveles también agregan tiempo de pensamiento y tiempo hasta la primera respuesta, así que sube a ellos para las tareas más sensibles a la capacidad y donde tus evaluaciones muestren la mejora. Ejecuta un barrido nuevo en tus propias evaluaciones en lugar de trasladar una configuración ajustada para Claude Fable 5. Consulta [Niveles de esfuerzo recomendados para Claude Fable 5.1](https://platform.claude.com/docs/es/build-with-claude/effort#recommended-effort-levels-for-claude-fable-5-1).

5. **Recorta el contexto en el servidor, o compacta con una forma que no arrastre pensamiento obsoleto:** Si tu código trunca o resume turnos anteriores en el cliente, la solución más sencilla es trasladar ese trabajo a la [compactación](https://platform.claude.com/docs/es/build-with-claude/compaction) o la [edición de contexto](https://platform.claude.com/docs/es/build-with-claude/context-editing) del lado del servidor. Ninguna de las dos cuenta como edición, porque la [verificación del historial](https://platform.claude.com/docs/es/models/fable-5-1/migration-guide#fable-5-1-preserved-thinking) compara la conversación tal como la enviaste, así que nada de lo que eliminan invalida los bloques de pensamiento posteriores, y el [parámetro `instructions`](https://platform.claude.com/docs/es/build-with-claude/compaction-threshold#custom-summarization-instructions) de la compactación acepta tu propio prompt de resumen. Si conservas los turnos recientes textualmente detrás del resumen, o resumes en segundo plano mientras la conversación continúa, usa la [compactación bajo demanda](https://platform.claude.com/docs/es/build-with-claude/compaction-on-demand) (encabezado beta `compact-2026-09-04`) en lugar de un resumen escrito por el cliente. La API escribe un bloque de resumen firmado que colocas en lugar de los mensajes que resume. Los bloques de pensamiento de los turnos que conservas pueden seguir siendo válidos, bajo las condiciones descritas en [Compactación y pensamiento preservado](https://platform.claude.com/docs/es/build-with-claude/compaction-thinking-blocks#conditions-for-kept-thinking-to-stay-valid). Si mantienes la compactación en el cliente, elige una de estas tres formas:

   * **Compactación simple (recomendada):** reemplaza todo el historial con un mensaje de resumen más el nuevo turno del usuario y no reproduzcas nada más. No se traslada ningún bloque de pensamiento, así que nada falla. Los modelos Claude están entrenados en tareas de horizonte largo con este esquema, y su rendimiento es comparable al de esquemas más elaborados para la mayoría de las cargas de trabajo.
   * **Compactación con cola conservada:** si mantienes los turnos más recientes textualmente detrás de un resumen, elimina los bloques `thinking` y `redacted_thinking` de esos turnos (el texto y las llamadas a herramientas pueden quedarse), o establece `prefix_mismatch_behavior: "drop_block"`. Su pensamiento se produjo frente al historial completo y de lo contrario falla detrás del resumen.
   * **Compactación en segundo plano:** si construyes el resumen fuera de la ruta crítica y lo insertas después, cada turno producido mientras tanto lleva pensamiento anterior a la inserción. Envía `"drop_block"` en cada solicitud que aún lleve bloques de pensamiento producidos antes de la inserción (o elimina esos bloques tú mismo; `input_transformations` en la primera respuesta después de la inserción lista exactamente cuáles), o compacta de forma síncrona.

   No recortes turnos individuales de la mitad de la transcripción: eso invalida todos los bloques de pensamiento posteriores y ninguna forma del lado del cliente lo evita. Usa un [mensaje del sistema a mitad de la conversación](https://platform.claude.com/docs/es/build-with-claude/mid-conversation-system-messages) para el cambio de instrucciones que estabas haciendo, o la [edición de contexto](https://platform.claude.com/docs/es/build-with-claude/context-editing) del lado del servidor para la eliminación selectiva. Consulta [Devolver los bloques de compactación](https://platform.claude.com/docs/es/build-with-claude/compaction-threshold#passing-compaction-blocks-back).

### Lista de verificación de migración

* Actualiza el nombre del modelo de `claude-fable-5` a `claude-fable-5-1` (o de `claude-mythos-5` a `claude-mythos-5-1`).
* Reemplaza el `tool_choice` forzado (`{type: "any"}` o `{type: "tool", ...}`). Devuelve un error 400. Usa `{type: "auto"}` junto con una instrucción explícita y herramientas con `strict: true`, o salidas JSON. Coloca la instrucción en el turno `user`, o en un mensaje `role: "system"` a mitad de la conversación cuando tu aplicación requiera la llamada.
* Sigue devolviendo los bloques `thinking` sin cambios en cada turno, incluidos los vacíos. Claude Fable 5.1 lee bloques de Claude Opus 5, Claude Fable 5, Claude Mythos 5 y modelos anteriores. Mover una conversación de Claude Fable 5.1 a cualquier modelo que no sea Claude Mythos 5.1 descarta sus bloques.
* Si tu código construye el arreglo `messages` por sí mismo, comprueba si [edita turnos anteriores](https://platform.claude.com/docs/es/models/fable-5-1/migration-guide#fable-5-1-preserved-thinking): ejecuta una sesión con el encabezado beta `thinking-binding-controls-2026-08-01` y `prefix_mismatch_behavior: "drop_block"`, registra `input_transformations` y corrige cada `prefix_binding_mismatch`. Las entradas `model_binding_mismatch` después de un cambio de modelo son esperadas.
* Mantén el historial de conversación en modo de solo anexado: congela `system` y `tools` al inicio de la sesión y traslada los cambios a mitad de sesión a mensajes `role: "system"` y bloques `tool_addition` / `tool_removal`, envía los recordatorios por turno como mensajes del sistema con alcance de turno que nunca elimines, recorta el contexto del lado del servidor o elimina los bloques de pensamiento de cualquier turno que conserves a través de un resumen del lado del cliente, y haz referencia a los archivos usados en varios turnos mediante `file_id`.
* Elige un `prefix_mismatch_behavior` de producción (`"error"` de forma predeterminada, o `"drop_block"`) y supervísalo. Si mantienes una herramienta que otros ejecutan con su propia clave de API, prueba con el campo establecido: las cuentas nuevas tienen la verificación aplicada de forma predeterminada aunque la tuya no.
* Revisa los bucles de agente en busca del comportamiento de una llamada a herramienta por turno y agrega la instrucción de agrupación.
* Si tu interfaz muestra texto de progreso entre llamadas a herramientas, establece `thinking.display` en `"updates"` (beta) o `"summarized"` y solicita actualizaciones en el prompt.
* Si cambias el esfuerzo entre solicitudes, traslada el cambio a un mensaje `role: "system"` de [esfuerzo por mensaje](https://platform.claude.com/docs/es/build-with-claude/effort#change-effort-mid-conversation-beta) (beta) para conservar los aciertos de caché.
* Maneja `stop_reason: "refusal"` y lee `stop_details.category`. Considera `fallbacks: "default"` (beta).
* Vuelve a evaluar `effort` con un barrido nuevo, comenzando en `high`, y restablece la línea base de costo y latencia con tus propias cargas de trabajo. El tokenizador no cambia. Las lecturas de la caché de prompts cuestan una cuarta parte de la tarifa de Claude Fable 5.

## Migración a Claude Fable 5.1 desde Claude Opus 5

Claude Fable 5.1 usa los mismos patrones de la [API de Messages](https://platform.claude.com/docs/es/build-with-claude/working-with-messages) y de [uso de herramientas](https://platform.claude.com/docs/es/agents-and-tools/tool-use/overview) que Claude Opus 5. Mantiene la [ventana de contexto de 1M de tokens](https://platform.claude.com/docs/es/build-with-claude/context-windows) por defecto, los [128k tokens máximos de salida](https://platform.claude.com/docs/es/models/overview), el mínimo de 512 tokens para el almacenamiento en caché de prompts y la compatibilidad con [mensajes de sistema a mitad de conversación](https://platform.claude.com/docs/es/build-with-claude/mid-conversation-system-messages). La restricción de prellenado (prefill), la restricción de parámetros de muestreo y el valor por defecto `"omitted"` para `thinking.display` también se mantienen. Aplica todo lo indicado en [Migración a Claude Fable 5.1 desde Claude Fable 5](https://platform.claude.com/docs/es/models/fable-5-1/migration-guide#migrating-from-claude-fable-5-to-claude-fable-5-1), más lo siguiente.

### Actualiza el nombre de tu modelo

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

# O bien, para Claude Mythos 5.1, que ofrece las mismas capacidades a organizaciones verificadas:
model = "claude-mythos-5-1"  # After
```

### Qué cambió

1. **El pensamiento ya no se puede deshabilitar:** Claude Opus 5 acepta `thinking: {type: "disabled"}` en un nivel de [esfuerzo](https://platform.claude.com/docs/es/build-with-claude/effort) de `high` o inferior. En `claude-fable-5-1` y `claude-mythos-5-1`, el [pensamiento adaptativo](https://platform.claude.com/docs/es/build-with-claude/thinking) siempre está activado, y `thinking: {type: "disabled"}` devuelve un error 400 en cualquier nivel de esfuerzo. Elimina el campo, controla el gasto de tokens con niveles de esfuerzo más bajos y revisa `max_tokens` para las cargas de trabajo que se ejecutaban con el pensamiento deshabilitado.

2. **La elección forzada de herramientas no es compatible:** Claude Opus 5 acepta `tool_choice` `any` y `tool`. `claude-fable-5-1` devuelve un error 400. Consulta [Cambios incompatibles](https://platform.claude.com/docs/es/models/fable-5-1/migration-guide#fable-5-1-breaking-changes).

3. **Pensamiento preservado entre modelos:** Claude Fable 5.1 lee los bloques de pensamiento de Claude Opus 5: las conversaciones que pasan de `claude-opus-5` a `claude-fable-5-1` conservan su razonamiento. Claude Opus 5 no puede leer los bloques de Claude Fable 5.1. Los bloques de Claude Fable 5.1 también [dejan de ser válidos cuando cambian los turnos anteriores](https://platform.claude.com/docs/es/models/fable-5-1/migration-guide#fable-5-1-preserved-thinking): si tu código edita mensajes anteriores, reconstruye `system` o `tools`, o compacta en el cliente entre solicitudes, Claude Opus 5 no objetaba, pero `claude-fable-5-1` rechaza o descarta cada bloque de pensamiento posterior. Ejecuta la verificación de tres pasos de esa sección antes de cambiar el tráfico. Consulta [Cambios incompatibles](https://platform.claude.com/docs/es/models/fable-5-1/migration-guide#fable-5-1-breaking-changes).

4. **El texto entre llamadas de herramientas se devuelve en bloques de pensamiento:** En Claude Opus 5, el texto que el modelo escribe entre llamadas de herramientas se devuelve como bloques `text`. En `claude-fable-5-1`, al igual que en Claude Fable 5, esa narración se devuelve como bloques `thinking` de actualización de progreso, uno antes de cada llamada de herramienta. Con el valor por defecto de `thinking.display` de `"omitted"`, no contienen texto legible. Si tu interfaz muestra esa narración, establece `display: "updates"` (beta) para recibir las actualizaciones de progreso como texto mientras el razonamiento permanece oculto, o `"summarized"` para recibir ambos. Luego muestra los bloques `thinking` no vacíos entre los bloques `tool_use`. Consulta [Actualizaciones de progreso entre llamadas de herramientas](https://platform.claude.com/docs/es/build-with-claude/thinking#progress-updates).

5. **Clasificadores de seguridad y enrutamiento de fallback:** Claude Fable 5.1 ejecuta clasificadores de seguridad que cubren las mismas categorías de `stop_details` que Claude Fable 5, un conjunto más amplio que el de los clasificadores de Claude Opus 5. Espera valores adicionales de `stop_details.category`, como `"bio"`; consulta la [tabla de categorías de rechazo](https://platform.claude.com/docs/es/build-with-claude/refusals-and-fallback#refusal-response) para ver el conjunto completo. Para la configuración de `fallbacks` y los destinos permitidos, consulta [Usa `fallbacks: "default"` para los rechazos](https://platform.claude.com/docs/es/models/fable-5-1/migration-guide#fable-5-1-recommended-changes).

6. **Precios:** $10 USD por millón de tokens de entrada y $50 USD por millón de tokens de salida, en comparación con $5 USD y $25 USD para Claude Opus 5. Las lecturas de caché de prompts cuestan $0.25 USD por millón de tokens, la mitad de la tarifa de Claude Opus 5. Consulta [Precios de Claude](https://platform.claude.com/docs/es/about-claude/pricing).

7. **Retención de datos:** Claude Fable 5.1 y Claude Mythos 5.1 requieren una retención de datos de 30 días, no están disponibles bajo acuerdos de retención cero de datos (ZDR) a menos que Anthropic lo autorice expresamente, y están designados como Modelos Cubiertos. Claude Opus 5 está disponible bajo ZDR. Consulta [Requisitos de retención de datos específicos del modelo](https://platform.claude.com/docs/es/manage-claude/api-and-data-retention#model-specific-data-retention-requirements).

### Lista de verificación de migración

* Si tu organización tiene un acuerdo de "zero data retention" (retención cero de datos), o ZDR, confirma primero la elegibilidad: estos modelos no están disponibles bajo ZDR a menos que Anthropic lo autorice expresamente. Consulta [Requisitos de retención de datos específicos del modelo](https://platform.claude.com/docs/es/manage-claude/api-and-data-retention#model-specific-data-retention-requirements).
* Actualiza el nombre del modelo de `claude-opus-5` a `claude-fable-5-1` (o `claude-mythos-5-1`).
* Elimina cualquier configuración `thinking: {type: "disabled"}`: devuelve un error 400 en `claude-fable-5-1`. Controla el gasto de tokens con niveles más bajos de [effort](https://platform.claude.com/docs/es/build-with-claude/effort) (esfuerzo) y revisa `max_tokens`.
* Reemplaza el `tool_choice` forzado (`any` o `tool`) por `auto` junto con una instrucción explícita (turno de `user` o mensaje de sistema a mitad de la conversación) y herramientas con `strict: true`, o por salidas JSON.
* Si tu interfaz muestra texto entre llamadas a herramientas, establece `display: "updates"` (beta) o `"summarized"` y muestra los bloques `thinking` que no estén vacíos.
* Aplica los elementos de pensamiento preservado, edición del historial, comportamiento, esfuerzo y "fallback" (respaldo) de la [lista de verificación de Claude Fable 5](https://platform.claude.com/docs/es/models/fable-5-1/migration-guide#migration-checklist-fable-5-1-from-fable-5).
* Restablece la línea base de costos con tus propias cargas de trabajo. El "tokenizer" (tokenizador) no ha cambiado. El precio por token es diferente.

## Migración a Claude Fable 5.1 desde Claude Opus 4.8 o anterior

Sigue la lista de verificación que aparece a continuación. Si usas Claude Opus 4.7 o anterior, comienza con la sección correspondiente de la [guía de migración a Claude Opus 5.5](https://platform.claude.com/docs/es/models/opus-5-5/migration-guide).

### Actualiza el nombre de tu modelo

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

# O bien, para Claude Mythos 5.1, que ofrece las mismas capacidades a organizaciones verificadas:
model = "claude-mythos-5-1"  # After
```

### Lista de verificación de migración

* Si tu organización tiene un acuerdo de retención cero de datos (ZDR), confirma primero la elegibilidad: estos modelos no están disponibles bajo ZDR a menos que Anthropic lo autorice expresamente. Claude Opus 4.8 está disponible bajo ZDR.
* Actualiza el nombre del modelo de `claude-opus-4-8` a `claude-fable-5-1` (o `claude-mythos-5-1`).
* Elimina cualquier configuración `thinking: {type: "disabled"}` y revisa `max_tokens`. Las solicitudes sin un campo `thinking` se ejecutan con pensamiento adaptativo.
* Actualiza el análisis de respuestas que lee el contenido por posición, como `content[0].text`: ahora una respuesta puede comenzar con bloques `thinking`, así que selecciona los bloques de contenido por `type`.
* Reemplaza el `tool_choice` forzado (`any` o `tool`) con `auto` más una instrucción explícita (turno `user` o mensaje de sistema a mitad de conversación) y herramientas con `strict: true`, o con salidas JSON.
* Devuelve los bloques `thinking` sin cambios y trata su texto como solo de visualización. Claude Fable 5.1 lee los bloques de pensamiento de Claude Opus 4.8: una conversación que pasa a `claude-fable-5-1` conserva su razonamiento anterior. Claude Opus 4.8 no puede leer los bloques de Claude Fable 5.1.
* Si tu código construye el arreglo `messages` por sí mismo, verifica si [edita turnos anteriores](https://platform.claude.com/docs/es/models/fable-5-1/migration-guide#fable-5-1-preserved-thinking). Las integraciones escritas para Claude Opus 4.8 y anteriores a menudo truncan turnos antiguos, eliminan o reconstruyen mensajes anteriores, o actualizan la indicación del sistema `system` en cada solicitud, y Claude Opus 4.8 nunca objetó. En `claude-fable-5-1`, cada una de esas acciones invalida los bloques de pensamiento posteriores.
* Maneja `stop_reason: "refusal"`, lee `stop_details.category` y considera `fallbacks: "default"` (beta).
* Aplica los elementos de pensamiento preservado, edición del historial, comportamiento, esfuerzo por mensaje y actualización de progreso de la [lista de verificación de Claude Fable 5](https://platform.claude.com/docs/es/models/fable-5-1/migration-guide#migration-checklist-fable-5-1-from-fable-5).
* Vuelve a evaluar `effort` (comienza en `high`), revisa los prompts cercanos al [mínimo de almacenamiento en caché](https://platform.claude.com/docs/es/build-with-claude/prompt-caching#cache-limitations) de 512 tokens (1,024 tokens en Claude Opus 4.8), y vuelve a establecer la línea base de costo y latencia. Los precios por token son diferentes, y los tokens de pensamiento se facturan como tokens de salida, por lo que las cargas de trabajo que se ejecutaban sin pensamiento en Claude Opus 4.8 pueden producir más tokens de salida por solicitud.

## Migración a Claude Mythos 5.1 desde Claude Mythos 5

[Claude Mythos 5.1](https://platform.claude.com/docs/es/models/mythos-5-1/overview) es la contraparte de Claude Fable 5.1 para organizaciones verificadas a través de los programas de verificación de Anthropic, como el [Cyber Verification Program](https://support.claude.com/en/articles/14604842). Confirma que tu organización tiene acceso a Claude Mythos 5.1 antes de cambiar los ID de modelo.

La diferencia a nivel de API coincide con [Migración a Claude Fable 5.1 desde Claude Fable 5](https://platform.claude.com/docs/es/models/fable-5-1/migration-guide#migrating-from-claude-fable-5-to-claude-fable-5-1): la elección forzada de herramientas devuelve un error 400, y solo Claude Mythos 5.1 y Claude Fable 5.1 leen los bloques de pensamiento de Claude Mythos 5.1 (Claude Mythos 5.1 lee los bloques de Claude Mythos 5, no al revés). A diferencia de Claude Fable 5.1, Claude Mythos 5.1 no ejecuta la verificación de conversación, por lo que editar turnos anteriores no [invalida los bloques de pensamiento](https://platform.claude.com/docs/es/models/fable-5-1/migration-guide#fable-5-1-preserved-thinking), aunque sí reinicia la caché de prompts.

### Actualiza el nombre de tu modelo

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

### Lista de verificación de migración

* Actualiza el nombre del modelo de `claude-mythos-5` a `claude-mythos-5-1`.
* Reemplaza el `tool_choice` forzado (`any` o `tool`) con `auto` más una instrucción explícita (turno `user` o mensaje de sistema a mitad de conversación) y herramientas con `strict: true`, o con salidas JSON.
* Maneja `stop_reason: "refusal"` y lee `stop_details.category` antes del contenido de la respuesta. Consulta [Rechazos y respaldo](https://platform.claude.com/docs/es/build-with-claude/refusals-and-fallback).
* Sigue devolviendo los bloques `thinking` sin cambios en cada turno, incluidos los vacíos.
* Si tu código construye el arreglo `messages` por sí mismo, mantén el historial de conversación solo de anexado para mantener la caché de prompts activa. Claude Mythos 5.1 no ejecuta la [verificación de conversación](https://platform.claude.com/docs/es/build-with-claude/thinking#preserved-in-conversation), por lo que las ediciones no invalidan sus bloques de pensamiento.
* Aplica los cambios de comportamiento y los cambios recomendados de la [sección de Claude Fable 5](https://platform.claude.com/docs/es/models/fable-5-1/migration-guide#migrating-from-claude-fable-5-to-claude-fable-5-1), excepto los elementos de edición del historial, que no aplican a Claude Mythos 5.1.
* Reevalúa `effort` con un nuevo barrido y vuelve a establecer la línea base de costo y latencia. Las lecturas de caché de prompts cuestan una cuarta parte de la tarifa de Claude Mythos 5.