🎁 Novo Cadastre-se grátis, 10 chamadas por nossa conta. Até US$ 1, sem cartão.

Claude Fable 5 vs GPT-5.6

vs

Qual usar, quando — veredito curado, não uma tabela de benchmark

Ambos recebem texto e imagem, retornam texto e limitam a saída em 128000 tokens, então a real divisão é preço e controle: o gpt-5.6 custa $5 de entrada / $30 de saída / $0.5 de leituras de cache contra $10 / $50 / $1 do claude-fable-5, tornando o modelo da Anthropic 2x mais caro na entrada e no cache e cerca de 1.67x o custo na saída, com uma janela marginalmente menor de 1000000 tokens versus 1050000. Escolha o gpt-5.6 para trabalho de alto volume ou sensível à latência, onde você queira desligar o thinking; escolha o claude-fable-5 quando quiser que seu modo de raciocínio sempre ativado seja aplicado a cada requisição e estiver disposto a pagar o valor premium.

Preços

Claude Fable 5 GPT-5.6 Δ
Entrada / 1M tokens $10 $5
Saída / 1M tokens $50 $30 1.7×
Leitura de cache / 1M tokens $1 $0.5
Escrita de cache 1.25x (5m) / 2x (1h) sem cobrança separada

Tarifas do catálogo em tempo real no momento do build; a página de cada modelo contém o cartão atual.

Onde eles se posicionam — preço de entrada por 1M tokens entre todos os 63 modelos de chat nesta unidade de cobrança (escala logarítmica)

Claude Fable 5 · $10 GPT-5.6 · $5
$0.05 · Qwen3 VL Flash $30 · GPT-5.4 Pro

Capacidades

Claude Fable 5 GPT-5.6
Uso de ferramentas sim sim
Controle de raciocínio sempre ativo configurável
Saída estruturada sim sim
Cache de prompt explícito (você marca o prefixo) implícito (automático)
Tempo de vida do cache 5m default, 1h option 5–10m, up to 1h
Prefixo mínimo em cache 1024 tokens 1024 tokens

Especificações

Claude Fable 5 GPT-5.6
Modalidades de entrada texto imagem texto imagem
Modalidades de saída texto texto
Lançamento 2026-06-09 2026-07-09
Corte de conhecimento 2026-01 2026-02
Janela de contexto 1M 1.1M
Saída máxima 128K 128K
Parâmetro de raciocínio output_config.effort (thinking.type is adaptive-only and needs no configuration) reasoning.effort
Valores aceitos
effort
  • low
  • medium
  • high
  • xhigh
  • max

both "enabled" and "disabled" return 400

reasoning.effort
  • none
  • low
  • medium
  • high
  • xhigh
  • max
Padrão

thinking always on (adaptive)

effort
  • high
medium

As especificações são transcritas da documentação de cada fornecedor; uma linha que um fornecedor não publica é omitida em vez de ser inferida. Fontes completas: Claude Fable 5 · GPT-5.6

Um prompt, ambos os modelos — medidos pelo gateway

PROMPT Explain to a CFO, in exactly three sentences, why our LLM bill doubled after we enabled reasoning. VERIFICAR exatamente 3 frases

Claude Fable 5 passou · 3 sentences

When we enabled reasoning, the model began generating extensive internal "thinking" tokens before each answer, and those tokens are billed as output even though users never see them. Output tokens typically cost several times more than input tokens, so adding thousands of hidden reasoning tokens per request effectively multiplied our per-query cost. In short, we're paying for a much longer response behind the scenes in exchange for higher answer quality, and we can manage this by tuning reasoning effort levels or reserving reasoning mode for complex tasks only.

saída 228 tok latência 6.7 s

GPT-5.6 passou · 3 sentences

Enabling reasoning makes the model generate many additional internal tokens before producing an answer, so each request consumes substantially more compute. Those reasoning tokens are billed even though they are not visible to users, and longer processing can also increase tool calls, retries, and output length. The bill doubled because our cost per request rose, not necessarily because usage volume increased; we can control it by limiting reasoning effort and routing simpler tasks to cheaper models.

saída 126 tok (+30 pensamento) latência 3.0 s

Cumprimento da instrução (exatamente três frases — contáveis), ajuste ao público (registro de CFO), e a lacuna de cobrança do pensamento oculto que os medidores de tokens abaixo expõem.

PROMPT This function is supposed to return the longest run of consecutive equal items, but callers report it is off by one on single-element inputs and misses runs that end at the last index. Fix it and explain the bug in one paragraph. VERIFICAR a correção passa nos testes

Claude Fable 5 passou · 8/8 cases

## Fixed code ```python def longest_run(xs): if not xs: return 0 best = cur = 1 for i in range(1, len(xs)): if xs[i] == xs[i - 1]: cur += 1 else: cur = 1 best = max(best, cur) return best ``` ## Explanation The original function counts **adjacent equal pairs** rather than **items in a run**: a run of length *n* contains only *n − 1* equal neighbor pairs, so every result is off by one — a single-element list yields 0 instead of 1, and `[1, 2, 2]` yields 1 instead of 2 (which callers perceive as "missing" the run at the end). The fix is to initialize both `cur` and `best` to 1 (any nonempty list has a run of at least length 1), reset `cur` to 1 rather than 0 when

saída 531 tok latência 12.5 s

GPT-5.6 passou · 8/8 cases

