Claude Fable 5.1과 Claude Mythos 5.1로 마이그레이션

Claude Fable 5.1과 Claude Mythos 5.1로 마이그레이션 (Migrating to Claude Fable 5.1 and Claude Mythos 5.1)

Claude Fable 5, Claude Mythos 5, Claude Opus 5 또는 Claude Opus 4.8에서 Claude Fable 5.1과 Claude Mythos 5.1로 옮길 때 필요한 모델 ID, 파괴적 변경, 마이그레이션 체크리스트를 정리한 가이드예요. 클로드 파블 5.1은 까다로운 추론과 장기 에이전트 작업에 특히 강한 모델이죠.

출처: 문서

본문

이 가이드는 [Messages API](https://platform.claude.com/docs/en/build-with-claude/working-with-messages) 코드 마이그레이션을 다뤄요. [Claude Managed Agents](https://platform.claude.com/docs/en/managed-agents/overview)를 쓴다면 모델 이름만 바꾸면 되고 다른 변경은 필요 없어요. **Claude API 스킬로 마이그레이션을 자동화하세요.** Claude Code에서 `/claude-api migrate`를 실행하면 내장된 [Claude API 스킬](https://platform.claude.com/docs/en/agents-and-tools/agent-skills/claude-api-skill#migrating-to-a-newer-claude-model)이 호출돼요. 대상으로는 현재 어떤 클로드 모델이든 지정할 수 있어요: 
/claude-api migrate this project to claude-fable-5-1

이 스킬이 코드베이스 전체에 걸쳐 모델 ID 교체와, 필요에 따라 대상 모델에 맞는 파괴적 파라미터 변경, 프리필 교체, effort 보정을 적용한 뒤, 수동으로 확인할 항목 체크리스트를 만들어 줘요. 파일을 편집하기 전에 마이그레이션 범위(전체 작업 디렉터리, 하위 디렉터리, 특정 파일 목록)를 확인해 달라고 물어보죠. Amazon Bedrock과 Claude Platform on AWS 클라이언트도 감지해서 해당 플랫폼의 모델 ID 형식과 기능 변경을 맞춰 조정해 줘요.

Claude Fable 5.1은 같은 입·출력 가격에, 캐시 읽기가 4분의 1 가격으로 Claude Fable 5의 후속 모델이에요. Claude API, Amazon Bedrock, Claude Platform on AWS, Google Cloud, Microsoft Foundry에서 제공돼요. Claude Mythos 5.1은 같은 성능을 공유하지만 Project Glasswing의 승인된 고객에게만 제공되죠. 동작 차이와 프롬프트 패턴은 Prompting Claude Fable 5.1을 참고하세요.

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

  • 생각(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 오류를 반환해요. 파괴적 변경 참고.
  • 모델 간 생각 보존: Claude Fable 5.1은 Claude Opus 5, Claude Fable 5, Claude Mythos 5 및 이전 클로드 모델의 생각 블록을 읽어요. 그 모델들 중 어느 것도 Claude Fable 5.1의 블록을 읽지 못해요. 파괴적 변경 참고.
  • 컨텍스트 윈도우와 출력: 기본 1M 토큰 컨텍스트 윈도우, 요청당 최대 128k 출력 토큰.
  • 가격: 백만 입력 토큰당 $10, 백만 출력 토큰당 $50로 Claude Fable 5와 동일해요. 프롬프트 캐시 읽기는 백만 토큰당 $0.25로, Claude Fable 5 요율의 4분의 1이에요. Claude 가격 참고.
  • 데이터 보존: 두 모델 모두 30일 데이터 보존이 필요하고, Anthropic이 명시적으로 승인하지 않는 한 제로 데이터 보존(ZDR) 체제에서는 사용할 수 없으며, Claude Fable 5와 Claude Mythos 5처럼 Covered Models로 지정됐어요. Claude API에서 30일 보존이 없는 조직이나 워크스페이스의 요청은 400 invalid_request_error를 반환해요. ZDR 체제의 조직은 Anthropic 계정 팀에 문의하거나 워크스페이스별로 보존을 구성하세요. 플랫폼별 세부사항은 모델별 데이터 보존 요건을 참고하세요.

두 모델이 갈리는 부분:

  • 제공 범위: Claude Fable 5.1은 접근 승인이 필요 없어요. Claude Mythos 5.1은 Project Glasswing의 승인된 고객에게만 제공돼요. 접근은 Anthropic 계정 팀에 문의하세요.
  • 안전성 분류기: Claude Fable 5.1은 Claude Fable 5와 같은 stop_details 범주를 다루는 안전성 분류기를 실행해요. 거절된 요청은 stop_details.category와 함께 stop_reason: "refusal"을 반환하고, fallbacks 파라미터나 클라이언트 쪽 재시도로 다른 모델에 폴백할 수 있어요. Refusals and fallback 참고.
  • Priority Tier: 어느 모델도 Priority Tier에서 지원되지 않아요. Claude Fable 5는 지원되죠.

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

마이그레이션은 대부분 드롭인이에요. API 표면, 한도, 토큰당 가격, 토크나이저, 항상 켜진 적응형 생각, 거절 처리, stop_details 범주 모두 Claude Fable 5와 일치해요. 달라지는 것: 강제 도구 선택이 400 오류를 반환하고, 생각 블록은 그것을 만든 모델이나 더 새로운 모델, 그리고 그것을 만든 대화에서만 보존되며, 캐시 읽기가 더 저렴하고, 에이전트 루프 동작이 세 가지 방식으로 달라져요. 같은 변경이 Claude Mythos 5.1에도 적용되지만, Claude Mythos 5.1이 실행하지 않는 생각 블록에 대한 대화 검사는 제외돼요.

모델 이름 업데이트

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

# Or, for the Project Glasswing model with the same capabilities:
model = "claude-mythos-5-1"  # After

파괴적 변경 (Breaking changes)

  1. 강제 도구 선택이 지원되지 않아요: Claude Fable 5는 tool_choice auto, none, any, tool을 받아요. claude-fable-5-1에서는 {type: "any"}와 {type: "tool", name: "..."}이 400 invalid_request_error를 반환해요:

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

    이 검사는 Messages API, Message Batches API, 토큰 계산 엔드포인트에 적용돼요.

    이전(Claude Fable 5):

    ```bash cURL curl -sS https://api.anthropic.com/v1/messages \ -H "content-type: application/json" \ -H "x-api-key: $ANTHR...KEY" \ -H "anthropic-version: 2023-06-01" \ -d @- <<'EOF' { "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."} ] } EOF ``` 
    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

    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)

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

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

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

    
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);
}

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

    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

    이후(Claude Fable 5.1): tool_choice를 auto로 두고, 지침에서 도구 이름을 지정하고, strict: true를 설정해 호출이 스키마와 일치하게 만드세요. 설치형 구조화 출력(strict: true 포함)이 CMEK 조직에서 Claude Fable 모델에는 제공되지 않으므로 그곳에서는 지침에만 의존하세요. 예:

    ```bash cURL curl -sS https://api.anthropic.com/v1/messages \ -H "content-type: application/json" \ -H "x-api-key: $ANTHR...KEY" \ -H "anthropic-version: 2023-06-01" \ -d @- <<'EOF' { "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."} ] } EOF ``` 
    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

    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)

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

    AnthropicClient client = new();

