Anthropic colocou uma etiqueta de preço bem clara na autonomia de fronteira: Claude Fable 5 aparece por US$ 10 por milhão de tokens de entrada e US$ 50 por milhão de tokens de saída na Claude API, enquanto Sonnet 4.6 custa US$ 3/US$ 15 e Opus 4.8 custa US$ 5/US$ 25 (Fable, Sonnet, Opus). Essa diferença é a decisão de produto inteira.
Se você manda todo prompt de programação para Fable, você não está sendo “frontier”. Você está pulando arquitetura.
Em 16 de junho de 2026, também existe uma complicação de disponibilidade: a página de Fable da Anthropic diz que Fable 5 está indisponível no momento, e a Anthropic afirma que suspendeu o acesso em 12 de junho depois de uma diretiva do governo dos EUA cobrindo Fable 5 e Mythos 5 (comunicado da Anthropic). Isso não torna a camada de roteamento menos útil. Torna mais urgente. Seu app já deveria saber degradar de Fable para Opus ou Sonnet sem acordar um engenheiro.
Este guia cria essa camada: Sonnet por padrão, Opus para trabalho de produção de alto risco, Fable só para jobs longos de agentes em que o valor de uma resposta correta supera a conta de tokens.
A regra de roteamento: Fable é especialista, não padrão
Comece com uma tabela direta.
| Model | API model ID | Input / output price | Use it for |
|---|---|---|---|
| Claude Sonnet 4.6 | claude-sonnet-4-6 | $3 / $15 per 1M tokens | programação rotineira, revisão, suporte, extração, a maioria dos agentes |
| Claude Opus 4.8 | claude-opus-4-8 | $5 / $25 per 1M tokens | código em nível de produção, revisões complexas, etapas de agentes que exigem julgamento |
| Claude Fable 5 | claude-fable-5 | $10 / $50 per 1M tokens | trabalho longo e de alto valor com agentes, quando há ganho real |
O posicionamento da própria Anthropic combina com essa divisão. Sonnet 4.6 é apresentado como o modelo versátil do dia a dia para programação, agentes e fluxos profissionais, com uma janela de contexto de 1 milhão de tokens atualmente em beta na API (Anthropic Sonnet). Opus 4.8 é posicionado para programação séria, fluxos agentic e tarefas corporativas de alto risco (Anthropic Opus). Fable 5 é descrito como um modelo em nível Mythos para projetos ambiciosos e longos, e agentes capazes de planejar em etapas, delegar e checar o próprio trabalho (Anthropic Fable).
Isso dá uma política limpa:
- Use Sonnet por padrão. A maioria dos prompts não merece um modelo de US$ 50/M em saída.
- Escale para Opus quando errar sai caro. Pense em migrações de schema, revisão de PR sensível a segurança, análise financeira e refatorações multiarquivo.
- Use Fable só quando a tarefa for grande, ambígua e justificar uma conta maior. Execuções de agentes por vários dias, modernização de codebase, pacotes de pesquisa profunda e fluxos do tipo “leve este projeto até o fim”.
O debate da comunidade gira principalmente em torno desse terceiro balde. A thread do HN sobre a suspensão da Anthropic em 12 de junho atraiu mais de mil comentários segundo recaps indexados do HN, e a discussão rapidamente se dividiu entre segurança, geopolítica e se alguém consegue bancar uso agentic com esses preços (thread no HN, referência de recap). As threads no Reddit foram mais diretas: desenvolvedores reclamaram de sessões do Claude Code famintas por tokens, limites de assinatura e se US$ 50/M em saída empurra Fable para território exclusivo de empresas (discussão no ClaudeCode, discussão no subreddit do ChatGPT).
A resposta prática que falta na maioria das threads: não discuta sobre um único “melhor modelo” global. Faça roteamento por valor esperado.
Passo 1: Use OneHop como camada de acesso drop-in
Se você quer o caminho mais curto, use OneHop como camada de provedor e mantenha o código do seu app neutro em relação a provedor. A página de Fable da OneHop lista anthropic/claude-fable-5, mostra preços oficiais ao lado dos preços da OneHop e diz que novas contas recebem US$ 10 grátis sem exigir cartão (OneHop Fable 5). A página atual lista suporte a Anthropic Messages em https://api.onehop.ai/anthropic; use isso com o Anthropic SDK.
Instale o SDK:
pip install anthropic
export ONEHOP_API_KEY="your_key_here"Chamada mínima:
from anthropic import Anthropic
client = Anthropic(
api_key=os.environ["ONEHOP_API_KEY"],
base_url="https://api.onehop.ai/anthropic",
)
message = client.messages.create(
model="anthropic/claude-fable-5",
max_tokens=1024,
messages=[{"role": "user", "content": "Plan a safe Rails 6 to Rails 8 migration."}],
)
print(message.content[0].text)Esse é o ponto de integração. Sua camada de roteamento deve ficar acima dele e decidir qual string de modelo enviar.
O valor da OneHop aqui é tedioso do melhor jeito: uma conta, uma página de modelo clara e uma troca de base URL em vez de reescrever sua aplicação. Se Fable estiver pausado ou indisponível, o mesmo roteador pode apontar tarefas premium para Opus e manter o produto vivo.
Comece por aqui se você só quer acesso e créditos: Claude Fable 5 na OneHop, depois comece com US$ 10 grátis.
Passo 2: Crie um roteador consciente de orçamento
Aqui vai um roteador compacto em Python que você pode rodar. Ele estima o custo da requisição, aplica um teto por chamada, faz fallback quando Fable está indisponível e mantém Sonnet como padrão.
import os
from dataclasses import dataclass
from anthropic import Anthropic, APIError, RateLimitError
PRICES = {
"sonnet": {"model": "claude-sonnet-4-6", "in": 3.00, "out": 15.00},
"opus": {"model": "claude-opus-4-8", "in": 5.00, "out": 25.00},
"fable": {"model": "anthropic/claude-fable-5", "in": 10.00, "out": 50.00},
}
@dataclass
class Task:
kind: str
prompt: str
max_output_tokens: int = 2000
budget_usd: float = 0.25
high_value: bool = False
long_running: bool = False
production_risk: bool = False
def rough_tokens(text: str) -> int:
return max(1, len(text) // 4)
def estimate_cost_usd(model_key: str, input_tokens: int, output_tokens: int) -> float:
price = PRICES[model_key]
return (input_tokens / 1_000_000 * price["in"]) + (output_tokens / 1_000_000 * price["out"])
def choose_model(task: Task) -> str:
if task.high_value and task.long_running:
return "fable"
if task.production_risk or task.kind in {"migration", "security_review", "architecture"}:
return "opus"
return "sonnet"
def route_with_budget(task: Task) -> list[str]:
first = choose_model(task)
fallbacks = {
"fable": ["fable", "opus", "sonnet"],
"opus": ["opus", "sonnet"],
"sonnet": ["sonnet"],
}[first]
input_tokens = rough_tokens(task.prompt)
return [
key for key in fallbacks
if estimate_cost_usd(key, input_tokens, task.max_output_tokens) <= task.budget_usd
] or ["sonnet"]
def run(task: Task) -> str:
client = Anthropic(
api_key=os.environ["ONEHOP_API_KEY"],
base_url="https://api.onehop.ai/anthropic",
)
last_error = None
for key in route_with_budget(task):
try:
response = client.messages.create(
model=PRICES[key]["model"],
max_tokens=task.max_output_tokens,
messages=[{"role": "user", "content": task.prompt}],
)
return response.content[0].text
except (APIError, RateLimitError) as exc:
last_error = exc
continue
raise RuntimeError(f"All model routes failed: {last_error}")
if __name__ == "__main__":
task = Task(
kind="migration",
prompt="Create a step-by-step plan to migrate a 200k-line Django app from 3.2 to 5.x.",
max_output_tokens=3000,
budget_usd=0.20,
production_risk=True,
)
print(run(task))O ponto importante não é o estimador de tokens. É a fronteira de política. Você precisa de um lugar no seu codebase onde o produto diga: “Esta tarefa tem permissão para gastar mais porque o resultado importa.”
Passo 3: Adicione limites que combinem com o comportamento real de agentes
Custos de agentes são irregulares. Uma conclusão de chat é fácil de precificar. Um agente de programação pode inspecionar arquivos, chamar ferramentas, reescrever, testar, tentar de novo e resumir. Uma thread no Reddit afirmou que uma execução com Fable queimou milhões de tokens em uma hora; trate isso como anedota, mas o padrão é real o bastante: agentes de horizonte longo multiplicam o uso de tokens por meio de loops (Reddit).
Adicione três limites:
- Limite por chamada: recuse ou reduza o modelo se o custo estimado passar do orçamento da requisição.
- Limite por tarefa: pare o agente depois de um limite em dólares, mesmo que as chamadas individuais sejam válidas.
- Limite por usuário ou workspace: impeça um time de queimar a conta compartilhada.
Em produção, armazene o gasto em uma tabela de banco de dados com chave por workspace_id, task_id e model. Não dependa só dos dashboards do fornecedor. Eles servem para reconciliação de cobrança, não para controle ao vivo do produto.
Também use prompt caching de forma agressiva. A Anthropic diz que Fable mantém o desconto existente de 90% em tokens de entrada com prompt caching, e as páginas de Sonnet e Opus também listam economia de até 90% com prompt caching (Fable, Sonnet, Opus). Faça cache das partes estáveis: mapa do repositório, padrões de código, docs de API, resumos de schema e especificações longas de produto. Não faça cache de instruções voláteis do usuário.
Uma boa camada de roteamento deve registrar estes campos em cada chamada:
{
"task_kind": "migration",
"chosen_model": "opus",
"fallback_from": "fable",
"estimated_cost_usd": 0.18,
"budget_usd": 0.20,
"input_tokens": 12000,
"max_output_tokens": 3000
}Esse log é como você responde ao CFO, ao staff engineer e ao usuário que pergunta por que o agente parou.
Passo 4: Trate fallback como comportamento de produto
Fable tem dois tipos de fallback que você precisa planejar.
O primeiro é o fallback normal de infraestrutura: modelo indisponível, rate limit, timeout, problema no provedor. O status atual de Fable prova que isso importa. A Anthropic diz que o acesso a outros modelos não foi afetado pela diretiva de 12 de junho (Anthropic), então um bom app deve continuar funcionando via Opus ou Sonnet.
O segundo é fallback de segurança. A Anthropic diz que Fable roteia algumas solicitações sinalizadas de cibersegurança e biologia para Opus 4.8, e que usuários não pagam preço de Fable por requisições rerroteadas (Anthropic Fable). O post de lançamento diz que essas salvaguardas disparam em menos de 5% das sessões, em média, com alguns falsos positivos esperados (lançamento da Anthropic).
Não esconda isso dos usuários. Se o seu produto de revisão de segurança pede Fable e recebe comportamento de Opus, a UI deve dizer algo como:
“Esta solicitação usou a rota de fallback mais segura para a parte sinalizada. Os resultados podem ser menos exaustivos. O impacto no orçamento foi ajustado.”
Isso é melhor do que fingir que toda resposta veio do mesmo modelo. Também protege suas avaliações. Se você faz benchmark de Fable mas metade do seu conjunto de testes aciona fallback, você está medindo o caminho do classificador tanto quanto o modelo.
O que enviar esta semana
Entregue o roteador antes de entregar a feature flag de Fable.
Para a maioria dos produtos de desenvolvedor, meus padrões recomendados são simples:
- Explicação de código, pequenas correções, testes, docs: Sonnet 4.6.
- Revisão de PR, bugs em produção, decisões de arquitetura: Opus 4.8.
- Trabalho de agente por várias horas ou dias com retorno de negócio claro: Fable 5 quando disponível, com fallback para Opus.
- Qualquer coisa sem limites: nada de Fable até o usuário definir um orçamento.
- Qualquer coisa repetida para muitos usuários: faça cache do contexto longo ou processe em lote.
O ponto não é venerar o modelo do topo. O ponto é gastar tokens de fronteira onde eles mudam o resultado.
Fable 5 pode ser o modelo sobre o qual as pessoas vão discutir no HN esta semana. Sonnet ainda é onde a maior parte do tráfego de produção deve começar. Opus é o meio confiável. A implementação vencedora é um roteador tedioso, com limites duros, fallback honesto e logs bons o suficiente para depurar tanto qualidade quanto custo.
Se você quer o caminho mais rápido para testar a configuração, abra Claude Fable 5 na OneHop, crie uma conta e comece com US$ 10 grátis. Depois conecte o roteador acima a um fluxo, não ao produto inteiro. Meça o custo por resultado aceito. Esse número importa mais do que qualquer benchmark de semana de lançamento.