```python def longest_run(xs): if not xs: return 0 best = cur = 1 for i in range(1, len(xs)): if xs[i] == xs[i - 1]: cur += 1 else: best = max(best, cur) cur = 1 return max(best, cur) ``` The original code counted equal *transitions* rather than items, so a run of one had length `0`, a run of three had length `2`, and tracking from zero caused the off-by-one error. The corrected version starts each run at length `1`, resets to `1` when the value changes, and performs a final `max` after the loop so a run ending at the last element is included; an empty input still returns `0`.

saída 277 tok (+93 pensamento) latência 4.2 s

Se a correção é de fato certa (executável), a densidade da explicação, e a eficiência em tokens numa tarefa delimitada.

PROMPT Extract a JSON object with fields {company, quarter, revenue_usd_m, growth_pct, guidance} from this text. Use null for anything not stated; add no other fields. VERIFICAR JSON válido, esquema exato

Claude Fable 5 passou · 5/5 fields, guidance null

```json { "company": "Meridian Robotics", "quarter": "Q3 (September quarter)", "revenue_usd_m": 412, "growth_pct": 11, "guidance": null } ``` Notes on interpretation: "up eleven and change" is rendered as 11 (the precise figure isn't stated), and guidance is null because it was explicitly withheld.

saída 192 tok latência 6.5 s

GPT-5.6 passou · 5/5 fields, guidance "withheld pending the Q4 close"

{ "company": "Meridian Robotics", "quarter": "September quarter", "revenue_usd_m": 412, "growth_pct": null, "guidance": "withheld pending the Q4 close" }

saída 179 tok (+118 pensamento) latência 3.7 s

Obediência ao esquema (sem campos inventados), pressão de alucinação (guidance é explicitamente retida), e diferenças no caminho de saída estruturada.

PROMPT Write a 120-word product announcement for an API gateway feature that caches prompts across providers. Forbidden words: "seamless", "unlock", "game-changer", "revolutionize", "empower". Exactly one sentence must be a question. VERIFICAR 120 palavras, 0 palavras proibidas

Claude Fable 5 passou · 120 words, 0 banned, 1 question

**Introducing Cross-Provider Prompt Caching for our API Gateway** Starting today, your repeated prompts are cached once and reused across OpenAI, Anthropic, Google, and any other provider you route through the gateway. Instead of paying full token costs every time your application sends the same system prompt or context block, the gateway detects matching prefixes and serves cached results in milliseconds. Why keep spending money and latency on identical requests? Early adopters report cost reductions of up to 60 percent on high-volume workloads, along with faster median response times. Configuration is simple: enable caching in your dashboard, set a TTL, and choose which routes participate. Cache entries are encrypted at rest and never shared between accounts. Available now on all plans.

saída 1173 tok latência 18.2 s

GPT-5.6 passou · 120 words, 0 banned, 1 question

Today we are introducing Prompt Cache, a new API gateway feature that stores reusable prompt prefixes and serves them across supported model providers. By recognizing identical system instructions, tools, examples, and context blocks, Prompt Cache reduces repeated input processing, lowers latency, and helps control token costs without changing application code. Teams can configure retention windows, cache keys, provider routing, encryption, and regional storage policies from one dashboard or API. What happens when a preferred provider is unavailable? The gateway can route requests to another provider while reusing eligible cached content, preserving performance and consistency. Built-in metrics report hit rates, savings, latency, and provider usage, while audit logs support governance. Prompt Cache is available today in public preview for all customers.

saída 628 tok (+473 pensamento) latência 7.3 s

Obediência às restrições (orçamento de palavras, lista de palavras proibidas, a única pergunta), impressão digital de estilo, e controle de comprimento.

Alterne entre eles com uma linha

Ambos os IDs estão em todas as abas abaixo — o par de linhas destacado é a única edição. Mesmo endpoint, mesma chave, mesmo formato de requisição.

from openai import OpenAI

client = OpenAI(
    base_url="https://synthorai.io/v1",
    api_key="sk-syn-...",
)

resp = client.chat.completions.create(
    model="claude-fable-5",
    # model="gpt-5.6",  # descomente esta linha, comente a linha acima
    messages=[{"role": "user", "content": "Summarize this diff"}],
    reasoning_effort="medium",
)
print(resp.choices[0].message.content)

Obter uma chave de API →

FAQ

Qual é mais barato, Claude Fable 5 ou GPT-5.6?

GPT-5.6 é mais barato em entrada / 1m tokens ($5 vs $10, com 2.0× de diferença). Outras linhas podem apontar para o outro lado — a tabela acima traz o quadro completo, e o custo real depende do seu mix.

Posso fazer um teste A/B de Claude Fable 5 contra GPT-5.6 sem duas integrações?

Sim. Ambos são servidos pelo mesmo endpoint compatível com OpenAI com uma única chave de API — a troca é uma alteração de uma linha na string do modelo, de modo que você pode rotear uma fração do tráfego para cada um e comparar as faturas diretamente.

Claude Fable 5 e GPT-5.6 suportam prompt caching?

Sim — ambos cobram leituras em cache abaixo da sua taxa de entrada, então cargas de trabalho com warm-prefix custam menos do que as taxas listadas sugerem. As linhas exatas de leitura em cache estão na tabela de preços acima.

Comparações relacionadas

De nossos estudos medidos