Claude Fable 5 vs Qwen3.8 Max: preços e especificações, medidos

Qual usar e quando

Ambos recebem texto e imagem, retornam texto, e ambos ficam próximos da marca de um milhão de tokens (1000000 para o claude-fable-5 contra 983616 para o qwen3.8-max), então a real divisão é a tabela de preços: o claude-fable-5 custa 5x mais na entrada ($10 vs $2), cerca de 8.3x mais na saída ($50 vs $6), e 4x mais em leituras de cache ($1 vs $0.25). Escolha o claude-fable-5 quando desejar seu thinking sempre ativado, que não pode ser desabilitado e por isso cobra o raciocínio na taxa de saída de $50; escolha o qwen3.8-max para trabalho de contexto longo em alto volume, com uma saída máxima ligeiramente maior de 131072 contra 128000.

Benchmarks

À frenteAcima da médiaNenhum melhorClaude Fable 52787 ~~/ 97~~40 ~~/ 97~~Qwen3.8 Max631 ~~/ 40~~8 ~~/ 40~~

35 medidos em ambos, 2 empatados.

Claude Fable 5 Qwen3.8 Max outros modelos medidos média dos modelos comparados ★ nenhum outro modelo teve pontuação maior

SWE-Bench Pro

nenhum outro modelo teve pontuação maior 80.3%

67.7%

BioMysteryBench hard

46.5%

N/A

AndroidBench

nenhum outro modelo teve pontuação maior 84.5%

75.1%

Cybergym

83.1%

78.5%

HealthBench Professional

60.9%

N/A

JobBench

nenhum outro modelo teve pontuação maior 57.4%

53.4%

PLawBench

70.2%

nenhum outro modelo teve pontuação maior 73.2%

GPQA Diamond

92.6%

Blueprint-Bench 2

38.6%

N/A

Agents' Last Exam

48.7%

27%

CharXiv (RQ) reasoning

nenhum outro modelo teve pontuação maior 88.9%

N/A

SWE-Bench Pro

nenhum outro modelo teve pontuação maior 80.3%

67.7%

DeepSWE 1.1

69.7%

56.6%

Terminal-Bench 2.1

88%

86.6%

ProgramBench Almost Solved

33%

10.5%

MLS-Bench-Lite

nenhum outro modelo teve pontuação maior 49.9%

41%

FrontierSWE

nenhum outro modelo teve pontuação maior 88.8%

73.5%

QwenQoderBench

nenhum outro modelo teve pontuação maior 63.1%

58.4%

QwenReactBench 1538-1770

nenhum outro modelo teve pontuação maior 1770

1724

QwenSVGBench 1499-1713 segundo Alibaba (Qwen) · 2026-08-25

1690

nenhum outro modelo teve pontuação maior 1713

QwenSWEBench

nenhum outro modelo teve pontuação maior 86.3%

80.7%

NL2Repo

N/A

55.9%

Terminal-bench 4.0

42%

N/A

Terminal-bench 3.0

33.7%

N/A

SciCode

nenhum outro modelo teve pontuação maior 60.2%

N/A

FrontierCode 1.1 Main

53.5%

N/A

DeepSWE

70%

N/A

Kimi Code Bench 2.0

nenhum outro modelo teve pontuação maior 76.9%

N/A

PostTrainBench

nenhum outro modelo teve pontuação maior 41.4%

N/A

ProgramBench

76.8%

N/A

DSBench-FullStack

nenhum outro modelo teve pontuação maior 77.2%

N/A

DSBench-Hard

68.3%

N/A

FrontierCode 1.1 Extended

nenhum outro modelo teve pontuação maior 64.9%

N/A

NL2Repo-Bench

N/A

55.9%

SWE-Marathon

35%

N/A

SWE-Marathon v1.1

33.1%

N/A

FrontierSWE Dominance

nenhum outro modelo teve pontuação maior 88.2%

N/A

CursorBench 3.2.0

70.5%

N/A

Frontier-Bench v0.1

33.7%

N/A

Internal Database Migration Tasks

50.3%

N/A

FrontierCode (Diamond) xhigh

29.3%

N/A

Publicado pelos provedores: Alibaba (Qwen) Anthropic ByteDance DeepSeek Google MiniMax Moonshot OpenAI Tencent Z.ai

Preços

	Claude Fable 5	Qwen3.8 Max	Δ
Entrada / 1M tokens	$10	$2	5×
Saída / 1M tokens	$50	$6	8.3×
Leitura de cache / 1M tokens	$1	$0.25	4×
Escrita de cache	1.25x (5m) / 2x (1h)	1.25x	-

