---
title: Claude Fable 5.1 및 Claude Mythos 5.1 마이그레이션 가이드
url: https://platform.claude.com/docs/ko/models/fable-5-1/migration-guide
description: 이 마이그레이션 가이드를 통해 Claude Fable 5, Claude Mythos 5, Claude Opus 5 또는 Claude Opus 4.8에서 Claude Fable 5.1 및 Claude Mythos 5.1로 전환하세요. Claude Fable 5.1 및 Claude Mythos 5.1을 활성화하기 위한 안내에는 모델 ID, 호환성이 깨지는 변경 사항, 마이그레이션 체크리스트가 포함되어 있습니다.
---

<Note>
  이 가이드는 [Messages API](https://platform.claude.com/docs/ko/build-with-claude/working-with-messages) 코드 마이그레이션을 다룹니다. [Claude Managed Agents](https://platform.claude.com/docs/ko/managed-agents/overview)를 사용하는 경우, 모델 이름을 업데이트하는 것 외에는 변경이 필요하지 않습니다.
</Note>

<Tip>
  **Claude API 스킬로 마이그레이션을 자동화하세요.** Claude Code에서 `/claude-api migrate`를 실행하여 번들로 제공되는 [Claude API 스킬](https://platform.claude.com/docs/ko/agents-and-tools/agent-skills/claude-api-skill#migrating-to-a-newer-claude-model)을 호출하세요. 현재 제공되는 모든 Claude 모델을 대상으로 사용할 수 있습니다:

  Claude Code가 코드를 대신 마이그레이션하도록 하세요

  ```text
  /claude-api migrate 이 프로젝트를 claude-fable-5-1 모델로 마이그레이션해 줘
  ```

  이 스킬은 코드베이스 전반에 걸쳐 모델 ID 교체를 적용하고, 필요에 따라 호환성이 깨지는 매개변수 변경, 프리필(prefill) 대체, 대상 모델에 맞춘 effort 보정을 수행한 다음, 수동으로 확인해야 할 항목의 체크리스트를 생성합니다. 파일을 편집하기 전에 마이그레이션 범위(전체 작업 디렉터리, 하위 디렉터리 또는 특정 파일 목록)를 확인하도록 요청합니다. 또한 이 스킬은 Amazon Bedrock 및 Claude Platform on AWS 클라이언트를 감지하여 해당 플랫폼에 맞게 모델 ID 형식과 기능 변경 사항을 조정합니다.
</Tip>

[Claude Fable 5.1](https://platform.claude.com/docs/ko/models/fable-5-1/whats-new-fable-5-1)은 동일한 입력 및 출력 가격으로 Claude Fable 5를 계승하며, 캐시 읽기 비용은 4분의 1입니다. Claude API, [Amazon Bedrock](https://platform.claude.com/docs/ko/build-with-claude/claude-in-amazon-bedrock), [Claude Platform on AWS](https://platform.claude.com/docs/ko/build-with-claude/claude-platform-on-aws), [Google Cloud](https://platform.claude.com/docs/ko/build-with-claude/claude-on-vertex-ai), [Microsoft Foundry](https://platform.claude.com/docs/ko/build-with-claude/claude-in-microsoft-foundry)에서 사용할 수 있습니다. [Claude Mythos 5.1](https://platform.claude.com/docs/ko/models/mythos-5-1/overview)은 동일한 기능을 공유하며, [Cyber Verification Program](https://support.claude.com/en/articles/14604842)과 같은 Anthropic의 검증 프로그램을 통해 검증된 조직만 사용할 수 있습니다. 동작 차이와 프롬프팅 패턴에 대해서는 [Claude Fable 5.1 프롬프팅](https://platform.claude.com/docs/ko/build-with-claude/prompt-engineering/prompting-claude-fable-5-1)을 참조하세요.

`claude-fable-5-1`과 `claude-mythos-5-1`이 공유하는 기본 설정:

* **사고(Thinking):** [Adaptive thinking](https://platform.claude.com/docs/ko/build-with-claude/thinking)(적응형 사고)은 Claude Fable 5와 마찬가지로 항상 켜져 있습니다. 모델이 언제, 얼마나 사고할지 결정합니다. `thinking` 구성은 필요하지 않습니다. `thinking: {type: "disabled"}`와 수동 확장 사고(`thinking: {type: "enabled", budget_tokens: N}`) 모두 400 오류를 반환합니다.
* **프리필(Prefill):** 어시스턴트 메시지를 프리필하면 400 오류가 반환되며, Claude Fable 5와 동일합니다. 대신 시스템 프롬프트 지침을 사용하세요.
* **도구 선택(Tool choice):** `{type: "auto"}`(기본값)와 `{type: "none"}`이 지원됩니다. `{type: "any"}` 또는 `{type: "tool", name: "..."}`로 도구 호출을 강제하면 400 오류가 반환됩니다. [호환성이 깨지는 변경 사항](https://platform.claude.com/docs/ko/models/fable-5-1/migration-guide#fable-5-1-breaking-changes)을 참조하세요.
* **모델 간 보존된 사고(Preserved thinking):** Claude Fable 5.1은 Claude Opus 5, Claude Fable 5, Claude Mythos 5 및 이전 Claude 모델의 thinking 블록을 읽습니다. 이들 모델 중 어느 것도 Claude Fable 5.1의 블록을 읽을 수 없습니다. [호환성이 깨지는 변경 사항](https://platform.claude.com/docs/ko/models/fable-5-1/migration-guide#fable-5-1-breaking-changes)을 참조하세요.
* **컨텍스트 윈도우 및 출력:** 기본적으로 [1M 토큰 "context window"(컨텍스트 윈도우)](https://platform.claude.com/docs/ko/build-with-claude/context-windows)를 제공하며, 요청당 최대 128k 출력 토큰을 지원합니다.
* **가격:** 입력 토큰 백만 개당 $10 USD, 출력 토큰 백만 개당 $50 USD로 Claude Fable 5와 동일합니다. 프롬프트 캐시 읽기는 토큰 백만 개당 $0.25 USD로, Claude Fable 5 요금의 4분의 1입니다. [Claude 가격](https://platform.claude.com/docs/ko/about-claude/pricing)을 참조하세요.
* **데이터 보존:** 두 모델 모두 30일 데이터 보존이 필요하며, Anthropic이 명시적으로 승인하지 않는 한 "zero data retention"(제로 데이터 보존), 즉 ZDR 계약 하에서는 사용할 수 없고, Claude Fable 5 및 Claude Mythos 5와 마찬가지로 Covered Models로 지정됩니다. Claude API에서 30일 보존이 설정되지 않은 조직 또는 워크스페이스의 요청은 400 `invalid_request_error`를 반환합니다. ZDR 계약이 있는 조직은 Anthropic 계정 팀에 문의하거나 워크스페이스별로 보존을 구성해야 합니다. 플랫폼별 세부 사항은 [모델별 데이터 보존 요구 사항](https://platform.claude.com/docs/ko/manage-claude/api-and-data-retention#model-specific-data-retention-requirements)을 참조하세요.

두 모델이 다른 점:

* **가용성:** Claude Fable 5.1은 액세스 승인이 필요하지 않습니다. Claude Mythos 5.1은 [Cyber Verification Program](https://support.claude.com/en/articles/14604842)과 같은 Anthropic의 검증 프로그램을 통해 검증된 조직만 사용할 수 있습니다. 액세스를 요청하려면 사용 사례에 해당하는 프로그램에 신청하거나 Anthropic 계정 팀에 문의하세요.
* **Priority Tier:** 두 모델 모두 [Priority Tier](https://platform.claude.com/docs/ko/api/service-tiers#supported-models)에서 지원되지 않습니다. Claude Fable 5는 지원됩니다.

## Claude Fable 5에서 Claude Fable 5.1로 마이그레이션하기

마이그레이션은 대부분 그대로 교체하는 방식으로 가능합니다. API 표면, 제한, 토큰당 가격, 토크나이저, 항상 켜져 있는 적응형 사고, 거부 처리, `stop_details` 카테고리는 모두 Claude Fable 5와 동일합니다. 변경되는 사항은 다음과 같습니다. 강제 도구 선택은 400 오류를 반환합니다. Claude Fable 5.1의 thinking 블록은 Claude Fable 5.1과 Claude Mythos 5.1만 읽을 수 있으며, 해당 블록을 생성한 대화에서만 읽을 수 있습니다. 캐시 읽기 비용이 낮아집니다. 그리고 에이전트 루프 동작이 세 가지 면에서 달라집니다. 동일한 변경 사항이 [Claude Mythos 5.1](https://platform.claude.com/docs/ko/models/fable-5-1/migration-guide#migrating-from-claude-mythos-5-to-claude-mythos-5-1)에도 적용되지만, Claude Mythos 5.1은 thinking 블록에 대한 대화 검사를 실행하지 않습니다.

### 모델 이름 업데이트

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

# 또는 검증된 조직에 동일한 기능을 제공하는 Claude Mythos 5.1의 경우:
model = "claude-mythos-5-1"  # After
```

### 호환성이 깨지는 변경 사항

1. **강제 도구 선택은 지원되지 않습니다:** Claude Fable 5는 `tool_choice` `auto`, `none`, `any`, `tool`을 허용합니다. `claude-fable-5-1`에서는 `{type: "any"}`와 `{type: "tool", name: "..."}`이 400 `invalid_request_error`를 반환합니다:

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

   이 검사는 Messages API, Message Batches API, [토큰 카운팅](https://platform.claude.com/docs/ko/build-with-claude/token-counting) 엔드포인트에 적용됩니다.

   이전 (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>

   이후 (Claude Fable 5.1): `tool_choice`를 `auto`로 두고, 지침에서 도구 이름을 명시하고, 호출이 스키마와 일치하도록 `strict: true`를 설정하세요. ([CMEK](https://platform.claude.com/docs/ko/manage-claude/cmek) 조직에서는 `strict: true`를 포함한 [구조화된 출력](https://platform.claude.com/docs/ko/build-with-claude/structured-outputs)을 Claude Fable 모델에서 사용할 수 없으므로 지침에만 의존하세요.) 예를 들어:

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

   [엄격한 도구 사용](https://platform.claude.com/docs/ko/agents-and-tools/tool-use/strict-tool-use) 및 [도구 사용 강제하기](https://platform.claude.com/docs/ko/agents-and-tools/tool-use/define-tools#forcing-tool-use)를 참조하세요. 스키마를 준수하는 JSON을 얻기 위해서만 도구를 강제했다면, 대신 [JSON 출력](https://platform.claude.com/docs/ko/build-with-claude/structured-outputs#usage)(`output_config.format`)을 사용하세요.

   사용자가 아닌 애플리케이션이 멀티턴 대화의 현재 턴에서 특정 도구 호출을 요구하는 경우, 최신 `user` 턴 뒤에 [대화 중간 시스템 메시지](https://platform.claude.com/docs/ko/build-with-claude/mid-conversation-system-messages)를 추가하세요. 도구 이름을 명시하고, 이 턴에서 호출이 필수라고 말하고, Claude에게 응답을 해당 호출로 시작하라고 지시하세요. 메시지가 최상위 `system` 프롬프트에 작성되는 것이 아니라 추가되기 때문에, 이전 턴은 바이트 단위로 동일하게 유지되며 ["prompt caching"(프롬프트 캐싱)](https://platform.claude.com/docs/ko/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?"},
             # 이 애플리케이션은 정책 관련 답변을 하기 전에 반드시
             # 헬프 센터 조회를 요구합니다. 이 요구 사항을 시스템 메시지로 추가하면
             # 이전 턴은 변경되지 않고 그대로 유지됩니다.
             {
                 "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?" },
         // 이 애플리케이션은 정책 관련 답변을 하기 전에 반드시
         // 헬프 센터 조회를 요구합니다. 이 요구 사항을 시스템 메시지로 추가하면
         // 이전 턴은 변경되지 않고 그대로 유지됩니다.
         {
           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?" },
             // 이 애플리케이션은 정책 관련 답변을 하기 전에 반드시
             // 도움말 센터 조회를 거쳐야 합니다. 이 요구 사항을 시스템 메시지로 추가하면
             // 이전 턴은 변경되지 않은 채로 유지됩니다.
             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?")),
     		// 이 애플리케이션은 정책 관련 답변을 하기 전에 반드시
     		// 도움말 센터 조회를 요구합니다. 이 요구 사항을 시스템 메시지로 추가하면
     		// 이전 턴은 변경되지 않고 그대로 유지됩니다.
     		{
     			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?")
             // 이 애플리케이션은 정책 관련 답변을 하기 전에 반드시
             // 도움말 센터 조회를 요구합니다. 이 요구 사항을 system message(시스템 메시지)로 추가하면
             // 이전 턴은 변경되지 않고 그대로 유지됩니다.
             .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?'],
             // 이 애플리케이션은 정책 관련 답변을 하기 전에
             // 반드시 헬프 센터 조회를 거쳐야 합니다. 이 요구 사항을 시스템 메시지로 추가하면
             // 이전 턴은 변경되지 않고 그대로 유지됩니다.
             ['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?" },
         # 애플리케이션은 정책 관련 답변을 하기 전에
         # 반드시 헬프 센터 조회를 요구합니다. 이 요구 사항을 시스템 메시지로 추가하면
         # 이전 턴은 변경되지 않고 그대로 유지됩니다.
         {
           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>

   다른 턴과 마찬가지로 이후 요청에서도 `role: "system"` 메시지를 히스토리에 유지하세요. 대화 중간 시스템 메시지에는 베타 헤더가 필요하지 않습니다. 도구를 호출해서는 안 되는 턴에는 `tool_choice: {"type": "none"}`이 여전히 작동합니다.

2. **Claude Fable 5.1의 thinking 블록은 Claude Fable 5.1과 Claude Mythos 5.1만 읽습니다:** 모든 `thinking` 블록은 자신을 생성한 모델을 기록합니다. Claude Fable 5.1은 자체 블록과 Claude Mythos 5.1, Claude Opus 5, Claude Fable 5, Claude Mythos 5 및 이전 Claude 모델의 블록을 읽습니다. 이들 모델 중 어느 것에서든 `claude-fable-5-1`로 이동하는 대화는 이전 추론을 유지합니다. 이 조건은 단방향입니다. Claude Mythos 5.1을 제외하면 이들 모델 중 어느 것도 Claude Fable 5.1의 블록을 읽을 수 없습니다.

   Claude Fable 5.1에서 실행된 대화는 라우터 전환, 클라이언트 측 재시도, 또는 [서버 측 폴백](https://platform.claude.com/docs/ko/build-with-claude/refusals-and-fallback#server-side-fallback)을 포함한 [분류기 거부 폴백](https://platform.claude.com/docs/ko/build-with-claude/refusals-and-fallback)을 통해 더 오래되었거나 더 새로운 다른 모델로 넘어갈 수 있습니다. API는 해당 모델이 읽을 수 없는 블록을 모델이 보기 전에 제거하고, 요청은 성공하며, 삭제된 입력 토큰에 대해서는 요금이 청구되지 않습니다. 대상 모델은 해당 추론 없이 다시 계획을 세우므로, 전환 후 첫 번째 턴에서 비용과 지연 시간이 증가할 수 있습니다. 무엇이 삭제되었는지 확인하려면 `thinking-binding-controls-2026-08-01` [베타 헤더](https://platform.claude.com/docs/ko/api/beta-headers)를 보내세요. 그러면 응답에 삭제된 각 블록을 `reason: "model_binding_mismatch"`와 함께 명시하는 `input_transformations` 배열이 포함됩니다. [대화 중 모델 전환](https://platform.claude.com/docs/ko/build-with-claude/preserved-thinking#switching-models)을 참조하세요.

3. **이전 턴을 편집하면 thinking 블록이 무효화됩니다:** Claude Fable 5.1의 각 `thinking` 블록은 그 앞에 있던 `system` 프롬프트, `tools`, 대화 히스토리에 대해서만 유효합니다. Claude Code, claude.ai, [Claude Managed Agents](https://platform.claude.com/docs/ko/managed-agents/overview) 또는 [Claude Agent SDK](https://code.claude.com/docs/ko/agent-sdk/overview)가 대화 히스토리를 관리하는 경우, 이미 해당 접두사를 그대로 유지합니다. 코드가 `messages` 배열을 직접 구성하는 경우 이 항목이 적용되며, [보존된 사고](https://platform.claude.com/docs/ko/build-with-claude/preserved-thinking)가 전체 통합 가이드입니다. 검사가 시행되는 경우, 이들 중 하나라도 변경된 후 블록을 다시 전송하는 요청은 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.
   ```

   API는 2026년 8월 31일 이후에 생성된 신규 계정에 대해 이 검사를 적용합니다. 그 이전에 생성된 계정의 경우, API는 불일치를 기록하지만 요청에서 `thinking.block_binding.prefix_mismatch_behavior`를 설정하여 적용을 선택하지 않는 한 이에 대해 조치를 취하지 않습니다. 해당 계정에서 `thinking-binding-controls-2026-08-01` 베타 헤더를 보내고 해당 필드를 설정하지 않으면, 응답은 검사에 실패한 각 블록을 `input_transformations`에 `thinking_mismatch_allowed` 항목으로 나열합니다. 계정 생성 시기와 관계없이 애플리케이션이 이 검사와 호환되도록 만드세요: 동일한 패턴이 프롬프트 캐싱을 유효하게 유지하며, `prefix_mismatch_behavior`를 보내면 어떤 계정에서든 검사에 대해 테스트할 수 있습니다. 사용자가 자신의 API 키로 실행하는 도구나 프레임워크를 배포하는 경우, 출시 전에 그 방식으로 테스트하세요: 여러분의 키는 아마도 이전 계정에 속해 있을 것이고, 신규 계정을 사용하는 사용자는 여러분보다 먼저 검사에 걸리게 됩니다. 자신의 계정에 기본적으로 검사가 적용되는지 확인하려면, 베타 헤더 없이 기록을 편집하는 요청을 보내세요: 헤더 이름을 명시하는 400 오류가 반환되면 적용되는 것입니다.

   이 오류는 해당 요청 본문에 대해 영구적입니다: 자동 재시도 루프로는 해결되지 않습니다. 실패하는 대신 무효화된 추론 없이 계속하려면, 히스토리에서 `thinking` 블록을 제거하고 한 번 재시도하거나, `thinking-binding-controls-2026-08-01` [베타 헤더](https://platform.claude.com/docs/ko/api/beta-headers)를 전송하고 `prefix_mismatch_behavior`를 `"drop_block"`으로 설정하세요(기본값은 `"error"`). `"drop_block"`을 사용하면 API는 불일치하는 블록과 대화에서 그 이후의 모든 thinking 블록을 삭제하고, 응답의 `input_transformations` 배열에 각각을 `reason: "prefix_binding_mismatch"`와 함께 보고합니다:

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

   [토큰 카운팅](https://platform.claude.com/docs/ko/build-with-claude/token-counting) 엔드포인트도 동일한 검사를 실행합니다. 응답 형태와 스트리밍 배치에 대해서는 [보존되지 않는 블록에 대한 제어(베타)](https://platform.claude.com/docs/ko/build-with-claude/thinking#preserved-thinking-controls)를 참조하세요.

   이후 thinking 블록을 무효화하는 패턴과 대신 해야 할 일:

   * 이전 턴을 편집, 재정렬 또는 제거하는 경우. 오래된 도구 결과 삭제, 대화 기록 중간의 턴 잘라내기, 최근 턴과 그 사고 블록을 요약 뒤에 그대로 남기는 클라이언트 측 압축(몇 턴 뒤에 요약을 교체하는 백그라운드 압축 포함)이 여기에 해당합니다. 대신 서버 측 [compaction](https://platform.claude.com/docs/ko/build-with-claude/compaction)(압축) 또는 [context editing](https://platform.claude.com/docs/ko/build-with-claude/context-editing)(컨텍스트 편집)을 사용하거나(오래된 도구 결과에는 [도구 결과 지우기](https://platform.claude.com/docs/ko/build-with-claude/context-editing#tool-result-clearing) 사용), [서버에서 컨텍스트 정리](https://platform.claude.com/docs/ko/models/fable-5-1/migration-guide#fable-5-1-trim-context)에 설명된 클라이언트 측 압축 형태 중 하나를 사용하세요.
   * 기록에 남기지 않는 콘텐츠를 주입하는 경우. 예를 들어 `tool_result` 블록 뒤에 턴별 리마인더를 추가했다가 다음 요청에서 제거하는 경우입니다. 대신 리마인더를 [턴 범위 시스템 메시지](https://platform.claude.com/docs/ko/build-with-claude/mid-conversation-system-messages#turn-scoped-system-messages)로 보내고 기록에 남겨 두세요.
   * 같은 대화에서 요청 사이에 최상위 `system` 프롬프트나 `tools` 배열을 다시 구성하는 경우. 예를 들어 현재 날짜를 갱신하거나 도구를 추가 또는 제거하는 경우입니다. 대신 새 지침("현재 날짜는 2026-09-14입니다.")이나 `tool_addition` 및 `tool_removal` 블록을 담은 [대화 중간 시스템 메시지](https://platform.claude.com/docs/ko/build-with-claude/mid-conversation-system-messages)를 추가하세요. 처음에 `tools`에 선언하지 않은 도구는 [`tool_addition` 블록 안에서 정의](https://platform.claude.com/docs/ko/build-with-claude/mid-conversation-system-messages#define-tools-in-a-message-beta)할 수 있습니다(베타 헤더 `inline-tools-2026-09-15`).
   * 이후 요청에서 다른 바이트를 반환하는 이미지 또는 문서 URL. 검사 대상은 URL 문자열이 아니라 바이트이므로, 같은 파일을 가리키는 서명 URL이 바뀌는 것은 문제가 되지 않습니다. 여러 턴에 걸쳐 참조하는 콘텐츠는 [Files API](https://platform.claude.com/docs/ko/build-with-claude/files)로 한 번 업로드한 뒤 `file_id`를 보내거나, base64로 보내세요.

   각 대체 방법은 또한 이전 턴을 바이트 단위로 동일하게 유지하며, 히스토리, `system` 프롬프트 또는 `tools` 배열을 편집하면 잃게 될 [프롬프트 캐시](https://platform.claude.com/docs/ko/build-with-claude/prompt-caching) 히트를 보존합니다.

   계속 작동하는 패턴:

   * 추가 전용(append-only) 히스토리: 턴을 추가하고 이전 턴을 전송 및 수신한 그대로 정확히 다시 전달하는 것. 추가된 `role: "system"` 메시지 포함.
   * 이전 어시스턴트 턴에서 thinking 블록을 가장 오래된 것부터 제거하는 것.
   * `effort`, `max_tokens` 또는 `system`, `tools`, `messages` 외부의 다른 요청 매개변수를 변경하는 것, 그리고 `cache_control` 마커를 추가하거나 이동하는 것.
   * [thinking 블록 지우기](https://platform.claude.com/docs/ko/build-with-claude/context-editing#thinking-block-clearing)를 포함한 서버 측 압축 및 컨텍스트 편집. 검사는 여러분이 전송한 대로의 대화를 비교하므로 이들은 편집으로 간주되지 않습니다.

   기존 통합을 확인하려면:

   1. 몇 번의 일반적인 턴 동안 통합이 보내는 정확한 요청 본문을 캡처하세요. 제품에 압축이나 도구 변경이 있다면 이를 포함하세요. 연속된 각 요청 쌍에 대해 `system` 프롬프트, `tools` 배열, `messages`의 공통 접두사를 비교하세요. 새로 추가된 턴 이전까지는 바이트 단위로 동일해야 합니다. 예상되는 예외는 [온디맨드 압축](https://platform.claude.com/docs/ko/build-with-claude/compaction-on-demand)에서 받은 서명된 `compaction` 블록으로 교체하는 요청입니다: 이 블록은 `messages` 앞부분에서 자신이 요약하는 메시지를 대체하며, 그 이후의 모든 내용은 여전히 일치해야 합니다.
   2. `thinking-binding-controls-2026-08-01` 베타 헤더와 `prefix_mismatch_behavior: "drop_block"`을 사용하여 `claude-fable-5-1`에 대해 일반적인 멀티턴 세션을 실행하고, 모든 응답에서 `input_transformations`를 로깅하세요. 모든 턴에서 빈 배열이면 기록이 온전하다는 의미입니다. `reason: "prefix_binding_mismatch"` 항목은 이전 요청 이후 `path`에 있는 블록 앞의 무언가가 변경되었음을 의미합니다. `reason: "model_binding_mismatch"` 항목은 대화가 모델을 전환했음을 의미하며, 이는 코드의 버그가 아닙니다. 필드를 설정하면 요청이 적용을 선택하게 되므로 이 방법은 어떤 계정에서든 작동합니다. CI에서는 편집이 발생하면 실행이 실패하도록 대신 `"error"`를 설정하세요.
   3. 프로덕션 설정을 선택하세요. 접두사 불일치가 코드의 버그만을 의미할 수 있다면 기본값 `"error"`를 그대로 두고, 실패하는 대신 영향을 받는 블록을 삭제하려면 `"drop_block"`을 설정하세요. 어느 쪽이든 400 오류나 `input_transformations` 항목을 모니터링하세요.

   예를 들어 압축 경계에서 thinking 블록을 한 번 삭제하는 것은 영향이 거의 없습니다. 모든 요청에서 이전 사고를 무효화하는 통합은 매번 프롬프트 캐시를 다시 시작하므로 작업당 비용이 증가할 수 있습니다([대화 히스토리를 추가 전용으로 유지하기](https://platform.claude.com/docs/ko/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#keep-the-conversation-history-append-only) 참조).

### 동작 변경 사항

1. **긴 에이전트 루프에서 병렬 도구 호출 감소:** 다음 독립적인 읽기가 작업에 의해 암시되기만 하는 장기 실행 루프(커스텀 코딩 에이전트, bash 및 에디터 하네스, 컴퓨터 사용)에서 Claude Fable 5.1은 턴당 하나의 도구 호출을 발행할 수 있습니다. 추가 턴마다 토큰, 왕복, 실제 경과 시간이 소요됩니다. 각 사용자 메시지 뒤에 한 문장의 배치 지침을 [턴 범위 시스템 메시지](https://platform.claude.com/docs/ko/build-with-claude/mid-conversation-system-messages#turn-scoped-system-messages)(`clear_at: "next_user_message"`, 베타)로 추가하거나, 베타 없이는 `tool_result` 블록 뒤의 텍스트 블록에 추가하고, 이후 요청에서 이전 사본을 히스토리에 남겨두세요. [에이전트 루프에서 독립적인 도구 호출 배치하기](https://platform.claude.com/docs/ko/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#batch-independent-tool-calls-in-agent-loops)를 참조하세요.

2. **도구 호출 사이의 진행 메시지 감소:** Claude Fable 5.1은 긴 도구 시퀀스 동안 Claude Fable 5보다 상태 업데이트를 적게 작성하며, 에이전트 코딩 요약이 더 짧습니다. 인터페이스가 이러한 업데이트를 렌더링한다면, `thinking.display`를 `"updates"`(베타) 또는 `"summarized"`로 설정하고 명시적으로 프롬프트하세요. [도구 호출 사이의 진행 업데이트](https://platform.claude.com/docs/ko/build-with-claude/thinking#progress-updates) 및 [사용자 대상 진행 업데이트 요청하기](https://platform.claude.com/docs/ko/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#ask-for-user-facing-progress-updates)를 참조하세요.

3. **낮은 effort에서 검색 및 검색(retrieval) 호출 감소:** `low` effort에서 Claude Fable 5.1은 검색 또는 검색(retrieval) 도구를 호출하는 대신 Claude Fable 5보다 더 자주 기억에서 답변합니다. 제품이 낮은 effort에서 검색(retrieval)에 의존한다면, 해당 요청의 effort를 높이거나 모델에게 언제 검색할지 알려주세요. [낮은 effort에서의 검색 트리거](https://platform.claude.com/docs/ko/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#search-triggering-at-low-effort)를 참조하세요.

API 통합에 영향을 주지 않는 산문 밀도, 채팅 서식, 요약에서의 인용, 파일 편집의 차이에 대해서는 [Claude Fable 5에서 변경된 사항](https://platform.claude.com/docs/ko/models/fable-5-1/whats-new-fable-5-1#changed-from-claude-fable-5)을 참조하세요.

### 권장 변경 사항

이러한 변경 사항은 필수는 아니지만, 각각 비용이나 지연 시간을 낮추거나 실패 모드를 제거합니다:

1. **대화 중간에 effort 변경하기(베타):** Claude Fable 5에서 `output_config.effort`는 요청 수준이며, 요청 사이에 이를 변경하면 이전 턴의 캐시된 접두사가 삭제됩니다. `claude-fable-5-1`에서는 `output_config`만 담은 `role: "system"` 메시지가 [프롬프트 캐시](https://platform.claude.com/docs/ko/build-with-claude/prompt-caching)를 무효화하지 않고 어려운 단계에서는 effort를 높이고 일상적인 단계에서는 낮춥니다:

   <CodeGroup>
     ```bash cURL
     # effort 전용 시스템 메시지: 새 수준은 다음 사용자 턴부터 적용됩니다.
     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."
       # effort 전용 시스템 메시지: 새 수준은 다음 사용자 턴부터 적용됩니다.
       - 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.",
             },
             # effort 전용 시스템 메시지: 새 수준은 다음 사용자 턴부터 적용됩니다.
             {"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."
         },
         // effort 전용 시스템 메시지: 새 수준은 다음 사용자 턴부터 적용됩니다.
         { 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." },
             // effort 전용 시스템 메시지: 새 수준은 다음 사용자 턴부터 적용됩니다.
             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.")},
     		},
     		// effort만 담은 시스템 메시지: 새 수준은 다음 사용자 턴부터 적용됩니다.
     		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.")
             // effort만 담은 시스템 메시지: 새 수준은 다음 사용자 턴부터 적용됩니다.
             .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.'),
             // effort 전용 시스템 메시지: 새 수준은 다음 사용자 턴부터 적용됩니다.
             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."},
         # effort 전용 시스템 메시지: 새 수준은 다음 사용자 턴부터 적용됩니다.
         {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>

   여기서처럼 `assistant` 턴과 다음 `user` 턴 사이에 배치하면, 메시지는 해당 `user` 턴부터 적용됩니다. 새 입력이 있는 `user` 턴 바로 뒤에 배치하면, 해당 턴에 대한 Claude의 응답 수준을 설정합니다. 도구 결과만 담은 `user` 턴은 새 입력으로 간주되지 않으며, 변경은 새 입력이 있는 다음 `user` 턴까지 대기합니다. 그런 다음 해당 수준은 다른 `role: "system"` 메시지가 변경할 때까지 유지됩니다. 명명된 수준(`low`, `medium`, `high`, `xhigh`, `max`)만 허용되며, `mid-conversation-output-config-2026-07-01` 베타 헤더가 필요합니다. [메시지별 effort](https://platform.claude.com/docs/ko/build-with-claude/effort#change-effort-mid-conversation-beta)를 참조하세요.

2. **대화 중간 시스템 메시지로 지침 및 도구 변경:** 세션 도중에 지침이나 도구를 변경하려면 [`role: "system"` 메시지](https://platform.claude.com/docs/ko/build-with-claude/mid-conversation-system-messages)를 추가하세요. 도구를 변경할 때는 `tool_addition` 및 `tool_removal` 블록을 사용합니다(Claude API에서는 베타 헤더 `inline-tools-2026-09-15` 필요). `tool_addition` 블록은 세션 시작 시 `tools`에 선언된 도구를 이름으로 지정할 수도 있고, [도구의 전체 정의를 담을](https://platform.claude.com/docs/ko/build-with-claude/mid-conversation-system-messages#define-tools-in-a-message-beta) 수도 있습니다. 따라서 세션 시작 시점에 알 수 없는 도구를 `tools`에 미리 넣어 둘 필요가 없습니다. 이 방식을 사용하면 이전 턴의 프롬프트 캐시 적중이 보존되고 대화 기록도 추가 전용으로 유지됩니다. 기존 `mid-conversation-tool-changes-2026-07-01` 헤더도 도구를 이름으로 참조하는 변경에 한해 Claude API, Amazon Bedrock, Google Cloud에서 계속 사용할 수 있습니다. 현재 턴에서 특정 도구를 반드시 실행해야 할 때도 같은 메시지로 강제 `tool_choice`를 대체할 수 있습니다([호환성이 깨지는 변경 사항](https://platform.claude.com/docs/ko/models/fable-5-1/migration-guide#fable-5-1-breaking-changes) 참조). 한 턴에만 적용되는 리마인더는 `clear_at: "next_user_message"`를 설정한 별도의 텍스트 전용 `role: "system"` 메시지로 보내고([턴 범위 시스템 메시지](https://platform.claude.com/docs/ko/build-with-claude/mid-conversation-system-messages#turn-scoped-system-messages), 베타 헤더 `mid-conversation-system-clear-at-2026-08-21`), 기록에 남겨 두세요. 이 메시지는 다음 사용자 메시지 이후에는 더 이상 렌더링되지 않으며, 지워진 뒤에는 토큰 비용이 발생하지 않습니다. `tool_addition` 또는 `tool_removal` 블록을 담은 메시지는 턴 범위로 지정할 수 없습니다.

3. **거부에 `fallbacks: "default"` 사용:** `stop_reason: "refusal"`을 계속 처리하고 응답 콘텐츠보다 먼저 `stop_details.category`를 읽으세요. 거부된 요청을 다른 모델에서 자동으로 다시 실행하려면 `fallbacks: "default"`(베타, `server-side-fallback-2026-07-01` 헤더)를 설정하세요. `"default"`는 거부된 요청을 해당 카테고리에 대해 Anthropic이 권장하는 모델에서 재시도합니다. Claude Fable 5.1에 허용되는 폴백 대상은 Claude Opus 4.8(`claude-opus-4-8`)과 Claude Opus 5(`claude-opus-5`)입니다. 명시적인 `fallbacks` 목록에서 둘 중 하나를 지정할 수 있습니다. 폴백 모델은 Claude Fable 5.1의 thinking 블록을 받지 않습니다. `fallbacks` 매개변수는 Amazon Bedrock, Google Cloud 또는 Microsoft Foundry에서 사용할 수 없습니다. 이러한 플랫폼에서는 대신 [클라이언트 측 폴백](https://platform.claude.com/docs/ko/build-with-claude/refusals-and-fallback#client-side-fallback)을 사용하세요. 재시도를 직접 구축하는 경우, [폴백 크레딧](https://platform.claude.com/docs/ko/build-with-claude/fallback-credit)이 Claude Fable 5와 동일한 조건으로 적용됩니다. [거부 및 폴백](https://platform.claude.com/docs/ko/build-with-claude/refusals-and-fallback)을 참조하세요.

4. **`high` effort에서 시작하여 스윕하기:** [effort 매개변수](https://platform.claude.com/docs/ko/build-with-claude/effort) 기본값은 `high`이며, 다섯 가지 수준 모두 지원됩니다. Claude Fable 5 지침을 유지하세요: 대부분의 작업에는 `high`, 테스트해 볼 만한 비용 제어로는 `medium`. Claude Fable 5 대비 Claude Fable 5.1의 향상은 `xhigh`와 `max`에서 가장 크지만, 이 수준들은 사고 시간과 첫 응답까지의 시간도 늘리므로, 가장 기능에 민감한 작업과 평가에서 향상이 나타나는 곳에서 이 수준으로 올리세요. Claude Fable 5에 맞춰 조정된 설정을 그대로 가져오지 말고 자체 평가에서 새로 스윕을 실행하세요. [Claude Fable 5.1 권장 effort 수준](https://platform.claude.com/docs/ko/build-with-claude/effort#recommended-effort-levels-for-claude-fable-5-1)을 참조하세요.

5. **서버에서 컨텍스트를 정리하거나, 오래된 사고를 담지 않는 형태로 압축하기:** 코드가 클라이언트에서 이전 턴을 잘라내거나 요약하는 경우, 가장 간단한 해결책은 해당 작업을 서버 측 [압축](https://platform.claude.com/docs/ko/build-with-claude/compaction) 또는 [컨텍스트 편집](https://platform.claude.com/docs/ko/build-with-claude/context-editing)으로 옮기는 것입니다. [기록 검사](https://platform.claude.com/docs/ko/models/fable-5-1/migration-guide#fable-5-1-preserved-thinking)는 여러분이 보낸 대화를 비교하므로 둘 다 편집으로 간주되지 않으며, 따라서 이들이 제거하는 어떤 것도 이후 사고 블록을 무효화하지 않습니다. 또한 압축의 [`instructions` 매개변수](https://platform.claude.com/docs/ko/build-with-claude/compaction-threshold#custom-summarization-instructions)에 자체 요약 프롬프트를 지정할 수 있습니다. 최근 턴을 요약 뒤에 그대로 유지하거나, 대화가 계속되는 동안 백그라운드에서 요약하는 경우, 클라이언트가 작성한 요약 대신 [온디맨드 압축](https://platform.claude.com/docs/ko/build-with-claude/compaction-on-demand)(베타 헤더 `compact-2026-09-04`)을 사용하세요. API가 서명된 요약 블록을 작성하면, 여러분은 이를 요약 대상 메시지 자리에 넣습니다. 유지하는 턴의 사고 블록은 [압축과 보존된 사고](https://platform.claude.com/docs/ko/build-with-claude/compaction-thinking-blocks#conditions-for-kept-thinking-to-stay-valid)에 설명된 조건에 따라 유효한 상태로 유지될 수 있습니다. 클라이언트에서 압축을 계속 수행하는 경우, 다음 세 가지 형태 중 하나를 선택하세요:

   * **단순 압축(권장):** 전체 히스토리를 하나의 요약 메시지와 새 사용자 턴으로 교체하고 다른 것은 아무것도 재생하지 않습니다. thinking 블록이 이월되지 않으므로 아무것도 실패하지 않습니다. Claude 모델은 이 방식으로 장기 작업에 대해 학습되었으며, 대부분의 워크로드에서 더 정교한 방식과 비슷한 성능을 냅니다.
   * **꼬리 유지(keep-tail) 압축:** 요약 뒤에 가장 최근 턴을 그대로 유지한다면, 해당 턴에서 `thinking` 및 `redacted_thinking` 블록을 제거하거나(텍스트와 도구 호출은 남겨둘 수 있음), `prefix_mismatch_behavior: "drop_block"`을 설정하세요. 그 사고는 전체 히스토리에 대해 생성되었으므로 그렇지 않으면 요약 뒤에서 실패합니다.
   * **백그라운드 압축:** 요약을 임계 경로 밖에서 구축하고 나중에 교체해 넣는다면, 그 사이에 생성된 모든 턴은 교체 이전의 사고를 담고 있습니다. 교체 전에 생성된 thinking 블록을 여전히 담고 있는 모든 요청에 `"drop_block"`을 전송하거나(또는 해당 블록을 직접 제거하세요; 교체 후 첫 번째 응답의 `input_transformations`가 정확히 어떤 블록인지 나열합니다), 동기적으로 압축하세요.

   대화 기록 중간에서 개별 턴을 잘라내지 마세요: 이는 이후의 모든 thinking 블록을 무효화하며 어떤 클라이언트 측 형태로도 이를 피할 수 없습니다. 수행하려던 지침 변경에는 [대화 중간 시스템 메시지](https://platform.claude.com/docs/ko/build-with-claude/mid-conversation-system-messages)를, 선택적 제거에는 서버 측 [컨텍스트 편집](https://platform.claude.com/docs/ko/build-with-claude/context-editing)을 사용하세요. [압축 블록 다시 전달하기](https://platform.claude.com/docs/ko/build-with-claude/compaction-threshold#passing-compaction-blocks-back)를 참조하세요.

### 마이그레이션 체크리스트

* 모델 이름을 `claude-fable-5`에서 `claude-fable-5-1`로(또는 `claude-mythos-5`에서 `claude-mythos-5-1`로) 업데이트하세요.
* 강제 `tool_choice`(`{type: "any"}` 또는 `{type: "tool", ...}`)는 400 오류를 반환하므로 대체하세요. `{type: "auto"}`에 명시적 지침과 `strict: true` 도구를 함께 사용하거나, JSON 출력을 사용하세요. 지침은 `user` 턴에 넣고, 애플리케이션이 호출을 요구하는 경우에는 대화 중간 `role: "system"` 메시지에 넣으세요.
* 빈 블록을 포함하여 모든 턴에서 `thinking` 블록을 변경 없이 계속 다시 전달하세요. Claude Fable 5.1은 Claude Opus 5, Claude Fable 5, Claude Mythos 5 및 이전 모델의 블록을 읽습니다. Claude Fable 5.1에서 Claude Mythos 5.1 이외의 모델로 대화를 이동하면 해당 블록이 삭제됩니다.
* 코드에서 `messages` 배열을 직접 구성한다면 [이전 턴을 편집](https://platform.claude.com/docs/ko/models/fable-5-1/migration-guide#fable-5-1-preserved-thinking)하는지 확인하세요. `thinking-binding-controls-2026-08-01` 베타 헤더와 `prefix_mismatch_behavior: "drop_block"`을 설정해 세션을 실행하고, `input_transformations`를 로깅한 다음, 모든 `prefix_binding_mismatch`를 수정하세요. 모델 전환 후 나타나는 `model_binding_mismatch` 항목은 정상입니다.
* 대화 기록을 추가 전용으로 유지하세요. 세션 시작 시 `system`과 `tools`를 고정하고, 세션 중 변경 사항은 `role: "system"` 메시지와 `tool_addition` / `tool_removal` 블록으로 처리하세요. 턴별 리마인더는 제거하지 않는 턴 범위 시스템 메시지로 보내세요. 컨텍스트는 서버 측에서 정리하거나, 클라이언트 측 요약 뒤에 남기는 턴에서는 사고 블록을 제거하세요. 여러 턴에 걸쳐 사용하는 파일은 `file_id`로 참조하세요.
* 프로덕션용 `prefix_mismatch_behavior`(기본값 `"error"` 또는 `"drop_block"`)를 선택하고 모니터링하세요. 다른 사람이 자신의 API 키로 실행하는 도구를 유지 관리한다면, 이 필드를 설정한 상태로 테스트하세요. 여러분의 계정에는 적용되지 않더라도 새 계정에는 기본적으로 적용됩니다.
* 에이전트 루프에서 턴당 도구 호출이 하나만 발생하는지 검토하고, 일괄 처리 지침을 추가하세요.
* 인터페이스에서 도구 호출 사이의 진행 텍스트를 표시한다면, `thinking.display`를 `"updates"`(베타) 또는 `"summarized"`로 설정하고 프롬프트에서 업데이트를 요청하세요.
* 요청 사이에 effort를 변경한다면, 캐시 적중을 유지할 수 있도록 [메시지별 effort](https://platform.claude.com/docs/ko/build-with-claude/effort#change-effort-mid-conversation-beta) `role: "system"` 메시지(베타)로 변경하세요.
* `stop_reason: "refusal"`을 처리하고 `stop_details.category`를 확인하세요. `fallbacks: "default"`(베타) 사용을 고려하세요.
* `high`부터 시작해 스윕을 새로 실행하여 `effort`를 재평가하고, 자체 워크로드에서 비용과 지연 시간의 기준선을 다시 설정하세요. 토크나이저는 변경되지 않았습니다. 프롬프트 캐싱 읽기 비용은 Claude Fable 5 요금의 4분의 1입니다.

## Claude Opus 5에서 Claude Fable 5.1로 마이그레이션

Claude Fable 5.1은 Claude Opus 5와 동일한 [Messages API](https://platform.claude.com/docs/ko/build-with-claude/working-with-messages) 및 [도구 사용](https://platform.claude.com/docs/ko/agents-and-tools/tool-use/overview) 패턴을 사용합니다. 기본적으로 [1M 토큰 컨텍스트 윈도우](https://platform.claude.com/docs/ko/build-with-claude/context-windows), [128k 최대 출력 토큰](https://platform.claude.com/docs/ko/models/overview), 512 토큰 프롬프트 캐싱 최소값, [대화 중간 시스템 메시지](https://platform.claude.com/docs/ko/build-with-claude/mid-conversation-system-messages) 지원을 유지합니다. 프리필 제한, 샘플링 매개변수 제한, `thinking.display`의 `"omitted"` 기본값도 그대로 이어집니다. [Claude Fable 5에서 Claude Fable 5.1로 마이그레이션](https://platform.claude.com/docs/ko/models/fable-5-1/migration-guide#migrating-from-claude-fable-5-to-claude-fable-5-1)의 모든 내용과 함께 다음을 적용하세요.

### 모델 이름 업데이트

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

# 또는 검증된 조직에 동일한 기능을 제공하는 Claude Mythos 5.1의 경우:
model = "claude-mythos-5-1"  # After
```

### 변경 사항

1. **사고를 더 이상 비활성화할 수 없음:** Claude Opus 5는 [effort](https://platform.claude.com/docs/ko/build-with-claude/effort) 수준이 `high` 이하일 때 `thinking: {type: "disabled"}`를 허용합니다. `claude-fable-5-1`과 `claude-mythos-5-1`에서는 [적응형 사고](https://platform.claude.com/docs/ko/build-with-claude/thinking)가 항상 켜져 있으며, `thinking: {type: "disabled"}`는 모든 effort 수준에서 400 오류를 반환합니다. 해당 필드를 제거하고, 더 낮은 effort 수준으로 토큰 사용량을 제어하고, 사고를 비활성화한 상태로 실행하던 워크로드의 `max_tokens`를 재검토하세요.

2. **강제 도구 선택이 지원되지 않음:** Claude Opus 5는 `tool_choice` `any`와 `tool`을 허용합니다. `claude-fable-5-1`은 400 오류를 반환합니다. [호환성이 깨지는 변경 사항](https://platform.claude.com/docs/ko/models/fable-5-1/migration-guide#fable-5-1-breaking-changes)을 참조하세요.

3. **모델 간 보존된 사고:** Claude Fable 5.1은 Claude Opus 5의 thinking 블록을 읽습니다. `claude-opus-5`에서 `claude-fable-5-1`로 이동하는 대화는 추론을 유지합니다. Claude Opus 5는 Claude Fable 5.1의 블록을 읽을 수 없습니다. Claude Fable 5.1의 블록은 또한 [이전 턴이 변경되면 더 이상 유효하지 않게 됩니다](https://platform.claude.com/docs/ko/models/fable-5-1/migration-guide#fable-5-1-preserved-thinking). 코드가 요청 사이에 이전 메시지를 편집하거나, `system` 또는 `tools`를 재구성하거나, 클라이언트에서 압축하는 경우, Claude Opus 5는 이의를 제기하지 않았지만 `claude-fable-5-1`은 이후의 모든 thinking 블록을 거부하거나 삭제합니다. 트래픽을 전환하기 전에 해당 섹션의 3단계 점검을 실행하세요. [호환성이 깨지는 변경 사항](https://platform.claude.com/docs/ko/models/fable-5-1/migration-guide#fable-5-1-breaking-changes)을 참조하세요.

4. **도구 호출 사이의 텍스트가 thinking 블록으로 반환됨:** Claude Opus 5에서는 모델이 도구 호출 사이에 작성하는 텍스트가 `text` 블록으로 반환됩니다. `claude-fable-5-1`에서는 Claude Fable 5와 마찬가지로 해당 내레이션이 각 도구 호출 앞에 하나씩 진행 상황 업데이트 `thinking` 블록으로 반환됩니다. 기본 `thinking.display` 값인 `"omitted"`에서는 읽을 수 있는 텍스트가 포함되지 않습니다. 인터페이스가 해당 내레이션을 렌더링하는 경우, 추론은 숨긴 채 진행 상황 업데이트를 텍스트로 받으려면 `display: "updates"`(베타)를, 둘 다 받으려면 `"summarized"`를 설정하세요. 그런 다음 `tool_use` 블록 사이의 비어 있지 않은 `thinking` 블록을 렌더링하세요. [도구 호출 사이의 진행 상황 업데이트](https://platform.claude.com/docs/ko/build-with-claude/thinking#progress-updates)를 참조하세요.

5. **안전 분류기 및 폴백 라우팅:** Claude Fable 5.1은 Claude Fable 5와 동일한 `stop_details` 카테고리를 다루는 안전 분류기를 실행하며, 이는 Claude Opus 5의 분류기보다 더 넓은 범위입니다. `"bio"`와 같은 추가 `stop_details.category` 값이 나타날 수 있습니다. 전체 목록은 [거부 카테고리 표](https://platform.claude.com/docs/ko/build-with-claude/refusals-and-fallback#refusal-response)를 참조하세요. `fallbacks` 구성 및 허용되는 대상에 대해서는 [거부에 `fallbacks: "default"` 사용](https://platform.claude.com/docs/ko/models/fable-5-1/migration-guide#fable-5-1-recommended-changes)을 참조하세요.

6. **가격:** 입력 토큰 백만 개당 $10 USD, 출력 토큰 백만 개당 $50 USD이며, Claude Opus 5는 $5 USD 및 $25 USD입니다. 프롬프트 캐시 읽기는 토큰 백만 개당 $0.25 USD로, Claude Opus 5 요금의 절반입니다. [Claude 가격](https://platform.claude.com/docs/ko/about-claude/pricing)을 참조하세요.

7. **데이터 보존:** Claude Fable 5.1과 Claude Mythos 5.1은 30일 데이터 보존이 필요하며, Anthropic이 명시적으로 승인하지 않는 한 제로 데이터 보존(ZDR) 계약 하에서는 사용할 수 없고, Covered Models로 지정됩니다. Claude Opus 5는 ZDR 하에서 사용할 수 있습니다. [모델별 데이터 보존 요구 사항](https://platform.claude.com/docs/ko/manage-claude/api-and-data-retention#model-specific-data-retention-requirements)을 참조하세요.

### 마이그레이션 체크리스트

* 조직에 "zero data retention"(데이터 무보존), 즉 ZDR 계약이 있는 경우 먼저 자격 여부를 확인하세요. 이 모델들은 Anthropic이 명시적으로 승인하지 않는 한 ZDR 환경에서 사용할 수 없습니다. [모델별 데이터 보존 요구 사항](https://platform.claude.com/docs/ko/manage-claude/api-and-data-retention#model-specific-data-retention-requirements)을 참조하세요.
* 모델 이름을 `claude-opus-5`에서 `claude-fable-5-1`(또는 `claude-mythos-5-1`)로 업데이트하세요.
* `thinking: {type: "disabled"}` 구성을 모두 제거하세요. 이 구성은 `claude-fable-5-1`에서 400 오류를 반환합니다. 토큰 사용량은 더 낮은 [effort](https://platform.claude.com/docs/ko/build-with-claude/effort) 수준으로 제어하고, `max_tokens`를 다시 검토하세요.
* 강제 `tool_choice`(`any` 또는 `tool`)를 `auto`로 바꾸고 명시적 지시(`user` 턴 또는 대화 중간의 시스템 메시지)와 `strict: true` 도구를 함께 사용하거나, JSON 출력으로 대체하세요.
* 인터페이스에서 도구 호출 사이의 텍스트를 렌더링하는 경우 `display: "updates"`(베타) 또는 `"summarized"`를 설정하고, 비어 있지 않은 `thinking` 블록을 렌더링하세요.
* [Claude Fable 5 체크리스트](https://platform.claude.com/docs/ko/models/fable-5-1/migration-guide#migration-checklist-fable-5-1-from-fable-5)의 보존된 사고, 기록 편집, 동작, effort, 폴백 항목을 적용하세요.
* 자체 워크로드를 기준으로 비용 기준선을 다시 설정하세요. "tokenizer"(토크나이저)는 변경되지 않았지만, 토큰당 가격은 다릅니다.

## Claude Opus 4.8 이하에서 Claude Fable 5.1로 마이그레이션

아래 체크리스트를 따라 진행하세요. Claude Opus 4.7 이하를 사용 중이라면 해당하는 [Claude Opus 5.5 마이그레이션 가이드](https://platform.claude.com/docs/ko/models/opus-5-5/migration-guide) 섹션부터 시작하세요.

### 모델 이름 업데이트

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

# 또는 검증된 조직에 동일한 기능을 제공하는 Claude Mythos 5.1의 경우:
model = "claude-mythos-5-1"  # After
```

### 마이그레이션 체크리스트

* 조직에 제로 데이터 보존(ZDR) 계약이 있는 경우, 먼저 자격을 확인하세요. 이 모델들은 Anthropic이 명시적으로 승인하지 않는 한 ZDR 하에서 사용할 수 없습니다. Claude Opus 4.8은 ZDR 하에서 사용할 수 있습니다.
* 모델 이름을 `claude-opus-4-8`에서 `claude-fable-5-1`(또는 `claude-mythos-5-1`)로 업데이트하세요.
* 모든 `thinking: {type: "disabled"}` 구성을 제거하고 `max_tokens`를 재검토하세요. `thinking` 필드가 없는 요청은 적응형 사고로 실행됩니다.
* `content[0].text`와 같이 위치로 콘텐츠를 읽는 응답 파싱을 업데이트하세요. 이제 응답이 `thinking` 블록으로 시작할 수 있으므로 대신 `type`으로 콘텐츠 블록을 선택하세요.
* 강제 `tool_choice`(`any` 또는 `tool`)를 `auto`와 명시적 지시(`user` 턴 또는 대화 중간 시스템 메시지) 및 `strict: true` 도구로 교체하거나, JSON 출력으로 교체하세요.
* `thinking` 블록을 변경 없이 다시 전달하고 해당 텍스트는 표시 전용으로 취급하세요. Claude Fable 5.1은 Claude Opus 4.8의 thinking 블록을 읽습니다. `claude-fable-5-1`로 이동하는 대화는 이전 추론을 유지합니다. Claude Opus 4.8은 Claude Fable 5.1의 블록을 읽을 수 없습니다.
* 코드에서 `messages` 배열을 직접 구성하는 경우, [이전 턴을 편집하는지](https://platform.claude.com/docs/ko/models/fable-5-1/migration-guide#fable-5-1-preserved-thinking) 확인하세요. Claude Opus 4.8 및 이전 버전용으로 작성된 통합은 종종 오래된 턴을 잘라내거나, 이전 메시지를 제거 또는 재구성하거나, 매 요청마다 `system` 프롬프트를 새로 고치며, Claude Opus 4.8은 이에 이의를 제기하지 않았습니다. `claude-fable-5-1`에서는 이러한 각 작업이 이후의 thinking 블록을 무효화합니다.
* `stop_reason: "refusal"`을 처리하고, `stop_details.category`를 읽고, `fallbacks: "default"`(베타)를 고려하세요.
* [Claude Fable 5 체크리스트](https://platform.claude.com/docs/ko/models/fable-5-1/migration-guide#migration-checklist-fable-5-1-from-fable-5)의 보존된 사고, 기록 편집, 동작, 메시지별 effort, 진행 상황 업데이트 항목을 적용하세요.
* `effort`를 재평가하고(`high`부터 시작), 512 토큰 [캐싱 최소값](https://platform.claude.com/docs/ko/build-with-claude/prompt-caching#cache-limitations)(Claude Opus 4.8에서는 1,024 토큰) 근처의 프롬프트를 검토하고, 비용 및 지연 시간 기준선을 다시 설정하세요. 토큰당 가격이 다르고 사고 토큰은 출력 토큰으로 청구되므로, Claude Opus 4.8에서 사고 없이 실행되던 워크로드는 요청당 더 많은 출력 토큰을 생성할 수 있습니다.

## Claude Mythos 5에서 Claude Mythos 5.1로 마이그레이션

[Claude Mythos 5.1](https://platform.claude.com/docs/ko/models/mythos-5-1/overview)은 [Cyber Verification Program](https://support.claude.com/en/articles/14604842)과 같은 Anthropic의 검증 프로그램을 통해 검증된 조직을 위한 Claude Fable 5.1의 대응 모델입니다. 모델 ID를 전환하기 전에 조직이 Claude Mythos 5.1에 액세스할 수 있는지 확인하세요.

API 수준의 변경 사항은 [Claude Fable 5에서 Claude Fable 5.1로 마이그레이션](https://platform.claude.com/docs/ko/models/fable-5-1/migration-guide#migrating-from-claude-fable-5-to-claude-fable-5-1)과 동일합니다. 강제 도구 선택은 400 오류를 반환하며, Claude Mythos 5.1과 Claude Fable 5.1만 Claude Mythos 5.1의 thinking 블록을 읽을 수 있습니다(Claude Mythos 5.1은 Claude Mythos 5의 블록을 읽을 수 있지만, 그 반대는 불가능합니다). Claude Fable 5.1과 달리 Claude Mythos 5.1은 대화 검사를 실행하지 않으므로, 이전 턴을 편집해도 [thinking 블록이 무효화](https://platform.claude.com/docs/ko/models/fable-5-1/migration-guide#fable-5-1-preserved-thinking)되지는 않지만 프롬프트 캐시는 여전히 다시 시작됩니다.

### 모델 이름 업데이트

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

### 마이그레이션 체크리스트

* 모델 이름을 `claude-mythos-5`에서 `claude-mythos-5-1`로 업데이트하세요.
* 강제 `tool_choice`(`any` 또는 `tool`)를 `auto`와 명시적 지시(`user` 턴 또는 대화 중간 시스템 메시지) 및 `strict: true` 도구로 교체하거나, JSON 출력으로 교체하세요.
* `stop_reason: "refusal"`을 처리하고 응답 콘텐츠보다 먼저 `stop_details.category`를 읽으세요. [거부 및 폴백](https://platform.claude.com/docs/ko/build-with-claude/refusals-and-fallback)을 참조하세요.
* 빈 블록을 포함하여 매 턴마다 `thinking` 블록을 변경 없이 계속 다시 전달하세요.
* 코드에서 `messages` 배열을 직접 구성하는 경우, 프롬프트 캐시를 웜 상태로 유지하기 위해 대화 기록을 추가 전용으로 유지하세요. Claude Mythos 5.1은 [대화 점검](https://platform.claude.com/docs/ko/build-with-claude/thinking#preserved-in-conversation)을 실행하지 않으므로, 편집해도 thinking 블록이 무효화되지 않습니다.
* [Claude Fable 5 섹션](https://platform.claude.com/docs/ko/models/fable-5-1/migration-guide#migrating-from-claude-fable-5-to-claude-fable-5-1)의 동작 및 권장 변경 사항을 적용하되, Claude Mythos 5.1에는 적용되지 않는 기록 편집 항목은 제외하세요.
* 새로운 스윕으로 `effort`를 재평가하고 비용과 지연 시간의 기준선을 다시 설정하세요. 프롬프트 캐시 읽기 비용은 Claude Mythos 5 요금의 4분의 1입니다.