var parameters = new MessageCreateParams
{
    Model = "claude-fable-5-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);

    client := anthropic.NewClient()

response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
	Model:     "claude-fable-5-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())

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

    MessageCreateParams params = MessageCreateParams.builder()
        .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);
}

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

    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

    Strict tool use와 도구 사용 강제를 참고하세요. 스키마에 맞는 JSON만 얻으려고 도구를 강제했었다면 JSON 출력(output_config.format)을 대신 쓰세요.

    사용자가 아니라 애플리케이션이 다중 턴 대화의 현재 턴에서 특정 도구 호출을 요구한다면, 가장 최근 user 턴 뒤에 mid-conversation system message를 추가하세요. 도구 이름을 지정하고, 이 턴에 호출이 필요하다고 말하고, 응답을 그 도구 호출로 시작하라고 지시하세요. 메시지가 최상위 system 프롬프트에 쓰이는 게 아니라 추가되므로 이전 턴들이 바이트 단위로 동일하게 유지되고 프롬프트 캐시 히트를 유지해요:

    ```bash cURL curl -sS https://api.anthropic.com/v1/messages \ -H "content-type: application/json" \ -H "x-api-key: $ANTHR...KEY" \ -H "anthropic-version: 2023-06-01" \ -d @- <<'EOF' { "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." } ] } EOF ``` 
    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

    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?"},
        # The application requires a help center lookup before any policy
        # answer. Appending the requirement as a system message leaves the
        # earlier turns unchanged.
        {
            "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)

    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?" },
    // The application requires a help center lookup before any policy
    // answer. Appending the requirement as a system message leaves the
    // earlier turns unchanged.
    {
      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);

    AnthropicClient client = new();

var parameters = new MessageCreateParams
{
    Model = "claude-fable-5-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?" },
        // The application requires a help center lookup before any policy
        // answer. Appending the requirement as a system message leaves the
        // earlier turns unchanged.
        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);

    client := anthropic.NewClient()