Tarifas do catálogo em tempo real, lidas no momento do build; a página de cada modelo traz a tabela de preços atual.

Onde cada um fica: preço de entrada por 1M tokens entre os 76 modelos de chat com esta unidade de cobrança (escala logarítmica)

Claude Fable 5 · $10 Qwen3.8 Max · $2

$0.05 · Qwen3 VL Flash $30 · GPT-5.4 Pro

Capacidades

	Claude Fable 5	Qwen3.8 Max
Uso de ferramentas	sim	sim
Controle de raciocínio	sempre ativo	sim o provedor não publica o controle
Saída estruturada	sim	sim
Cache de prompts	explícito (você marca o prefixo)	implícito + explícito
Tempo de vida do cache	5m default, 1h option	explicit: 5m, reset on hit
Prefixo mínimo em cache	1024 tokens	1024 tokens

Especificações

	Claude Fable 5	Qwen3.8 Max
Modalidades de entrada	texto imagem	texto imagem
Modalidades de saída	texto	texto
Lançamento	2026-06-09	2026-08-03
Corte de conhecimento	2026-01	-
Janela de contexto	1M	984K
Saída máxima	128K	131K
Parâmetro de raciocínio	output_config.effort (thinking.type is adaptive-only and needs no configuration)	-
Valores aceitos	effort low medium high xhigh max both "enabled" and "disabled" return 400	-
Padrão	thinking always on (adaptive) effort high	-

As especificações são transcritas da documentação de cada provedor; quando um provedor não publica um dado, a linha é omitida, e não inferida. Fontes completas: Claude Fable 5 · Qwen3.8 Max

Um prompt, os dois modelos, medidos pelo gateway

Raciocínio para um CFO Corrigir uma função com bug Extrair para um schema Escrever com restrições

PROMPT Explain to a CFO, in exactly three sentences, why our LLM bill doubled after we enabled reasoning. VERIFICAÇÃO 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

Qwen3.8 Max passou · 3 sentences

Enabling reasoning makes the model produce additional hidden steps before responding, and those tokens are billable. It also tends to lengthen each interaction because the model works through more possibilities before settling on an answer. Therefore, the bill doubled mainly due to higher compute and token usage per request, not necessarily because the number of requests doubled.

saída 378 tok (+305 raciocínio) latência 8.6 s

Se a instrução é seguida (exatamente três frases, dá para contar), a adequação ao público (tom para um CFO) e a diferença de cobrança causada pelo raciocínio oculto, que os medidores de tokens abaixo deixam à mostra.

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. VERIFICAÇÃO 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

