Resumo rápido: Claude Fable 5.1 vale a pena ser avaliado para depuração difícil, refatoração em escala de repositório e implementação que abrange muitos arquivos e chamadas de ferramentas. No Claude Code, selecione o modelo explicitamente, verifique o modelo ativo e a conexão, e escolha um nível de esforço adequado à tarefa. Este guia aborda acesso nativo, roteamento opcional via CometAPI, configuração persistente e um fluxo prático de inspecionar–implementar–testar–revisar. O objetivo é uma mudança funcional e revisável — não apenas uma resposta mais longa do modelo.
Principais pontos
- Selecione e verifique: use /model ou --model quando o modelo estiver disponível para sua conta ou provedor, depois confira
/statusantes de iniciar trabalhos substanciais. - Combine capacidade com a tarefa: reserve o modelo para trabalhos difíceis e multi-etapas nos quais o raciocínio adicional compense a latência e o custo; pontuações de benchmark não garantem desempenho no seu repositório.
- Ajuste o esforço de forma deliberada: comece com high para trabalho de codificação exigente, compare com medium em tarefas rotineiras, e use xhigh ou max apenas quando suas próprias avaliações justificarem.
- Proteja o fluxo: mantenha chaves de API fora de configurações de projeto compartilhadas, valide a conexão, alinhe o escopo, rode testes relevantes e revise o diff final.
O que é o Claude Fable 5.1?
Claude Fable 5.1 é o sucessor de setembro de 2026 do Claude Fable 5. A Anthropic o posiciona para raciocínio exigente e trabalho agentivo de longo horizonte. Ele oferece janela de contexto de 1 milhão de tokens, até 128K tokens de saída, entrada de texto e imagem, pensamento adaptativo sempre ativo e cinco níveis de esforço de low a max.
O formato da carga de trabalho importa mais do que o rótulo. O Fable 5.1 é projetado para tarefas que podem abranger muitos arquivos, comandos, testes, revisões e etapas de recuperação. A Anthropic ainda recomenda começar a maioria das cargas com o Opus 5 e migrar para o Fable 5.1 quando avaliações de esforço mais alto com o Opus forem insuficientes.
| Especificação oficial | Claude Fable 5.1 |
|---|---|
| Desenvolvedora | Anthropic |
| ID do modelo | claude-fable-5-1 |
| Data de lançamento | 1º de setembro de 2026 |
| Janela de contexto | 1M tokens |
| Saída máxima | 128K tokens |
| Entrada / saída | Texto e imagens → texto |
| Raciocínio | Adaptativo, sempre ativo |
| Esforço padrão | high |
| Níveis de esforço | low, medium, high, xhigh, max |
| Corte de conhecimento | junho de 2026 |
| Preço oficial de entrada | $10 / MTok |
| Preço oficial de saída | $50 / MTok |
| Leitura do cache | $0.25 / MTok |
| Latência comparativa | Mais lenta |
Por que o Claude Fable 5.1 é relevante para o Claude Code
O Claude Code é um ambiente de codificação agentiva: ele pode inspecionar um repositório, editar arquivos, executar comandos e rodar testes, em vez de apenas gerar trechos isolados. Benchmarks de codificação agentiva e fluxos de trabalho de negócios são, portanto, mais relevantes aqui do que pontuações gerais de curiosidades.
Quais tarefas justificam seu uso? Considere o Claude Fable 5.1 para uma refatoração entre módulos, uma falha recorrente com causa raiz pouco clara ou um recurso que exige mudanças coordenadas em APIs, persistência e testes. Use isso como regra prática de decisão, não como garantia derivada de benchmarks: comece trabalhos comuns com o Claude Opus 5, e escale quando avaliações de esforço mais alto ainda ficarem aquém. Para edições minúsculas ou iterações rápidas e econômicas, considere o Claude Sonnet 5. Julgue a escolha pela qualidade de conclusão verificada e pelo custo total da tarefa no seu repositório.
| Benchmarks oficiais selecionados | Fable 5.1 | Fable 5 | Opus 5 | GPT-5.6 Sol |
|---|---|---|---|---|
| Terminal-Bench 4.0 | 55.8% | 42.0% | 52.3% | 37.3% |
| AutomationBench | 31.4% | 17.1% | 26.9% | 19.6% |
| CursorBench 3.2.0 | 73.4% | 70.5% | 70.0% | 67.2% |
A Anthropic reporta 55.8% no Terminal-Bench 4.0, 31.4% no AutomationBench e 73.4% no CursorBench 3.2.0. Esses resultados sustentam o papel pretendido do Fable 5.1 em fluxos de trabalho de codificação voltados a terminal e multi-etapas, mas não garantem que ele será o melhor em todo repositório ou em todo nível de esforço.
Imagem oficial de benchmark da Anthropic
O que você precisa antes de usar o Claude Fable 5.1 no Claude Code?
Antes de configurar o Claude Fable 5.1 no Claude Code, conclua estas três verificações prévias:
- Versão do Claude Code: use Claude Code v2.1.255 ou superior. Rode
claude --versione atualize o cliente antes de solucionar problemas de seleção de modelo. - Acesso à conta ou API: confirme que seu plano Claude, conta na API da Anthropic ou credenciais de um gateway compatível estão ativos.
- Disponibilidade do modelo: verifique se
claude-fable-5-1está habilitado para sua conta, organização ou provedor antes de adicionar configuração persistente.
claude --version
npm install -g @anthropic-ai/claude-code@latest
Você também precisa de acesso por meio do seu plano Claude ou de uma configuração de API ou gateway. A Anthropic lista o modelo como ativo nas plataformas de desenvolvedor suportadas.
Torne a configuração persistente sem vazar sua chave de API
Exports no shell se aplicam apenas ao terminal atual. O Claude Code também suporta um bloco env em configurações no nível do usuário e locais do projeto. No Windows, o caminho de usuário é %USERPROFILE%\.claude\settings.json; no macOS e Linux é ~/.claude/settings.json.
{
"env": {
"ANTHROPIC_BASE_URL": "https://api.cometapi.com",
"ANTHROPIC_MODEL": "claude-fable-5-1"
}
}
Mantenha o segredo fora de configurações de projeto commitadas. A Anthropic alerta explicitamente para não colocar credenciais em um arquivo de configurações do projeto compartilhado. Forneça COMETAPI_KEY ou ANTHROPIC_AUTH_TOKEN por meio do seu shell local, fluxo de credenciais do sistema operacional ou um gerenciador de segredos.
Método 1: use o Claude Fable 5.1 diretamente no Claude Code
Etapa 1: inicie o Claude Code a partir da raiz do repositório
cd /path/to/your/project
claude
Começar pela raiz do repositório dá ao Claude Code o contexto do projeto desde o início.
Etapa 2: selecione o Fable 5.1 com /model
/model
Escolha Claude Fable 5.1 no seletor. O Claude Code suporta seleção de modelo por comando na sessão, flag de inicialização, variável de ambiente ou configurações. A referência oficial confirma que /model e --model substituem ANTHROPIC_MODEL.
Etapa 3: inicie diretamente no Fable 5.1
claude --model claude-fable-5-1
Use a flag de lançamento quando você já souber que a sessão justifica o Fable 5.1 e não quiser alternar depois.
Etapa 4: verifique o modelo ativo
/status
A verificação importa quando há várias camadas de configuração. A aba Status mostra o modelo ativo, a URL base e a origem da credencial, facilitando detectar uma configuração inesperada do usuário, do projeto, variável de ambiente ou rota do gateway.
Método 2: como conectar o Claude Code ao CometAPI?
O Claude Code pode conectar-se a um gateway que exponha um formato de API suportado. A documentação da Anthropic explica como definir a URL do gateway e a credencial e alerta que gateways de terceiros não são endossados nem mantidos pela Anthropic. Valide todo recurso do Claude Code do qual seu fluxo de trabalho dependa.
O CometAPI lista o Claude Fable 5.1 como ativo e expõe um endpoint Anthropic-compatível de Messages em /v1/messages. Como o Claude Code mapeia ANTHROPIC_AUTH_TOKEN para um cabeçalho Authorization Bearer, confirme o formato de autenticação atual na página do modelo antes do uso em produção.
macOS, Linux ou WSL
export COMETAPI_KEY="YOUR_COMETAPI_KEY"
export ANTHROPIC_BASE_URL="https://api.cometapi.com"
export ANTHROPIC_AUTH_TOKEN="$COMETAPI_KEY"
export ANTHROPIC_MODEL="claude-fable-5-1"
claude
Windows PowerShell
$env:COMETAPI_KEY = "YOUR_COMETAPI_KEY"
$env:ANTHROPIC_BASE_URL = "https://api.cometapi.com"
$env:ANTHROPIC_AUTH_TOKEN = $env:COMETAPI_KEY
$env:ANTHROPIC_MODEL = "claude-fable-5-1"
claude
Após iniciar, rode /status. As linhas de URL base da Anthropic e credencial devem mostrar a rota do gateway e um token de autenticação ativo. Em seguida, envie um prompt pequeno de teste antes de iniciar uma tarefa longa.
Um gateway pode ficar atrás de novos campos ou endpoints do Claude Code. Se um recurso se comportar de forma diferente via CometAPI, repita o mesmo fluxo diretamente na Anthropic antes de atribuir o comportamento ao modelo.
Qual nível de esforço escolher para codificação?
O Fable 5.1 usa pensamento adaptativo e suporta esforços low, medium, high, xhigh e max. A Anthropic recomenda começar no nível padrão high e testar os demais com seu próprio conjunto de avaliação. Esforço é o principal controle para equilibrar inteligência, latência e custo.
| Esforço | Bons casos de uso no Claude Code | Trade-off |
|---|---|---|
| low | Edições minúsculas, explicações rápidas, mudanças locais simples | Menor custo de raciocínio; pode buscar menos |
| medium | Implementação rotineira, correções diretas, revisão normal | Bom equilíbrio entre qualidade e custo |
| high | Trabalho sério multi-arquivo, depuração, implementação com testes | Ponto de partida recomendado |
| xhigh | Refatorações difíceis, depuração complexa, trabalho sensível à arquitetura | Mais raciocínio e latência |
| max | Tarefas muito difíceis e sensíveis à capacidade, de longo horizonte | Maior tempo e uso de tokens |
Em medium, a Anthropic diz que o Fable 5.1 pode aproximar o Fable 5 a um custo menor. Em low, ele pode acionar ferramentas de busca e recuperação com menos frequência; portanto, low não é automaticamente a escolha certa para tarefas que dependem do código ou documentação atuais.
Um fluxo de trabalho prático com Fable 5.1 no Claude Code
A configuração é apenas metade do trabalho. O Fable 5.1 funciona melhor quando a tarefa separa explicitamente inspeção, confirmação de escopo, implementação, verificação e revisão.
Etapa 1: comece com análise do repositório
Analyze this repository before editing anything.
Goal: add a new /api/v1/reports endpoint that returns a paginated report list.
First:
1. Find the current API routing pattern.
2. Identify the service and persistence layers involved.
3. Find existing pagination conventions.
4. Identify the relevant tests.
5. Propose the smallest implementation plan.
Do not modify files until you have summarized the plan.
Essa primeira passagem expõe suposições incorretas antes que elas se espalhem por vários arquivos.
Etapa 2: confirme o escopo e só então implemente
Implement the approved plan.
Constraints:
- Change only files required for this feature.
- Follow existing project conventions.
- Prefer targeted edits over whole-file rewrites.
- Do not refactor unrelated code.
- Add or update only the tests needed for this feature.
- Report unrelated defects instead of fixing them automatically.
Essa redação segue a recomendação da Anthropic de preferir edições pontuais e manter o trabalho dentro do escopo solicitado.
Etapa 3: rode os testes relevantes
Run the relevant unit and integration tests after implementation.
If a test fails:
1. Identify the root cause.
2. Explain whether this change caused the failure.
3. Fix only failures caused by this change.
4. Rerun the smallest relevant test set before the broader suite.
O checkpoint é observável: os testes relevantes passam, ou o Claude relata a falha restante e sua relação com a mudança solicitada.
Etapa 4: revise o diff antes de aceitar o trabalho
Review your final changes as if you were a code reviewer.
Check for:
- behavior outside the requested scope,
- missing edge cases,
- regressions,
- duplicated logic,
- unnecessary file changes,
- tests that do not verify the new behavior.
Then summarize the final diff, tests run, and remaining risks.
Essa última passagem oferece ao revisor humano uma lista de aceitação compacta e ajuda a expor trabalho desnecessário antes de chegar ao pull request.
Instruções recomendadas de CLAUDE.md para o Claude Fable 5.1
Um arquivo curto de instruções no nível do repositório pode melhorar a consistência entre sessões. Inclua apenas regras e comandos que o Claude, de outra forma, precisaria redescobrir.
# Repository Instructions
- Inspect the existing implementation before editing.
- Keep changes within the requested scope.
- Prefer surgical edits over whole-file rewrites.
- Follow existing project conventions.
- Run relevant tests after implementation.
- Fix root causes rather than patching symptoms.
- Report unrelated issues instead of changing them automatically.
- Summarize files changed, tests run, and remaining risks.
Para um monorepo grande, adicione o gerenciador de pacotes, comandos de teste e lint, limites de arquitetura, regras de arquivos gerados e diretórios que não devem ser editados manualmente.
Quando usar o Claude Fable 5.1 em vez do Opus 5?
A questão prática não é se o Claude Fable 5.1 é mais novo, mas se sua tarefa precisa de mais raciocínio sustentado do que o Opus 5 consegue entregar de forma confiável. A Anthropic recomenda começar a maioria das cargas com o Opus 5; no Claude Code, trate o Fable 5.1 como opção de escalonamento para o trabalho mais difícil de longo horizonte.
| Fator de decisão | Claude Fable 5.1 | Claude Opus 5 |
|---|---|---|
| Escopo da tarefa | Migrações em escala de repositório, refatorações entre módulos e investigações ambíguas | Recursos, correções, revisões e refatorações contidas |
| Horizonte de razão | Sessões autônomas longas com uso repetido de ferramentas, testes, revisões e recuperação | Sessões de codificação mais curtas e bem delimitadas, com caminhos de conclusão mais claros |
| Qualidade vs velocidade | Use quando a qualidade de conclusão verificada nas tarefas mais difíceis for o que mais importa | Melhor equilíbrio padrão entre qualidade, latência e custo |
| Gatilho de escalonamento | Esforços mais altos no Opus ainda falham, perdem coerência ou exigem recuperação repetida | Primeira escolha para a maioria do trabalho no Claude Code |
| Latência e custo | Vale o prêmio apenas quando muda materialmente o resultado verificado | Melhor ajuste para trabalho rotineiro ou interativo |
| Melhor encaixe | Codificação agentiva difícil e de longo horizonte | Codificação profissional complexa padrão |
Uma regra prática de escalonamento
Comece com o Opus 5 em high. Troque para o Fable 5.1 quando uma ou mais das seguintes forem verdadeiras:
- Escopo: a tarefa abrange muitos arquivos ou serviços interdependentes e requer uso repetido de ferramentas, testes, revisões e recuperação.
- Confiabilidade: o Opus 5 em high ainda perde dependências, perde coerência entre etapas ou não conclui o fluxo com confiabilidade.
- Custo de falha: o custo de uma mudança incompleta ou incorreta é maior do que a latência adicional e o gasto de API exigidos pelo Fable 5.1.
Use o Fable 5.1 apenas se ele melhorar materialmente a conclusão verificada na mesma tarefa do repositório; caso contrário, volte ao Opus 5.
Na prática, o Fable 5.1 é o candidato mais forte para migrações em todo o repositório, depuração entre módulos, trabalho de recursos multi-serviço e análise difícil de causa raiz que exige inspeção, execução, testes e recuperação repetidos. Para correções isoladas, trabalho de recursos rotineiro, revisão de código e documentação, o Opus 5 continua sendo o padrão melhor.
Solução de problemas
O Claude Fable 5.1 não aparece em /model
Atualize o Claude Code, reinicie o terminal e a sessão e confirme que a conta ou organização tem acesso. Em seguida, verifique se configurações gerenciadas restringem a seleção de modelos.
O Claude Code está usando o modelo errado
Rode /status e inspecione todas as camadas de configuração. A referência oficial afirma que --model e /model substituem ANTHROPIC_MODEL. Verifique também configurações de usuário, projeto e locais do projeto.
O CometAPI retorna 401 ou erros de autenticação
Verifique a chave de API, a URL base e a variável de credencial. O Claude Code envia ANTHROPIC_AUTH_TOKEN via Authorization: Bearer, enquanto ANTHROPIC_API_KEY mapeia para x-api-key. Use a forma aceita pelo endpoint atual do CometAPI.
A sessão está muito lenta ou cara
Não use max para toda tarefa. Compare medium e high em um conjunto representativo de avaliação, meça o custo total da tarefa e a qualidade de conclusão, e reserve xhigh ou max para casos em que o raciocínio adicional muda o resultado.
O Fable 5.1 reescreve mais código do que o necessário
Adicione a seguinte restrição de escopo ao prompt ou ao CLAUDE.md.
Prefer targeted edits over whole-file rewrites unless a rewrite is required for correctness.
A Anthropic documenta especificamente esse comportamento e recomenda edições pontuais para mudanças pequenas.
Perguntas frequentes
O Claude Fable 5.1 pode rodar no Claude Code?
Sim. Use o seletor de modelos ou inicie o Claude Code com --model claude-fable-5-1 quando o modelo estiver disponível para sua conta ou provedor.
Qual é o ID do modelo Claude Fable 5.1?
O ID oficial na API do Claude é claude-fable-5-1.
Como alternar modelos durante uma sessão?
Rode /model, escolha Claude Fable 5.1 e use /status para confirmar o modelo ativo e a rota.
Qual nível de esforço devo usar?
Comece com high para trabalho sério de codificação. Teste medium em tarefas rotineiras e use xhigh ou max apenas quando suas próprias avaliações mostrarem ganho de qualidade significativo.
Posso usar o CometAPI com o Claude Code?
O Claude Code suporta gateways compatíveis, e o CometAPI expõe um endpoint Messages compatível com a Anthropic para o Fable 5.1. Valide o formato de autenticação e todo recurso do Claude Code do qual você dependa.
O Fable 5.1 é sempre melhor que o Opus 5?
Não. A Anthropic recomenda o Opus 5 para a maioria das cargas e o Fable 5.1 para raciocínio exigente, trabalho agentivo de longo horizonte ou casos em que o Opus 5 em esforço mais alto é insuficiente.
Por que usar o Fable 5.1 em vez do Sonnet 5?
Use o Fable 5.1 quando raciocínio de longo horizonte e conclusão autônoma importarem mais do que velocidade e preço. O Sonnet 5 costuma ser a escolha mais econômica para ciclos rápidos e rotineiros de codificação.
Conclusão
O Claude Fable 5.1 é mais atraente no Claude Code quando a tarefa é maior do que uma edição normal: um recurso em escala de repositório, investigação difícil, migração multi-arquivos ou sessão autônoma que precise continuar planejando, executando, testando e se recuperando ao longo de um longo horizonte.
A rota nativa mais rápida é /model ou claude --model claude-fable-5-1. Se preferir uma camada de API unificada, o CometAPI fornece o Claude Fable 5.1 por meio de um endpoint Messages compatível com a Anthropic. Independentemente da rota escolhida, trate o nível de esforço, o controle de escopo, os testes e a revisão do diff final como parte da configuração do modelo.