Claude Fable 5 vs Kimi K3: preços e especificações, medidos

Qual usar e quando

O kimi-k3 custa cerca de 3.3x menos que o claude-fable-5 em toda a tabela de preços ($3 vs $10 por milhão na entrada, $15 vs $50 na saída, $0.3 vs $1 em leituras de cache), e ele também aceita entrada de vídeo e pode emitir até 1,048,576 tokens de saída dentro da sua janela de 1,048,576 tokens. O claude-fable-5 oferece um contexto de 1,000,000 tokens, mas limita a saída em 128,000 tokens, e possui uma capacidade de thinking explícita mais um corte de conhecimento em janeiro de 2026. Escolha o kimi-k3 para entrada de vídeo e gerações muito longas com custo mais baixo; escolha o claude-fable-5 quando essa capacidade de thinking e recência declarada importarem mais que o preço.

Benchmarks

À frenteAcima da médiaNenhum melhorClaude Fable 54087 ~~/ 97~~40 ~~/ 97~~Kimi K31752 ~~/ 67~~12 ~~/ 67~~

58 medidos em ambos, 1 empatados.

Claude Fable 5 Kimi K3 outros modelos medidos média dos modelos comparados ★ nenhum outro modelo teve pontuação maior

DeepSWE 1.1

69.7%

67.5%

BioMysteryBench hard

46.5%

N/A

OSWorld-Verified

nenhum outro modelo teve pontuação maior 85%

84.8%

Cybergym

83.1%

80%

HealthBench Professional

60.9%

N/A

Finance Agent v2

56.3%

54.4%

Harvey Lab-AA

93.6%

nenhum outro modelo teve pontuação maior 94.6%

GPQA Diamond

92.6%

93.5%

Blueprint-Bench 2

38.6%

N/A

BrowseComp

87.4%

91.2%

CharXiv (RQ) reasoning

nenhum outro modelo teve pontuação maior 88.9%

84.8%

DeepSWE 1.1

69.7%

67.5%

Terminal-Bench 2.1

88%

88.3%

Terminal-bench 4.0

42%

12.6%

Terminal-bench 3.0

33.7%

17.7%

SciCode

nenhum outro modelo teve pontuação maior 60.2%

58.7%

DeepSWE

70%

67.5%

ProgramBench Almost Solved

33%

17.5%

MLS-Bench-Lite

nenhum outro modelo teve pontuação maior 49.9%

48.3%

FrontierSWE

nenhum outro modelo teve pontuação maior 88.8%

81.2%

Kimi Code Bench 2.0

nenhum outro modelo teve pontuação maior 76.9%

72.9%

PostTrainBench

nenhum outro modelo teve pontuação maior 41.4%

36.6%

ProgramBench

76.8%

nenhum outro modelo teve pontuação maior 77.8%

DSBench-FullStack

nenhum outro modelo teve pontuação maior 77.2%

73.7%

DSBench-Hard

68.3%

63%

SWE-Marathon

35%

nenhum outro modelo teve pontuação maior 42%

SWE-Marathon v1.1

33.1%

48.1%

SWE-Bench Pro

nenhum outro modelo teve pontuação maior 80.3%

N/A

NL2Repo

N/A

58%

FrontierCode 1.1 Main

53.5%

N/A

FrontierCode 1.1 Extended

nenhum outro modelo teve pontuação maior 64.9%

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

QwenQoderBench

nenhum outro modelo teve pontuação maior 63.1%

N/A

QwenReactBench 1538-1770

nenhum outro modelo teve pontuação maior 1770

N/A

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

1690

N/A

QwenSWEBench

nenhum outro modelo teve pontuação maior 86.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	Kimi K3	Δ
Entrada / 1M tokens	$10	$3	3.3×
Saída / 1M tokens	$50	$15	3.3×
Leitura de cache / 1M tokens	$1	$0.3	3.3×
Escrita de cache	1.25x (5m) / 2x (1h)	-	-

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 Kimi K3 · $3

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