response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
	Model:     "claude-fable-5-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?")),
		// The application requires a help center lookup before any policy
		// answer. Appending the requirement as a system message leaves the
		// earlier turns unchanged.
		{
			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())

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

    MessageCreateParams params = MessageCreateParams.builder()
        .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?")
        // The application requires a help center lookup before any policy
        // answer. Appending the requirement as a system message leaves the
        // earlier turns unchanged.
        .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);
}

    $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?'],
        // The application requires a help center lookup before any policy
        // answer. Appending the requirement as a system message leaves the
        // earlier turns unchanged.
        ['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;

    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?" },
    # The application requires a help center lookup before any policy
    # answer. Appending the requirement as a system message leaves the
    # earlier turns unchanged.
    {
      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

    나중 요청에서도 role: "system" 메시지를 다른 턴과 마찬가지로 이력에 유지하세요. Mid-conversation system message에는 베타 헤더가 필요 없어요. 도구를 호출하면 안 되는 턴에는 tool_choice: {"type": "none"}이 여전히 동작해요.

  2. 생각 블록은 그것을 만든 모델 또는 더 새로운 모델에 대해서만 보존돼요: 모든 thinking 블록은 어느 모델이 만들었는지 기록해요. Claude Fable 5.1은 자신의 블록과 Claude Mythos 5.1, Claude Opus 5, Claude Fable 5, Claude Mythos 5 및 이전 클로드 모델의 블록을 읽어요. 그 모델들 중 어느 쪽에서 claude-fable-5-1로 옮겨온 대화는 이전 추론을 유지해요. 이 조건은 단방향이에요: Claude Mythos 5.1을 제외하면 그 모델들 중 어느 것도 Claude Fable 5.1의 블록을 읽지 못해요.

    Claude Fable 5.1에서 실행된 대화는 라우터 전환, 클라이언트 쪽 재시도, 분류기 거절 폴백(서버 쪽 폴백 포함)을 통해 이전 모델로 내려갈 수 있어요. API는 그 모델이 읽지 못하는 블록을 그 모델이 보기 전에 제거하고, 요청은 성공하며, 제거된 입력 토큰은 청구되지 않아요. 대상 모델은 그 추론 없이 다시 계획하므로 전환 후 첫 턴에서 비용과 지연 시간이 올라갈 수 있어요. 무엇이 제거됐는지 보려면 thinking-binding-controls-2026-08-01 베타 헤더를 보내세요. 그러면 응답에 각 제거된 블록을 reason: "model_binding_mismatch"로 명명하는 input_transformations 배열이 담겨요. 대화 중간 모델 전환 참고.

  3. 이전 턴을 편집하면 생각 블록이 무효화돼요: Claude Fable 5.1의 각 thinking 블록은 그것보다 앞선 system 프롬프트, tools, 대화 이력에 대해서만 유효해요. Claude Code, claude.ai, Claude Managed Agents, Claude Agent SDK가 대화 이력을 관리한다면 이미 그 프리픽스를 유지해 줘요. 코드가 messages 배열을 직접 만든다면 이 항목이 여러분에게 적용되고, Preserved thinking이 전체 통합 가이드예요. 검사가 적용되는 곳에서, 그런 것 중 하나라도 변경된 뒤 블록을 다시 보내는 요청은 400 오류로 거부돼요:

    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 베타 헤더를 보내고 prefix_mismatch_behavior를 "drop_block"으로 설정하세요(기본은 "error"). "drop_block"을 쓰면 API가 불일치 블록과 그 뒤의 모든 생각 블록을 대화에서 제거하고, 응답의 input_transformations 배열에 각각 reason: "prefix_binding_mismatch"와 함께 보고해요:

    ```bash cURL curl https://api.anthropic.com/v1/messages \ -H "x-api-key: $ANTHR...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?" } ] }' ``` 
    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

    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 [])}")

    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}`);

    using Anthropic.Models.Beta;
using Anthropic.Models.Beta.Messages;

AnthropicClient client = new();

var response = await client.Beta.Messages.Create(
    new()
    {
        Model = "claude-fable-5-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}");

    client := anthropic.NewClient()

response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
	Model:     "claude-fable-5-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))

    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;

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

    MessageCreateParams params = MessageCreateParams.builder()
        .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));
}

    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;

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

    토큰 계산 엔드포인트도 같은 검사를 실행해요. 응답 형태와 스트리밍 배치는 보존되지 않는 블록에 대한 제어(베타)를 참고하세요.

    이후 생각 블록을 무효화하는 패턴과 대신 할 일:

    • 이전 턴 편집, 재정렬, 제거. 여기에는 오래된 도구 결과 삭제, 대화록 중간에서 턴 잘라내기, 요약 뒤에 최근 턴과 생각 블록을 그대로 보관하는 클라이언트 쪽 컴팩션(몇 턴 뒤에 요약을 교체하는 백그라운드 컴팩션 포함)이 있어요. 대신 서버 쪽 컴팩션이나 컨텍스트 편집(오래된 도구 결과용 도구 결과 지우기), 또는 서버에서 컨텍스트 다듬기의 클라이언트 쪽 컴팩션 형태 중 하나를 쓰세요.
    • 지속하지 않는 콘텐츠 주입, 예를 들어 tool_result 블록 뒤에 붙였다가 다음 요청에서 제거하는 턴별 알림. 대신 알림을 턴 범위 시스템 메시지로 보내고 이력에 남겨두세요.
    • 같은 대화의 요청 사이에 최상위 system 프롬프트나 tools 배열 재구축, 예를 들어 현재 날짜를 갱신하거나 도구를 추가·제거하려고 할 때. 대신 새 지침("The current date is 2026-09-14.")이나 tool_addition·tool_removal 블록을 담은 mid-conversation system message를 추가하세요. 시작 시 tools에 선언되지 않은 도구는 tool_addition 블록 안에서 정의할 수 있어요(베타 헤더 inline-tools-2026-09-15).
    • 나중 요청에서 다른 바이트를 제공하는 이미지·문서 URL. 검사는 URL 문자열이 아니라 바이트를 다루므로 같은 파일의 회전 서명 URL은 괜찮아요. 턴에 걸쳐 참조하는 콘텐츠는 Files API로 한 번 업로드하고 file_id를 보내거나 base64로 보내세요.

    각 대체안은 이전 턴을 바이트 단위로 동일하게 유지하고 이력, system 프롬프트, tools 배열을 편집할 때 잃게 될 프롬프트 캐시 히트도 보존해요.

    계속 동작하는 패턴:

    • 추가 전용 이력: 턴을 추가하고 이전 턴을 받은 그대로·보낸 그대로 다시 전달(추가된 role: "system" 메시지 포함).
    • 이전 어시스턴트 턴에서 가장 오래된 것부터 생각 블록 제거.
    • system, tools, messages 밖의 effort, max_tokens 등 요청 파라미터 변경과 cache_control 마커 추가·이동.
    • 서버 쪽 컴팩션과 컨텍스트 편집(생각 블록 지우기 포함). 이들은 편집으로 간주되지 않아요. 검사가 보낸 그대로의 대화를 비교하거든요.

    기존 통합을 확인하려면:

    1. 정상 턴 몇 개에 걸쳐 보내는 정확한 요청 본문을 캡처하세요. 제품에 컴팩션이나 도구 변경이 있다면 그것도 포함해요. 연속된 요청 쌍마다 system 프롬프트, tools 배열, messages의 공유 프리픽스를 비교하세요. 새로 추가된 턴까지는 바이트 단위로 동일해야 해요. 예상되는 예외는 온디맨드 컴팩션의 서명된 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 항목을 모니터링하세요.

    컴팩션 경계처럼 생각 블록을 한 번 제거하는 건 영향이 작아요. 매번 요청에서 이전 생각을 무효화하는 통합은 매번 프롬프트 캐시를 다시 시작하므로 작업당 비용이 올라갈 수 있어요(대화 이력을 추가 전용으로 유지 참고).

동작 변경 (Behavior changes)

  1. 긴 에이전트 루프에서 병렬 도구 호출 감소: 다음 독립 읽기가 작업에 의해 암시되는 장기 실행 루프(커스텀 코딩 에이전트, bash·에디터 하네스, 컴퓨터 사용)에서 Claude Fable 5.1은 턴당 하나의 도구 호출만 발행할 수 있어요. 추가 턴마다 토큰, 왕복, 벽시계 시간이 들죠. 각 사용자 메시지 뒤에 한 문장 배치 지침을 턴 범위 시스템 메시지(clear_at: "next_user_message", 베타)로 추가하거나, 베타 없이 tool_result 블록 뒤 텍스트 블록으로 추가하고 나중 요청에서는 이전 복사본을 이력에 남겨두세요. 에이전트 루프에서 독립 도구 호출 배치 참고.

  2. 도구 호출 사이 진행 메시지 감소: Claude Fable 5.1은 Claude Fable 5보다 긴 도구 시퀀스 중 상태 업데이트를 덜 쓰고, 에이전트 코딩 요약도 더 짧아요. 인터페이스가 그 업데이트를 렌더링한다면 thinking.display를 "updates"(베타) 또는 "summarized"로 설정하고 명시적으로 프롬프트하세요. 도구 호출 사이 진행 업데이트와 사용자 대상 진행 업데이트 요청 참고.

  3. 낮은 effort에서 검색·검색 호출 감소: low effort에서 Claude Fable 5.1은 Claude Fable 5보다 검색·검색 도구를 호출하는 대신 메모리에서 답할 때가 많아요. 제품이 낮은 effort에서 검색에 의존한다면 그 요청에 대해 effort를 올리거나 언제 검색할지 모델에 지시하세요. 낮은 effort에서 검색 트리거 참고.

API 통합에 영향이 없는 산문 밀도, 채팅 서식, 요약 인용, 파일 편집 차이는 Claude Fable 5에서 변경된 점을 참고하세요.

이 변경들은 필수가 아니지만, 각각 비용·지연을 낮추거나 실패 모드를 없애줘요:

  1. 대화 중간에 effort 변경(베타): Claude Fable 5에서는 output_config.effort가 요청 수준이고, 요청 사이에 변경하면 이전 턴의 캐시된 프리픽스가 버려져요. claude-fable-5-1에서는 output_config만 담은 role: "system" 메시지가 프롬프트 캐시를 무효화하지 않고 어려운 단계의 effort를 올리거나 일상 단계에서 내려요:

    ```bash cURL # Effort-only system message: the new level takes effect from the next user turn. curl https://api.anthropic.com/v1/messages \ -H "x-api-key: $ANTHR...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."} ] }' ``` 
    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-only system message: the new level takes effect from the next user turn.
  - role: system
    content: []
    output_config:
      effort: low
  - role: user
    content: Summarize the plan in one sentence.
