DEV Community: Lucas

Como Funcionam os Limites de Requisição do Claude Fable 5

Lucas — Thu, 11 Jun 2026 02:57:01 +0000

Se você está desenvolvendo com o modelo mais recente da Anthropic e precisa planejar os limites de taxa do Claude Fable 5, comece por aqui: a Anthropic não lançou um limite separado e exclusivo para o Fable 5 no lançamento. O Fable 5 (claude-fable-5, US$ 10 por milhão de tokens de entrada e US$ 50 por milhão de tokens de saída, lançado em 9 de junho de 2026) usa a API de Mensagens padrão e os limites de taxa por nível da sua organização. Na prática, você deve dimensionar sua aplicação com base no nível de uso da sua conta, não em um número fixo do modelo. Se você ainda está avaliando o modelo, leia também a visão geral do Claude Fable 5.

Experimente o Apidog hoje

TL;DR

O Claude Fable 5 usa os limites de taxa padrão da Anthropic, baseados em níveis:

RPM: requisições por minuto.
ITPM: tokens de entrada por minuto.
OTPM: tokens de saída por minuto.

Esses limites são aplicados por organização e por classe de modelo. Eles aumentam conforme seus gastos cumulativos movem sua conta entre os níveis 1 a 4. Para produção, sempre confirme os números reais no Console da Anthropic e trate erros 429 usando o cabeçalho retry-after.

Como os limites de taxa da Anthropic funcionam

A Anthropic não trabalha com um único “limite global” para toda a API. Ela usa um sistema de níveis de uso. Seu nível define quanto throughput sua organização pode consumir.

Existem dois conceitos relacionados:

Limites de gastos: quanto sua organização pode gastar no mês civil.
Limites de taxa: com que velocidade sua aplicação pode chamar a API.

Este artigo foca nos limites de taxa, mas os dois conceitos estão conectados porque o mesmo sistema de níveis influencia ambos.

Tipos de limite que você precisa monitorar

Para a API de Mensagens, a Anthropic mede os limites em três dimensões.

1. RPM: requisições por minuto

O RPM define quantas chamadas separadas sua organização pode iniciar por minuto.

Exemplo prático: se sua aplicação dispara muitas chamadas pequenas em paralelo, você pode atingir o RPM mesmo com baixo uso de tokens.

2. ITPM: tokens de entrada por minuto

O ITPM mede quantos tokens de entrada você envia por minuto.

Na maioria dos modelos atuais, tokens de entrada lidos do cache de prompt não contam para o ITPM. Isso torna o cache importante quando você reutiliza:

prompts de sistema longos;
definições de ferramentas;
documentos de referência;
instruções fixas de agente.

3. OTPM: tokens de saída por minuto

O OTPM mede quantos tokens o modelo gera por minuto.

Esse limite é avaliado em tempo real enquanto a resposta é produzida. O valor de max_tokens não é cobrado antecipadamente contra o OTPM. Apenas os tokens realmente gerados contam.

Isso significa que:

max_tokens=8192

não consome 8.192 tokens automaticamente. Mas se o modelo gerar uma resposta longa, esses tokens reduzirão seu orçamento de OTPM conforme forem produzidos.

Por que rajadas causam 429 mesmo com média baixa

A Anthropic aplica limites usando um algoritmo de balde de tokens. A capacidade é recarregada continuamente, não apenas no início de cada minuto.

Na prática, um limite como 50 RPM pode se comportar como algo próximo de uma requisição por segundo. Se você enviar 20 chamadas ao mesmo tempo, pode receber 429, mesmo que sua média por minuto pareça aceitável.

Para evitar isso:

distribua chamadas ao longo do tempo;
use filas;
limite concorrência;
leia os cabeçalhos anthropic-ratelimit-*;
aplique backoff quando receber 429.

Limites são por organização e por classe de modelo

Dois detalhes são importantes para implementação.

Primeiro, os limites são definidos no nível da organização, não por chave de API. Todas as chaves da organização compartilham o mesmo pool. Você pode definir limites menores por workspace se quiser isolar ambientes ou times.

Segundo, os limites são aplicados por classe de modelo. O tráfego do Fable 5 usa um balde separado de outras classes, como Opus. Isso permite executar diferentes classes de modelo ao mesmo tempo sem que uma consuma diretamente o limite da outra.

Como os níveis avançam

Os níveis aumentam automaticamente conforme suas compras cumulativas de crédito cruzam os limites publicados pela Anthropic.

A estrutura publicada é:

Nível 1: desbloqueado com compra de crédito de US$ 5.
Nível 2: US$ 40 acumulados.
Nível 3: US$ 200 acumulados.
Nível 4: US$ 400 acumulados.

Cada etapa aumenta os tetos mensais de gasto e os limites de taxa. Você avança quando cruza o limite; não precisa abrir ticket.

Acima do Nível 4, limites maiores normalmente passam por vendas ou faturamento mensal.

Para entender como isso se relaciona ao custo do modelo, veja a análise de preços do Claude Fable 5.

O que isso significa para o Claude Fable 5

O Fable 5 não tem uma estrutura de limite especial. Ele entra na tabela padrão da Anthropic como sua própria classe de modelo.

Então a pergunta correta não é:

“Qual é o limite fixo do Fable 5?”

A pergunta correta é:

“Qual é o nível da minha organização e quais são os limites do Fable 5 nesse nível?”

De acordo com os limites de taxa publicados pela Anthropic, a linha do Fable 5 escala aproximadamente assim:

Nível	RPM	ITPM	OTPM
Nível 1	50	100.000	20.000
Nível 2	1.000	500.000	100.000
Nível 3	2.000	1.500.000	300.000
Nível 4	4.000	4.000.000	800.000

Trate esses números como referência estrutural, não como contrato. A Anthropic pode atualizar tabelas, contas empresariais podem ter arranjos diferentes e o Console da Anthropic é sempre a fonte da verdade.

O limite mais crítico para Fable 5 costuma ser OTPM

O Fable 5 é voltado a tarefas longas, incluindo execuções com muitos tokens e agentes que trabalham por mais tempo.

Nesse tipo de uso, o gargalo geralmente não é RPM. É OTPM.

Exemplo:

você inicia poucos jobs;
cada job gera uma resposta longa;
as respostas são transmitidas por bastante tempo;
o consumo de tokens de saída permanece alto por vários minutos.

Nesse cenário, mesmo com poucas requisições, você pode atingir o OTPM.

Para reduzir risco:

Defina max_tokens com base no tamanho real esperado da resposta.
Use streaming para respostas longas.
Controle concorrência de jobs longos.
Monitore anthropic-ratelimit-output-tokens-remaining.

Se você está conectando o modelo pela primeira vez, o guia da API do Claude Fable 5 mostra o formato da requisição.

Como verificar seus limites reais

Não dimensione produção apenas com base em uma postagem de blog. Verifique os números reais da sua organização.

Você tem duas fontes principais.

1. Console da Anthropic

No Console da Anthropic, verifique:

o nível atual da organização;
os limites de taxa por modelo;
gráficos de uso;
consumo de tokens de entrada;
consumo de tokens de saída;
taxa de acerto de cache.

Use essa tela antes de aumentar tráfego, ativar novos workers ou liberar uma feature para mais usuários.

2. Cabeçalhos de resposta da API

Cada chamada retorna cabeçalhos anthropic-ratelimit-*.

Monitore estes campos:

anthropic-ratelimit-requests-limit
anthropic-ratelimit-requests-remaining

anthropic-ratelimit-input-tokens-limit
anthropic-ratelimit-input-tokens-remaining

anthropic-ratelimit-output-tokens-limit
anthropic-ratelimit-output-tokens-remaining

Também existem cabeçalhos *-reset em formato RFC 3339, indicando quando o balde será totalmente reabastecido.

Exemplo de lógica de monitoramento:

def log_rate_limits(response):
    headers = response.headers

    print("RPM restante:", headers.get("anthropic-ratelimit-requests-remaining"))
    print("ITPM restante:", headers.get("anthropic-ratelimit-input-tokens-remaining"))
    print("OTPM restante:", headers.get("anthropic-ratelimit-output-tokens-remaining"))

Ler esses valores permite que seu cliente desacelere antes de receber 429.

Como lidar com erros 429

Um erro 429 significa que você atingiu um limite de taxa.

A resposta inclui um cabeçalho importante:

retry-after

Esse valor informa quantos segundos você deve aguardar antes de tentar novamente. Se você tentar antes, a nova chamada provavelmente falhará também.

Use as retentativas do SDK

Os SDKs oficiais da Anthropic já fazem retentativas automáticas para respostas 429 e 5xx, com backoff exponencial. Por padrão, são duas tentativas.

Exemplo em Python:

import anthropic

client = anthropic.Anthropic()  # lê ANTHROPIC_API_KEY do ambiente

# Aumente max_retries para cargas em lote mais propensas a 429.
resilient = client.with_options(max_retries=5)

message = resilient.messages.create(
    model="claude-fable-5",
    max_tokens=4096,
    messages=[
        {
            "role": "user",
            "content": "Rascunhe um resumo de lançamento para nosso changelog de junho."
        }
    ],
)

print(message.content[0].text)

Para a maioria das aplicações, isso é suficiente. Evite criar um loop manual de retry se o SDK já cobre seu caso.

Controle manual quando necessário

Se você precisa mostrar estado na UI, registrar métricas específicas ou controlar uma fila, capture a exceção tipada:

import anthropic

client = anthropic.Anthropic()

try:
    message = client.messages.create(
        model="claude-fable-5",
        max_tokens=4096,
        messages=[
            {
                "role": "user",
                "content": "Resuma este relatório de incidente."
            }
        ],
    )

except anthropic.RateLimitError as exc:
    wait_seconds = int(exc.response.headers.get("retry-after", "60"))
    print(
        f"Limite de taxa atingido. "
        f"Aguardando {wait_seconds}s antes de tentar novamente."
    )

Use fila para tráfego em rajadas

Retentativas resolvem falhas temporárias. Para pressão sustentada, use fila.

Um padrão simples:

Receba as requisições do usuário.
Coloque-as em uma fila.
Drene a fila com concorrência controlada.
Ajuste a taxa com base nos cabeçalhos anthropic-ratelimit-*-remaining.
Reagende itens que receberem 429 usando retry-after.

Pseudoestrutura:

while queue.has_items():
    if rate_limit_budget_is_low():
        sleep_until_reset_or_retry_after()
        continue

    job = queue.pop()
    process_fable_5_job(job)

Esse padrão transforma uma sequência de erros 429 em um pipeline mais previsível.

Os mesmos princípios de teste e limitação aparecem ao trabalhar com outras APIs. Os padrões em testar a API do ChatGPT com Apidog também se aplicam ao Claude.

Como aumentar limites ou reduzir consumo

Quando você atinge limites com frequência, há duas estratégias:

Conseguir mais capacidade.
Consumir menos tokens por unidade de trabalho.

1. Aumente seu nível

Como os níveis sobem com compras cumulativas de crédito, uso constante leva sua conta para níveis maiores. Cada etapa aumenta RPM, ITPM e OTPM.

Se você precisa antecipar esse crescimento ou obter limites personalizados, use a página de Limites no Console para falar com vendas. Nível Prioritário e faturamento mensal existem para cargas de trabalho maiores e mais previsíveis.

2. Use Batches para jobs assíncronos

Para tarefas que não exigem baixa latência, use a API de Batches.

Ela processa requisições da API de Mensagens de forma assíncrona, com aproximadamente 50% do custo padrão, e possui um pool separado de limites de taxa.

Use Batches para:

processamento de documentos;
classificação em massa;
geração offline;
análises que podem esperar;
tarefas recorrentes de backoffice.

3. Ative cache de prompt

Se você reutiliza contexto, cache de prompt pode reduzir pressão sobre ITPM.

Bons candidatos:

prompt de sistema longo;
políticas internas;
documentação fixa;
catálogo de ferramentas;
instruções de agente;
documentos de referência usados em várias chamadas.

Depois de ativar, confira no Console se a taxa de acerto de cache está subindo.

4. Ajuste `max_tokens`

Um max_tokens alto não consome OTPM antecipadamente, mas permite que uma resposta longa continue gerando tokens por mais tempo.

Defina o valor com base no que a tarefa precisa.

Exemplo:

# Resumo curto
max_tokens = 512

# Relatório detalhado
max_tokens = 4096

# Execução longa com agente
max_tokens = 8192

Use limites diferentes por tipo de tarefa, em vez de um único valor alto para tudo.

5. Use streaming para respostas longas

Streaming ajuda em dois pontos:

reduz risco de timeout em gerações grandes;
permite observar a saída enquanto o modelo gera.

Exemplo conceitual:

import anthropic

client = anthropic.Anthropic()

with client.messages.stream(
    model="claude-fable-5",
    max_tokens=4096,
    messages=[
        {
            "role": "user",
            "content": "Gere um plano técnico detalhado para migração de API."
        }
    ],
) as stream:
    for text in stream.text_stream:
        print(text, end="")

Para cargas no estilo de agente, o passo a passo do agente Claude Fable 5 mostra como essas alavancas se encaixam em um loop de longa duração.

Se você está comparando classes de modelo para workloads sensíveis a throughput, veja também o guia da API do Claude Opus 4.8 e as notas de preços do Opus 4.8.

Monitore seu uso do Fable 5 com Apidog

A forma mais prática de entender seus limites reais é observar requisições ao vivo.

Com o Apidog, você pode montar uma chamada para o Fable 5 na Messages API, enviar a requisição e inspecionar a resposta completa, incluindo:

cabeçalhos anthropic-ratelimit-*;
objeto usage;
tokens de entrada;
tokens de saída;
tokens lidos do cache.

Isso permite ver, chamada por chamada, quão perto você está de atingir ITPM ou OTPM.

Um fluxo simples de teste:

Crie uma requisição Fable 5 no Apidog.
Envie um prompt representativo.
Leia anthropic-ratelimit-output-tokens-remaining.
Compare com usage.output_tokens.
Aumente ou reduza max_tokens.
Repita com cache de prompt.
Verifique se usage.cache_read_input_tokens aumenta.
Observe se o consumo de ITPM diminui.

Esse teste transforma a tabela de limites em dados concretos da sua própria aplicação.

Você pode baixar o Apidog para executar esse experimento com sua chave e acompanhar os cabeçalhos de resposta enquanto ajusta sua taxa de requisições. Equipes que já usam o Apidog para design e teste de APIs podem adicionar o monitoramento do Fable 5 ao mesmo workspace.

Como usar Claude Fable 5 no Cursor

Lucas — Wed, 10 Jun 2026 10:31:05 +0000

Executar o Claude Fable 5 no Cursor transforma o editor em um ambiente para refatorações longas, migrações em vários arquivos e sessões de agente com mais autonomia. O Fable 5 é o modelo de codificação de longo prazo da Anthropic, projetado para manter uma tarefa coesa por milhões de tokens sem perder contexto. Como o Cursor já oferece suporte a modelos da Anthropic, a configuração prática se resume a adicionar sua chave de API, habilitar o modelo claude-fable-5 e selecioná-lo antes de iniciar a execução.

Experimente o Apidog hoje

Se você já configurou outros modelos no editor, como no fluxo de executar o DeepSeek V4 Pro dentro do Cursor, os passos serão familiares. A diferença principal está no custo: ao usar sua própria chave da Anthropic, você paga diretamente pelos tokens consumidos.

TL;DR

Abra as configurações do Cursor.
Vá para Models.
Cole sua chave de API da Anthropic.
Clique em Verify.
Adicione o modelo claude-fable-5.
Habilite o modelo.
Selecione claude-fable-5 no seletor de modelos antes de usar o chat ou o agente.

Com sua própria chave, a Anthropic cobra diretamente US$ 10 por milhão de tokens de entrada e US$ 50 por milhão de tokens de saída. Use o Fable 5 para migrações, refatorações amplas e tarefas longas. Para edições pequenas, volte para um modelo mais barato.

Por que usar o Fable 5 no Cursor

Modelos de codificação costumam funcionar bem em tarefas curtas:

criar uma função;
corrigir um bug pequeno;
gerar um teste simples;
explicar um trecho de código.

O problema aparece quando a tarefa envolve dezenas de arquivos, várias decisões sequenciais e muito contexto. Em execuções longas, o agente pode esquecer decisões anteriores, repetir trabalho ou alterar partes do código de forma inconsistente.

O Claude Fable 5 foi criado para esse cenário. Segundo a Anthropic, ele consegue manter foco por milhões de tokens e trabalhar de forma autônoma por mais tempo do que modelos Claude anteriores. Dentro do Cursor, isso é útil principalmente no modo agente, onde o modelo pode:

