Guia da API do Claude Fable 5

Para chamar o Claude Fable 5, usa o ID do modelo claude-fable-5 e liga o thinking com thinking: {"type": "adaptive"}. É esse o caminho feliz por inteiro. As armadilhas são tudo o que está à volta: parâmetros de amostragem que antes funcionavam agora devolvem um 400, e um parâmetro que é bem aceite no Opus 4.8 vai partir o teu pedido no Fable 5.

O Fable 5 foi lançado a 9 de junho de 2026 como o modelo mais capaz da Anthropic, um patamar acima do Opus. Tem uma janela de contexto de 1M e um teto de saída de 128K, e custa $10 por milhão de tokens de entrada e $50 por milhão de tokens de saída. Isso é o dobro do Opus 4.8, por isso é um modelo que apontas a problemas difíceis, não a trabalho de rotina.

Este é o guia prático. Como fazer a chamada, que 400s e porquê, como afinar o esforço e os orçamentos, como muda o caching, e o único passo do Bedrock que te vai bloquear se o saltares.

A Chamada Mínima Funcional

Começa aqui. Esta é a chamada mais pequena que funciona, em Python com o SDK oficial da Anthropic. O cliente lê a tua ANTHROPIC_API_KEY do ambiente, escolhe o modelo, liga o thinking adaptativo e define o esforço como xhigh porque é a definição certa para programação e trabalho agêntico.

import anthropic

client = anthropic.Anthropic()

message = client.messages.create(
    model="claude-fable-5",
    max_tokens=16000,
    thinking={"type": "adaptive"},
    output_config={"effort": "xhigh"},
    messages=[{"role": "user", "content": "Explain what a row-level security policy does."}],
)

print(message.content[0].text)

O ID do modelo é a string exata claude-fable-5. Não há sufixo de data. Se acrescentares um, recebes um 404.

Se não queres thinking de todo, removes a linha thinking. Não a defines como desativada. Essa distinção é a maior cilada deste modelo, e tem a sua própria secção mais abaixo.

As Armadilhas dos 400

O Fable 5 deixou cair um conjunto de parâmetros que os modelos anteriores aceitavam. Enviar qualquer um deles devolve um HTTP 400 (invalid_request_error). Aqui fica a matriz completa do que parte e como resolver.

Um prefill significa que o teu array messages termina com um turno role: "assistant" que começaste a escrever para o modelo continuar. Esse padrão devolve um 400 no Fable 5. Se o usavas para forçar JSON, muda para structured outputs, mostrados mais à frente.

Porque é que o Thinking Desativado Devolve um 400

Esta é a armadilha que parte os upgrades "diretos", por isso vale a pena ser preciso.

No Opus 4.8 e no Opus 4.7, duas coisas correm um pedido sem thinking: omitir o campo thinking, ou definir thinking: {"type": "disabled"}. São intermutáveis.

No Fable 5 não são. Um thinking: {"type": "disabled"} explícito devolve um 400. Só omitir o campo é que corre sem thinking. Por isso código que funcionava ontem no Opus e definia explicitamente disabled vai começar a dar erro no momento em que trocas o ID do modelo.

Este snippet mostra a versão partida e a versão funcional lado a lado. A primeira dá 400 no Fable 5. A segunda corre sem thinking, que era o que a primeira estava a tentar fazer.

# WRONG on Fable 5 - returns a 400
message = client.messages.create(
    model="claude-fable-5",
    max_tokens=4096,
    thinking={"type": "disabled"},
    messages=[{"role": "user", "content": "Classify this ticket as bug or feature."}],
)

# RIGHT - omit the thinking param to run without thinking
message = client.messages.create(
    model="claude-fable-5",
    max_tokens=4096,
    messages=[{"role": "user", "content": "Classify this ticket as bug or feature."}],
)

A solução é uma eliminação, não uma mudança de valor. Remove a linha. Não tentes encontrar um valor diferente para type.

Mais uma mudança de comportamento que convém conhecer: com o thinking desligado, o Fable 5 às vezes escreve raciocínio mais longo dentro da resposta visível. Se precisas de respostas curtas e rápidas, a solução mais limpa é deixar o thinking adaptativo ligado, o que mantém o raciocínio fora do texto final. Se tens mesmo de correr sem thinking, adiciona uma instrução de sistema que diga ao modelo para responder só com a resposta final.

Afinação do Esforço

O esforço controla com que intensidade o modelo pensa e age. Defines-lo dentro de output_config, não ao nível de topo. O padrão é high.

