Kimi K3 vs Claude Fable 5: Open Weights vs the Closed Frontier (2026)

TL;DR

Last updated August 21, 2026.

Claude Fable 5 is Anthropic's most capable widely released model: $10/M input, $50/M output, 1M-token context, 128K max output, thinking always on, closed weights, API only. Kimi K3 is Moonshot's 2.8-trillion-parameter MoE, launched July 16, 2026 and open-weighted on Hugging Face since July 27 under the Kimi K3 License, the largest open-weight model ever released: $3/M input and $15/M output at Moonshot, flat at any context length, 1M context, native vision for images and video. Independent tests place K3 just behind Fable 5: 69.9 vs 68.5 pass@1 on Together AI's DeepSWE head-to-head, 1574 vs 1543 on AA-Briefcase. Fable is the capability pick; K3 is the price-and-open-weights pick.

The 30-Second Verdict

Fable 5 is the stronger model. The decision is not who wins a benchmark table; it is whether the last increment of capability is worth 3.3x the price and closed weights for your specific workload.

• Hardest agentic work? Fable 5. Long-horizon tasks, deepest reasoning, sub-agent orchestration. It keeps the first-shot edge: 69.9 vs 68.5 pass@1 on Together's DeepSWE head-to-head.
• Optimizing cost per task? Kimi K3. $3/$15 at Moonshot, $2.80/$14 on Morph, versus $10/$50. In agent loops the 90%-off cached-input rate widens the gap further.
• Need vision? Kimi K3. Native image and video input. Fable 5's strength is text and code agentics.
• Need weights, on-prem, or zero-data-retention? Kimi K3 only. Fable 5 is closed, API-only, and requires 30-day data retention.
• Long-context workloads? Both run 1M tokens. K3 prices the full window flat; Fable charges 3.3x more per token across it.

Spec-by-Spec

The two models match on context length and always-on thinking, then diverge on everything structural: weights, modality, price, and how much of the reasoning trace you are allowed to see.

One architectural note explains K3's flat long-context pricing: Kimi Delta Attention, a hybrid linear-attention design that interleaves linear and full-attention layers in a 3:1 ratio and cuts KV-cache memory by up to 75%. Moonshot charges the same $3/M whether you send 4K or 900K input tokens. K3's active parameter count is genuinely unsettled in public sources: Latent Space's "2.8T-A50B" framing implies ~50B, while unsloth documentation says 104B. Moonshot has not settled it, so we present both. Full K3 details are on the Kimi K3 page.

Benchmarks: A Narrowing Gap

Every K3 headline number is Moonshot-reported, so treat the vendor table as a claim. The useful part is that independent replication kept landing after launch and tells a consistent story: K3 leads the open lineage, and by August the measured gap to Fable 5 is small. Moonshot even ships a conformance harness, Kimi-Vendor-Verifier (OCRBench, MMMU Pro Vision, BEAM-1M, DeepSWE), so anyone can check whether a provider serves the model faithfully.

The closest thing to a clean side-by-side is Together AI's DeepSWE run: 452 rollouts on 113 real feature requests, 4 attempts each. Fable 5 wins pass@1, 69.9 to 68.5. K3 wins pass@2 (82.0 vs 80.2) and pass@4 (89.4 vs 88.5), at $4.65 per rollout to Fable's $13.41. Give K3 a retry budget and it matches or passes Fable on this harness at roughly 2.8x the solves per dollar. Fable's edge shows up most where benchmarks measure it least, in many-minute single turns at higher effort, first-shot implementations that need no retry loop, and orchestrating parallel sub-agents over long horizons.

Price: The 3.3x Question

The sticker math is simple. Fable 5 charges $10/M input and $50/M output. K3 at Moonshot list is $3/$15, flat at any context length: 3.3x cheaper on both legs. On Morph, K3 is $2.80/$14, under Moonshot's own list on every leg.