ler arquivos do repositório;
planejar mudanças;
editar múltiplos arquivos;
executar comandos;
interpretar erros;
continuar a refatoração com base nos resultados.

Um exemplo citado no anúncio do Fable 5 da Anthropic foi uma migração em uma base Ruby de 50 milhões de linhas na Stripe, concluída em um dia. O ponto prático para desenvolvedores é simples: o Fable 5 faz mais sentido quando a tarefa exige consistência por muito tempo.

Use o Fable 5 quando você estiver:

migrando uma versão de framework, ORM ou formato de serialização;
renomeando APIs, métodos ou contratos em muitos arquivos;
executando uma refatoração grande com o agente do Cursor;
analisando módulos legados com dependências espalhadas;
pedindo ao agente para planejar, executar e corrigir sem intervenção constante.

Não use o Fable 5 para tudo. Para uma correção de uma linha, um componente pequeno ou um teste simples, um modelo padrão do Cursor tende a ser mais barato e suficiente. O objetivo é escolher o modelo conforme o tamanho do trabalho, assim como você faria ao comparar Cursor versus Claude Code para um fluxo específico.

Pré-requisitos

Antes de configurar, confirme estes pontos:

Cursor instalado e atualizado.

Use uma versão recente para garantir suporte a modelos personalizados e ao seletor de modelos atualizado.
Plano do Cursor com suporte a modelos personalizados.

A opção de usar sua própria chave e selecionar modelos específicos exige um plano pago. O modo gratuito “Somente Auto” não permite fixar um modelo específico.
Chave de API da Anthropic com acesso ao Fable 5.

Crie a chave no console da Anthropic e confirme que o workspace tem faturamento habilitado.
Entendimento do custo.

O Fable 5 custa US$ 10 por milhão de tokens de entrada e US$ 50 por milhão de tokens de saída.

Para consultar IDs e preços atualizados, veja a visão geral dos modelos Claude. Para entender melhor o posicionamento do modelo, veja também o guia sobre o que é o Claude Fable 5.

Como adicionar o Claude Fable 5 ao Cursor

A configuração tem duas partes:

conectar sua chave da Anthropic ao Cursor;
adicionar claude-fable-5 à lista de modelos disponíveis.

A documentação de chaves de API do Cursor deve ser usada como referência principal se a interface mudar.

1. Abra as configurações do Cursor

No Cursor, abra as configurações pela paleta de comandos ou pelo ícone de engrenagem.

Depois, acesse a seção Models.

Esse painel lista os modelos disponíveis e os campos de chave de API dos provedores.

2. Localize o campo da Anthropic

Na área de chaves de provedores, encontre o campo da Anthropic API Key.

Ele fica separado dos campos de outros provedores, como OpenAI e Google.

3. Cole sua chave e verifique

Cole a chave da Anthropic no campo correspondente.

Em seguida, clique em Verify.

O Cursor fará uma solicitação de teste para confirmar que:

a chave é válida;
a conta consegue acessar a API da Anthropic;
o workspace possui faturamento configurado.

Se a verificação falhar, confira:

se a chave foi copiada corretamente;
se ela pertence ao workspace certo;
se a conta da Anthropic tem billing ativo;
se o modelo está disponível para sua conta.

4. Habilite a chave

Depois da verificação, ative a chave da Anthropic no Cursor.

Dependendo da versão, a interface pode mostrar um botão de ativação ou uma opção como Enable Anthropic key.

Quando essa opção estiver ativa, as chamadas para modelos Claude passam a usar sua chave da Anthropic.

5. Adicione o modelo `claude-fable-5`

Na lista de modelos do Cursor, use a busca ou opção de adicionar modelo.

Digite exatamente:

claude-fable-5

Quando o modelo aparecer, selecione a opção para adicioná-lo como modelo personalizado.

6. Habilite o modelo

Depois de adicionar claude-fable-5, confirme que o interruptor ao lado do modelo está ativado.

Se o modelo estiver desabilitado, ele não aparecerá no seletor durante o uso do chat ou do agente.

Observação sobre Base URL

Se você está usando a API padrão da Anthropic, não altere a Base URL.

Substituições de Base URL são úteis apenas quando você usa proxies ou gateways próprios. Ativar uma substituição incorreta pode quebrar o roteamento das chamadas para a Anthropic.

Como selecionar o Fable 5 e confirmar que ele está ativo

Adicionar o modelo não significa que ele será usado automaticamente. Você precisa selecioná-lo antes da conversa ou execução.

1. Abra o chat ou painel do agente

No Cursor, abra um chat ou uma sessão do agente.

Procure o seletor de modelos, geralmente próximo ao campo de entrada ou no cabeçalho da conversa.

2. Selecione `claude-fable-5`

Clique no seletor e escolha:

claude-fable-5

A seleção vale para a conversa atual. Você pode manter uma thread com o Fable 5 e outra com um modelo mais barato.

3. Verifique o rótulo antes de executar

Antes de enviar uma solicitação longa, confira se o seletor realmente mostra claude-fable-5.

Esse hábito evita gastar tokens caros por engano ou iniciar uma refatoração grande no modelo errado.

4. Faça um teste pequeno

Envie um prompt simples, por exemplo:

Resuma o arquivo atual e liste os principais pontos de atenção antes de uma refatoração.

Depois, abra o console da Anthropic e verifique o painel de uso.

Se aparecer uma nova solicitação associada a claude-fable-5, o Cursor está usando sua chave corretamente.

5. Entenda possíveis fallbacks

A Anthropic pode rotear automaticamente uma pequena parte das solicitações para o Claude Opus 4.8 em tópicos específicos, como segurança cibernética, biologia, química ou destilação de modelos.

Segundo a Anthropic, mais de 95% das sessões do Fable não envolvem fallback. Para uso comum de codificação, isso raramente deve aparecer. Se quiser entender o modelo de fallback, veja a análise do Claude Opus 4.8.

Como controlar custo e faturamento

Ao usar sua própria chave da Anthropic, você não está consumindo apenas os créditos incluídos no Cursor. A cobrança acontece diretamente na Anthropic.

Preço do Fable 5

Com chave própria:

Tipo de token	Preço
Entrada	US$ 10 / milhão
Saída	US$ 50 / milhão

Isso significa que uma execução longa do agente pode ficar cara, principalmente se o modelo gerar muito código, logs, explicações e diffs.

Compare com o Opus 4.8

O Opus 4.8 custa:

Tipo de token	Preço
Entrada	US$ 5 / milhão
Saída	US$ 25 / milhão

Ou seja, o Fable 5 custa o dobro em entrada e saída. Antes de iniciar uma tarefa grande, pergunte:

preciso mesmo de foco de longo prazo?
a tarefa envolve muitos arquivos?
o agente vai trabalhar por muito tempo?
a consistência global é mais importante que o custo?

Para uma comparação direta, veja Fable 5 versus Opus 4.8.

Onde o custo aumenta

Em fluxos de agente, o custo tende a se concentrar nos tokens de saída, porque o modelo:

escreve código;
explica decisões;
lê erros;
gera novas alterações;
executa ciclos de correção.

Quanto mais longa for a sessão, maior será a saída acumulada.

Estratégia prática

Use este padrão:

modelo barato por padrão;
Fable 5 apenas para tarefas grandes;
monitoramento do painel da Anthropic durante execuções longas;
troca de volta para outro modelo após a refatoração.

Exemplo de uso adequado para Fable 5:

Analise este repositório e planeje a migração do Express 4 para Express 5.
Depois, aplique as mudanças em etapas pequenas, execute os testes após cada etapa
e corrija regressões sem alterar o comportamento público da API.

Exemplo de uso que não precisa do Fable 5:

Crie um teste unitário para esta função.

Cursor vs Claude Code para Fable 5

Cursor e Claude Code podem usar bem o Fable 5, mas atendem fluxos diferentes.

Use o Cursor se você prefere:

editor completo;
diffs inline;
árvore de arquivos visível;
chat ao lado do código;
revisão manual enquanto o agente trabalha.

Use o Claude Code se você prefere:

fluxo no terminal;
automação via shell;
integração com scripts;
execução mais próxima do ambiente CLI.

A força de longo prazo do Fable 5 aparece nos dois ambientes. Se estiver escolhendo entre eles, veja a comparação entre Cursor e Claude Code em 2026. Se quiser testar a rota do terminal, veja também o guia para executar o Fable 5 no Claude Code.

Teste as APIs que o Cursor constrói com o Apidog

Quando você usa o Fable 5 em uma tarefa de backend, ele pode gerar rotas, handlers, schemas e endpoints. Mas código gerado ainda precisa ser validado com solicitações reais.

O Apidog é uma ferramenta de design e teste de APIs que permite chamar endpoints, inspecionar respostas e comparar o comportamento real com o contrato esperado.

Um loop prático após o Fable 5 gerar endpoints:

1. Importe a definição da API

Se o agente gerou um arquivo OpenAPI ou Swagger, importe-o no Apidog.

A ferramenta cria os endpoints com:

caminhos;
métodos HTTP;
parâmetros;
corpos de requisição;
schemas de resposta.

2. Execute uma requisição real

Escolha um endpoint, preencha parâmetros ou body e envie a requisição para seu servidor local.

Você verá:

status code real;
headers;
payload JSON;
tempo de resposta.

3. Compare a resposta com o schema

Verifique se o retorno bate com o contrato definido.

Procure problemas como:

campo ausente;
tipo incorreto;
campo null indevido;
formato diferente do schema;
status code inesperado.

4. Salve as requisições

Agrupe as chamadas em uma coleção para repetir os testes após novas execuções do agente.

Isso ajuda a detectar regressões quando o Fable 5 altera endpoints em etapas posteriores da refatoração.

O fluxo recomendado é:

Gerar no Cursor → testar no Apidog → corrigir no Cursor → repetir

Esse ciclo mantém a velocidade do agente sem confiar cegamente no código gerado.

Próximo passo

Agora você tem:

o Fable 5 conectado ao Cursor;
o modelo disponível no seletor;
uma forma de confirmar o uso pela Anthropic;
uma estratégia básica para controlar custo;
um fluxo para validar APIs geradas com o Apidog.

Comece com uma tarefa que realmente precise de contexto longo, como uma migração ou refatoração ampla. Observe a primeira execução no painel do agente, revise os diffs e valide endpoints no Apidog antes de implantar.

Se quiser comparar essa configuração com o uso direto via API, veja o guia da API Claude Fable 5.

Colaboração nativa Git para Testes e Engenharia de API

Lucas — Wed, 10 Jun 2026 10:28:19 +0000

Sua especificação OpenAPI é o contrato entre sua API e seus consumidores. Para manter esse contrato confiável, ele precisa viver no mesmo lugar que o código: no Git.

Experimente o Apidog hoje

Quando a especificação fica isolada em uma ferramenta, ela tende a ficar desatualizada: a implementação muda, a documentação não acompanha, as coleções de teste divergem e os revisores aprovam PRs sem validar o contrato da API.

O Modo Spec-first muda esse fluxo. Seus arquivos OpenAPI ou Swagger passam a ser a fonte da verdade, versionados no repositório Git junto com a implementação. Assim, design de API, testes e documentação permanecem sincronizados com branches, commits e pull requests.

Neste tutorial, você vai configurar um projeto Spec-first no Apidog, editar arquivos de especificação e sincronizar as mudanças com seu fluxo Git.

O que é o Modo Spec-first?

Em um projeto de API tradicional, você geralmente cria endpoints em formulários visuais ou importa uma especificação inicial. A ferramenta armazena as definições internamente, e o Git entra apenas como uma etapa de exportação.

No Modo Spec-first, o fluxo é baseado em arquivos:

openapi.yaml ou openapi.json ficam no seu repositório
O Apidog lê esses arquivos e gera uma estrutura navegável da API
Você edita os arquivos diretamente ou por formulários suportados
As alterações são sincronizadas de volta para o Git

Ou seja: o arquivo de especificação continua sendo a fonte autoritativa. O Apidog lê, valida, edita e sincroniza esse arquivo.

Pré-requisitos

Antes de começar, você precisa de:

Uma conta Apidog
Um repositório Git com um arquivo OpenAPI/Swagger ou um repositório vazio
Permissão de escrita no repositório
Conhecimento básico de OpenAPI ou Swagger

Exemplo mínimo de arquivo openapi.yaml para iniciar um repositório vazio:

openapi: 3.0.3
info:
  title: Minha API
  version: 1.0.0
paths:
  /health:
    get:
      summary: Verifica o status da API
      responses:
        '200':
          description: API disponível

Etapa 1: Criar um projeto Spec-first

No Apidog:

Clique em + Novo Projeto
Escolha Modo Spec-first
Conecte seu provedor Git
Selecione o repositório
Escolha o branch principal para sincronização

Provedores suportados incluem:

GitHub
GitLab
Azure DevOps
Bitbucket

O Apidog sincroniza com o branch padrão do repositório. Se ele não se chamar main, o Apidog detecta e usa o branch configurado no repositório.

Etapa 2: Configurar sincronização por webhook

Durante a configuração, o Apidog pode solicitar a instalação de um webhook. Use essa opção sempre que possível.

O webhook permite que o Apidog sincronize automaticamente quando alguém envia alterações para o repositório.

Nota: instalar o webhook geralmente exige permissão de administrador no repositório. Se você não tiver essa permissão, pule a etapa e use Git Pull manualmente.

Com webhook ativado:

Um desenvolvedor faz push para o repositório
O Apidog detecta o evento
A especificação é atualizada no projeto
A equipe vê a versão mais recente

Se você pular essa configuração, poderá adicioná-la depois em:

Configurações do Projeto > Git & Branches

Etapa 3: Navegar pelo workspace de especificações

Depois de criar o projeto, abra o workspace Specs.

Ele é dividido em três áreas principais:

Painel	O que mostra
Explorador de Arquivos	Arquivos e pastas do repositório sincronizado
Árvore de Estrutura da API	Endpoints, esquemas, definições e visão geral extraídos do OpenAPI
Editor	Edição em código ou formulário

Fluxo prático:

Clique em um endpoint na árvore da API
O Apidog localiza a seção correspondente no arquivo OpenAPI
Edite o YAML/JSON ou use a visualização em formulário quando disponível

Isso ajuda a navegar entre a visão de alto nível da API e o arquivo-fonte sem alternar entre ferramentas.

Etapa 4: Editar arquivos de especificação

Edição em código

Use a visualização de Código para editar diretamente arquivos YAML, JSON ou Markdown.

Exemplo de alteração em um endpoint:

paths:
  /users/{id}:
    get:
      summary: Buscar usuário por ID
      parameters:
        - name: id
          in: path
          required: true
          schema:
            type: string
      responses:
        '200':
          description: Usuário encontrado
        '404':
          description: Usuário não encontrado

As alterações continuam no arquivo. O Apidog não cria uma cópia separada da definição da API.

Edição em formulário

Para nós OpenAPI suportados, como endpoints, esquemas, definições e visão geral da API, você pode usar a visualização de Formulário.

Use o formulário para:

Criar endpoints sem memorizar toda a estrutura YAML
Editar parâmetros, responses e schemas visualmente
Atualizar metadados da API
Configurar definições de segurança

Se um nó não suportar edição em formulário, o Apidog mantém a edição em código.

Etapa 5: Validar e pré-visualizar a especificação

O Modo Spec-first inclui validação em tempo real e pré-visualização da documentação.

Validar problemas

Clique em Validação no cabeçalho do editor.

O painel mostra avisos e erros encontrados na especificação, como:

Erros de sintaxe YAML/JSON
Campos obrigatórios ausentes
Violações de schema
Problemas de nomenclatura
Definições incompletas

Corrija esses problemas antes do commit. Isso reduz retrabalho durante a revisão do PR.

Pré-visualizar documentação

Clique em Pré-visualizar para verificar como a especificação será renderizada como documentação.

Para endpoints, a pré-visualização inclui:

Aba	Conteúdo
Documentação	Documentação gerada do endpoint
Experimentar	Painel de requisição ao vivo baseado na definição do endpoint

Para schemas e definições, a pré-visualização mostra a documentação renderizada.

Validação e Pré-visualização usam o mesmo painel lateral. Abrir um fecha o outro.

Etapa 6: Puxar alterações da equipe

Quando outra pessoa altera a especificação no Git, atualize seu workspace:

Abra Specs
Clique no nome do branch atual
Selecione Git Pull

Se o webhook estiver ativo, o Apidog sincroniza automaticamente após eventos de push no repositório.