Esta chamada define o esforço explicitamente. Valores mais baixos significam menos chamadas de ferramentas, menos preâmbulo e saída mais sucinta. Valores mais altos significam raciocínio mais profundo e mais minúcia, a um custo de tokens mais alto.

message = client.messages.create(
    model="claude-fable-5",
    max_tokens=16000,
    thinking={"type": "adaptive"},
    output_config={"effort": "high"},  # low | medium | high | xhigh | max
    messages=[{"role": "user", "content": "Refactor this module for testability."}],
)

Aqui fica como escolher um nível.

O esforço importa mais no Fable 5 do que em qualquer Opus anterior. Se estás a migrar, reafina-o por rota em vez de assumir que a definição antiga ainda serve. Para tarefas agênticas de longa duração, dá a especificação completa da tarefa logo à partida num turno e corre em high ou xhigh. Em xhigh ou max, dá ao max_tokens margem a sério (começa em 64K) para o modelo ter espaço para pensar e agir ao longo das chamadas de ferramentas.

Orçamentos de Tarefa

Um orçamento de tarefa diz ao modelo quantos tokens tem para um loop agêntico inteiro, contando o thinking, as chamadas de ferramentas e a saída final. O modelo vê uma contagem decrescente e regula o ritmo, a fechar de forma graciosa à medida que o orçamento se esgota.

Isto é diferente do max_tokens. O max_tokens é um teto rígido que o modelo não vê. Um orçamento de tarefa é uma sugestão da qual o modelo tem consciência e em torno da qual planeia. Usa o orçamento para o modelo se auto-moderar, e mantém o max_tokens como o limite imposto.

Os orçamentos de tarefa estão em beta, por isso passas um header beta e chamas através do namespace beta. O orçamento mínimo é de 20.000 tokens.

message = client.beta.messages.create(
    betas=["task-budgets-2026-03-13"],
    model="claude-fable-5",
    max_tokens=64000,
    thinking={"type": "adaptive"},
    output_config={
        "effort": "high",
        "task_budget": {"type": "tokens", "total": 128000},
    },
    messages=[{"role": "user", "content": "Migrate the auth module off the deprecated API."}],
)

Define um orçamento generoso para execuções agênticas abertas e um mais apertado para tarefas sensíveis à latência. Se o orçamento for pequeno demais para o trabalho, o modelo termina de forma menos minuciosa e diz-te que o orçamento foi a restrição.

Notas sobre Caching

O prompt caching funciona da mesma forma que em todos os modelos Claude: é uma correspondência de prefixo, por isso qualquer alteração de um byte em qualquer ponto do prefixo em cache invalida tudo o que vem depois. Mantém o conteúdo estável primeiro e põe o conteúdo volátil (timestamps, IDs de pedido, a pergunta por pedido) depois do teu último breakpoint.

Dois números são diferentes no Fable 5. O prefixo mínimo em cache é de 2048 tokens, abaixo dos 4096 no Opus 4.8. Por isso um prompt de 3K tokens que falhava silenciosamente o caching no Opus 4.8 vai entrar em cache no Fable 5. As leituras de cache custam cerca de 0,1x da taxa base de entrada, e as escritas custam cerca de 1,25x com a janela padrão de cinco minutos.

Esta chamada faz cache de um system prompt grande e estável. O marcador cache_control vai no bloco de sistema. A pergunta por pedido no turno do utilizador fica sem cache, que é o que queres.

message = client.messages.create(
    model="claude-fable-5",
    max_tokens=16000,
    system=[
        {
            "type": "text",
            "text": LARGE_STABLE_SYSTEM_PROMPT,
            "cache_control": {"type": "ephemeral"},
        }
    ],
    messages=[{"role": "user", "content": "Summarize the key risks in section 4."}],
)

Para confirmar um acerto de cache, lê message.usage.cache_read_input_tokens. Se ficar a zero ao longo de pedidos repetidos com o mesmo prefixo, alguma coisa no prefixo está a mudar a cada chamada. Os culpados habituais são um timestamp no system prompt, JSON serializado sem chaves ordenadas, ou um conjunto de ferramentas que varia por pedido.

Streaming para Saídas Grandes

O Fable 5 consegue produzir até 128K tokens de saída, mas o SDK vai atingir um timeout de HTTP num pedido não-streaming que peça uma saída grande. A regra prática: faz streaming de tudo acima de cerca de 16K max_tokens.

Isto faz streaming da resposta e recolhe a mensagem final no fim, por isso ficas com os tokens ao vivo e com um objeto de resultado completo.