The sticker understates the gap for agent workloads. In an agent loop, most input tokens are replayed context: the same system prompt, file contents, and tool results resent every turn. K3's cached-input rate is 90% off ($0.29/M on Morph), so the cached rate, not the base rate, dominates real cost once a loop runs more than a few turns. Both models think on every request with no off switch, K3 with effort locked to max at launch, so reasoning tokens land on the output meter for both; at $14/M versus $50/M, the same trace costs 3.6x less on K3.

The counterweight is failure cost. A model that lands a hard task in one attempt is cheaper than one that burns three retries at a third the rate. Together's DeepSWE run priced this directly: even with retries counted, K3 solved roughly 2.8x more tasks per dollar ($4.65 vs $13.41 per rollout). Fable 5's one-attempt case is real on the hardest tier of work; it just does not apply to the bulk of coding volume, where the measured numbers say the task lands either way.

Open Weights vs Closed

This is the axis where the two models are not on a spectrum but in different categories. On July 27, 2026, Moonshot published the full 2.8T-parameter K3 weights on Hugging Face (moonshotai/Kimi-K3, 96 shards plus a technical report) under the custom Kimi K3 License, the largest open-weight model ever released. vLLM shipped day-zero support for Kimi Delta Attention, and The New York Times covered the release the same day. The shipped checkpoint is natively MXFP4 quantization-aware trained, experts in MXFP4 with MXFP8 activations, and an early-August repo revision moved four attention projections from BF16 to FP8 E4M3. Fable 5 is closed weights, served by exactly one vendor, with no self-host, fine-tune, or third-party option.

Open weights buy three concrete things. First, a provider market: multiple hosts compete on price and latency, which is why K3 is already available below Moonshot's own list, and Moonshot polices quality across it with the public Kimi-Vendor-Verifier conformance harness. Second, no deprecation risk: Anthropic can retire or re-price Fable 5 on its own schedule, and API models do get retired; Moonshot itself is sunsetting kimi-k2.5 and the moonshot-v1 series on August 31, 2026. Nobody can take the K3 weights back. Third, deployment freedom: on-prem, air-gapped, fine-tuned, or audited at the weight level. Fable 5 additionally requires 30-day data retention and is not available under zero-data-retention agreements, which is disqualifying for some regulated workloads regardless of capability.

Agent-Harness Differences That Bite in Production

Three behavioral differences matter more day-to-day than any benchmark row, because they change how you build the loop around the model.

• K3 requires preserved thinking history. K3 was trained in preserved-thinking-history mode: in multi-turn and tool-call conversations, the full assistant message (content, reasoning_content, and tool_calls) must be passed back verbatim. Harnesses that strip thinking history silently degrade the model; Moonshot's own docs example shows the correctly replayed turn billing 599 prompt tokens versus 198 stripped. If your framework drops reasoning fields, fix that before benchmarking K3 at all.
• Fable 5 never shows its reasoning. Raw chain of thought is never returned; you get summaries only (display: "summarized"). It also does not support assistant prefill. K3 returns its full trace, which developers read when debugging agent behavior.
• Fable 5 can refuse via safety classifiers. Requests can stop with stop_reason "refusal" in categories like cyber and bio, and benign security work occasionally trips false positives; Anthropic recommends configuring fallbacks to Opus 4.8. Production pipelines on Fable 5 need a refusal branch. K3's failure modes are the ordinary ones.

Which One to Pick, by Workload

The answer many teams land on is a split stack: K3 or GLM-5.2 as the high-volume default for bulk build work, Fable 5 or Opus for the gnarliest debugging and the tasks that keep failing downstream. At 3.3x the per-token price, Fable 5 earns its slot when the task is hard enough that the cheaper model would retry its way past the price gap, and not before.

Running Kimi K3 on Morph

Morph serves K3 as morph-kimik3 at $2.80/M input, $0.29/M cached, and $14/M output with the full 1M context, under Moonshot's list on every leg. A latency-tuned SKU, morph-kimik3-fast, runs the same weights at $6.00/$22.50 for interactive workloads.

Directly relevant on a vs-Claude page: Morph serves the Anthropic Messages API natively, so Claude Code runs Kimi K3 with two environment variables and no proxy.