Use Git Pull manualmente quando:

O webhook não estiver configurado
Você quiser garantir que está vendo a versão mais recente
Houve alterações recentes em outro branch

Etapa 7: Fazer commit e push das suas alterações

Depois de editar a especificação no Apidog:

Abra Alterações na barra lateral
Revise arquivos modificados, adicionados, renomeados ou excluídos
Clique em Commit & Push
Selecione os arquivos que farão parte do commit
Escreva uma mensagem clara
Clique em Push

Exemplos de mensagens de commit úteis:

docs: adiciona endpoint GET /users/{id}

fix: corrige schema de resposta de criação de usuário

feat: adiciona autenticação bearer na especificação

Depois do push, as alterações entram no mesmo fluxo de pull request usado pelo código. A equipe pode revisar implementação e contrato da API no mesmo processo.

Dica: use Descartar todas as alterações se quiser abandonar edições locais antes do push.

Etapa 8: Trabalhar com branches

O Modo Spec-first suporta colaboração baseada em branches. Branches Git são mapeados para branches do projeto no Apidog.

Operações comuns:

Ação	Como fazer
Alternar branches	Clique no nome do branch e selecione outro
Importar branch Git existente	Clique em Importar Novo Branch, selecione e importe
Criar novo branch	Vá em Configurações do Projeto > Git & Branches > Novo Branch
Corrigir problemas de sincronização	Use Re-sincronizar nas configurações do branch
Visualizar logs de sincronização	Acesse Ações do Branch > Visualizar Logs

Fluxo recomendado para uma alteração de API:

Crie um branch de feature
Atualize openapi.yaml
Valide a especificação
Faça commit e push
Abra um pull request
Revise contrato e implementação juntos

Exemplo:

git checkout -b feat/users-search

No Apidog, importe ou selecione esse branch e edite a especificação correspondente.

Etapa 9: Integrar com CI/CD

Como a especificação está no Git, ela pode passar pelos mesmos gates de qualidade do código.

Você pode usar o pipeline para:

Validar OpenAPI em cada PR
Executar lint com ferramentas como Spectral
Gerar documentação quando alterações forem mescladas no main
Acionar testes de API a partir de mudanças na especificação
Sincronizar com gateways, mocks ou geradores de SDK

Exemplo de workflow com GitHub Actions:

name: Validate and Test API Spec

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  validate:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v4

      - name: Lint OpenAPI Spec
        run: npx spectral lint openapi.yaml

      - name: Run API Tests
        run: apidog run tests --spec openapi.yaml

Com isso, uma alteração inválida no contrato da API pode ser bloqueada antes do merge.

Alternativa: projetos baseados em armazenamento

Se você ainda não quer conectar um repositório Git externo, o Apidog também oferece projetos Spec-first baseados em armazenamento.

Eles usam o armazenamento interno do Apidog, mas ainda oferecem:

Edição baseada em arquivos
Validação
Pré-visualização
Gerenciamento de branches

A interface muda levemente:

Git Pull vira Sincronizar
Commit & Push vira Salvar

Use essa opção para começar rapidamente e migre para Git externo quando o time estiver pronto.

Resumo

Com o Modo Spec-first, o fluxo de trabalho da API fica mais próximo do fluxo de desenvolvimento:

Antes do Spec-first	Depois do Spec-first
Especificações ficam em uma ferramenta separada	Especificações ficam no repositório Git
Sincronização via export/import	Sincronização automática ou via Git Pull
Revisões fora do fluxo de código	Revisões em pull requests
Documentação gerada separadamente	Pré-visualização durante a edição
Testes desconectados da especificação	Testes acionados por mudanças no contrato

O Modo Spec-first mantém arquivos OpenAPI versionados, revisáveis e alinhados com a implementação.

Para começar, crie um projeto Spec-first no Apidog, conecte seu repositório e trate sua especificação como parte do código.

Se o problema com o Scalar é...	Considere
Preciso de testes, mocks e documentação a partir de uma única especificação	Apidog
Preciso de linting e governança multi-API	Redocly
Minha documentação é composta principalmente por guias e tutoriais	Mintlify
Quero logs de API por usuário dentro da documentação	ReadMe
Preciso de um catálogo empresarial para muitas especificações	SwaggerHub
Quero design visual de especificação e mocking	Stoplight
Preciso de changelogs automáticos para consumidores	Bump.sh

Você precisa de	Escolha
Documentação mais design, teste e mocking em uma ferramenta	Apidog
Referência gratuita de código aberto com "Experimente"	Scalar
Site de documentação bonito e focado em guias	Mintlify
Hub de desenvolvedores com logs de API em nível de usuário	ReadMe
Design visual OpenAPI e governança	Stoplight (com cautela no roadmap)
Catálogo de especificações corporativas	SwaggerHub
Changelogs automáticos e alertas de diff	Bump.sh

Claude Fable 5 vs. Opus 4.8: Quando o dobro do preço vale a pena?

Lucas — Wed, 10 Jun 2026 03:41:46 +0000

A Anthropic lançou o Claude Fable 5 em 9 de junho de 2026 com uma decisão de custo bem direta: Claude Fable 5 vs Opus 4.8 é, antes de tudo, uma comparação de preço por token. O Fable 5 custa exatamente o dobro do Opus 4.8: entrada a $10 por milhão de tokens contra $5, e saída a $50 por milhão contra $25. Como ambos usam a mesma API de Mensagens, a decisão prática é: quando a melhoria do Fable 5 paga esse prêmio de 2x? Se você quiser entender o modelo mais antigo primeiro, veja nosso guia para Claude Opus 4.8.

Experimente o Apidog hoje

TL;DR

Use esta regra inicial:

Use Claude Opus 4.8 por padrão para chat, geração de código, RAG, Q&A de documentos e tarefas interativas.
Use Claude Fable 5 quando a tarefa exigir autonomia de longa duração, coerência em milhões de tokens ou agentes que rodam por horas.
O Fable 5 custa 2x o Opus 4.8 por token. Só promova uma carga de trabalho para ele quando o ganho de qualidade justificar o custo.

Claude Fable 5 vs Opus 4.8: comparação rápida

Dimensão	Claude Fable 5	Claude Opus 4.8
ID do modelo na API	`claude-fable-5`	`claude-opus-4-8`
Preço de entrada	$10 por 1M de tokens	$5 por 1M de tokens
Preço de saída	$50 por 1M de tokens	$25 por 1M de tokens
Custo relativo	2x Opus 4.8	Linha de base
Contexto	Opera em milhões de tokens; nenhum número fixo publicado	Janela de contexto de 1M de tokens
Pensamento e esforço	Pensamento adaptativo	Pensamento adaptativo + esforço baixo/médio/alto/muito alto/máximo
Posicionamento	Modelo de classe Mythos seguro para uso geral; o mais capaz disponibilizado publicamente pela Anthropic	Modelo altamente capaz; era o mais capaz da Anthropic antes do Fable 5
Melhor uso	Agentes de longa duração, grandes migrações, refatorações extensas	Chat, codegen, RAG, Q&A e fluxos interativos

Observação importante sobre contexto: a Anthropic não publicou um número exato para a janela de contexto do Fable 5. Ela descreve o modelo como capaz de permanecer focado em milhões de tokens, então trate isso como uma força qualitativa, não como uma especificação fixa. Já o Opus 4.8 tem uma janela documentada de 1M de tokens. A documentação geral dos modelos da Anthropic lista as especificações publicadas. Para uma introdução ao novo modelo, veja nosso explicativo sobre o que é Claude Fable 5 e nossa análise de preços do Opus 4.8.

Preço: calcule antes de trocar o modelo

O Fable 5 custa exatamente o dobro do Opus 4.8:

Modelo	Entrada por 1M tokens	Saída por 1M tokens
Claude Fable 5	$10	$50
Claude Opus 4.8	$5	$25

Você pode confirmar as taxas atuais na página de preços da Anthropic.

Por 1.000 tokens:

Fable 5: $0.010 entrada, $0.050 saída
Opus 4.8: $0.005 entrada, $0.025 saída

O impacto aparece no volume. Exemplo mensal:

200M tokens de entrada
40M tokens de saída

No Opus 4.8:

200 x $5  = $1.000
40 x $25  = $1.000
Total     = $2.000

No Fable 5:

200 x $10 = $2.000
40 x $50  = $2.000
Total     = $4.000

Mesmos tokens, mesma carga de trabalho, dobro do custo.

A pergunta correta não é “o Fable 5 é melhor?”. A pergunta é:

O Fable 5 melhora esta carga de trabalho o suficiente para justificar dobrar este item de custo?

Para um fluxo interno de baixo volume, o custo extra pode ser aceitável. Para um endpoint de alto volume voltado ao cliente, pode afetar diretamente a margem. Portanto, precifique a carga de trabalho, não apenas o modelo. Para mais detalhes, veja a análise de preços do Opus 4.8 e o guia de preços do Claude Fable 5.

Onde o Fable 5 se destaca

O Fable 5 é mais indicado quando a tarefa exige coerência sustentada por muito tempo.

Segundo o anúncio do Claude Fable 5, a Anthropic posiciona o modelo como uma versão de classe Mythos tornada segura para uso geral, projetada para trabalho autônomo de longa duração e foco em milhões de tokens.

Na prática, isso importa quando o modelo precisa:

manter um plano por horas;
trabalhar sobre muito contexto;
fazer várias decisões encadeadas;
usar memória persistente;
executar migrações ou refatorações grandes;
evitar perda de foco ao longo de uma sessão extensa.

Um exemplo citado é a migração de uma base Ruby de 50 milhões de linhas para a Stripe em um único dia, um trabalho que a equipe estimava que levaria dois meses ou mais. Esse tipo de tarefa não depende apenas de gerar bons trechos de código. Depende de manter coerência durante uma execução longa.

Outro ponto é o uso de memória. Em um teste com Slay the Spire, fornecer memória de arquivo persistente ao Fable 5 gerou uma melhoria de 3x sobre o Opus 4.8. A lição prática: se seu agente escreve notas, mantém um plano, lê o próprio histórico e continua trabalhando por muitas etapas, o Fable 5 tende a aproveitar melhor essa estrutura.

Exemplo de arquitetura onde o Fable 5 faz sentido:

Agente de migração
├── Lê árvore do repositório
├── Cria plano de refatoração
├── Escreve arquivo de memória/plano
├── Edita lote de arquivos
├── Executa testes
├── Atualiza plano
├── Repete por horas
└── Gera relatório final

Esse é o tipo de fluxo no qual pagar 2x pode fazer sentido.

Em benchmarks, o Fable 5 apareceu em posições de ponta em avaliações como FrontierCode, FrontierBench, CursorBench e Hebbia’s Finance Benchmark. A Anthropic não divulgou pontuações públicas para todos esses resultados, então use as classificações como sinal direcional, não como número fechado para um documento de arquitetura.

Também há uma diferença comportamental: certas consultas sensíveis — segurança cibernética, biologia, química e destilação de modelos — podem ser direcionadas para o Opus 4.8 em vez de respondidas diretamente pelo Fable 5. A Anthropic afirma que isso ocorre em menos de 5% das sessões. Para a maioria dos fluxos, isso não deve aparecer. Para comparações com outros fornecedores, veja nossa comparação do Opus 4.8 contra GPT-5.5 e Gemini 3.5 e o artigo Fable 5 contra GPT-5.5 e Gemini 3.5.

Onde o Opus 4.8 é a escolha mais econômica

Para grande parte das cargas de produção, o Opus 4.8 é a melhor escolha.

Ele continua sendo um modelo forte, com:

janela de contexto documentada de 1M de tokens;
pensamento adaptativo;
níveis de esforço de baixo a máximo;
metade do custo do Fable 5.

Use o Opus 4.8 quando a tarefa couber confortavelmente em 1M de tokens e for resolvida em uma interação curta ou em poucos passos.

Bons casos de uso:

Chat interativo e assistentes

O usuário envia uma pergunta, o modelo responde, e o contexto não precisa sustentar um plano de várias horas.

Geração e revisão de código

Funções, arquivos individuais, pull requests pequenos ou médios e explicações técnicas.

RAG e Q&A de documentos

Você recupera documentos relevantes, injeta no prompt e faz uma pergunta focada.

Extração e classificação

Tarefas como classificar tickets, extrair campos de contratos ou resumir documentos.

Análise dentro de 1M de tokens

Se a janela documentada do Opus 4.8 cobre o caso, você provavelmente não precisa pagar 2x.

Um detalhe relevante: o próprio Fable 5 pode encaminhar certas categorias sensíveis para o Opus 4.8. Isso reforça que o Opus 4.8 continua confiável e capaz para tráfego real.

A estratégia recomendada:

Comece com Opus 4.8
        ↓
Meça qualidade, custo e falhas
        ↓
Promova apenas tarefas específicas para Fable 5
        ↓
Mantenha o restante no modelo mais barato

Se até o Opus 4.8 for mais caro do que sua carga precisa, o Claude Sonnet 4.6 fica abaixo dele em custo, com $3 de entrada e $15 de saída, e pode ser suficiente para tarefas simples de alto volume. Para detalhes de configuração, veja nosso guia da API Opus 4.8.

Framework de decisão

Use esta matriz para escolher o modelo por carga de trabalho.

Carga de trabalho	Modelo recomendado	Motivo
Chat curto	Opus 4.8	Metade do custo; o Fable 5 não usa sua vantagem de longo prazo
Classificação ou extração	Opus 4.8	Tarefa curta e objetiva
Resumo de documento	Opus 4.8	A janela de 1M costuma ser suficiente
RAG e Q&A	Opus 4.8	Boa relação custo/qualidade
Geração de função ou arquivo	Opus 4.8	Codegen limitado não exige autonomia prolongada
Revisão de PR	Opus 4.8	Contexto geralmente controlado
Agente de várias horas	Fable 5	Coerência sustentada é o diferencial
Grande migração de código	Fable 5	O gargalo é manter plano e contexto por muito tempo
Agente com memória persistente	Fable 5	O modelo tende a aproveitar melhor memória em execuções longas
Custo é a restrição principal	Opus 4.8 ou Sonnet 4.6	Reduz custo por token

Regra prática:

Use Opus 4.8 por padrão. Faça upgrade para Fable 5 apenas quando a carga provar que precisa de autonomia de longa duração.

Alternando entre Fable 5 e Opus 4.8 no código

A troca é simples porque os dois modelos usam a mesma API de Mensagens. Você altera apenas o ID do modelo:

claude-opus-4-8
claude-fable-5

Exemplo em Python:

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-opus-4-8",  # troque para "claude-fable-5" quando necessário
    max_tokens=16000,
    thinking={"type": "adaptive"},
    messages=[
        {
            "role": "user",
            "content": "Resuma este documento de design e liste as perguntas em aberto."
        }
    ],
)

for block in response.content:
    if block.type == "text":
        print(block.text)

Para implementar roteamento por carga de trabalho, mantenha o modelo em configuração:

def select_model(task_type: str) -> str:
    long_running_tasks = {
        "large_code_migration",
        "multi_hour_agent",
        "persistent_memory_agent",
    }

    if task_type in long_running_tasks:
        return "claude-fable-5"

    return "claude-opus-4-8"

Depois use a função na chamada:

task_type = "rag_question_answering"

response = client.messages.create(
    model=select_model(task_type),
    max_tokens=8000,
    thinking={"type": "adaptive"},
    messages=[
        {
            "role": "user",
            "content": "Com base nos documentos recuperados, responda à pergunta do usuário."
        }
    ],
)

Também vale registrar tokens e custo por chamada:

MODEL_PRICING = {
    "claude-opus-4-8": {
        "input_per_million": 5,
        "output_per_million": 25,
    },
    "claude-fable-5": {
        "input_per_million": 10,
        "output_per_million": 50,
    },
}


def estimate_cost(model: str, input_tokens: int, output_tokens: int) -> float:
    pricing = MODEL_PRICING[model]

    input_cost = input_tokens / 1_000_000 * pricing["input_per_million"]
    output_cost = output_tokens / 1_000_000 * pricing["output_per_million"]

    return input_cost + output_cost

Assim você consegue comparar qualidade e custo por tipo de tarefa, em vez de decidir com base apenas no nome do modelo.

Para detalhes da superfície de requisição, veja o guia da API Opus 4.8 e o guia da API Fable 5.

Como testar os dois modelos na prática

A forma mais confiável de decidir é rodar o mesmo prompt nos dois modelos e comparar:

qualidade da resposta;
completude;
aderência às instruções;
latência;
tokens de entrada;
tokens de saída;
custo estimado.