with client.messages.stream(
    model="claude-fable-5",
    max_tokens=64000,
    thinking={"type": "adaptive"},
    output_config={"effort": "xhigh"},
    messages=[{"role": "user", "content": "Write the full migration plan."}],
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)
    final = stream.get_final_message()

Uma nota de streaming específica do Fable 5: os blocos de thinking fazem streaming, mas o seu texto está vazio por defeito. Se mostras o raciocínio aos utilizadores, esse padrão parece uma longa pausa silenciosa antes de a resposta começar. Para repor o progresso visível, pede thinking resumido com thinking={"type": "adaptive", "display": "summarized"}.

Fable 5 no Amazon Bedrock

O Bedrock tem um passo que vai bloquear todos os pedidos até o fazeres: tens de optar pela partilha de dados antes de poderes invocar o Fable 5. Não há UI na consola para isto no lançamento, por isso é fácil de saltar e o erro que produz não é óbvio.

Optas através da Data Retention API definindo o modo como provider_data_share. Esta chamada curl fá-lo para o motor bedrock-mantle, que é o que usas com a Anthropic Messages API. Corre-a uma vez por conta antes da tua primeira chamada ao modelo.

curl -X PUT https://bedrock-mantle.us-east-1.api.aws/v1/data_retention \
  -H "x-api-key: <your-bedrock-api-key>" \
  -H "Content-Type: application/json" \
  -d '{ "mode": "provider_data_share" }'

Se em vez disso chamares a Converse ou Invoke API no motor bedrock-runtime, o endpoint e a autenticação são diferentes. Esta é a opção equivalente para esse motor.

curl -X PUT https://bedrock.us-east-1.amazonaws.com/data-retention \
  -H "Authorization: Bearer <your_bearer_token>" \
  -H "Content-Type: application/json" \
  -d '{ "mode": "provider_data_share" }'

Optar significa que a Anthropic retém as tuas entradas e saídas durante 30 dias. Os dados não são usados para treino, o acesso humano a eles é registado, e são apagados ao fim de 30 dias. É um requisito para todo o tráfego de classe Mythos, e assim que optas os teus dados saem da fronteira de segurança da AWS. Decide se isso é aceitável para a tua carga de trabalho antes de o ativares.

Depois de optares, aponta o SDK da Anthropic ao endpoint do Bedrock. O ID do modelo na Messages API é anthropic.claude-fable-5, com o prefixo anthropic.. Esta chamada Python corre contra o bedrock-mantle.

import anthropic

client = anthropic.Anthropic(
    base_url="https://bedrock-mantle.us-east-1.api.aws/anthropic",
    api_key="<your-bedrock-api-key>",
)

message = client.messages.create(
    model="anthropic.claude-fable-5",
    max_tokens=4096,
    messages=[{"role": "user", "content": "Design a multi-region architecture for 100k requests per second."}],
)

print(message.content[0].text)

Se preferes a Converse API através do boto3, o ID do modelo muda para global.anthropic.claude-fable-5 e chamas o bedrock-runtime. Este é o mesmo pedido nessa forma.

import boto3

bedrock_runtime = boto3.client("bedrock-runtime", region_name="us-east-1")

response = bedrock_runtime.converse(
    modelId="global.anthropic.claude-fable-5",
    messages=[{"role": "user", "content": [{"text": "Design a multi-region architecture for 100k RPS."}]}],
    inferenceConfig={"maxTokens": 4096},
)

print(response["output"]["message"]["content"][0]["text"])

No lançamento, o Bedrock serve o Fable 5 em US East (N. Virginia) e Europa (Estocolmo). O acesso expande-se gradualmente pelas contas AWS; se a tua ainda não estiver ativada, contacta o AWS Support para acelerar.

Uma Surpresa de Faturação a Prever

O Fable 5 vem com salvaguardas conservadoras. As perguntas sobre temas de cyber, bio, química e saúde recorrem antes a uma resposta do Opus 4.8, e o utilizador é avisado. Isto dispara em menos de 5% das sessões em média.

A parte que afeta o teu código é a faturação. As respostas de fallback são cobradas a taxas de Opus, não a taxas de Fable. No Bedrock, se um pedido for bloqueado a meio da conversa, os tokens iniciais faturam a taxas de Fable e o resto a taxas de Opus. Por isso algumas respostas vão ser mais baratas do que o teu seletor de modelos dá a entender e vão trazer uma nota a dizer que foram respondidas pelo Opus 4.8. Constrói o teu modelo de custos para o prever em vez de tratares cada chamada de Fable como uma cobrança de Fable fixa.