YAML

    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-only system message: the new level takes effect from the next user turn.
        {"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)

    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-only system message: the new level takes effect from the next user turn.
    { 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);
  }
}

    using Anthropic.Models.Beta;
using Anthropic.Models.Beta.Messages;

AnthropicClient client = new();

var response = await client.Beta.Messages.Create(new MessageCreateParams
{
    Model = "claude-fable-5-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-only system message: the new level takes effect from the next user turn.
        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);
    }
}

    client := anthropic.NewClient()

response, err := client.Beta.Messages.New(context.Background(), anthropic.BetaMessageNewParams{
	Model:     "claude-fable-5-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-only system message: the new level takes effect from the next user turn.
		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)
	}
}

    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;

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

    MessageCreateParams params = MessageCreateParams.builder()
        .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-only system message: the new level takes effect from the next user turn.
        .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()));
}

    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-only system message: the new level takes effect from the next user turn.
        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;
    }
}

    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-only system message: the new level takes effect from the next user turn.
    {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

    값은 다음 사용자 턴과, 다른 role: "system" 메시지가 변경할 때까지의 모든 이후 턴에 적용돼요. 명명된 수준만 허용되고(low, medium, high, xhigh, max), mid-conversation-output-config-2026-07-01 베타 헤더가 필요해요. 메시지별 effort 참고.

  2. 지침과 도구를 mid-conversation system message로 변경: 세션 중간에 지침이나 도구를 바꾸려면 role: "system" 메시지를 추가하세요. 도구 변경은 tool_addition·tool_removal 블록으로 해요(베타 헤더 mid-conversation-tool-changes-2026-07-01, 전체 도구 세트는 세션 시작 시 tools에 선언). inline-tools-2026-09-15 베타 헤더를 쓰면 tool_addition 블록이 도구의 전체 정의를 담을 수 있어서 세션 시작 시 모르는 도구도 tools에 있을 필요가 없어요. 이렇게 하면 이전 턴의 프롬프트 캐시 히트를 보존하고 대화 이력을 추가 전용으로 유지해요. 특정 도구가 현재 턴에서 실행돼야 할 때 강제 tool_choice를 대체하는 것도 같은 메시지가 해요(파괴적 변경 참고). 한 턴에만 적용되는 알림은 별도의 텍스트 전용 role: "system" 메시지로 clear_at: "next_user_message"를 붙여 보내고(턴 범위 시스템 메시지, 베타 헤더 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의 생각 블록을 받지 않아요. 재시도를 직접 만든다면 폴백 크레딧이 Claude Fable 5와 같은 조건으로 적용돼요. Refusals and fallback 참고.

  4. high effort에서 시작하고 스윕: effort 파라미터 기본값은 high이고, 다섯 수준 모두 지원돼요. Claude Fable 5 지침을 유지하세요: 대부분의 작업에 high, 비용 통제로 테스트할 가치가 있는 medium. Claude Fable 5.1이 Claude Fable 5보다 얻는 이득은 xhigh와 max에서 가장 크지만, 그 수준은 생각 시간과 첫 응답까지의 시간도 늘리므로 가장 성능 민감한 작업과 평가에서 이득을 보여주는 곳에만 올리세요. Claude Fable 5에 맞춘 설정을 이어받지 말고 자체 평가에서 새로 스윕하세요. Claude Fable 5.1 권장 effort 수준 참고.

  5. 서버에서 컨텍스트를 다듬거나, 오래된 생각을 담지 않는 형태로 컴팩트하세요: 코드가 클라이언트에서 오래된 턴을 자르거나 요약한다면 가장 간단한 수정은 그 작업을 서버 쪽 컴팩션이나 컨텍스트 편집으로 옮기는 거예요. 이력 검사가 보낸 그대로의 대화를 비교하므로 둘 다 편집으로 간주되지 않고, 제거한 것 때문에 이후 생각 블록이 무효화되지 않아요. 컴팩션의 instructions 파라미터는 자체 요약 프롬프트를 받아요. 요약 뒤에 최근 턴을 그대로 보관하거나, 대화가 계속되는 동안 백그라운드에서 요약한다면 클라이언트가 쓴 요약 대신 온디맨드 컴팩션(베타 헤더 compact-2026-09-04)을 사용하세요. API가 요약하는 메시지 자리에 두는 서명된 요약 블록을 써요. 보관하는 턴의 생각 블록은 컴팩션과 보존된 생각의 조건 아래 유효하게 유지될 수 있어요. 컴팩션을 클라이언트에 유지한다면 세 가지 형태 중 하나를 고르세요:

    • 단순 컴팩션(권장): 전체 이력을 하나의 요약 메시지와 새 사용자 턴으로 대체하고 다른 것을 재생하지 않아요. 생각 블록이 이월되지 않으므로 실패할 게 없어요. 클로드 모델은 이 방식으로 장기 과제에 학습됐고, 대부분의 워크로드에서 더 정교한 방식과 비슷하게 수행돼요.
    • 꼬리 유지 컴팩션(Keep-tail): 요약 뒤에 가장 최근 턴을 그대로 보관한다면 그 턴에서 thinking과 redacted_thinking 블록을 제거하거나(텍스트와 도구 호출은 유지 가능), prefix_mismatch_behavior: "drop_block"을 설정하세요. 그 생각은 전체 이력에 대해 생성됐고, 그렇지 않으면 요약 뒤에서 실패하거든요.
    • 백그라운드 컴팩션: 요약을 중요 경로 밖에서 만들고 나중에 교체한다면, 그 사이 만들어진 모든 턴은 교체 이전의 생각을 담아요. 교체 전에 생성된 생각 블록을 여전히 담은 모든 요청에 "drop_block"을 보내거나(또는 직접 제거하세요. 교체 후 첫 응답의 input_transformations가 정확히 어느 것인지 목록으로 알려줘요), 동기적으로 컴팩트하세요.

    대화록 중간에서 개별 턴을 잘라내지 마세요. 이후의 모든 생각 블록이 무효화되고 어떤 클라이언트 쪽 형태로도 피할 수 없어요. 하려던 지침 변경에는 mid-conversation system message를, 선택적 제거에는 서버 쪽 컨텍스트 편집을 쓰세요. 컴팩션 블록 다시 전달 참고.

마이그레이션 체크리스트

  • 모델 이름을 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 턴에, 또는 애플리케이션이 호출을 요구할 때는 mid-conversation 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 배열을 직접 만든다면 이전 턴을 편집하는지 확인하세요: 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 role: "system" 메시지(베타)로 옮기세요.
  • stop_reason: "refusal"을 처리하고 stop_details.category를 읽으세요. fallbacks: "default"(베타)를 고려하세요.
  • 새 스윕으로 effort를 high에서 시작해 재평가하고, 자체 워크로드에서 비용과 지연 시간을 다시 기준 삼으세요. 토크나이저는 동일해요. 프롬프트 캐시 읽기가 Claude Fable 5 요율의 4분의 1이에요.

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

Claude Fable 5.1은 Claude Opus 5와 같은 Messages API와 도구 사용 패턴을 써요. 기본 1M 토큰 컨텍스트 윈도우, 128k 최대 출력 토큰, 512-토큰 프롬프트 캐싱 최소, mid-conversation system message 지원을 유지해요. 프리필 제한, 샘플링 파라미터 제한, thinking.display의 "omitted" 기본값도 이어져요. Claude Fable 5에서 Claude Fable 5.1로 마이그레이션의 모든 내용에 더해 다음을 적용하세요.

모델 이름 업데이트

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

# Or, for the Project Glasswing model with the same capabilities:
model = "claude-mythos-5-1"  # After

달라진 점

  1. 생각을 더 이상 비활성화할 수 없어요: Claude Opus 5는 high 이하의 effort 수준에서 thinking: {type: "disabled"}를 받아요. claude-fable-5-1과 claude-mythos-5-1에서는 적응형 생각이 항상 켜져 있고, 어떤 effort 수준에서도 thinking: {type: "disabled"}는 400 오류를 반환해요. 필드를 제거하고, 더 낮은 effort 수준으로 토큰 지출을 통제하고, 생각을 끈 채 돌렸던 워크로드는 max_tokens를 다시 검토하세요.

  2. 강제 도구 선택이 지원되지 않아요: Claude Opus 5는 tool_choice any와 tool을 받아요. claude-fable-5-1은 400 오류를 반환해요. 파괴적 변경 참고.

  3. 모델 간 생각 보존: Claude Fable 5.1은 Claude Opus 5의 생각 블록을 읽어요. claude-opus-5에서 claude-fable-5-1로 옮겨오는 대화는 추론을 유지하죠. Claude Opus 5는 Claude Fable 5.1의 블록을 읽지 못해요. Claude Fable 5.1의 블록은 이전 턴이 바뀌면 유효하지 않게 돼요: 코드가 요청 사이에 이전 메시지를 편집하거나, system·tools를 재구축하거나, 클라이언트에서 컴팩트한다면 Claude Opus 5는 반대하지 않았지만 claude-fable-5-1은 이후의 모든 생각 블록을 거부하거나 버려요. 트래픽을 전환하기 전에 그 섹션의 3단계 검사를 실행하세요. 파괴적 변경 참고.

  4. 도구 호출 사이 텍스트는 thinking 블록으로 반환돼요: Claude Opus 5에서는 모델이 도구 호출 사이에 쓰는 텍스트가 text 블록으로 돌아와요. claude-fable-5-1에서는 Claude Fable 5와 마찬가지로 그 서술이 각 도구 호출 앞에 하나씩 진행 업데이트 thinking 블록으로 돌아와요. 기본 thinking.display "omitted"에서는 읽을 수 있는 텍스트가 없어요. 인터페이스가 그 서술을 렌더링한다면 display: "updates"(베타)를 설정해 추론은 숨기고 진행 업데이트를 텍스트로 받거나, "summarized"로 둘 다 받으세요. 그런 다음 tool_use 블록 사이의 비어 있지 않은 thinking 블록을 렌더링하세요. 도구 호출 사이 진행 업데이트 참고.

  5. 안전성 분류기와 폴백 라우팅: Claude Fable 5.1은 Claude Fable 5와 같은 stop_details 범주를 다루는 안전성 분류기를 실행해요. 이는 Claude Opus 5의 사이버보안 전용 분류기보다 더 넓은 집합이에요. stop_details.category가 "cyber" 너머의 값, 예를 들어 "bio"나 "reasoning_extraction"을 가질 것으로 예상하세요. 전체 집합은 거절 범주 표를 참고하세요. fallbacks 구성과 허용 대상은 거절에는 fallbacks: "default" 사용을 참고하세요.

  6. 가격: 백만 입력 토큰당 $10, 백만 출력 토큰당 $50로, Claude Opus 5의 $5 / $25와 비교돼요. 프롬프트 캐시 읽기는 백만 토큰당 $0.25로, Claude Opus 5 요율의 절반이에요. Claude 가격 참고.

  7. 데이터 보존: Claude Fable 5.1과 Claude Mythos 5.1은 30일 데이터 보존이 필요하고, Anthropic이 명시적으로 승인하지 않는 한 제로 데이터 보존(ZDR) 체제에서는 사용할 수 없으며, Covered Models로 지정됐어요. Claude Opus 5는 ZDR에서 제공돼요. 모델별 데이터 보존 요건 참고.

마이그레이션 체크리스트

  • 조직에 제로 데이터 보존(ZDR) 체제가 있다면 먼저 자격을 확인하세요. 이 모델은 Anthropic이 명시적으로 승인하지 않는 한 ZDR에서 사용할 수 없어요. 모델별 데이터 보존 요건 참고.
  • 모델 이름을 claude-opus-5에서 claude-fable-5-1(또는 claude-mythos-5-1)로 업데이트.
  • thinking: {type: "disabled"} 설정 제거. claude-fable-5-1에서 400 오류를 반환해요. 더 낮은 effort 수준으로 토큰 지출을 통제하고 max_tokens를 다시 검토하세요.
  • 강제 tool_choice(any 또는 tool)를 auto + 명시적 지침(user 턴 또는 mid-conversation system message) + strict: true 도구, 또는 JSON 출력으로 교체.
  • 인터페이스가 도구 호출 사이 텍스트를 렌더링한다면 display: "updates"(베타) 또는 "summarized"를 설정하고 비어 있지 않은 thinking 블록을 렌더링하세요.
  • Claude Fable 5 체크리스트의 보존 생각, 이력 편집, 동작, effort, 폴백 항목을 적용하세요.
  • 자체 워크로드에서 비용을 다시 기준 삼으세요. 토크나이저는 동일해요. 토큰당 가격이 달라요.

Claude Opus 4.8 또는 그 이전에서 Claude Fable 5.1로 마이그레이션

먼저 Claude Opus 4.8에서의 API 수준 변경에 대해 Claude Opus 4.8에서 Claude Mythos 5와 Claude Fable 5로 마이그레이션을 적용하세요. 거기서 적응형 생각, 생각 출력, 거절, effort, 캐싱 최소, 가격, 데이터 보존을 다뤄요. 그런 다음 Claude Fable 5에서 Claude Fable 5.1로 마이그레이션의 나머지 델타를 적용하세요. Claude Opus 4.7 이하라면 해당하는 Migrating to Claude Opus 5.5 섹션부터 시작하세요.

모델 이름 업데이트

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

# Or, for the Project Glasswing model with the same capabilities:
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 필드 없는 요청은 적응형 생각으로 실행돼요.
  • 강제 tool_choice(any 또는 tool)를 auto + 명시적 지침(user 턴 또는 mid-conversation system message) + strict: true 도구, 또는 JSON 출력으로 교체.
  • thinking 블록을 그대로 다시 전달하고 그 텍스트를 표시 전용으로 취급하세요. Claude Fable 5.1은 Claude Opus 4.8의 생각 블록을 읽어요. claude-fable-5-1로 옮겨오는 대화는 이전 추론을 유지하죠. Claude Opus 4.8은 Claude Fable 5.1의 블록을 읽지 못해요.
  • 코드가 messages 배열을 직접 만든다면 이전 턴을 편집하는지 확인하세요. Claude Opus 4.8 이하용으로 작성된 통합은 종종 오래된 턴을 자르거나, 이전 메시지를 제거·재구성하거나, 요청마다 system 프롬프트를 새로고침하며, Claude Opus 4.8은 절대 반대하지 않았어요. claude-fable-5-1에서는 그 각각이 이후 생각 블록을 무효화해요.
  • stop_reason: "refusal"을 처리하고, stop_details.category를 읽고, fallbacks: "default"(베타)를 고려하세요.
  • Claude Fable 5 체크리스트의 보존 생각, 이력 편집, 동작, 메시지별 effort, 진행 업데이트 항목을 적용하세요.
  • effort(high에서 시작)를 재평가하고, 512-토큰 캐싱 최소 부근의 프롬프트를 검토하고, 비용·지연을 다시 기준 삼으세요. 토큰당 가격이 달라요.

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

Claude Mythos 5.1은 Claude Fable 5.1의 접근 제한 대응 모델이에요. 모델 ID를 바꾸기 전에 Anthropic 계정 팀과 조직의 접근을 확인하세요.

API 수준 델타는 Claude Fable 5에서 Claude Fable 5.1로 마이그레이션과 일치해요: 강제 도구 선택은 400 오류를 반환하고, 생각 블록은 그것을 만든 모델 또는 더 새로운 모델에 대해서만 보존돼요(Claude Mythos 5.1은 Claude Mythos 5의 블록을 읽지만 그 반대는 아님). Claude Fable 5.1과 달리 Claude Mythos 5.1은 대화 검사를 실행하지 않으므로 이전 턴을 편집해도 생각 블록이 무효화되지 않지만, 여전히 프롬프트 캐시를 다시 시작해요.

모델 이름 업데이트

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

마이그레이션 체크리스트

  • 모델 이름을 claude-mythos-5에서 claude-mythos-5-1로 업데이트.
  • 강제 tool_choice(any 또는 tool)를 auto + 명시적 지침(user 턴 또는 mid-conversation system message) + strict: true 도구, 또는 JSON 출력으로 교체.
  • 응답 콘텐츠 전에 stop_reason: "refusal"을 처리하고 stop_details.category를 읽으세요. Refusals and fallback 참고.
  • 빈 블록을 포함해 매 턴 thinking 블록을 그대로 다시 전달하세요.
  • 코드가 messages 배열을 직접 만든다면 대화 이력을 추가 전용으로 유지해 프롬프트 캐시를 따뜻하게 하세요. Claude Mythos 5.1은 대화 검사를 실행하지 않으므로 편집이 생각 블록을 무효화하지 않아요.
  • Claude Fable 5 섹션의 동작·권장 변경을 적용하세요. 단, Claude Mythos 5.1에 적용되지 않는 이력 편집 항목은 제외.
  • 새 스윕으로 effort를 재평가하고 비용·지연을 다시 기준 삼으세요. 프롬프트 캐시 읽기가 Claude Mythos 5 요율의 4분의 1이에요.

더 알아보기 (Learn more)