export ANTHROPIC_BASE_URL="https://api.morphllm.com"
export ANTHROPIC_AUTH_TOKEN="YOUR_MORPH_API_KEY"
# then select morph-kimik3 as the model in Claude Code

The same key works on the OpenAI-compatible endpoint:

from openai import OpenAI

client = OpenAI(
    base_url="https://api.morphllm.com/v1",
    api_key="YOUR_MORPH_API_KEY",
)

resp = client.chat.completions.create(
    model="morph-kimik3",
    messages=[
        {"role": "user", "content": "Refactor this function to remove the nested loop."},
    ],
)
print(resp.choices[0].message.content)

For multi-turn agent workloads, Morph adds Agent Runs, program-aware scheduling from the ThunderAgent paper, available on Kimi K3 and unique to Morph. Tag requests with a run_id and the scheduler treats the whole run as one unit: sticky placement routes every turn to the worker holding its KV cache, so nothing re-prefills between tool calls; priority resume admits a run returning from a tool call ahead of new arrivals; and under load, whole runs pause instead of every run slowing down. One field to adopt, and program_id aliases work for ThunderAgent-convention clients. Details in the Agent Runs docs. The same key covers the full Open Source Models lineup.

Kimi K3 vs Claude Fable 5: The Trade-Offs

Frequently Asked Questions

Is Kimi K3 better than Claude Fable 5?

Fable 5 is still ahead, narrowly. Together AI's independent DeepSWE head-to-head has Fable 5 at 69.9 pass@1 to K3's 68.5, with K3 ahead at pass@2 and pass@4; Artificial Analysis has K3 second on AA-Briefcase at 1543 Elo to Fable's 1574. K3's case is everything around the capability: 3.3x lower price on both legs, roughly 2.8x more DeepSWE solves per dollar, open weights under the Kimi K3 License, native vision, and a provider market.

What is the price difference?

Fable 5: $10/M input, $50/M output. K3 at Moonshot: $3/$15, flat at any context length, 3.3x cheaper on both legs. On Morph: $2.80/$14 with $0.29/M cached input, under Moonshot's own list on every leg. In agent loops the 90%-off cached rate dominates real cost.

Can I self-host Kimi K3?

Yes, since July 27: full weights on Hugging Face (moonshotai/Kimi-K3) under the Kimi K3 License, with day-zero vLLM support for Kimi Delta Attention. The shipped checkpoint is natively MXFP4 quantization-aware trained. At 2.8T total parameters it is still a multi-node serving problem, so most teams take the price benefit through a hosted provider instead.

Does Fable 5 have open weights?

No. Closed weights, API only, one vendor. It also requires 30-day data retention, never returns raw chain of thought, and does not support assistant prefill.

How do they compare on context window?

Tied at 1M tokens. Fable 5 runs 1M default and max with 128K max output. K3 reaches 1M via Kimi Delta Attention (3:1 linear-to-full ratio, up to 75% less KV-cache memory) and prices the whole window flat.

Can Claude Code use Kimi K3?

Yes. Morph serves the Anthropic Messages API natively, so two environment variables (ANTHROPIC_BASE_URL pointed at https://api.morphllm.com and ANTHROPIC_AUTH_TOKEN set to a Morph key) put morph-kimik3 behind Claude Code unchanged.

Are Kimi K3's benchmarks trustworthy?

The vendor table (81.2 FrontierSWE, 88.3 Terminal-Bench 2.0, 91.2 BrowseComp, 93.5 GPQA-Diamond) is Moonshot-reported. Independent numbers back the direction: 60 on Artificial Analysis's Intelligence Index at max effort, 1543 Elo on AA-Briefcase (second behind Fable 5), 68.5 pass@1 on Together AI's DeepSWE run, 80.9 on Terminal-Bench 2.1 via Vals, #1 debut on LMArena's Frontend Code Arena at 1679 Elo. Moonshot also publishes the Kimi-Vendor-Verifier harness for checking provider fidelity.