Migrar do Opus 4.8 ou 4.7

Se o teu código Opus existente já está limpo, mudar para o Fable 5 é uma troca do ID do modelo e nada mais. "Limpo" significa sem parâmetros de amostragem, sem budget_tokens, e sem thinking: {"type": "disabled"} explícito.

Aqui fica a checklist.

• Troca o ID do modelo para claude-fable-5.
• Apaga qualquer thinking: {"type": "disabled"}. Dá 400 no Fable 5. Omite o campo em vez disso.
• Remove temperature, top_p e top_k. Já davam 400 no Opus 4.7 e 4.8, e dão 400 aqui também.
• Substitui budget_tokens por thinking: {"type": "adaptive"}.
• Substitui qualquer prefill no último turno do assistant por output_config: {"format": {...}}.
• Reafina o effort por rota. Pesa mais no Fable 5.
• Define thinking.display como "summarized" se mostras o raciocínio aos utilizadores.
• Refaz a baseline dos teus max_tokens e dashboards de custo, já que o Fable corre ao dobro do preço do Opus.

Se vens do Opus 4.6 ou mais antigo, aplica primeiro a migração completa do thinking adaptativo, e depois os deltas do Fable 5 acima.

A única mudança disruptiva genuinamente nova face ao Opus 4.8 e 4.7 é o 400 do thinking desativado explícito. Tudo o resto nesta lista já se aplicava aos modelos Opus recentes. É por isso que as pessoas chamam ao Fable 5 "quase direto". A palavra que faz o trabalho é "quase".

Perguntas Frequentes

Qual é o ID do modelo Claude Fable 5?

O ID do modelo em primeira mão é a string exata claude-fable-5, sem sufixo de data. No Amazon Bedrock leva um prefixo anthropic.: anthropic.claude-fable-5 na Messages API (bedrock-mantle), e global.anthropic.claude-fable-5 na Converse ou Invoke API (bedrock-runtime).

Porque é que o thinking desativado devolve um 400 no Fable 5?

No Fable 5, um thinking: {"type": "disabled"} explícito não é aceite e devolve um 400. Isto é único do Fable 5; o Opus 4.8 e 4.7 aceitam-no. Para correr um pedido sem thinking, omite o parâmetro thinking por completo em vez de o definires como desativado.

Como uso o Fable 5 no Bedrock?

Primeiro opta pela partilha de dados definindo o modo da Data Retention API como provider_data_share. Não há UI na consola para isto no lançamento, por isso fá-lo com uma chamada curl ao endpoint de retenção de dados. Depois disso, aponta o SDK da Anthropic ao base URL do Bedrock e usa o ID do modelo anthropic.claude-fable-5, ou usa a Converse API do boto3 com global.anthropic.claude-fable-5.

Quanto custa o Claude Fable 5?

$10 por milhão de tokens de entrada e $50 por milhão de tokens de saída. Isso é o dobro dos $5 e $25 do Opus 4.8. As respostas que atingem as salvaguardas e recorrem ao Opus 4.8 são faturadas a taxas de Opus, por isso algumas chamadas custam menos do que o valor de Fable anunciado.

Como desligo o thinking no Fable 5 sem um erro?

Remove o campo thinking do teu pedido. Um pedido sem campo thinking corre sem thinking. Não definas thinking: {"type": "disabled"}, que devolve um 400. Se vires o modelo a escrever raciocínio longo dentro da resposta visível com o thinking desligado, ou deixas o thinking adaptativo ligado ou adicionas uma instrução de sistema para responder só com a resposta final.

O prompt caching muda no Fable 5?

A mecânica é a mesma, mas o prefixo mínimo em cache é mais baixo: 2048 tokens no Fable 5 contra 4096 no Opus 4.8. Por isso um prompt de tamanho médio que não entraria em cache no Opus 4.8 vai entrar no Fable 5. Confirma os acertos com usage.cache_read_input_tokens.

Fontes

• Claude Fable 5 and Claude Mythos 5
• Anthropic Claude Fable 5 on AWS (AWS News Blog)
• Models overview (API docs)
• Model migration guide (API docs)
• Building with extended thinking (API docs)
• Claude Fable 5 model card (Amazon Bedrock)
• Data retention practices for Mythos-class models

Páginas Relacionadas

• Cheatsheet do Opus 4.8
• Modelos do Claude Code
• Claude Mythos e OpenMythos