Você pode fazer isso com um pequeno teste A/B.

Exemplo de payload para Opus 4.8:

{
  "model": "claude-opus-4-8",
  "max_tokens": 8000,
  "thinking": {
    "type": "adaptive"
  },
  "messages": [
    {
      "role": "user",
      "content": "Analise este plano de migração e liste riscos, etapas faltantes e recomendações."
    }
  ]
}

Depois duplique e troque apenas o modelo:

{
  "model": "claude-fable-5",
  "max_tokens": 8000,
  "thinking": {
    "type": "adaptive"
  },
  "messages": [
    {
      "role": "user",
      "content": "Analise este plano de migração e liste riscos, etapas faltantes e recomendações."
    }
  ]
}

Avalie com uma tabela simples:

Critério	Opus 4.8	Fable 5	Vencedor
Correção
Profundidade
Seguiu instruções
Latência
Tokens de entrada
Tokens de saída
Custo estimado

Se o Fable 5 vencer por pouco em uma tarefa curta, provavelmente não vale pagar 2x. Se ele evitar falhas em uma execução longa, manter plano melhor ou concluir uma migração que o Opus 4.8 não sustenta, o custo extra pode ser justificado.

Compare os dois com Apidog

Tabelas de preços e benchmarks ajudam, mas a decisão deve ser baseada no seu tráfego real. O Apidog facilita esse teste.

Fluxo recomendado:

Crie uma requisição para a API de Mensagens da Anthropic.
Configure o modelo como claude-opus-4-8.
Duplique a requisição.
Troque apenas o campo model para claude-fable-5.
Envie o mesmo prompt para ambos.
Compare resposta, latência e uso de tokens.
Salve as duas chamadas como uma coleção de teste A/B.

Use prompts parecidos com produção, não perguntas triviais. Por exemplo:

um trecho real de documentação interna;
um PR representativo;
um plano de migração;
um caso real de suporte;
uma consulta RAG com documentos relevantes.

O Apidog permite manter as duas requisições lado a lado e repetir o teste quando seus prompts mudarem ou quando um novo modelo for lançado. Se quiser experimentar, baixe o Apidog e configure as duas chamadas em alguns minutos. O Apidog ajuda a transformar a comparação em um teste reproduzível, em vez de uma decisão baseada apenas em especificações.

Como usar a API Claude Fable 5

Lucas — Wed, 10 Jun 2026 03:13:45 +0000

A Anthropic lançou o Claude Fable 5 em 9 de junho de 2026. Para quem desenvolve integrações, a parte prática é simples: ele usa a mesma API de Mensagens do Claude, e a principal mudança é a string do modelo: claude-fable-5. Neste guia, você vai montar chamadas reais com curl, Python e TypeScript, ativar streaming, usar ferramentas, tratar erros e calcular custo por requisição.

Experimente o Apidog hoje

TL;DR

Crie uma chave no Anthropic Console.
Exporte a chave como variável de ambiente:

export ANTHROPIC_API_KEY="sk-ant-..."

Envie um POST para a API de Mensagens usando:

{
  "model": "claude-fable-5",
  "max_tokens": 1024,
  "messages": [
    {
      "role": "user",
      "content": "Explique o que faz uma boa API REST."
    }
  ]
}

Use streaming para respostas longas.
Leia usage.input_tokens e usage.output_tokens para calcular custo.
O preço é de US$10 por milhão de tokens de entrada e US$50 por milhão de tokens de saída.

Se você já integrou outro modelo Claude, a migração é parecida com a troca usada na API do Claude Opus 4.8: altere o model e valide a resposta.

Pré-requisitos

Antes da primeira chamada, confirme estes itens:

Conta Anthropic

Crie ou acesse sua conta em console.anthropic.com.
Chave de API

Gere uma chave em API Keys no Console. Copie e armazene com segurança. Você não deve versioná-la no Git.
Faturamento ativo ou plano Enterprise

O Fable 5 está disponível na API padrão do Claude e em planos Enterprise baseados em consumo. Confirme seu método de pagamento ou cobertura do plano antes de enviar tráfego. Se ainda estiver avaliando o modelo, veja também o que é o Claude Fable 5.
SDK ou cliente HTTP

Você pode usar HTTP puro, curl, Python ou TypeScript/Node.

Defina a chave no ambiente:

export ANTHROPIC_API_KEY="sk-ant-..."

Os SDKs oficiais leem ANTHROPIC_API_KEY automaticamente. Evite passar a chave diretamente no código. Se uma chave vazar, revogue-a e gere outra no Console.

Um detalhe operacional: o Fable 5 possui salvaguardas que podem redirecionar uma pequena parcela de consultas sensíveis, como cibersegurança, biologia, química e tentativas de destilação de modelos, para o Claude Opus 4.8. Isso ocorre em menos de 5% das sessões. A requisição continua válida, mas response.model pode indicar outro modelo.

Primeira chamada com `curl`

O endpoint é:

POST https://api.anthropic.com/v1/messages

Exemplo mínimo:

curl https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-fable-5",
    "max_tokens": 1024,
    "messages": [
      {
        "role": "user",
        "content": "Summarize what makes a good REST API in 3 bullet points."
      }
    ]
  }'

Cabeçalhos usados:

Cabeçalho	Função
`x-api-key`	Envia sua chave de API
`anthropic-version`	Define a versão da API
`content-type`	Indica que o corpo está em JSON

Campos principais do corpo:

Campo	Obrigatório	Descrição
`model`	Sim	Use `claude-fable-5`
`max_tokens`	Sim	Limite máximo de tokens de saída
`messages`	Sim	Histórico da conversa

Resposta simplificada:

{
  "id": "msg_01ABC...",
  "type": "message",
  "role": "assistant",
  "model": "claude-fable-5",
  "content": [
    {
      "type": "text",
      "text": "- URLs previsíveis e orientadas a recursos..."
    }
  ],
  "stop_reason": "end_turn",
  "usage": {
    "input_tokens": 18,
    "output_tokens": 96
  }
}

Pontos importantes:

content é uma lista de blocos, não uma string.
Sempre verifique type antes de ler text.
stop_reason indica por que a resposta terminou.
usage contém os tokens usados e deve ser salvo para custo, métricas e auditoria.

Usando Claude Fable 5 com Python

Instale o SDK oficial:

pip install anthropic

Chamada básica:

import anthropic

client = anthropic.Anthropic()  # lê ANTHROPIC_API_KEY do ambiente

response = client.messages.create(
    model="claude-fable-5",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": "Resuma o que faz uma boa API REST."
        }
    ],
)

for block in response.content:
    if block.type == "text":
        print(block.text)

Esse padrão deve ser a base da sua integração:

Instancie o cliente.
Envie model, max_tokens e messages.
Itere por response.content.
Extraia apenas blocos com type == "text".

Adicionando prompt de sistema

Use system para definir papel, restrições e formato da resposta:

response = client.messages.create(
    model="claude-fable-5",
    max_tokens=2048,
    system=(
        "Você é um engenheiro de backend sênior. "
        "Responda de forma concisa e use exemplos de código quando necessário."
    ),
    messages=[
        {
            "role": "user",
            "content": "Escreva uma rota Flask que valida um corpo JSON."
        }
    ],
)

for block in response.content:
    if block.type == "text":
        print(block.text)

Use system para regras estáveis, como:

tom da resposta;
formato de saída;
limites técnicos;
idioma;
persona do assistente;
restrições de segurança.

Evite alterar o prompt de sistema sem necessidade, especialmente se depois você usar cache de prompt.

Streaming para respostas longas

Use streaming quando a resposta puder ser grande. Isso melhora a UX e reduz o risco de timeout.

with client.messages.stream(
    model="claude-fable-5",
    max_tokens=4096,
    messages=[
        {
            "role": "user",
            "content": "Explique as chaves de idempotência para APIs de pagamento."
        }
    ],
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

    final = stream.get_final_message()

print(f"\n\nTokens de saída: {final.usage.output_tokens}")

Boas práticas:

use flush=True para imprimir os chunks imediatamente;
use get_final_message() para obter a resposta completa;
leia final.usage para registrar custo;
prefira streaming em chats, geração de documentos e respostas técnicas longas.

Usando Claude Fable 5 com TypeScript / Node

Instale o SDK:

npm install @anthropic-ai/sdk

Chamada básica:

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic(); // lê ANTHROPIC_API_KEY

const msg = await client.messages.create({
  model: "claude-fable-5",
  max_tokens: 1024,
  messages: [
    {
      role: "user",
      content: "Liste 3 erros comuns de segurança de API."
    }
  ],
});

console.log(msg.content);

Para extrair apenas texto:

const text = msg.content
  .filter((block) => block.type === "text")
  .map((block) => block.text)
  .join("");

console.log(text);

Em uma aplicação real, encapsule essa lógica em uma função:

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

export async function askFable(prompt: string): Promise<string> {
  const msg = await client.messages.create({
    model: "claude-fable-5",
    max_tokens: 1024,
    messages: [{ role: "user", content: prompt }],
  });

  return msg.content
    .filter((block) => block.type === "text")
    .map((block) => block.text)
    .join("");
}

Para frontends de chat, faça o streaming no backend e encaminhe os chunks para o navegador. Antes de implementar o cliente final, você pode validar o contrato manualmente com uma ferramenta como Apidog, no mesmo fluxo mostrado em testando a API ChatGPT com Apidog.

Uso de ferramentas com Fable 5

O uso de ferramentas permite que o modelo solicite a execução de funções definidas por você. O fluxo é:

Você descreve a ferramenta com JSON Schema.
O modelo decide quando usá-la.
Sua aplicação executa a função real.
Você envia o resultado de volta.
O modelo responde usando esse resultado.

Exemplo de definição de ferramenta:

tools = [
    {
        "name": "get_order_status",
        "description": "Consulta o status de um pedido do cliente por ID.",
        "input_schema": {
            "type": "object",
            "properties": {
                "order_id": {
                    "type": "string"
                }
            },
            "required": ["order_id"],
        },
    }
]

Envie a ferramenta junto da mensagem:

messages = [
    {
        "role": "user",
        "content": "Qual o status do pedido A1855?"
    }
]

response = client.messages.create(
    model="claude-fable-5",
    max_tokens=1024,
    tools=tools,
    messages=messages,
)

Quando o modelo quiser chamar a ferramenta, a resposta terá:

response.stop_reason == "tool_use"

E um bloco do tipo tool_use.

Exemplo de loop manual:

if response.stop_reason == "tool_use":
    tool_use = next(
        block for block in response.content
        if block.type == "tool_use"
    )

    # Execute sua função real
    result = lookup_order(tool_use.input["order_id"])

    # Preserve a resposta do assistente no histórico
    messages.append({
        "role": "assistant",
        "content": response.content
    })

    # Envie o resultado da ferramenta
    messages.append({
        "role": "user",
        "content": [
            {
                "type": "tool_result",
                "tool_use_id": tool_use.id,
                "content": result,
            }
        ],
    })

    followup = client.messages.create(
        model="claude-fable-5",
        max_tokens=1024,
        tools=tools,
        messages=messages,
    )

O detalhe mais importante é tool_use_id. O bloco tool_result precisa apontar para o id exato do bloco tool_use.

Para agentes multi-etapas, envolva isso em um loop:

while True:
    response = client.messages.create(
        model="claude-fable-5",
        max_tokens=1024,
        tools=tools,
        messages=messages,
    )

    messages.append({
        "role": "assistant",
        "content": response.content
    })

    if response.stop_reason != "tool_use":
        break

    tool_use = next(
        block for block in response.content
        if block.type == "tool_use"
    )

    result = lookup_order(tool_use.input["order_id"])

    messages.append({
        "role": "user",
        "content": [
            {
                "type": "tool_result",
                "tool_use_id": tool_use.id,
                "content": result,
            }
        ],
    })

Esse formato também é útil para adicionar:

logs de auditoria;
aprovação humana antes da execução;
limites de chamadas;
validação de input;
fallback quando uma ferramenta falha.

Pensamento adaptativo e esforço

O Fable 5 suporta pensamento adaptativo. Com ele, o modelo decide quando raciocinar mais profundamente antes de responder.

Exemplo:

response = client.messages.create(
    model="claude-fable-5",
    max_tokens=4096,
    thinking={"type": "adaptive"},
    output_config={"effort": "high"},  # low | medium | high
    messages=[
        {
            "role": "user",
            "content": "Projete uma estratégia de repetição para um receptor de webhook instável."
        }
    ],
)

Use thinking e effort quando a tarefa envolver:

planejamento multi-etapas;
arquitetura;
análise de trade-offs;
depuração complexa;
raciocínio de produto ou sistema.

Evite em tarefas simples, como:

reformular uma frase;
classificar texto curto;
gerar uma resposta pequena;
extrair campos simples.

effort maior tende a consumir mais tokens. Comece sem thinking, meça a qualidade e ative apenas nas rotas que realmente precisam.

Tratamento de erros

Integrações de produção devem capturar exceções tipadas em vez de comparar strings.

Exemplo em Python:

import anthropic

client = anthropic.Anthropic()

try:
    response = client.messages.create(
        model="claude-fable-5",
        max_tokens=1024,
        messages=[
            {
                "role": "user",
                "content": "Explique as requisições de preflight do CORS."
            }
        ],
    )

except anthropic.AuthenticationError:
    # HTTP 401
    print("Chave de API inválida ou ausente. Verifique ANTHROPIC_API_KEY.")

except anthropic.RateLimitError as e:
    # HTTP 429
    retry_after = e.response.headers.get("retry-after", "60")
    print(f"Limite de taxa atingido. Tente novamente após {retry_after}s.")

except anthropic.BadRequestError as e:
    # HTTP 400
    print(f"Requisição inválida: {e.message}")

Resumo dos erros comuns:

Erro	HTTP	Causa comum	Como corrigir
`AuthenticationError`	401	Chave ausente, inválida ou revogada	Verifique `ANTHROPIC_API_KEY` e gere outra chave se necessário
`RateLimitError`	429	Limite de requisições ou tokens excedido	Use backoff e respeite `retry-after`
`BadRequestError`	400	Corpo inválido	Verifique `model`, `max_tokens`, `messages` e formato dos papéis

O SDK já tenta novamente erros 429 e 5xx com backoff exponencial, com duas tentativas por padrão. Se você implementar retry próprio, evite duplicar tentativas sem controle.

Lidando com fallback de salvaguarda

O fallback de salvaguarda não é erro. A requisição pode ser bem-sucedida, mas response.model pode vir como outro modelo, como Claude Opus 4.8.

Não faça isto:

assert response.model == "claude-fable-5"

Prefira registrar o modelo retornado:

print(f"Modelo usado: {response.model}")

Se sua aplicação depende do modelo exato usado, leia response.model da resposta em vez de assumir que será sempre igual ao model enviado.

Calculando custo por requisição

O preço informado é:

Entrada: US$10 por milhão de tokens
Saída: US$50 por milhão de tokens

Cada resposta inclui usage, então calcule o custo real por chamada:

response = client.messages.create(
    model="claude-fable-5",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": "Escreva uma consulta SQL para encontrar e-mails duplicados."
        }
    ],
)

input_tokens = response.usage.input_tokens
output_tokens = response.usage.output_tokens

input_cost = input_tokens / 1_000_000 * 10
output_cost = output_tokens / 1_000_000 * 50
total = input_cost + output_cost

print(f"Entrada: {input_tokens} tokens = ${input_cost:.6f}")
print(f"Saída:   {output_tokens} tokens = ${output_cost:.6f}")
print(f"Total:   ${total:.6f}")

Exemplo de cálculo:

Entrada: 2.000 tokens
Saída:     500 tokens

Entrada: 2000 / 1.000.000 * US$10 = US$0,020
Saída:    500 / 1.000.000 * US$50 = US$0,025

Total: US$0,045

Como tokens de saída custam mais, as principais alavancas de custo são:

limitar max_tokens;
pedir respostas concisas no prompt de sistema;
usar streaming sem aumentar o tamanho da saída;
evitar raciocínio adaptativo em tarefas simples;
registrar usage por rota, usuário ou tenant.

O cálculo segue a mesma lógica usada em preços do Claude Opus 4.8, mas com os valores do Fable 5.

Testando e depurando a API do Claude Fable 5 com Apidog

Antes de codar o cliente final, envie algumas requisições manualmente para validar headers, corpo, streaming e formato de resposta. Apidog permite criar uma requisição real para https://api.anthropic.com/v1/messages, inspecionar a resposta e salvar o contrato para a equipe.

Fluxo recomendado:

Crie uma requisição HTTP

Método:

   POST

