Kimi K3 vs Claude Fable 5: Pricing, Speed & Value (July 2026)
2026-07-26
Kimi K3 lists at $3/M input and $15/M output. Claude Fable 5 lists at $10/M input and $50/M output. That's a 3.3× gap on both ends of the meter, and it's the first thing anyone notices.
It's also the least useful way to compare them.
Per-token price only tells you what a token costs. It doesn't tell you how many tokens a model burns to finish your task, how many retries it needs, or how long you wait. Those are the numbers that hit your invoice. This piece works through both layers — the sticker price and the real per-task math — plus what K3 actually is architecturally, what it's proven outside benchmark tables, and the regulatory and funding context shaping both models right now.
The Pricing Gap, and Why It Isn't the Whole Story
Here's the full picture side by side.
| Kimi K3 | Claude Fable 5 | |
|---|---|---|
| Input | $3.00/M (miss) / $0.30/M (hit) | $10.00/M / $1.00/M (cache read hit) |
| Output | $15.00/M | $50.00/M |
| Caching | Automatic — 90%+ hit rate on code | Manual breakpoints — $1/M read hit (write premium: $12.50/MTok 5-min, $20/MTok 1-hr) |
| Total params | 2.8T (MoE, 896 experts) | Not disclosed by Anthropic |
| Active params / token | ~50B (16 of 896 experts) | Not disclosed by Anthropic |
| Context window | 1M tokens | 1M tokens (128k max output) |
| Weights | Open — July 27, 2026 | Proprietary |
| Strongest domain | Long-horizon coding | Frontier general reasoning |
K3 specs and pricing from Moonshot's technical blog. Fable 5 pricing and caching (including cache write premiums) from OpenRouter and Anthropic's prompt caching docs.
Cheaper per token ≠ cheaper per task
A model that costs a third as much per token but spends twice as many tokens reaching the same answer has erased most of its advantage. Moonshot is unusually candid about K3's tendencies here: the company notes that K3 ships with max thinking effort on by default, with lower-effort modes arriving in later updates. Max effort means more reasoning tokens, and reasoning tokens bill as output — the $15/M line, not the $3/M line.
Moonshot also flags a behavioral trait it calls "excessive proactiveness": because K3 was trained hard on long-horizon tasks, it can make unrequested decisions when it hits ambiguity, which the company recommends constraining explicitly in the system prompt or AGENTS.md. In practice, unrequested decisions mean extra work — sometimes extra work you then have to undo.
Add wall-clock time. Moonshot recommends deploying K3 on supernode configurations with 64 or more accelerators for inference efficiency, which tells you something about the serving profile of a 2.8T-parameter model even with sparse activation. If a task takes longer to complete, that latency is a real cost in interactive developer workflows even when it never shows up on the bill.
The takeaway: benchmark the two on your workload and measure dollars-per-completed-task, not dollars-per-million-tokens. The list price is the starting point of that calculation, not the conclusion.
Caching: Automatic vs. Manual, Not Present vs. Absent
This is the most commonly botched part of the comparison, so let's be precise.
Both models cache. The difference is who does the work and what setup costs.
Kimi K3: automatic, no write premium disclosed
Moonshot serves K3 through Mooncake's disaggregated inference architecture and reports a cache hit rate above 90% in coding workloads. Cached input drops from $3.00/MTok to $0.30/MTok — a 90% discount. You don't configure anything. Moonshot also notes that Kimi Delta Attention created new challenges for conventional prefix caching, and that it contributed an implementation to the vLLM community to ship alongside the weights.
Claude Fable 5: manual breakpoints, with a write premium
Anthropic's caching gets you the same discount magnitude — cache reads on Fable 5 drop to $1/MTok against a $10/MTok base input price, also 90% off. But you pay to put content into the cache:
$12.50/MTok** for 5-minute cache writes, **$20/MTok for 1-hour cache writes on Claude Fable 5 — Anthropic prompt caching pricing
Those figures follow a documented multiplier structure: 5-minute writes are 1.25× base input, 1-hour writes are 2× base input, and reads are 0.1× base input. The default TTL is five minutes, and — importantly — the cache refreshes at no additional cost each time it's used. Anthropic's own guidance is that if your prompt gets hit more often than every five minutes, stay on the 5-minute cache and let free refreshes carry it. The 1-hour tier is for gaps longer than five minutes but shorter than an hour.
Anthropic also supports automatic caching now — a single top-level cache_control field that places the breakpoint on the last cacheable block, no per-block annotation required. It uses the same pricing and the same minimums. For Fable 5, the minimum cacheable prompt is 512 tokens.
The honest framing
| Setup cost | Write cost | Read cost | Breakeven | |
|---|---|---|---|---|
| Kimi K3 | None — on by default | Not separately priced | $0.30/M | Immediate |
| Claude Fable 5 | Breakpoint placement (or top-level auto flag) | $12.50–$20/M | $1.00/M | After enough reuse to offset the write |
Fable's caching pays off well when a large static prefix — system prompt, tool definitions, a document corpus — gets hammered repeatedly. It pays off poorly on one-shot requests where you write the cache and never read it. K3's model removes that calculation entirely, which is a genuine operational advantage even before you compare the raw numbers.
Where Each Model Actually Wins
Kimi K3: long-horizon coding and value density
Moonshot positions K3 squarely at agentic software engineering — sustaining long sessions with minimal oversight, navigating large repositories, and orchestrating terminal tools. It also emphasizes tasks that blend software engineering with visual reasoning, using screenshots and visuals to iterate on game dev, frontend, and CAD work. The company describes this as "vision in the loop": the model writes code, looks at the rendered output, and refines.
K3 is currently the strongest coding value-for-money option on the table, and it ranks #1 on the Frontend Code Arena.
Claude Fable 5: frontier general reasoning
The most credible endorsement of Fable 5's overall capability comes from Moonshot itself. In the K3 launch post, the company writes that while K3 hit frontier-level performance across its evaluation suite, its overall performance "still trails the most powerful proprietary models, Claude Fable 5 and GPT 5.6 Sol."
Moonshot goes further in its limitations section, acknowledging that "despite being a highly competitive model overall, K3 nonetheless exhibits a noticeable gap in user experience compared with Claude Fable 5 and GPT 5.6 Sol." When a lab volunteers that about its own flagship launch, take it at face value.
Reading the split: if your workload is long-running code generation and repository work, K3's price-to-capability ratio is hard to argue with. If it's frontier reasoning where the top few percentage points of quality determine whether the output is usable, Fable 5 is what you pay for.
Under the Hood: What Kimi K3 Actually Is
2.8T total, ~50B active — always quote both
K3 is a 2.8-trillion-parameter model, the first open model to reach that scale. But it's a Mixture-of-Experts architecture that effectively activates 16 of 896 experts per token — roughly 50B active parameters. The 2.8T figure describes capacity; the ~50B figure describes what fires on any given forward pass. Quoting 2.8T without that context misrepresents both the compute cost and the serving profile.
Moonshot reports this sparsity scaling, combined with refined training and data recipes, yields roughly a 2.5× improvement in overall scaling efficiency compared to Kimi K2.
The architecture stack
Every term below appears in Moonshot's launch post:
- Kimi Delta Attention (KDA) — a hybrid linear attention foundation for scaling attention efficiently across sequence length.
- Attention Residuals (AttnRes) — selectively retrieves representations across model depth rather than accumulating them uniformly.
- Stable LatentMoE — the framework enabling the 16-of-896 expert activation at extreme sparsity.
- Quantile Balancing — derives expert allocation from router-score quantiles, removing heuristic updates and a sensitive balancing hyperparameter.
- Per-Head Muon — extends the Muon optimizer by optimizing attention heads independently.
- Sigmoid Tanh Unit (SiTU) and Gated MLA — activation control and attention selectivity respectively.
Moonshot also applies quantization-aware training from the SFT stage onward, using MXFP4 weights with MXFP8 activations for broad hardware compatibility.
The practical spec sheet
- 1M-token context window, native visual understanding
- Max thinking effort by default at launch; low- and high-effort modes coming in later updates
- Available now on Kimi.com, Kimi Work, Kimi Code, and the Kimi API (model ID
kimi-k3) - Weights release: by July 27, 2026 — full details on architecture, training, and evaluations arrive alongside the K3 technical report
- Recommended deployment: supernode configurations with 64+ accelerators
One compatibility warning worth reading twice
K3 was trained in preserved-thinking-history mode. Moonshot warns that if your agent harness fails to pass back all historical thinking content, or if you switch an in-progress session from another model over to K3, generation quality can become highly unstable. Use a harness with verified compatibility — Kimi Code is the reference implementation — and don't hot-swap mid-session. This is the kind of detail that turns into a mysterious quality regression if you skip it.
Proof That Isn't a Benchmark Table
Benchmark scores are contested, harness-dependent, and gameable. Three things in K3's launch material are harder to hand-wave.
🔧 It designed a chip. Autonomously. In 48 hours.
In a single 48-hour autonomous run, K3 built, optimized, and verified a chip using open-source EDA tools on the Nangate 45nm library. The result: within 4 mm², the design closes timing at 100 MHz and sustains over 8,700 tokens/s decode throughput in simulation, packing 1.46M standard cells, 0.277 MB of SRAM, and an INT4 MAC array with fused dequantization.
The chip's purpose was to serve a nano model built on K3's own architecture — a model designing silicon for a model. Whatever you think of that as a demo, it's a long-horizon agentic task with a verifiable pass/fail outcome.
🔬 Two hours instead of two weeks
To reproduce the I–Love–Q universal relations in computational astrophysics, K3 reviewed and cross-validated 20+ papers, implemented the full numerical pipeline, evaluated 300+ equations of state, identified inconsistencies in published formulas, generated 3,000+ lines of Python, and produced an interactive HTML dashboard for exploring results.
Moonshot's framing: about two hours for work that typically takes an experienced researcher one to two weeks.
💼 A leading Western coding tool built on an open Kimi model
This is the strongest evidence in the pile, and it doesn't come from Moonshot at all.
Cursor's technical report on Composer 2 states that the model was trained in two phases starting from continued pretraining on an open base model — Kimi K2.5 — followed by large-scale reinforcement learning in realistic Cursor sessions. The report credits "the teams behind Kimi K2.5, Ray, ThunderKittens, PyTorch, and the broader open-source community."
The attribution surfaced following a public discussion about crediting the base model, which makes it more notable, not less: a leading Western AI coding product built its agentic coding model on an open Kimi foundation. Cursor reports Composer 2 scoring 61.3 on CursorBench, 73.7 on SWE-bench Multilingual, and 61.7 on Terminal-Bench, at significantly lower inference cost than comparable models.
No leaderboard row makes the case for open Kimi weights as effectively as a commercial product shipping on top of them.
The Context Around Both Labs
Moonshot: $2B at a $20B valuation
Moonshot AI raised about $2 billion at a $20 billion valuation in a round led by Long-Z Investments, the VC arm of food delivery company Meituan, per a post from advisory firm Huafeng Capital. Tsinghua Capital, China Mobile, and CPE Yuanfeng also participated. Moonshot's broader backer list includes Alibaba, Tencent, HongShan, ZhenFund, IDG Capital, and 5Y Capital.
For trajectory: TechCrunch reports Moonshot raised $3.9 billion over the prior six months, and the company is reportedly seeking a larger round still. The lab was founded in 2023 by Yang Zhilin, formerly of Meta AI and Google Brain.
The investor thesis TechCrunch identifies is worth stating plainly: buyers who "don't mind a performance hit in exchange for cheap inference" are a large and growing market. That's precisely the segment K3 targets — and precisely why the per-task cost question above matters so much.
Anthropic: the June 2026 export-control episode
On the evening of 12 June 2026, three days after launch, the U.S. Commerce Department directed Anthropic to suspend all access to Claude Fable 5 and Claude Mythos 5 by any foreign national anywhere in the world. Both models went offline for every customer globally. Other Claude models — Opus, Sonnet, Haiku — remained available. Controls lifted June 30.
This was an export-control action, not a product recall, and Anthropic disputed the underlying assessment directly. In its public statement, the company said it reviewed what it believed to be the report in question and concluded that "the level of capability demonstrated is available from other publicly deployed models, including OpenAI's GPT-5.5, and is used by cybersecurity defenders routinely."
Anthropic added: "We disagree that the finding of a narrow potential jailbreak should be cause for recalling a commercial model deployed to hundreds of millions of people. If this standard was applied across the industry, we believe it would essentially halt all new model deployments for all frontier model providers." A source close to the company contended Anthropic was never presented with details and never refused to fix issues. Forbes notes the competing accounts have not been reconciled.
Why it belongs in a buyer's guide: it's a live demonstration that access to a proprietary frontier model can be interrupted by a party that is neither you nor the vendor. That's a procurement risk variable, independent of any judgment about who was right.
The strategic thread
Put the two stories together and the shape of 2026 is visible: Moonshot is converting architectural efficiency — extreme MoE sparsity, hybrid linear attention, quantization-aware training — into frontier-adjacent capability at a fraction of the token price, under chip access constraints. Anthropic is operating at the capability frontier under a regulatory regime that has now shown it can reach the deploy switch.
Algorithmic efficiency versus raw compute isn't a theoretical debate anymore. It's two different risk profiles you can put on a purchase order.
Running Kimi K3 Yourself: What to Expect on July 27
The weights land by July 27, 2026, and Moonshot says it is working with inference partners and open-source maintainers to align technical details for a reliable ecosystem rollout. A few grounded expectations:
- This is not a laptop model. A 2.8T-parameter MoE with ~50B active per token still requires the full parameter set resident to route. Moonshot's own recommendation is 64+ accelerator supernode configurations for efficient inference.
- vLLM support is being contributed upstream. Because KDA complicates conventional prefix caching, Moonshot contributed an implementation to the vLLM community, to be released alongside the model.
- Quantization is baked in. MXFP4 weights with MXFP8 activations, applied from the SFT stage onward, chosen explicitly for broad hardware compatibility.
- Full technical report follows. Detailed architecture, training, and evaluation specifics arrive with the K3 technical report.
For most teams, the API at $3/$15 will be the practical path. Self-hosting makes sense when data residency, custom fine-tuning, or fixed-cost inference at high volume outweighs the infrastructure burden.
The Real Answer: Stop Picking One
Work through the comparison honestly and the conclusion isn't a winner. It's a routing problem.
- Long-horizon repository work, frontend iteration, high-volume code generation → K3's economics are genuinely hard to beat, especially with automatic caching hitting above 90% on coding workloads.
- Frontier reasoning, high-stakes analysis, tasks where the top slice of output quality is the entire point → Fable 5, by Moonshot's own assessment.
- Everything in between → depends on your prompt shape, your reuse patterns, and your latency tolerance.
Teams that lock into a single provider end up doing one of two things: overpaying for frontier reasoning on tasks that didn't need it, or underspending on tasks where quality actually mattered. Both are expensive. The second is worse.
This is why Jenova is built around unified, multi-model access rather than a single-model bet. One subscription, access spanning US frontier models and open-weight models, with intelligent routing that sends each task to the model suited to it. When the price-performance frontier shifts — and it has shifted twice in the last three months — you adjust routing instead of renegotiating a contract or rewriting an integration.
The comparison above is the argument. Models specialize. Your access shouldn't.
FAQ
How much does the Kimi K3 API cost?
Kimi K3 is priced at **$3.00/MTok for cache-miss input, $0.30/MTok for cache-hit input, and $15.00/MTok for output**, per [Moonshot's launch post](https://www.kimi.com/blog/kimi-k3). The API is OpenAI SDK-compatible — select `kimi-k3` on the Kimi API Platform. Because caching is automatic and Moonshot reports a 90%+ hit rate on coding workloads, effective input cost on repetitive code sessions often lands well below the $3 list price.
When do the Kimi K3 open weights release?
Moonshot states that full model weights will be released by July 27, 2026. The company is coordinating with inference partners and open-source maintainers ahead of the drop, and has contributed a prefix-caching implementation to vLLM to ship alongside the model. A full technical report covering architecture, training, and evaluations is scheduled to accompany the release.
Is Kimi K3 better than Claude Fable 5?
Depends on the task. Moonshot's own launch post says K3's overall performance "still trails the most powerful proprietary models, Claude Fable 5 and GPT 5.6 Sol," and separately acknowledges a noticeable user-experience gap. K3's advantage is long-horizon coding at roughly a third of Fable 5's token price. Fable 5's advantage is frontier general reasoning. Different jobs, different answers.
How does Kimi K3 caching compare to Claude Fable 5 caching?
Both cache, and both discount reads by about 90%. K3 caching is automatic — $0.30/MTok on hits against $3.00 base, no setup. Fable 5 reads drop to $1/MTok against $10 base, but you pay a write premium: $12.50/MTok for 5-minute writes and $20/MTok for 1-hour writes, per Anthropic's caching docs. Fable's cache refreshes free on each hit, so savings depend on reuse frequency clearing the write cost.
Can I run Kimi K3 locally?
Not on consumer hardware. K3 activates ~50B parameters per token, but the full 2.8T MoE must be resident for routing. Moonshot recommends supernode configurations with 64 or more accelerators for inference efficiency. Quantization-aware training with MXFP4 weights and MXFP8 activations helps hardware compatibility, and vLLM support is being contributed upstream — but this is datacenter-class deployment, not a local workstation project.
What happened to Claude Fable 5 in June 2026?
On 12 June 2026, the U.S. Commerce Department issued an export-control directive suspending all access to Fable 5 and Mythos 5 by any foreign national worldwide, forcing Anthropic to disable both models for all customers. Anthropic publicly disputed the severity of the underlying finding, stating comparable capability exists in other deployed models. Controls lifted June 30. Other Claude models were unaffected throughout.
Does the Kimi K3 context window match Claude Fable 5?
Both offer 1M-token context windows. Fable 5 caps output at 128k tokens. The practical difference is less about the window size and more about cost of filling it: at $3/M versus $10/M input, loading a large context is meaningfully cheaper on K3 — but output-heavy reasoning over that context bills at $15/M versus $50/M, which is where the per-task math gets decided.
Bottom Line
The Kimi K3 vs Claude Fable 5 comparison resolves into three durable facts.
One: the pricing gap is real — 3.3× on input, 3.3× on output — but it's a starting point for your cost model, not the answer. Token efficiency, retry rates, and latency on your specific workload determine actual spend.
Two: the caching story is automatic-versus-manual, not present-versus-absent. Both models discount cached reads by roughly 90%. Fable 5 charges $12.50–$20/MTok to write that cache; K3 turns it on for free and reports 90%+ hits on code.
Three: each model owns a different domain. K3 is built for long-horizon coding and priced to be used heavily. Fable 5 sits at the frontier of general reasoning, confirmed by Moonshot's own admission.
Which means the operationally correct answer is access to both, routed by task. That's the position worth building toward — and what Jenova is designed to deliver: unified multi-model access across US frontier and open-weight models under one subscription, with routing that adapts as the frontier moves.
Mark July 27 on your calendar. This page gets updated when the weights land.
For Developers: Multi-model access and intelligent routing are available programmatically via the Jenova API — build model-agnostic AI features into your application with a single integration. Full documentation →