Moonshot AI didn’t launch Kimi K3 quietly. The company’s own benchmark table, published alongside the model on July 16, 2026, put it in blunt terms: K3 beats Claude Opus 4.8 and GPT-5.5 across coding and agentic benchmarks, and trails only two models on the planet: Claude Fable 5 and GPT-5.6 Sol. That’s not a company hedging. That’s a company naming the two models it wants you to compare it against.
So let’s do that comparison properly, on the coding question specifically, because “which is better for coding” and “which is better overall” are different questions with different answers here.
Kimi K3 and Claude Fable 5, side by side
| Kimi K3 | Claude Fable 5 | |
| Maker | Moonshot AI (Beijing) | Anthropic |
| Released | July 16, 2026 | June 9, 2026 |
| Architecture | 2.8T-parameter MoE, 16 of 896 experts active per token (~1.8%) | Not disclosed (Anthropic never publishes parameter counts) |
| Weights | Open, full weights scheduled for July 27, 2026 | Closed, API-only |
| Context window | 1,000,000 tokens, native vision | 1,000,000 tokens (per generally-available Claude models) |
| Input price | $0.30/M (cache hit), $3/M (cache miss) | Not independently confirmed; reported at roughly 2x Opus 4.8’s $5/$25 |
| Output price | $15/M | Roughly 2x Opus 4.8’s output rate, in the neighborhood of $50/M |
| Availability status | Live now via Moonshot’s API and Kimi products | Restored July 1, 2026, after a 19-day suspension for U.S. export-control compliance |
That availability line matters more than it looks. Fable 5 was suspended from June 12 to July 1, 2026, while Anthropic complied with a U.S. Department of Commerce export-control order, not a performance issue, a regulatory one, and it’s been fully restored since (Anthropic’s statement). If you’re weighing which model to build a production dependency on, that’s a real data point about single-provider risk, not a knock on either model’s capability.
The coding benchmarks, and what each one is actually testing
Benchmark names get thrown around like they’re interchangeable. They’re not. Here’s the coding-specific table, with what each test is actually measuring underneath the score.
| Benchmark | What it measures | Kimi K3 | Claude Fable 5 |
| SWE-bench Verified | Fixing human-filtered real GitHub issues, single-pass | not published by Moonshot | 95.0% |
| SWE-bench Pro | Harder, contamination-resistant version across professional, multi-file repos | not published by Moonshot | 80.3% |
| Terminal-Bench 2.1 | Shell-driven agentic work: installing dependencies, chaining commands, recovering from failures | 88.3% (KimiCode harness, max effort) | 83.4%–88.0% (source-dependent) |
| Frontend Code Arena (arena.ai) | Blind human preference on generated frontend code, head-to-head | 1,679 Elo, ranked #1, ahead of Fable 5 | ranked below K3 on this leaderboard |
| Kimi Code Bench 2.0 | Moonshot’s internal coding-agent benchmark | 72.9% | not applicable (Moonshot’s own test) |
| FrontierCode Diamond | Anthropic’s hardest coding tier, contamination-resistant | not published by Moonshot | 29.3% (reported as roughly 5x GPT-5.5’s score on this specific test) |
A few things are worth slowing down on before you read a winner off this table.
SWE-bench Pro is the one that matters most for “can this replace a mid-level engineer on a real ticket.” It’s designed specifically to resist the memorization and contamination problems that made the original SWE-bench too easy to game: ambiguous problem statements, multiple files touched, build and test failures, existing behavior that must not regress. Fable 5’s 80.3% is the highest published score on this benchmark by any model as of this writing, roughly 11 points ahead of Claude Opus 4.8’s 69.2%. Moonshot has not published a K3 score on SWE-bench Pro at all, which is a gap in the comparison you should weight accordingly, not proof K3 is weaker there, but not evidence it’s stronger either.
Terminal-Bench 2.1 is close, and the winner depends on which source you trust. Moonshot’s own benchmark run (KimiCode harness, max reasoning effort) has K3 at 88.3%, edging out most published Fable 5 numbers, though one source reports Fable 5 as high as 88.0% on the same test. This is a case where the harness matters as much as the model: Terminal-Bench scores shift meaningfully depending on which coding agent (KimiCode, Claude Code, a bare model API call) is doing the driving, not just which model is underneath it.
Frontend Code Arena is a genuinely different kind of signal. It’s not an automated pass/fail grader; it’s blind human preference on generated frontend code, head-to-head. K3 topping that leaderboard ahead of Fable 5 tells you something real: when developers look at two pieces of generated UI code side by side without knowing which model wrote which, they’re picking K3’s output more often. That’s a meaningfully different claim than “K3 passes more automated test cases,” and it’s worth taking seriously precisely because it isn’t gameable the way an automated benchmark can be.
FrontierCode Diamond is where Fable 5’s lead stops looking close. Anthropic’s hardest coding tier, and the one place in this comparison where the gap between “frontier” and “very good” becomes visible. Fable 5’s score there is reported at roughly five times GPT-5.5’s, and Moonshot hasn’t published a competing K3 number on this specific test.
What Moonshot’s own demo tells you that the benchmark table doesn’t
The benchmark scores are Moonshot’s own self-reported claim, but the company also published something harder to fake: a 48-hour autonomous run where K3 designed a physical chip layout for a nano-scale version of itself, using open-source EDA tools, closing timing at 100MHz within a 4mm² die and packing 1.46 million standard cells. In a separate GPU-kernel benchmark, K3’s published trace hit a 59.7% speedup over baseline versus 57.1% for Fable 5, though Moonshot itself flagged that the Fable 5 number came from third-party evaluation and may include fallback behavior, which is exactly the kind of caveat you should want a lab to disclose about its own comparison table, and exactly the kind of caveat that makes the rest of Moonshot’s numbers more credible by association.
What this actually demonstrates isn’t “K3 can design chips,” which is a narrow flex. It’s long-horizon autonomous execution: staying on task, self-correcting, and producing a working artifact across many hours without a human steering it turn by turn. That’s a different capability than winning a single-shot coding benchmark, and it’s arguably the more important one if you’re building an agent meant to run unattended.
Kimi K3 vs Claude Fable 5: Pricing Comparison (and why it isn’t close)
This is where the comparison stops being subtle. Kimi K3’s pricing is $0.30 per million input tokens on a cache hit, $3 per million on a cache miss, and $15 per million output tokens. Fable 5 is reported at roughly double Claude Opus 4.8’s $5/$25 rate, call it somewhere near $10 input / $50 output per million tokens, since Anthropic hasn’t published Fable 5’s exact standalone rate card as clearly as it has for Opus.
Run the same moderately complex coding-agent task from the model cost comparisons everyone’s running right now: 400,000 input tokens, 60,000 output tokens.
| Model | Input cost | Output cost | Total |
| Kimi K3 (cache miss) | $1.20 | $0.90 | $2.10 |
| Kimi K3 (cache hit) | $0.12 | $0.90 | $1.02 |
| Claude Fable 5 (estimated) | $4.00 | $3.00 | $7.00 |
Artificial Analysis independently measured Kimi K3’s cost per task on their evaluation suite at $0.94, about half of Opus 4.8’s $1.80 and in the same range as GPT-5.6 Sol’s $1.04. That’s not a rounding difference. If you’re running thousands of coding-agent tasks a month, the gap between K3 and Fable 5 is the difference between a four-figure and a five-figure monthly line item, before you’ve weighed whether the extra capability at the top end is worth paying for.
Open weights vs. closed API: the decision most comparisons skip
This is the part of the Kimi K3 vs. Fable 5 question that has nothing to do with benchmark scores and everything to do with how you’re allowed to run the model. Kimi K3 is open-weight, with full weights scheduled for release by July 27, 2026. Moonshot recommends serving it on a supernode of at least 64 accelerators, which tells you this isn’t a model you’re casually self-hosting on a couple of GPUs, but it is a model you can self-host at all, fine-tune, and run inside your own infrastructure with no data leaving your network. Claude Fable 5 is API-only, full stop: you’re sending your code to Anthropic’s servers, subject to Anthropic’s terms, and you have zero ability to fine-tune or inspect the weights.
For a regulated enterprise with hard data-residency requirements, that difference alone can settle the question before a single benchmark gets looked at. For a small team without the infrastructure to run a 2.8-trillion-parameter MoE model, even a sparse one activating under 2% of experts per token, the API convenience of Fable 5 (or K3’s own hosted API, which is also available and much cheaper than Fable 5’s) is going to matter more than the philosophical appeal of owning your weights.
The real-world quirks nobody puts in the launch blog
Fable 5’s most-cited practical complaint from early adopters isn’t a benchmark gap; it’s that the model sometimes doesn’t know when to stop. It’s the kind of thing that shows up after the free-trial period, once you’re running it on real, messy, ambiguous tasks instead of clean benchmark problems: an agent that keeps iterating, re-checking, or expanding scope past the point where a human would have called the task done. That’s a real operational cost, it eats tokens and requires oversight, and it’s exactly the trade the “escalate the hardest 10-20% to Fable 5” strategy that’s become common practice is designed around: use a cheaper, more predictable model by default, and reserve Fable 5 for the tasks that are genuinely hard enough to justify both the cost and the extra supervision.
Kimi K3 doesn’t have an equivalent multi-week track record yet. It’s four days old at the time of writing, and while Moonshot’s benchmark disclosures have been unusually transparent about caveats (flagging the Fable 5 fallback-behavior issue in their own comparison table is a good sign), “unusually transparent” isn’t the same as “independently verified across months of production use.” There’s also a structural wrinkle specific to this model: it’s a Chinese-developed system built under U.S. export restrictions on advanced accelerators, and questions have already been raised in the tech press about exactly what hardware Moonshot used to train it. That’s not a reason to distrust the model’s output quality, nothing in the benchmark data suggests otherwise, but if your organization has procurement or compliance policies around the provenance of AI infrastructure, it’s a real diligence item, not a footnote.
The Bottom Line
For raw, hardest-tier coding capability, real GitHub issue resolution on messy professional repositories, the kind of task where a wrong answer costs an engineer’s afternoon, Claude Fable 5 currently holds the stronger published claim, led by its 80.3% on SWE-bench Pro and its wide lead on FrontierCode Diamond. If you’re building an agent meant to operate with minimal supervision on your hardest, highest-stakes tickets, and cost is a secondary concern next to correctness, Fable 5 is the safer bet on the numbers Anthropic has published.
For frontend work, terminal-driven agentic tasks, and any workload where cost per task actually matters at scale, Kimi K3 is the more interesting model right now. It topped a blind human-preference leaderboard for frontend code ahead of Fable 5, it’s competitive or ahead on Terminal-Bench 2.1 depending on the harness, and it does all of this at roughly a third to a seventh of the estimated per-task cost, with the added option of running it entirely on your own infrastructure if that matters to you.
Moonshot’s own framing, that K3 trails Fable 5 and GPT-5.6 Sol but beats everything else, is a more honest self-assessment than most model launches offer, and the benchmark data mostly backs it up on the hardest, most contamination-resistant tests. But “trails on the hardest benchmark” and “worse for your actual coding workload” aren’t the same claim. If your team’s daily work looks more like shipping frontend features and running terminal-heavy agent workflows than resolving Fortune-500-scale legacy bugs, K3’s combination of benchmark competitiveness, human-preference wins, and dramatically lower cost makes it the model worth prototyping against first, with Fable 5 kept in reserve for the tickets that are hard enough to justify the premium.