URL:

   https://api.anthropic.com/v1/messages

Armazene a chave como variável de ambiente

Crie uma variável chamada:

   anthropic_api_key

Salve o valor como secreto. Assim a chave não fica exposta na requisição salva.

Configure os headers

Use:

   x-api-key: {{anthropic_api_key}}
   anthropic-version: 2023-06-01
   content-type: application/json

Adicione o corpo mínimo

   {
     "model": "claude-fable-5",
     "max_tokens": 1024,
     "messages": [
       {
         "role": "user",
         "content": "Explique as chaves de idempotência para APIs de pagamento."
       }
     ]
   }

Envie e valide a resposta

Verifique se a resposta contém:

content;
stop_reason;
usage;
model.

Teste streaming

Adicione stream: true:

   {
     "model": "claude-fable-5",
     "max_tokens": 1024,
     "stream": true,
     "messages": [
       {
         "role": "user",
         "content": "Explique as chaves de idempotência para APIs de pagamento."
       }
     ]
   }

Observe os eventos chegando em tempo real. Isso ajuda a implementar corretamente o streaming no backend.

Salve a requisição e gere código

Salve a chamada em uma coleção e use a geração de código do Apidog para exportar exemplos em Python, JavaScript, curl ou outra linguagem.

Esse processo reduz tentativa e erro: primeiro você valida a requisição funcionando, depois replica o mesmo contrato no código. Quando estiver pronto, baixe o Apidog e comece com o payload mínimo acima.

Como os Mecanismos de Segurança do Claude Fable 5 Funcionam (Roteamento Explicado)

Lucas — Wed, 10 Jun 2026 03:09:16 +0000

Se você está usando o Claude Fable 5 via API e algumas respostas parecem diferentes em temas específicos, provavelmente está vendo as salvaguardas do modelo em ação. O Fable 5 foi lançado em 9 de junho de 2026 com o ID claude-fable-5 e inclui roteamento automático de segurança: em certas consultas sensíveis, a resposta é gerada pelo Claude Opus 4.8, não pelo Fable 5 completo.

Experimente o Apidog hoje

TL;DR

O Claude Fable 5 usa classificadores para detectar consultas em três áreas sensíveis:

Cibersegurança ofensiva
Biologia e química de alto risco
Destilação de modelos

Quando uma consulta é classificada como sensível, ela é roteada para o Claude Opus 4.8. Isso acontece em menos de 5% das sessões em média. Você não configura nada, não muda o ID do modelo e o preço permanece o mesmo.

Como o roteamento de segurança funciona

Ao chamar o modelo:

{
  "model": "claude-fable-5",
  "messages": [
    {
      "role": "user",
      "content": "Seu prompt aqui"
    }
  ]
}

a Anthropic executa classificadores antes de gerar a resposta. Esses classificadores verificam se o prompt se enquadra em uma das categorias protegidas.

Na maioria dos casos, o fluxo é simples:

Prompt do usuário
  -> Classificadores
  -> Claude Fable 5
  -> Resposta

Quando o prompt é sensível, o fluxo muda:

Prompt do usuário
  -> Classificadores
  -> Claude Opus 4.8
  -> Resposta pela mesma chamada de API

Do ponto de vista da sua aplicação, a chamada continua usando claude-fable-5. A diferença é que a resposta pode ter sido produzida pelo Opus 4.8.

Isso importa porque os modelos podem ter diferenças de estilo, profundidade e comportamento em tópicos sensíveis. Se você estiver avaliando qualidade de resposta, consistência ou cobertura de casos extremos, precisa considerar esse fallback.

Para entender a classe de modelo, veja também o que é um modelo de classe Mythos.

As três áreas protegidas

As salvaguardas do Claude Fable 5 cobrem três categorias. Elas não bloqueiam todo conteúdo desses domínios; o foco é reduzir riscos em capacidades consideradas mais sensíveis.

1. Cibersegurança

A primeira categoria é cibersegurança ofensiva. Isso inclui consultas relacionadas a:

Desenvolvimento de exploits
Fluxos de trabalho ofensivos
Tarefas agênticas de hacking
Aceleração de ataques

Quando o classificador detecta esse tipo de solicitação, a resposta é roteada para o Opus 4.8.

A intenção não é bloquear segurança defensiva, educação ou perguntas comuns de engenharia. O objetivo é evitar que o Fable 5 avance tarefas ofensivas de alto risco.

Na prática, se você cria ferramentas de segurança, inclua prompts defensivos e ofensivos simulados nos seus testes para entender onde o comportamento muda.

2. Biologia e química

A segunda categoria envolve consultas de biologia e química associadas a capacidades de maior risco, como design de AAV e temas relacionados a armas biológicas.

A maioria das perguntas científicas, médicas e educacionais deve seguir normalmente. O fallback é direcionado a uma faixa mais restrita de conteúdo perigoso.

Se seu produto atua em biotecnologia, saúde, química ou educação científica, teste prompts representativos antes de colocar o fluxo em produção.

3. Destilação de modelos

A terceira área é destilação de modelos.

Isso cobre tentativas de extrair comportamento do modelo para treinar ou reproduzir modelos concorrentes, por exemplo por meio de sondagem sistemática.

Diferente das duas primeiras categorias, aqui o risco principal não é dano físico, mas proteção do próprio modelo. O mecanismo, porém, é o mesmo:

Consulta suspeita de destilação
  -> Classificador
  -> Fallback para Opus 4.8

Como isso aparece na sua aplicação

O ponto mais importante: normalmente você não recebe um erro.

A chamada continua retornando uma resposta válida. O que pode mudar é o comportamento da resposta em tópicos protegidos.

Você pode observar diferenças como:

Tom diferente
Menos profundidade em certas instruções
Mais cautela em tópicos sensíveis
Respostas que parecem menos alinhadas ao perfil esperado do Fable 5

Como o fallback acontece na mesma chamada e com o mesmo ID de modelo, você não deve depender de uma única resposta para inferir qual modelo gerou a saída.

Uma abordagem prática é criar uma suíte de prompts.

Exemplo de estrutura:

tests/
  general/
    coding-prompts.txt
    writing-prompts.txt
  cybersecurity/
    defensive-prompts.txt
    offensive-boundary-prompts.txt
  biology-chemistry/
    educational-prompts.txt
    boundary-prompts.txt
  model-distillation/
    extraction-like-prompts.txt

Para cada prompt, registre:

{
  "prompt_id": "cyber-defense-001",
  "category": "cybersecurity",
  "expected_behavior": "resposta defensiva útil",
  "observed_behavior": "preencher após execução",
  "notes": "comparar tom, profundidade e completude"
}

Você pode executar esses prompts em uma ferramenta como Apidog, salvar coleções e repetir os testes quando mudar prompts, parâmetros ou fluxos do produto.

Por que rotear em vez de recusar

Uma recusa rígida é simples, mas também pode bloquear usos legítimos.

Exemplos de consultas legítimas que podem tocar áreas sensíveis:

Um pesquisador de segurança analisando defesa
Um estudante fazendo uma pergunta de biologia
Um desenvolvedor depurando comportamento que parece adversarial
Uma equipe de produto testando limites de segurança

O roteamento é uma alternativa mais flexível. Em vez de encerrar a interação, o sistema delega a resposta ao Opus 4.8, cujo comportamento nesses tópicos é considerado mais apropriado para exposição ampla.

O resultado prático é:

Tópicos comuns -> Fable 5 completo
Tópicos protegidos -> Opus 4.8

Assim, o Fable 5 continua disponível para a maioria dos casos, enquanto capacidades de maior risco são tratadas por um caminho mais controlado.

A Anthropic descreve sua abordagem geral na página de segurança e escalonamento responsável. Os detalhes de lançamento estão no anúncio do Fable 5 e Mythos 5.

Fable 5 vs Mythos 5

O Claude Mythos 5 é a contraparte do Fable 5 com salvaguardas suspensas em algumas áreas. Ele não é apresentado como uma arquitetura diferente ou como um modelo geralmente mais capaz; é o mesmo modelo subjacente com parte do roteamento removida.

Essa diferença muda o perfil de risco. Por isso, o Mythos 5 não é público. O acesso é restrito a parceiros do Projeto Glasswing, incluindo ciberdefensores, provedores de infraestrutura e pesquisadores de biologia selecionados.

Para uma comparação mais direta, veja Fable 5 vs Mythos 5.

Para a maioria dos desenvolvedores, a conclusão é simples:

Você usa claude-fable-5
As salvaguardas fazem parte do modelo
Não há flag pública para desativá-las
O acesso ao Mythos 5 não é feito por configuração de API

O que implementar no seu app

Para aplicações comuns, você não precisa alterar o código.

Use normalmente:

{
  "model": "claude-fable-5",
  "messages": [
    {
      "role": "user",
      "content": "Explique como estruturar testes unitários para esta função."
    }
  ]
}

As salvaguardas são automáticas e ficam do lado da Anthropic.

Mas se seu produto atua em cibersegurança, biologia, química ou avaliação de modelos, trate o fallback como parte do design.

Checklist prático

Antes de lançar, valide:

[ ] Seus prompts principais foram testados com claude-fable-5
[ ] Você tem casos de teste para domínios sensíveis, se aplicável
[ ] Sua UX não depende de respostas extremamente específicas nesses tópicos
[ ] Seus logs registram prompt, categoria e comportamento observado
[ ] Sua equipe entende que o fallback não gera erro de API
[ ] Seus testes cobrem mudanças de tom, profundidade e cautela

Exemplo de matriz de avaliação

| ID do prompt | Categoria | Resultado esperado | Resultado observado | Ação |
|-------------|-----------|-------------------|---------------------|------|
| gen-001 | Geral | Resposta completa pelo Fable 5 | OK | Nenhuma |
| cyber-001 | Segurança defensiva | Explicação segura e útil | OK | Nenhuma |
| cyber-002 | Limite ofensivo | Resposta cautelosa/fallback | Diferente do padrão | Ajustar UX |
| bio-001 | Educação científica | Resposta educacional | OK | Nenhuma |
| distill-001 | Extração de modelo | Comportamento controlado | OK | Documentar |

Custos

O preço permanece inalterado: US$ 10 por milhão de tokens de entrada e US$ 50 por milhão de tokens de saída. O fallback para Opus 4.8 não muda sua faixa de preço.

Para detalhes, consulte o guia de preços do Claude Fable 5.

Como testar o fallback

Uma forma prática de avaliar o comportamento é criar uma coleção de chamadas de API e executá-la repetidamente.

Fluxo sugerido:

Separe prompts por categoria.
Execute todos contra claude-fable-5.
Registre as respostas.
Compare tom, completude e restrições.
Atualize seus prompts ou sua UX quando encontrar comportamento diferente.
Repita antes de releases importantes.

Exemplo de registro simples:

{
  "model": "claude-fable-5",
  "prompt_category": "cybersecurity",
  "prompt_id": "cyber-002",
  "response_quality": "acceptable",
  "behavior_notes": "Resposta mais cautelosa do que prompts gerais",
  "requires_product_change": false
}

O guia de uso da API do Opus 4.8 também é útil, já que esse é o modelo usado no fallback para tópicos sensíveis.

Conclusão

As salvaguardas do Claude Fable 5 são uma camada automática de roteamento. Uma pequena parcela de solicitações sensíveis é enviada ao Claude Opus 4.8, enquanto o restante usa a capacidade completa do Fable 5.

Para a maioria dos aplicativos, isso não exige configuração. Para produtos em cibersegurança, biologia, química ou avaliação de modelos, o melhor próximo passo é montar uma suíte de prompts, executar testes pela API e documentar onde o comportamento muda.

Para continuar, veja:

Quando estiver pronto para testar prompts e comparar respostas, o Apidog pode ser usado para organizar e repetir suas chamadas de API.

Como Usar Claude Fable 5 com Claude Code

Lucas — Wed, 10 Jun 2026 03:04:36 +0000

A Anthropic lançou o Claude Fable 5 em 9 de junho de 2026 com foco em sessões de codificação longas e autônomas: exatamente o tipo de trabalho que muitos desenvolvedores tentam delegar ao Claude Code quando precisam alterar uma base de código inteira sem perder coerência. Se você já usa o CLI do Claude Code no dia a dia, habilitar o Fable 5 é basicamente uma troca de modelo — mas vale configurar, verificar e controlar custo antes de deixar o agente rodando por horas.

Experimente o Apidog hoje

Se você quer entender o modelo antes de configurá-lo, leia o que é o Claude Fable 5. Este guia foca no fluxo de trabalho prático com Claude Code.

TL;DR

Atualize e autentique o Claude Code para a versão v2.1.170 ou posterior. Depois, selecione o Fable 5 de uma destas formas:

/model fable

ou:

/model claude-fable-5

Você também pode iniciar uma sessão com:

claude --model fable

ou definir a variável de ambiente:

export ANTHROPIC_MODEL=claude-fable-5
claude

Confirme sempre com:

/status

O Fable 5 custa $10/M tokens de entrada e $50/M tokens de saída, ou seja, 2x o Opus 4.8. Use-o para tarefas longas e complexas, não como padrão para pequenas edições.

Quando usar o Claude Code com Fable 5

O Claude Code é o agente de codificação via terminal da Anthropic. Ele pode editar arquivos, executar comandos, navegar pelo projeto e realizar tarefas em várias etapas dentro do seu repositório.

O modelo escolhido define até onde esse agente consegue ir antes de perder contexto ou consistência. É aqui que o Fable 5 se diferencia.

Segundo a Anthropic, o Fable 5 foi criado para codificação autônoma de longo prazo. O modelo “mantém o foco em milhões de tokens em tarefas de longa duração e melhora suas saídas usando suas próprias anotações”.

Na prática, isso o torna mais adequado para tarefas como:

migrações grandes;
refatorações em vários módulos;
atualização de APIs em múltiplas rotas;
modernização de padrões internos;
alterações que exigem manter consistência em muitos arquivos;
execução de planos longos com validações intermediárias.

A Anthropic cita um caso da Stripe durante os testes: o Fable 5 completou uma alteração em uma base de 50 milhões de linhas de Ruby em um único dia, trabalho que a empresa estimou que levaria mais de dois meses manualmente. O relato completo está no anúncio do Claude Fable 5.

A contrapartida é custo. O Fable 5 custa:

$10 por milhão de tokens de entrada;
$50 por milhão de tokens de saída.

Isso é o dobro do Opus 4.8, que custa $5 e $25.

Portanto, não use Fable 5 para tudo. Uma regra prática:

Tarefa	Modelo recomendado
Ajuste pequeno em um arquivo	Sonnet ou Opus 4.8
Correção pontual de bug	Sonnet ou Opus 4.8
Refatoração local	Opus 4.8
Migração grande	Fable 5
Alteração em muitas rotas, schemas ou módulos	Fable 5
Sessão autônoma longa	Fable 5

Se você está comparando os modelos, veja também Claude Fable 5 vs Opus 4.8.

Se você já trocou modelos no Claude Code antes, o processo é o mesmo descrito em executando GLM-5.1 com Claude Code. O que muda é o ID do modelo.

Pré-requisitos

Antes de selecionar o Fable 5, valide estes pontos.

1. Atualize o Claude Code

O Fable 5 requer Claude Code v2.1.170 ou posterior.

Execute:

claude update

Depois confirme a versão:

claude --version

Se sua versão for anterior, o Fable 5 pode não aparecer no seletor de modelos.

2. Confirme acesso ao Fable 5

Você precisa de uma conta Anthropic com acesso ao modelo. Segundo o conteúdo original, o Fable 5 está disponível na API da Anthropic e em planos como Max, Team Premium, Enterprise pay-as-you-go e similares.

Importante: o Fable 5 não é o modelo padrão. Mesmo com acesso, você precisa selecioná-lo explicitamente.

3. Verifique faturamento ou assinatura

Como o Fable 5 é pago por token, sua conta precisa de faturamento de API ativo ou um plano que inclua o modelo.

Consulte os níveis atuais na visão geral dos modelos Anthropic.

4. Abra o terminal no repositório certo

O Claude Code opera dentro de um diretório de projeto.

Exemplo:

cd ~/projects/minha-api
claude

5. Atenção a ZDR

O Fable 5 não está disponível sob retenção zero de dados, ou ZDR.

Se sua organização usa Claude Code com ZDR ativado, o Fable 5 pode:

não aparecer no seletor;
aparecer desativado;
não poder ser selecionado.

Isso é uma restrição de política, não um bug do CLI.

Como configurar o Claude Code para usar Claude Fable 5

O Claude Code aceita quatro formas principais de escolher um modelo.