Qwen3.8 Max 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: cur = 1 best = max(best, cur) return best ``` The bug is that the original code starts `best` and `cur` at `0`, so it counts adjacent equal *transitions* rather than the number of items in the run. A run of length `n` has only `n - 1` equal-neighbor transitions, so single-element inputs return `0`, and runs that reach the end are undercounted by one. Initializing the current run to `1` for the first element, resetting it to `1` on a break, and updating `best` from that count fixes the off-by-one.

saída 1616 tok (+1411 raciocínio) latência 34.7 s

Se a correção está mesmo certa (dá para executar), a densidade da explicação e a eficiência em tokens em uma tarefa bem 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. VERIFICAÇÃO JSON válido, schema 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

Qwen3.8 Max passou · 5/5 fields, guidance null

{ "company": "Meridian Robotics", "quarter": "September quarter", "revenue_usd_m": 412, "growth_pct": 11, "guidance": null }

saída 1199 tok (+1141 raciocínio) latência 24.4 s

Aderência ao schema (sem campos inventados), pressão para alucinar (o texto diz explicitamente que o guidance não foi divulgado) 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. VERIFICAÇÃO 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

Qwen3.8 Max passou · 120 words, 0 banned, 1 question

Today, our API gateway adds prompt caching across major model providers. It stores prompts and responses in one fast cache layer. Teams can lower token spend, reduce latency, and repeat reliable answers. The feature supports OpenAI, Anthropic, Google, and Mistral through one configuration. You can set retention rules, scope access, and invalidate entries quickly. How does your team maintain consistent results during provider outages? Approved cached responses keep applications stable while fallback routes recover. The dashboard shows hit rates, savings, latency, and provider usage. Engineers receive audit trails for every cached prompt, enabling safer testing. Product managers can compare cost trends before and after cache adoption. Start with a small route, then safely expand caching to production traffic right now.

saída 2744 tok (+2591 raciocínio) latência 46.3 s

Respeito às restrições (limite de palavras, lista de palavras proibidas, uma única pergunta), a marca de estilo de cada modelo e o controle do tamanho.

Troque de um para o outro mudando uma linha

Os dois ids estão em todas as abas abaixo; o par de linhas destacado é a única alteração. O endpoint, a chave e o formato da requisição são os mesmos.

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="qwen3.8-max",  # descomente esta linha, comente a linha acima
    messages=[{"role": "user", "content": "Summarize this diff"}],
    reasoning_effort="medium",
)
print(resp.choices[0].message.content)

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://synthorai.io/v1",
  apiKey: "sk-syn-...",
});

const resp = await client.chat.completions.create({
  model: "claude-fable-5",
  // model: "qwen3.8-max",  // descomente esta linha, comente a linha acima
  messages: [{ role: "user", content: "Summarize this diff" }],
  reasoning_effort: "medium",
});
console.log(resp.choices[0].message.content);

curl https://synthorai.io/v1/chat/completions \
  -H "Authorization: Bearer sk-syn-..." \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-fable-5",
    # "model": "qwen3.8-max",  # descomente esta linha, comente a linha acima
    "messages": [{"role": "user", "content": "Hello"}],
    "reasoning_effort": "medium"
  }'

package main

import (
	"context"
	"fmt"

	"github.com/openai/openai-go/v3"
	"github.com/openai/openai-go/v3/option"
)

func main() {
	client := openai.NewClient(
		option.WithBaseURL("https://synthorai.io/v1"),
		option.WithAPIKey("sk-syn-..."),
	)
	resp, _ := client.Chat.Completions.New(context.TODO(), openai.ChatCompletionNewParams{
		Model: "claude-fable-5",
		// Model: "qwen3.8-max",  // descomente esta linha, comente a linha acima
		Messages: []openai.ChatCompletionMessageParamUnion{
			openai.UserMessage("Summarize this diff"),
		},
		ReasoningEffort: openai.ReasoningEffortMedium,
	})
	fmt.Println(resp.Choices[0].Message.Content)
}

import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.chat.completions.*;
import com.openai.models.ReasoningEffort;

OpenAIClient client = OpenAIOkHttpClient.builder()
    .baseUrl("https://synthorai.io/v1")
    .apiKey("sk-syn-...")
    .build();

ChatCompletion resp = client.chat().completions().create(
    ChatCompletionCreateParams.builder()
        .model("claude-fable-5")
        // .model("qwen3.8-max")  // descomente esta linha, comente a linha acima
        .addUserMessage("Summarize this diff")
        .reasoningEffort(ReasoningEffort.MEDIUM)
        .build());
System.out.println(resp.choices().get(0).message().content().orElse(""));

Obtenha sua chave de API →

Perguntas frequentes

Qual é mais barato, Claude Fable 5 ou Qwen3.8 Max?

Qwen3.8 Max sai mais barato na linha “Entrada / 1M tokens” ($2 contra $10, 5.0× de diferença). Outras linhas podem pender para o outro lado: a tabela acima mostra todos os preços, e o custo real depende do seu mix de uso.

Posso fazer um teste A/B de Claude Fable 5 contra Qwen3.8 Max sem duas integrações?

Sim. Os dois são servidos pelo mesmo endpoint compatível com OpenAI, com uma única chave de API. Para trocar, basta mudar uma linha, a string do modelo; assim você pode direcionar uma parte do tráfego para cada um e comparar as contas diretamente.

Claude Fable 5 e Qwen3.8 Max suportam cache de prompts?

Sim. Os dois cobram as leituras de cache abaixo da tarifa de entrada, então cargas de trabalho com prefixo já em cache custam menos do que os preços de tabela sugerem. Os valores exatos de leitura de cache estão na tabela de preços acima.

Comparações relacionadas

GPT-6.1 Sol vs Qwen3.8 Max Claude Sonnet 5.5 vs Qwen3.8 Max GPT-6 Sol vs Qwen3.8 Max GPT-6 Luna vs Qwen3.8 Max Compare dois modelos quaisquer →

Dos nossos estudos com medições

GPT-6.1 Sol vs Claude Sonnet 5.5: mesmo $2/$10, metade do custo Recusas excessivas: o benchmark pesa mais que o modelo GPT-6 Astra: max custa 2.3x low com respostas idênticas