Capacidades

	Claude Fable 5	Kimi K3
Uso de ferramentas	sim	sim
Controle de raciocínio	sempre ativo	sempre ativo
Saída estruturada	sim	sim
Cache de prompts	explícito (você marca o prefixo)	implícito (automático)
Tempo de vida do cache	5m default, 1h option	não publicado
Prefixo mínimo em cache	1024 tokens	não publicado

Especificações

	Claude Fable 5	Kimi K3
Modalidades de entrada	texto imagem	texto imagem vídeo
Modalidades de saída	texto	texto
Lançamento	2026-06-09	2026-07-16
Corte de conhecimento	2026-01	-
Janela de contexto	1M	1M
Saída máxima	128K	1M
Parâmetro de raciocínio	output_config.effort (thinking.type is adaptive-only and needs no configuration)	reasoning_effort (top-level; the thinking object is not accepted)
Valores aceitos	effort low medium high xhigh max both "enabled" and "disabled" return 400	reasoning_effort low high max
Padrão	thinking always on (adaptive) effort high	max

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 · Kimi K3

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

Kimi K3 passou · 3 sentences

Reasoning models don't just answer questions—they "think" first, generating long internal chains of step-by-step logic before producing a response. Those hidden thinking steps are billed as output tokens (the most expensive kind, typically 3–5x the price of input tokens), and a single query can generate thousands of them even when the visible answer is only a paragraph long. So you're paying for dramatically more compute per request: the bill doubled because the model does far more work behind the scenes, not because usage increased.

saída 755 tok (+637 raciocínio) latência 20.8 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

Kimi K3 passou · 8/8 cases

```python def longest_run(xs): if not xs: return 0 best = 1 cur = 1 for i in range(1, len(xs)): if xs[i] == xs[i - 1]: cur += 1 best = max(best, cur) else: cur = 1 return best ``` The bug is a fencepost error: `cur` counts *matching adjacent pairs* rather than *items in the run*, because it starts at 0 and only increments when `xs[i] == xs[i - 1]`. A run of length L contains L−1 equal pairs, so every run was undercounted by exactly one. For a single-element list (a run of length 1) the loop never runs and the function returns 0 instead of 1; likewise any run ending at the last index — e.g. the two `2`s in `[1, 2, 2]` — reported 1 instead of 2, making it look like no run existed at all. […]

saída 1837 tok (+1547 raciocínio) latência 47.2 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

Kimi K3 passou · 5/5 fields, guidance null

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

saída 924 tok (+863 raciocínio) latência 25.9 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

Kimi K3 passou · 120 words, 0 banned, 1 question

Meet Prompt Cache, a new API gateway capability that stores prompt responses and serves them across OpenAI, Anthropic, Google, and Azure endpoints. It matches requests by model, prompt hash, tools, temperature, and tenant policy, so repeated work returns fast while sensitive contexts stay isolated. Teams set TTLs, stale rules, encryption scopes, and bypass flags per route. Analytics show hit rate, latency saved, token spend avoided, and drift risk by provider. What changes for developers? Keep one integration, add cache headers, and watch fallback logic respect consent, residency, and audit needs. During rollout, canary keys compare fresh answers with cached copies before promotion. Prompt Cache cuts vendor calls, steadies p95 latency, and gives platform owners controls for cost, quality, and compliance.

saída 1527 tok (+1354 raciocínio) latência 37.9 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="kimi-k3",  # 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: "kimi-k3",  // 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": "kimi-k3",  # 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: "kimi-k3",  // 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("kimi-k3")  // 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 Kimi K3?

Kimi K3 sai mais barato na linha “Entrada / 1M tokens” ($3 contra $10, 3.3× 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 Kimi K3 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 Kimi K3 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 Kimi K3 Claude Sonnet 5.5 vs Kimi K3 GPT-6 Sol vs Kimi K3 GPT-6 Luna vs Kimi K3 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