A ordem de prioridade é:

comando /model dentro da sessão;
flag --model na inicialização;
variável de ambiente ANTHROPIC_MODEL;
campo model no arquivo de configurações.

Você pode usar:

fable

ou:

claude-fable-5

O alias fable aponta para a versão Fable recomendada para seu provedor e pode ser atualizado com o tempo. O ID completo claude-fable-5 fixa o modelo exato.

A referência oficial está na documentação de configuração de modelo do Claude Code.

Opção 1: trocar o modelo dentro da sessão com `/model`

Dentro de uma sessão do Claude Code, execute:

/model fable

Ou use o ID completo:

/model claude-fable-5

Você também pode abrir o seletor interativo:

/model

Depois selecione o Fable 5 na lista.

Nas versões recentes, escolher um modelo com /model pode salvá-lo como padrão para novas sessões, escrevendo o campo model nas configurações do usuário.

No seletor:

Enter: troca para o modelo e salva como padrão;
s: troca apenas para a sessão atual.

Se você digitar diretamente:

/model fable

o comportamento é equivalente a selecionar e salvar. Sessões futuras iniciarão com Fable 5 até você mudar o modelo novamente.

Cuidado ao trocar no meio de uma conversa

Se a sessão já tiver histórico, o Claude Code pode pedir confirmação antes de trocar.

Motivo: a próxima resposta reprocessa o histórico completo sem o mesmo contexto em cache. Isso pode gerar um custo único adicional.

Para sessões caras, prefira selecionar o modelo antes de começar.

Opção 2: iniciar uma sessão com `--model`

Para usar Fable 5 em uma sessão específica sem mudar o padrão salvo:

claude --model fable

Ou:

claude --model claude-fable-5

Essa é a melhor opção quando você quer rodar modelos diferentes em terminais diferentes.

Exemplo:

# Terminal 1: tarefa longa
claude --model fable

# Terminal 2: correções menores
claude --model opus

A flag --model vale apenas para a sessão iniciada com ela.

Opção 3: definir `ANTHROPIC_MODEL`

Se você quer iniciar o Claude Code com Fable 5 a partir do shell:

export ANTHROPIC_MODEL=claude-fable-5
claude

Ou usando o alias:

export ANTHROPIC_MODEL=fable
claude

Isso afeta apenas sessões iniciadas nesse ambiente.

Se você também definir ANTHROPIC_MODEL dentro de settings.json, a variável exportada no shell vence, porque ela já existe antes de o Claude Code carregar o bloco env das configurações.

Opção 4: fixar o modelo em `settings.json`

Para tornar o Fable 5 o padrão persistente, edite o arquivo de configurações.

Configuração global do usuário:

~/.claude/settings.json

Configuração do projeto:

.claude/settings.json

Configuração local do projeto, aplicada apenas a você:

.claude/settings.local.json

Exemplo mínimo:

{
  "model": "claude-fable-5"
}

Ou usando o alias:

{
  "model": "fable"
}

Configurações de projeto e configurações gerenciadas podem ter precedência. Isso é útil em equipes que querem padronizar o modelo usado em um repositório.

Exemplo de configuração de projeto:

{
  "model": "fable"
}

Se um colega escolher outro modelo com /model, a configuração do projeto poderá ser reaplicada quando ele reiniciar o Claude Code.

Como verificar se você está usando Fable 5

Não presuma que a troca funcionou. Antes de iniciar uma execução longa, confirme o modelo ativo.

Dentro da sessão, execute:

/status

O comando mostra o modelo em uso junto com informações da conta.

Se você usa uma linha de status, o modelo ativo também pode aparecer continuamente no terminal.

Troubleshooting: selecionei Fable 5, mas `/status` mostra outro modelo

Se /status mostrar Opus 4.8 ou outro modelo, verifique estes pontos.

1. Configuração de projeto sobrescrevendo sua escolha

Procure arquivos como:

.claude/settings.json
.claude/settings.local.json
~/.claude/settings.json

Verifique se algum deles contém:

{
  "model": "opus"
}

ou outro valor.

Se a inicialização vier de uma configuração de projeto ou gerenciada, o cabeçalho de inicialização normalmente informa qual arquivo definiu o modelo.

Você pode sobrescrever apenas a sessão atual com:

/model fable

Mas, ao reiniciar, a configuração do projeto pode voltar a vencer.

2. Fallback automático para Opus 4.8

O Fable 5 executa classificadores de segurança para conteúdo de segurança cibernética e biologia. Quando uma requisição é sinalizada, o Claude Code pode executá-la novamente no modelo Opus padrão, que na API da Anthropic é o Opus 4.8, e mostrar um aviso na transcrição.

Isso significa que, mesmo depois de selecionar Fable 5, uma requisição individual pode cair para Opus 4.8.

Segundo a Anthropic, mais de 95% das sessões Fable não envolvem fallback. Para código de aplicação comum, isso deve ser raro.

Para voltar ao Fable 5 depois de um fallback:

/model fable

Fluxo recomendado para sessões longas

Para aproveitar o Fable 5 sem perder controle de custo e qualidade, trate a sessão como uma execução planejada.

1. Comece com escopo claro

Evite prompts vagos como:

Refatore esta API.

Prefira algo específico:

Migre todos os endpoints de usuários de callbacks para async/await.

Regras:
- mantenha os contratos HTTP existentes;
- não altere nomes de rotas;
- atualize testes relacionados;
- atualize a especificação OpenAPI se existir;
- rode a suíte de testes ao final;
- liste arquivos alterados e riscos.

2. Peça um plano antes das edições

Use um prompt como:

Antes de editar arquivos, analise o repositório e proponha um plano de migração em etapas. 
Não modifique nada ainda.

Depois revise o plano e só então autorize:

Execute o plano. Faça commits lógicos ou agrupe as alterações por etapa.

3. Divida tarefas grandes

Mesmo com Fable 5, uma execução longa fica mais segura com checkpoints.

Exemplo:

Execute apenas a etapa 1: atualizar a camada de serviço.
Depois pare e mostre um resumo das alterações antes de seguir para controllers e testes.

4. Exija validações

Peça para o Claude Code rodar comandos concretos:

Depois das alterações, rode:
- npm test
- npm run lint
- npm run typecheck

Se algum comando falhar, corrija antes de finalizar.

Ajuste os comandos conforme seu projeto:

pytest
go test ./...
mvn test
cargo test

5. Revise diffs antes de aceitar

Ao final, revise:

git diff

ou:

git status

Para tarefas muito grandes, peça um resumo técnico:

Liste:
- arquivos alterados;
- comportamento modificado;
- testes executados;
- riscos conhecidos;
- próximos passos recomendados.

Emparelhando Claude Code com Apidog

Quando o Claude Code termina de escrever ou alterar uma API, você ainda precisa confirmar se os endpoints se comportam corretamente. Um diff pode parecer certo, mas a API pode retornar status, headers ou payloads incompatíveis com o contrato.

É aqui que o Apidog entra no fluxo: Claude Code altera o código; Apidog valida o comportamento da API.

Use este fluxo após uma sessão do Claude Code que alterou sua API.

Passo 1: peça ao Claude Code para atualizar a especificação OpenAPI

Se o projeto já tem OpenAPI, peça para atualizar junto com a implementação:

Atualize a especificação OpenAPI para refletir as rotas alteradas.
Garanta que métodos, parâmetros, status codes e schemas estejam sincronizados com o código.

Se o projeto não tem uma especificação, peça para gerar uma para as rotas modificadas:

Gere uma especificação OpenAPI apenas para os endpoints alterados nesta sessão.
Inclua parâmetros, exemplos de request, responses e schemas.

Passo 2: importe a especificação no Apidog

No Apidog:

crie ou abra um projeto;
importe o arquivo OpenAPI;
revise os endpoints gerados;
configure o ambiente local ou staging.

O Apidog transforma paths, métodos, parâmetros e schemas em requisições executáveis.

Passo 3: execute os endpoints alterados

Aponte para seu servidor local ou staging e execute as requisições.

Verifique:

status code;
headers;
body;
campos obrigatórios;
formatos de data;
mensagens de erro;
paginação;
autenticação;
compatibilidade com o schema.

Passo 4: valide respostas contra o schema

Use o schema importado para detectar divergências entre contrato e implementação.

Exemplos de problemas que isso ajuda a encontrar:

campo obrigatório ausente;
tipo errado, como string no lugar de number;
status code diferente do documentado;
resposta de erro sem schema;
payload novo não refletido na OpenAPI.

Esse tipo de desvio é comum depois de alterações automatizadas em grande escala.

Passo 5: salve as requisições como testes de regressão

Depois que os endpoints passarem, salve as requisições como casos de teste.

Na próxima alteração feita pelo Claude Code — ou por qualquer pessoa da equipe — você poderá reexecutar o conjunto e validar rapidamente se algo quebrou.

Esse emparelhamento importa ainda mais com modelos de longo prazo. Quanto maior a alteração autônoma, maior a área de superfície a validar. Um conjunto executável no Apidog transforma “o agente terminou” em “os endpoints foram verificados”.

Você pode baixar o Apidog e importar uma especificação existente em poucos minutos.

Checklist final

Antes de rodar uma sessão longa com Fable 5:

[ ] Claude Code está em v2.1.170 ou posterior;
[ ] sua conta tem acesso ao Fable 5;
[ ] faturamento ou plano está ativo;
[ ] você está no repositório correto;
[ ] o modelo foi definido com /model, --model, ANTHROPIC_MODEL ou settings.json;
[ ] /status confirma Fable 5;
[ ] a tarefa tem escopo claro;
[ ] há comandos de teste definidos;
[ ] você sabe o custo esperado da execução;
[ ] endpoints alterados serão validados depois.

Use o Fable 5 quando a tarefa justificar uma sessão autônoma longa. Para mudanças pequenas, continue usando modelos mais baratos. Para migrações e refatorações grandes, configure o modelo explicitamente, confirme com /status, execute com checkpoints e valide o resultado com testes e ferramentas de API.

Claude Fable 5 Benchmarks: O que os números dizem

Lucas — Wed, 10 Jun 2026 02:55:35 +0000

Quando a Anthropic lançou o Claude Fable 5 em 9 de junho de 2026, ela o posicionou como estado da arte em quase todos os benchmarks relatados. Há uma ressalva importante: o anúncio trouxe principalmente posicionamentos em rankings, não tabelas completas com pontuações copiáveis. Portanto, use estes resultados como sinais direcionais e valide o modelo com seus próprios prompts antes de decidir por adoção. Para uma comparação mais ampla, veja também Opus 4.8 contra GPT-5.5 e Gemini 3.5.

Experimente o Apidog hoje

O Fable 5 está disponível por US$ 10 por milhão de tokens de entrada e US$ 50 por milhão de tokens de saída, sob o ID de modelo claude-fable-5. Ele fica acima do Opus 4.8 em capacidade e preço, e a Anthropic o apresenta como o Claude publicamente disponível mais forte para engenharia de software, trabalho de conhecimento, visão computacional e pesquisa científica.

Em resumo

O Claude Fable 5 aparece em primeiro lugar entre modelos de fronteira no FrontierCode e no FrontierBench, ambos da Cognition. Ele também é descrito como estado da arte no CursorBench e como o modelo com maior pontuação no Finance Benchmark da Hebbia.

Na prática, o sinal mais relevante é este: o Fable 5 parece forte em tarefas longas, multi-etapas e com muito contexto. Ainda assim, como as pontuações públicas exatas são limitadas, trate os rankings como direcionais, não como prova final de desempenho no seu caso de uso.

O que o resultado principal significa

A Anthropic afirma que o Fable 5 é estado da arte em quase todos os benchmarks executados, cobrindo:

engenharia de software;
trabalho de conhecimento;
visão computacional;
pesquisa científica;
tarefas autônomas de longa duração.

Essa afirmação não significa que o Fable 5 vença todos os testes por grande margem. Também não significa que todos os resultados já foram reproduzidos por laboratórios independentes. O ponto mais útil é a consistência: um modelo que fica perto do topo em codificação, documentos, finanças, visão e ciência tende a ser mais interessante para aplicações reais do que um modelo excelente em apenas um benchmark isolado.

Se você está avaliando se vale pagar mais pelo Fable 5, olhe menos para um gráfico específico e mais para a amplitude dos resultados. Para entender o modelo em detalhes, consulte o que é o Claude Fable 5.

Outro ponto recorrente é o trabalho de longo prazo. A Anthropic afirma que o Fable 5 “mantém o foco em milhões de tokens em tarefas de longa duração” e trabalha autonomamente por mais tempo do que qualquer Claude anterior. Isso é importante porque muitos benchmarks modernos não medem apenas uma resposta correta, mas a capacidade de manter plano, contexto e consistência em várias etapas.

Benchmarks de codificação: FrontierCode e CursorBench

A codificação é onde a história do Fable 5 fica mais concreta.

No FrontierCode, avaliação de codificação da Cognition, a Anthropic relata que o Fable 5 é o modelo de fronteira com maior pontuação. Mais importante: ele mantém essa liderança mesmo com esforço médio.

Esse detalhe importa. Em modelos de fronteira, “esforço” geralmente está ligado ao quanto de computação de inferência, raciocínio ou tentativas o modelo usa. Um modelo que lidera com esforço médio pode ser mais útil no dia a dia do que um modelo que só alcança bons resultados em configurações caras.

No CursorBench, a Anthropic descreve o Fable 5 como estado da arte e enfatiza que o modelo abriu uma classe de problemas de longo prazo que estavam fora do alcance de modelos anteriores. Esse benchmark é relevante para fluxos reais de engenharia, porque avalia tarefas com múltiplos arquivos e múltiplas etapas, não apenas geração de funções isoladas.

A leitura prática para desenvolvedores:

se você usa agentes de codificação para editar vários arquivos;
se o fluxo envolve executar testes, corrigir falhas e iterar;
se o projeto exige manter contexto por muito tempo;

então os resultados em FrontierCode e CursorBench são mais relevantes do que benchmarks simples de autocomplete.

Conhecimento e finanças: Finance Benchmark da Hebbia

Fora do código, o resultado mais claro vem do Finance Benchmark, desenvolvido pela Hebbia, empresa focada em IA para fluxos financeiros e jurídicos com muitos documentos.

Segundo a Anthropic, o Fable 5 alcança a maior pontuação entre os modelos avaliados nesse benchmark. Os ganhos aparecem principalmente em:

raciocínio sobre documentos;
interpretação de gráficos;
leitura de tabelas.

Isso é relevante porque análise financeira raramente é uma pergunta simples. Normalmente envolve ler PDFs longos, localizar números em páginas diferentes, comparar texto com gráficos e extrair valores corretos de tabelas densas.

Também há um componente de visão computacional. Em documentos reais, tabelas e gráficos podem aparecer como imagens, layouts mistos ou PDFs mal estruturados. Um bom resultado nesse benchmark sugere que o Fable 5 pode ser útil em pipelines onde a entrada não é um JSON limpo, mas um relatório financeiro, contrato, extrato ou apresentação.

Casos de uso prováveis:

extração de dados de PDFs;
análise de contratos;
leitura de relatórios financeiros;
reconciliação de tabelas e gráficos;
workflows internos de due diligence.

Ainda assim, valide com seus próprios documentos antes de confiar em qualquer benchmark.

Raciocínio de longo prazo: FrontierBench da Cognition

A segunda avaliação da Cognition, o FrontierBench, é onde a Anthropic posiciona o Fable 5 como modelo forte para autonomia de longa duração.

A ideia central é medir se o modelo consegue manter objetivo, plano e contexto ao longo de uma tarefa grande. Isso é diferente de responder a uma pergunta isolada. Em tarefas longas, o modelo precisa:

lembrar decisões anteriores;
manter consistência;
não se perder no próprio raciocínio intermediário;
continuar avançando mesmo com muitos tokens de contexto.

A Anthropic relata o Fable 5 como o modelo com maior pontuação no FrontierBench e conecta esse resultado à capacidade de “manter foco em milhões de tokens”.

Esse também é o tipo de resultado mais difícil de verificar externamente. Avaliar tarefas longas exige definir como pontuar progresso parcial, como detectar desvios e como evitar que o modelo “pareça ocupado” sem realmente avançar. Portanto, trate o FrontierBench como um sinal forte de direção, mas ainda dependente de metodologia.

Em conjunto com o CursorBench, a mensagem é consistente: a vantagem do Fable 5 parece estar menos em responder uma pergunta difícil e mais em não desmoronar durante uma tarefa longa.

Evidências de uso real além dos benchmarks

Benchmarks ajudam, mas implantações reais podem ser mais informativas. A Anthropic destacou dois exemplos.

O primeiro é uma migração de base de código da Stripe. Segundo a Anthropic, o Fable 5 migrou uma base Ruby de 50 milhões de linhas para a Stripe em um único dia, trabalho que a equipe estimava levar dois meses ou mais.

Esse caso é relevante porque uma migração grande não é apenas um problema de “inteligência”. É uma tarefa repetitiva, extensa e com muito contexto, espalhada por muitos arquivos. Pequenas inconsistências podem quebrar builds ou testes. O sinal principal é a capacidade de sustentar alterações corretas e consistentes em escala.

O segundo exemplo é um teste com Slay the Spire, usado para avaliar memória. Com memória de arquivo persistente habilitada, o Fable 5 mostrou melhoria de 3 vezes em relação ao Opus 4.8 no jogo.

O ponto técnico é que o modelo podia escrever notas em arquivos e relê-las em execuções posteriores, acumulando estratégia. Isso sugere que o Fable 5 pode se beneficiar bastante quando conectado a ferramentas e memória durável, em vez de operar sempre do zero.

Para agentes autônomos, isso importa. Se o seu sistema permite que o modelo use arquivos, banco de dados, logs, histórico ou memória persistente, o comportamento real pode ser melhor do que o observado em prompts isolados.

Como interpretar esses resultados

Use os benchmarks como entrada para decisão, não como decisão final.

1. Os donos dos benchmarks são parceiros

FrontierCode e FrontierBench vêm da Cognition. O Finance Benchmark vem da Hebbia. São organizações relevantes, mas fazem parte da narrativa de lançamento. Isso não invalida os resultados, mas reforça a necessidade de reprodução independente.

Para contexto adicional, compare com análises neutras, como MiniMax M3 versus Opus 4.7 versus GPT-5.5.

2. Configurações de “esforço” mudam o resultado

O resultado do FrontierCode foi relatado com esforço médio, o que é positivo. Mas esforço é uma variável importante.

Ao comparar modelos, verifique:

nível de esforço;
número de tentativas;
temperatura;
limite de tokens;
ferramentas disponíveis;
se houve retry automático.

Sem isso, duas pontuações podem não ser comparáveis.

3. As pontuações públicas são limitadas

O anúncio da Anthropic relatou principalmente rankings e gráficos em imagem. Por isso, ainda há pouca informação pública em formato tabular verificável.

Quando Cognition e Hebbia publicarem tabelas próprias, prefira essas fontes.

4. Ranking não é margem

“Maior pontuação” informa a posição, não a diferença. Um modelo pode liderar por pouco ou por muito. Sem a margem, é difícil decidir se o ganho justifica o preço.

Antes de integrar, confirme IDs, preços e limites atuais na visão geral dos modelos.

Execute seu próprio benchmark com o Apidog

O benchmark mais confiável é aquele que usa seus prompts, seus dados e sua definição de “bom”.

Você não precisa montar uma infraestrutura complexa. Uma avaliação simples já ajuda a comparar Fable 5 com Opus 4.8 em três dimensões:

qualidade da saída;
latência;
custo por chamada.

Abaixo está um fluxo simples usando o Apidog, uma plataforma para projetar, testar e documentar APIs.

1. Crie uma requisição POST para a API do Claude

No Apidog, crie uma requisição reutilizável:

POST https://api.anthropic.com/v1/messages
x-api-key: {{ANTHROPIC_API_KEY}}
anthropic-version: 2023-06-01
content-type: application/json

Use uma variável de ambiente para ANTHROPIC_API_KEY, em vez de colar a chave diretamente na requisição.

2. Use um prompt parecido com seu caso real

Evite prompts artificiais. Escolha algo que represente o trabalho que você espera automatizar.

Exemplo para codificação:

{
  "model": "claude-fable-5",
  "max_tokens": 2048,
  "messages": [
    {
      "role": "user",
      "content": "Refatorar este método Ruby para usar argumentos de palavra-chave e adicionar testes RSpec. Retorne apenas o código atualizado:\n\ndef charge(amount, currency, customer_id, idempotency_key)\n  # ...\nend"
    }
  ]
}

3. Execute contra o Fable 5

Rode a chamada com:

"model": "claude-fable-5"

Salve a resposta.

4. Duplique a requisição e troque o modelo

Agora duplique a requisição e altere apenas o campo model:

"model": "claude-opus-4-8"

Mantenha o mesmo prompt, max_tokens e demais parâmetros. Assim, qualquer diferença relevante vem do modelo, não da configuração.

5. Compare qualidade, latência e custo

Avalie cada resposta com uma rubrica simples.

Exemplo:

Critério	Pergunta
Correção	O código compila?
Cobertura	Os testes cobrem casos importantes?
Segurança	A resposta evita mudanças perigosas?
Manutenção	O código ficou mais claro?
Aderência	O modelo seguiu exatamente a instrução?

Depois, compare os sinais operacionais:

Latência: o Apidog mostra o tempo de resposta da requisição.
Tokens: a resposta do Claude inclui usage.input_tokens e usage.output_tokens.
Custo: multiplique os tokens pelas taxas publicadas.

Para o Fable 5:

custo_entrada = input_tokens / 1_000_000 * 10
custo_saida   = output_tokens / 1_000_000 * 50
custo_total   = custo_entrada + custo_saida

Para o Opus 4.8, usando os valores citados no artigo:

custo_entrada = input_tokens / 1_000_000 * 5
custo_saida   = output_tokens / 1_000_000 * 25
custo_total   = custo_entrada + custo_saida

6. Repita com 5 a 10 prompts reais

Um único prompt não prova muita coisa. Monte um conjunto pequeno com tarefas representativas, por exemplo:

refatoração de código;
correção de bug;
geração de testes;
leitura de documento;
extração de dados de tabela;
resumo técnico;
planejamento multi-etapas.

Depois compare:

modelo vencedor = melhor qualidade aceitável / custo e latência toleráveis

Esse benchmark caseiro não substitui avaliações públicas, mas responde à pergunta que realmente importa: o Fable 5 melhora os seus fluxos o bastante para justificar o preço?

Você pode baixar o Apidog e configurar esse teste em poucos minutos. Para analisar custos em mais detalhes, veja o guia de preços do Fable 5.

Claude Fable 5 Preços: Análise Completa de Custos (2026)

Lucas — Wed, 10 Jun 2026 02:49:27 +0000

O preço do Claude Fable 5 começa em $10 por milhão de tokens de entrada e $50 por milhão de tokens de saída na API da Anthropic. Para integrar o modelo em produção, trate o custo como uma função direta de tokens enviados e gerados. Este guia mostra as taxas da API, o impacto nos planos Pro e Max, exemplos com aritmética real e formas práticas de reduzir gastos ao usar o Fable 5 em aplicações, agentes e fluxos de desenvolvimento.

Experimente o Apidog hoje

TL;DR

O Claude Fable 5 custa:

Entrada: $10 por 1 milhão de tokens
Saída: $50 por 1 milhão de tokens
Modelo da API: claude-fable-5

De 9 de junho a 22 de junho de 2026, ele está incluído gratuitamente nos planos Pro, Max, Team e Enterprise baseados em assentos. A partir de 23 de junho de 2026, o uso nesses planos passa a consumir créditos medidos nas mesmas taxas de token da API.

Preço do Claude Fable 5 em resumo

Use esta tabela para estimar rapidamente o custo de uma chamada:

Tipo de token	Preço por 1M tokens	Preço por 1K tokens	O que conta
Entrada	$10.00	$0.01	Prompt, mensagem do sistema, histórico, contexto, documentos e definições de ferramentas
Saída	$50.00	$0.05	Resposta gerada, raciocínio produzido e argumentos de chamadas de ferramenta

A fórmula básica é:

custo = (tokens_entrada / 1_000_000) * 10
      + (tokens_saida / 1_000_000) * 50

Exemplo rápido:

Entrada: 2.000 tokens * $10 / 1.000.000 = $0.02
Saída:     600 tokens * $50 / 1.000.000 = $0.03
Total: $0.05

O ID do modelo é:

claude-fable-5

Os tokens de saída custam 5x mais que os tokens de entrada. Isso significa que controlar o tamanho das respostas costuma ter impacto direto no custo.

Você pode confirmar as taxas atuais na página de preços da Anthropic e na documentação de modelos e preços. Para comparação com modelos mais baratos, veja também o guia sobre Claude Opus 4.8.

O que você paga na API

A Anthropic cobra separadamente por tokens de entrada e tokens de saída.

Tokens de entrada

Tokens de entrada incluem tudo que você envia ao modelo:

prompt do usuário
mensagem do sistema
histórico de conversa
documentos recuperados
contexto de código
definições de ferramentas
JSON de chamadas e schemas

Eles custam:

$10 por 1M tokens
$0.01 por 1K tokens

Tokens de saída

Tokens de saída incluem tudo que o modelo gera:

resposta final
texto intermediário produzido
argumentos de tool calls
raciocínio gerado pelo modelo, quando aplicável

Eles custam:

$50 por 1M tokens
$0.05 por 1K tokens

Não há uma taxa fixa adicional por requisição. O custo total é a soma dos tokens de entrada e saída em cada chamada.

A Anthropic posiciona o Fable 5 como “menos da metade do preço do Claude Mythos Preview”. O modelo irmão restrito, Claude Mythos 5, tem a mesma taxa de $10 de entrada e $50 de saída, então alternar entre esses dois modelos não muda o custo por token.

Se você precisa entender as capacidades antes de estimar orçamento, veja o que é o Claude Fable 5.

Inclusão no plano vs. créditos de uso

O preço da API é direto, mas os planos de assinatura seguem uma janela específica.

De 9 a 22 de junho de 2026

O Claude Fable 5 está incluído sem custo adicional nos planos:

Pro
Max
Team
Enterprise baseado em assentos

Durante esse período, o uso do modelo não consome saldo medido nesses planos.

A partir de 23 de junho de 2026

O Fable 5 deixa de fazer parte do conjunto incluído nesses planos. Depois dessa data, o uso passa a consumir créditos medidos nas mesmas taxas da API:

Entrada: $10 / 1M tokens
Saída:   $50 / 1M tokens

A Anthropic informou que planeja restaurar algum acesso padrão ao plano quando a capacidade permitir, mas o comportamento que você deve usar para orçamento é o de cobrança medida.

Planos Enterprise baseados em consumo

Nos planos Enterprise baseados em consumo, o Fable 5 está disponível desde o lançamento e já é cobrado por uso.

Se sua dúvida for sobre acesso, não apenas faturamento, veja como acessar o Claude Fable 5.

Exemplos práticos de custo

A fórmula será sempre:

(tokens_entrada / 1.000.000) * 10
+
(tokens_saida / 1.000.000) * 50

Exemplo 1: turno de chatbot de suporte

Cenário:

1.500 tokens de entrada
500 tokens de saída

Cálculo:

Entrada: 1.500 / 1.000.000 * $10 = $0.015
Saída:     500 / 1.000.000 * $50 = $0.025

Total: $0.04 por turno

Se o chatbot processar 1.000 turnos por dia:

1.000 * $0.04 = $40/dia

Estimativa mensal:

$40 * 30 = $1.200/mês

Exemplo 2: geração de código

Cenário:

8.000 tokens de entrada
3.000 tokens de saída

Esse caso pode incluir arquivo atual, trechos relacionados, instruções e resposta com explicação.

Cálculo:

Entrada: 8.000 / 1.000.000 * $10 = $0.08
Saída:   3.000 / 1.000.000 * $50 = $0.15

Total: $0.23 por solicitação

Mesmo com mais tokens de entrada, a saída domina o custo:

$0.15 de $0.23 vêm da saída

Por isso, limitar respostas longas é uma das otimizações mais efetivas.

Exemplo 3: agente com contexto grande

Cenário:

300.000 tokens de entrada
50.000 tokens de saída

Esse padrão aparece em agentes que leem bases de código, documentos ou executam várias etapas.

Cálculo:

Entrada: 300.000 / 1.000.000 * $10 = $3.00
Saída:    50.000 / 1.000.000 * $50 = $2.50

Total: $5.50 por execução

Se uma equipe executar isso 200 vezes por dia:

200 * $5.50 = $1.100/dia

Esse é o tipo de carga em que cache de prompts pode reduzir bastante o custo.

Como reduzir sua conta do Claude Fable 5

Depois de decidir usar o Fable 5, aplique estas otimizações no design da aplicação.

1. Use cache de prompts para contexto estável

Leituras do cache custam cerca de 0,1x o preço de entrada. Isso reduz a entrada em cache para aproximadamente:

$1 por 1M tokens

Gravações no cache custam cerca de 1,25x o preço de entrada, aproximadamente:

$12.50 por 1M tokens para TTL de 5 minutos

Cache compensa quando o mesmo contexto é reutilizado várias vezes.

No exemplo do agente:

entrada total: 300.000 tokens
contexto estável em cache: 250.000 tokens
entrada nova: 50.000 tokens
saída: 50.000 tokens

Sem cache:

Entrada: $3.00
Saída:   $2.50
Total:   $5.50

Com cache:

250.000 tokens em cache * $1 / 1.000.000  = $0.25
50.000 tokens novos * $10 / 1.000.000    = $0.50
50.000 tokens saída * $50 / 1.000.000    = $2.50

Total: $3.25

2. Use a API de Lotes para tarefas assíncronas

Para trabalhos que não precisam de resposta imediata, como:

classificação em massa
processamento noturno de documentos
extração de dados
análise de logs
enriquecimento de registros

A API de Lotes oferece cerca de 50% de desconto.

Isso transforma aproximadamente:

Entrada: $10 -> $5 por 1M tokens
Saída:   $50 -> $25 por 1M tokens

Se a tarefa tolera atraso, use lote por padrão.

3. Escolha o modelo certo por tipo de tarefa

Nem toda requisição precisa do Fable 5.

Use roteamento por complexidade:

Tarefa simples        -> modelo mais barato
Tarefa de rotina      -> Opus 4.8, Sonnet 4.6 ou Haiku 4.5
Tarefa difícil        -> Fable 5
Raciocínio complexo   -> Fable 5

Um roteador simples pode usar regras como:

function escolherModelo({ tipo, criticidade, tamanhoContexto }) {
  if (criticidade === "alta") return "claude-fable-5";
  if (tipo === "raciocinio_complexo") return "claude-fable-5";
  if (tamanhoContexto > 100_000) return "claude-fable-5";

  return "modelo-mais-barato";
}

Se 80% do tráfego for roteado para modelos mais baratos, a conta total pode cair significativamente.

4. Defina `max_tokens` com limite realista

Como saída custa $50 por milhão de tokens, evite deixar a geração aberta.

Exemplo de configuração:

{
  "model": "claude-fable-5",
  "max_tokens": 800,
  "messages": [
    {
      "role": "user",
      "content": "Resuma este documento em até 10 bullet points."
    }
  ]
}

Se uma resposta cair de 3.000 para 1.500 tokens:

3.000 tokens de saída = $0.15
1.500 tokens de saída = $0.075

Você reduz pela metade o custo de saída dessa chamada.

5. Peça formatos de resposta curtos

Se você precisa de JSON, peça apenas os campos necessários.

Evite:

Explique em detalhes sua resposta e depois retorne um JSON completo.

Prefira:

Retorne apenas JSON válido, sem explicações.
Use somente os campos: status, score, reason.
Limite reason a 240 caracteres.

Isso reduz tokens de saída e melhora previsibilidade.

6. Use streaming para interromper respostas cedo

Streaming não muda o preço por token, mas permite parar a geração quando você já tem o necessário.

Isso é útil para:

interfaces de chat
respostas longas
geração de código
depuração interativa
agentes com passos intermediários

Combine streaming com max_tokens para evitar respostas maiores que o necessário.

Rastreie os gastos do Claude Fable 5 com Apidog

A forma mais prática de controlar custo durante o desenvolvimento é observar o uso de tokens em cada requisição, não apenas na fatura do fim do mês.

O Apidog é um cliente de API que você pode usar para enviar solicitações à API da Anthropic e inspecionar a resposta retornada.

Ao chamar claude-fable-5, verifique o objeto usage na resposta:

{
  "usage": {
    "input_tokens": 1500,
    "output_tokens": 500
  }
}

Calcule o custo da chamada assim:

const inputTokens = 1500;
const outputTokens = 500;

const custo =
  inputTokens * 0.00001 +
  outputTokens * 0.00005;

console.log(custo); // 0.04

Ou como função reutilizável:

function calcularCustoFable5({ inputTokens, outputTokens }) {
  const precoEntradaPorToken = 10 / 1_000_000;
  const precoSaidaPorToken = 50 / 1_000_000;

  return (
    inputTokens * precoEntradaPorToken +
    outputTokens * precoSaidaPorToken
  );
}

console.log(
  calcularCustoFable5({
    inputTokens: 8000,
    outputTokens: 3000
  })
); // 0.23

Um fluxo de trabalho prático:

Configure a requisição da API da Anthropic no Apidog.
Use o modelo claude-fable-5.
Salve prompts representativos como exemplos.
Execute variações do prompt.
Compare input_tokens e output_tokens.
Ajuste mensagem do sistema, contexto e formato de saída.
Defina max_tokens com base nos resultados reais.

Isso mostra rapidamente quando uma mudança no prompt aumenta centenas ou milhares de tokens.

Você pode baixar o Apidog e combinar com o guia da API do Claude Fable 5 para configurar a estrutura da requisição. Se estiver controlando orçamento durante a janela de inclusão, veja também como usar o Claude Fable 5 gratuitamente.

O Apidog também mantém histórico de solicitações, o que ajuda a comparar chamadas anteriores e estimar o custo de novos recursos. Tratar o Apidog como camada de inspeção de custos durante o desenvolvimento evita surpresas quando o tráfego cresce.

Checklist de implementação

Antes de colocar o Claude Fable 5 em produção, valide:

[ ] Você está usando o modelo claude-fable-5.
[ ] Cada chamada registra input_tokens e output_tokens.
[ ] O custo por chamada é calculado no ambiente de teste.
[ ] max_tokens está limitado por caso de uso.
[ ] Prompts pedem respostas concisas.
[ ] Contexto estável usa cache de prompts quando possível.
[ ] Tarefas assíncronas usam API de Lotes.
[ ] Chamadas simples são roteadas para modelos mais baratos.
[ ] Estimativas mensais usam as taxas de $10/$50, não apenas a janela gratuita.

Conclusão

O preço do Claude Fable 5 se resume a dois números:

Entrada: $10 por 1M tokens
Saída:   $50 por 1M tokens

A janela gratuita nos planos Pro, Max, Team e Enterprise baseados em assentos vai até 22 de junho de 2026. A partir de 23 de junho de 2026, o uso passa a consumir créditos medidos.

Para controlar custo em produção, meça tokens por requisição, limite a saída, use cache para contexto repetido, processe cargas assíncronas em lote e roteie tarefas simples para modelos mais baratos. O próximo passo é enviar uma requisição real para claude-fable-5, ler o objeto usage e calcular o custo com dados reais. Você pode baixar o Apidog para fazer essa primeira chamada e acompanhar o custo durante a iteração.

Claude Fable 5 vs Claude Mythos 5: Qual a Diferença?

Lucas — Wed, 10 Jun 2026 02:13:10 +0000

Em 9 de junho de 2026, a Anthropic lançou dois nomes para o mesmo modelo base: Claude Fable 5 e Claude Mythos 5. A diferença não está na capacidade bruta, mas na configuração de segurança. O Fable 5 é a versão pública, com salvaguardas, disponível pela API Claude. O Mythos 5 usa o mesmo modelo subjacente, mas com algumas salvaguardas removidas para um pequeno grupo de parceiros confiáveis.

Experimente o Apidog hoje

Na prática: se você é desenvolvedor e quer integrar Claude em um produto, você quase certamente usará o Claude Fable 5. O Claude Mythos 5 não tem acesso público, não possui inscrição aberta e não é um endpoint que você escolhe na API.

Resumo prático

Claude Fable 5 e Claude Mythos 5 compartilham o mesmo modelo subjacente de “classe Mythos”. O que muda é a camada de segurança:

Fable 5: público, com salvaguardas ativas, disponível via API e planos de assinatura.
Mythos 5: restrito, com salvaguardas removidas em domínios específicos para usuários verificados.
Preço: igual para ambos — US$10 por milhão de tokens de entrada e US$50 por milhão de tokens de saída.
ID público de API: claude-fable-5.

Mesmo modelo, duas configurações de segurança

A forma mais simples de entender a divisão é esta:

Fable 5 e Mythos 5 não são dois modelos diferentes. Eles são o mesmo modelo com políticas de segurança diferentes.

A Anthropic descreve o modelo subjacente como de classe Mythos. Esse termo indica o nível de capacidade do modelo base, não um produto separado. Tanto Fable 5 quanto Mythos 5 herdam essa mesma capacidade. Para mais contexto, veja o explicador sobre o que significa classe Mythos.

A diferença operacional é:

Claude Fable 5
- Disponível publicamente.
- Acessível pela API Claude e por planos de assinatura.
- Inclui salvaguardas em três áreas sensíveis.
- Usa o ID claude-fable-5.
Claude Mythos 5
- Não é público.
- Disponível apenas para grupos verificados.
- Remove salvaguardas específicas conforme o domínio autorizado.
- Não há inscrição pública.

Claude Fable 5 vs Mythos 5

Dimensão	Claude Fable 5	Claude Mythos 5
Modelo subjacente	Classe Mythos, compartilhado	Classe Mythos, compartilhado
Disponibilidade	Público	Não público
Salvaguardas	Ativas em 3 áreas sensíveis	Removidas em algumas áreas
Quem pode usar	Qualquer pessoa com acesso à API ou assinatura	Pequeno grupo verificado
Rota de acesso	API Claude, `claude-fable-5`, assinaturas	Projeto Glasswing e programas de acesso confiável
Inscrição	Aberta e pública	Sem inscrição pública
Preço de entrada	US$10 por milhão de tokens	US$10 por milhão de tokens
Preço de saída	US$50 por milhão de tokens	US$50 por milhão de tokens

A leitura prática da tabela é direta: o modelo é o mesmo; o acesso e as salvaguardas mudam. O preço não muda. Para detalhes sobre custos, veja as notas sobre preços do Claude Fable 5.

Como funcionam as salvaguardas do Fable 5

As salvaguardas do Fable 5 não são um filtro genérico aplicado a tudo. Elas são direcionadas a três categorias sensíveis.

Quando uma solicitação entra em uma dessas categorias, o Fable 5 não responde usando o modelo completo de classe Mythos. Em vez disso, a consulta é roteada para o Claude Opus 4.8, um modelo anterior com histórico de segurança mais estabelecido. Para entender esse modelo, veja o guia sobre o que é o Claude Opus 4.8.

As três áreas protegidas são:

Cibersegurança
- Desenvolvimento de exploits.
- Operações cibernéticas ofensivas.
- Hacking agêntico.
- Solicitações que parecem construir ferramentas de ataque.
Biologia e química
- Trabalhos biológicos ou químicos de alto risco.
- Exemplos citados incluem design de AAV e solicitações relacionadas a armas biológicas.
Destilação
- Tentativas de extrair comportamento do modelo para treinar modelos concorrentes.
- Protege o modelo contra cópia via suas próprias saídas.

Segundo a Anthropic, essas salvaguardas são acionadas em menos de 5% das sessões, em média. Para a maioria dos usos comuns — geração de código, análise de texto, automação, refatoração, sumarização e uso de ferramentas — você interage com o modelo completo de classe Mythos.

A Anthropic também relatou que um parceiro externo considerou as salvaguardas cibernéticas do Fable 5 entre as mais resilientes que havia avaliado. Para mais detalhes, veja a visão geral das salvaguardas de segurança do Fable 5.

O que o Mythos 5 desbloqueia

O Mythos 5 é a mesma base do Fable 5, mas com salvaguardas removidas em domínios específicos para usuários específicos.

Ele não é disponibilizado por um endpoint público. O acesso ocorre por programas controlados.

Projeto Glasswing

O Projeto Glasswing é uma colaboração com o governo dos EUA. Por esse caminho, o Mythos 5 é disponibilizado a defensores cibernéticos e provedores de infraestrutura com as salvaguardas cibernéticas removidas.

A lógica é defensiva: equipes que protegem redes e infraestrutura crítica podem precisar da capacidade cibernética completa que o Fable 5 redireciona.

Pesquisadores de biologia

A Anthropic também informou que pesquisadores de biologia receberão acesso ao Mythos 5 com salvaguardas de biologia e química removidas.

Esse acesso é limitado ao domínio relevante. Para esse grupo, as proteções cibernéticas continuam ativas.

Programa de acesso confiável

A Anthropic sinalizou um programa mais amplo de acesso confiável, mas os detalhes não são públicos. O ponto importante é que o Mythos 5 continua sendo acesso concedido, não self-service.

Usuários do Mythos Preview

Usuários existentes do Claude Mythos Preview podem atualizar para o Mythos 5. Esse caminho só vale para quem já estava dentro da prévia.

Por que a Anthropic separou Fable 5 e Mythos 5

A divisão resolve uma tensão comum em modelos mais capazes: utilidade versus segurança.

O Fable 5 maximiza disponibilidade pública. Ele entrega a capacidade de classe Mythos para a maioria dos casos de uso e redireciona apenas consultas em domínios de alto risco.

O Mythos 5 preserva a capacidade completa para usuários verificados em contextos onde o bloqueio atrapalharia trabalho legítimo de alto valor, como defesa cibernética ou pesquisa biológica autorizada.

A diferença não é “modelo bom” versus “modelo limitado”. A diferença é:

quem pode acessar;
quais salvaguardas estão ativas;
em quais domínios essas salvaguardas são removidas;
sob qual programa de confiança.

Você pode ler a abordagem diretamente no anúncio de Claude Fable 5 e Mythos 5 e nas páginas da Anthropic sobre segurança e escalonamento responsável.

Como usar o Claude Fable 5 na prática

Se você está integrando Claude em uma aplicação, use o ID:

claude-fable-5

Você não precisa configurar nada para o Mythos 5. Não há endpoint público claude-mythos-5.

Um fluxo de integração típico fica assim:

Crie ou configure sua chave de API Claude.
Defina o modelo como claude-fable-5.
Estime custo com base em:
- US$10 por milhão de tokens de entrada;
- US$50 por milhão de tokens de saída.
Teste prompts reais antes de colocar em produção.
Monitore latência, custo, tamanho de contexto e qualidade das respostas.

Exemplo conceitual de corpo de requisição:

{
  "model": "claude-fable-5",
  "max_tokens": 1024,
  "messages": [
    {
      "role": "user",
      "content": "Explique este trecho de código e sugira melhorias."
    }
  ]
}

Para padrões de integração e estrutura de chamada, o guia da API Claude Opus 4.8 mostra formatos aplicáveis também ao Fable 5, já que a forma geral da requisição é a mesma entre esses modelos.

Testando o Fable 5 com Apidog

Ao validar uma integração com o Fable 5, você provavelmente vai repetir chamadas, comparar prompts e inspecionar campos de resposta. Um cliente de API ajuda a tornar isso reproduzível.

Com o Apidog, você pode:

criar uma coleção para chamadas ao Claude;
salvar o corpo da requisição com claude-fable-5;
configurar variáveis de ambiente para a chave de API;
alternar entre ambientes de teste e produção;
documentar formatos de request e response;
compartilhar testes reproduzíveis com a equipe.

Um setup simples:

Environment variable:
ANTHROPIC_API_KEY=your_api_key

Model:
claude-fable-5

Depois, salve a requisição na coleção e reutilize o mesmo contrato durante o desenvolvimento. Se a integração fizer parte de um pipeline maior, documentar as entradas e saídas ajuda backend, frontend e QA a trabalharem em paralelo.

Você também pode baixar o Apidog para organizar sua coleção de chamadas do Fable 5 e manter os contratos da API documentados conforme a integração evolui.

FAQ

Claude Mythos 5 é o mesmo que Claude Fable 5?

Eles compartilham o mesmo modelo subjacente de classe Mythos. A diferença é a configuração de segurança. O Fable 5 tem salvaguardas ativas e é público. O Mythos 5 remove salvaguardas específicas para grupos verificados.

Posso usar o Claude Mythos 5?

Quase certamente não. Não há inscrição pública. O Mythos 5 é distribuído por programas controlados, como o Projeto Glasswing, uma trilha futura para pesquisadores de biologia, um programa mais amplo de acesso confiável e atualização para usuários existentes do Mythos Preview.

O que significa classe Mythos?

“Classe Mythos” descreve o nível de capacidade do modelo subjacente. Não é um produto separado. Fable 5 e Mythos 5 usam essa mesma base. Veja também o explicador da classe Mythos.

Fable 5 e Mythos 5 custam o mesmo?

Sim. Ambos usam o mesmo preço informado: US$10 por milhão de tokens de entrada e US$50 por milhão de tokens de saída.

O que é o Projeto Glasswing?

É uma colaboração entre a Anthropic e o governo dos EUA para fornecer o Mythos 5 a defensores cibernéticos e provedores de infraestrutura, com salvaguardas cibernéticas removidas para uso defensivo.

Por que o Fable 5 usa o Claude Opus 4.8 em alguns casos?

Porque consultas em três áreas sensíveis — cibersegurança, biologia/química e destilação — são redirecionadas para o Claude Opus 4.8. Segundo a Anthropic, isso ocorre em menos de 5% das sessões, em média.

Onde estão os detalhes oficiais?

Consulte a documentação de visão geral dos modelos, o anúncio oficial do Fable 5 e Mythos 5 e as páginas da Anthropic sobre notícias e segurança.

Próximo passo

Se você está criando uma integração hoje, use o modelo público:

claude-fable-5

Teste seus prompts reais, meça custo e latência, valide o comportamento em seus casos de uso e só então mova a integração para produção.

DEV Community: Lucas

Como Funcionam os Limites de Requisição do Claude Fable 5

TL;DR

Como os limites de taxa da Anthropic funcionam

Tipos de limite que você precisa monitorar

1. RPM: requisições por minuto

2. ITPM: tokens de entrada por minuto

3. OTPM: tokens de saída por minuto

Por que rajadas causam 429 mesmo com média baixa

Limites são por organização e por classe de modelo

Como os níveis avançam

O que isso significa para o Claude Fable 5

O limite mais crítico para Fable 5 costuma ser OTPM

Como verificar seus limites reais

1. Console da Anthropic

2. Cabeçalhos de resposta da API

Como lidar com erros 429

Use as retentativas do SDK

Controle manual quando necessário

Use fila para tráfego em rajadas

Como aumentar limites ou reduzir consumo

1. Aumente seu nível

2. Use Batches para jobs assíncronos

3. Ative cache de prompt

4. Ajuste max_tokens

5. Use streaming para respostas longas

Monitore seu uso do Fable 5 com Apidog

Como usar Claude Fable 5 no Cursor

TL;DR

Por que usar o Fable 5 no Cursor

Pré-requisitos

Como adicionar o Claude Fable 5 ao Cursor

1. Abra as configurações do Cursor

2. Localize o campo da Anthropic

3. Cole sua chave e verifique

4. Habilite a chave

5. Adicione o modelo claude-fable-5

6. Habilite o modelo

Observação sobre Base URL

Como selecionar o Fable 5 e confirmar que ele está ativo

1. Abra o chat ou painel do agente

2. Selecione claude-fable-5

3. Verifique o rótulo antes de executar

4. Faça um teste pequeno

5. Entenda possíveis fallbacks

Como controlar custo e faturamento

Preço do Fable 5

Compare com o Opus 4.8

Onde o custo aumenta

Estratégia prática

Cursor vs Claude Code para Fable 5

Teste as APIs que o Cursor constrói com o Apidog

1. Importe a definição da API

2. Execute uma requisição real

3. Compare a resposta com o schema

4. Salve as requisições

Próximo passo

Colaboração nativa Git para Testes e Engenharia de API

O que é o Modo Spec-first?

Pré-requisitos

Etapa 1: Criar um projeto Spec-first

Etapa 2: Configurar sincronização por webhook

Etapa 3: Navegar pelo workspace de especificações

Etapa 4: Editar arquivos de especificação

Edição em código

Edição em formulário

Etapa 5: Validar e pré-visualizar a especificação

Validar problemas

Pré-visualizar documentação

Etapa 6: Puxar alterações da equipe

Etapa 7: Fazer commit e push das suas alterações

Etapa 8: Trabalhar com branches

Etapa 9: Integrar com CI/CD

Alternativa: projetos baseados em armazenamento

Resumo

Top 7 Alternativas ao Scalar para Documentação de API em 2026

1. Apidog

2. Redocly

3. Mintlify

4. ReadMe

4. Ajuste `max_tokens`

5. Adicione o modelo `claude-fable-5`

2. Selecione `claude-fable-5`

Primeira chamada com `curl`