What Kimi K3 Actually Is

Moonshot AI shipped Kimi K3 on the evening of July 16, 2026 (some early coverage, including Moonshot’s own blog timestamp, lists July 17 — the confusion comes from the staggered rollout between the tech blog going live and the products actually flipping on). It’s a 2.8-trillion-parameter Mixture-of-Experts model built on what Moonshot calls a Stable LatentMoE framework, routing each token through just 16 of 896 experts. That sparsity is the whole game: it’s why a model this large can be priced at $3 per million input tokens instead of the $10+ closed labs charge for comparable capability.

The headline spec is the 1-million-token context window — 1,048,576 tokens exactly, if you’re setting it manually in a third-party harness — with native multimodal input covering text, images, and video. Reasoning is always on. There’s no “fast mode” toggle at launch; the reasoning_effort field in the API currently accepts only max, with lower-effort modes promised for later. If you’ve priced out a task assuming you can dial down thinking depth the way you can with GPT-5.6 Sol’s effort controls, you can’t — not yet, anyway. That single detail matters more than it sounds like it should, and I’ll come back to it in the pricing section.

The Architecture: Kimi Delta Attention and Attention Residuals

Two named mechanisms carry Moonshot’s technical pitch. Kimi Delta Attention (KDA) is a hybrid linear-attention design aimed squarely at the long-context serving problem — Moonshot claims up to 6.3x faster decoding at the full 1M-token window. That’s the difference between a million-token context you can quote in a spec sheet and one your agents will actually use on every turn without the latency becoming a UX problem.

Attention Residuals (AttnRes) works the depth axis — residual pathways for attention state that Moonshot credits with roughly 25% higher training efficiency at under 2% additional inference cost. Combined with the MoE sparsity jump, Moonshot puts the total scaling-efficiency gain over Kimi K2.6 at about 2.5x. Those are vendor numbers, not independently audited ones, but they’re specific and falsifiable — which is exactly the kind of claim the open-weights release on July 27 will let outside researchers actually test instead of just repeating.

One deployment detail worth flagging if you’re weighing self-hosting once the weights land: the checkpoints ship in MXFP4 with MXFP8 activations, and Moonshot’s own serving guidance recommends supernode configurations of 64 or more accelerators. This is not a model you’re running on a beefy workstation. Realistically, “self-hosting K3” will mean renting managed capacity from an inference provider once they’ve indexed the weights — the same pattern Qwen and DeepSeek’s open releases established earlier this year.

Kimi K3 vs Claude Fable 5, GPT-5.6 Sol, and Claude Opus 4.8: The Benchmark Matrix

Every number below is Moonshot-reported at launch, with all models run at maximum thinking effort. No independent replication exists yet, though with weights dropping July 27 it will come quickly — which is itself a reason open-weight vendor charts tend to age better than closed-lab ones. Read this as a claim worth taking seriously, not a verdict.

Two things stood out once I put these side by side with independent numbers. First, Artificial Analysis puts K3’s Intelligence Index at 57, ranking it 4th of 189 tracked models — tied with Claude Opus 4.8, behind only Fable 5 and GPT-5.6 Sol. Second, on Arena’s blind-preference Frontend Code leaderboard, K3 actually took the #1 spot with 1,679 points, edging out Fable 5 (1,631) and Sol (1,618) — a 17-place jump from Kimi K2.6’s #18 finish. That’s a real, human-judged win, not just a vendor chart. For the fuller head-to-head against Anthropic’s flagship, I go deeper on pricing, coding accuracy, and agent behavior in my Kimi K3 vs Claude Fable 5 comparison.

How I Tested It — and What Actually Broke

My process for any model review is the same: run it through the API playground for raw capability checks, then live inside it for real work — in this case, Kimi Code sessions on a Moderato-tier plan, plus direct API calls for structured-output and tool-calling tests. I don’t just read the benchmark PDF and call it a review.

The first thing I hit was a plan-gating wall I hadn’t fully accounted for: K3 in Kimi Code is capped at 256K context on Moderato ($19/mo) and only opens to the full 1M window on Allegretto ($39/mo) and above. If you’re evaluating K3 for a large-codebase workflow, budget for Allegretto from day one or you’ll hit a context ceiling mid-session and have no idea why your file reads are getting truncated.

Second, and this cost me real money before I caught it: switching models mid-session invalidates the prompt cache. I bounced between K3 and K2.7 Code to compare outputs on the same task, and my next K3 call came back at full $3/M input pricing instead of the $0.30/M cached rate — because the cache had been wiped by the switch. Moonshot’s docs mention this, but it’s easy to miss if you’re used to providers that preserve cache across model swaps.

Third — and this matches Moonshot’s own launch-post caveats almost word for word — the model is proactive to a fault. On a multi-file refactor task, K3 started rewriting adjacent files I hadn’t asked it to touch, reasoning (correctly, technically) that they’d break otherwise. Useful in isolation, disruptive when you’re trying to review a scoped diff. I also noticed real sensitivity to how thinking history gets preserved across turns: truncate or summarize an earlier reasoning block, and follow-up answers get noticeably less coherent, in a way I don’t see as often with Fable 5 or Opus 4.8.

None of this is disqualifying. Moonshot’s tech blog is unusually candid about exactly these gaps — a noticeable UX deficit versus Fable 5 and GPT-5.6 Sol, thinking-history sensitivity, and excessive proactiveness — and a vendor that publishes its own weaknesses alongside its wins earns a bit more trust on the wins. If you’re setting up Kimi Code specifically, I wrote a full setup and cache-discipline walkthrough in my Kimi Code K3 setup guide and a broader Kimi K3 in Kimi Code plan breakdown that would’ve saved me the cache mistake above.

Pricing: API, Plans, and the Real Cost Trap

The API rate card is genuinely disruptive: $3.00 per million input tokens on a cache miss, $0.30 on a cache hit, and $15.00 per million output tokens — flat across the entire 1M-token context, with no long-context surcharge. Moonshot cites cache-hit rates above 90% in coding workloads, which pulls the effective input cost toward that $0.30 figure if your traffic looks similar.

Here’s the catch I mentioned earlier: because reasoning_effort is locked to max at launch, K3 spends more reasoning tokens per task than models that let you dial effort down. Artificial Analysis measured K3’s real cost-per-task at $0.94 — similar to GPT-5.6 Sol’s $1.04, about half of Opus 4.8’s $1.80, but meaningfully above what the sticker price alone suggests. Price-per-token and price-per-task are not the same number here, and anyone budgeting off the rate card alone is going to be surprised by their first invoice.

On the consumer side, Kimi runs five membership tiers: Adagio (free), Moderato ($19/mo), Allegretto ($39/mo), Allegro ($99/mo), and Vivace ($199/mo). All tiers get K3 in the chat app, but context length, agent credits, and Kimi Code allowance scale by plan — and Moonshot has already flagged that Kimi and Kimi Code benefits may be split into separate tracks soon, so don’t assume this pricing grid is permanent.

Open Weights: What July 27 Actually Buys You

As of today, K3 is API-only. No LICENSE file, no Hugging Face checkpoint, no technical report has shipped — Moonshot’s own Hugging Face org lists zero models named K3. The July 27 date is a commitment, not a delivered artifact, and the license is expected to follow the Modified MIT pattern used for K2, K2.5, K2.6, and K2.7-Code, but it isn’t confirmed until the repo itself goes live.

Be realistic about what “open” means at this scale, too. Even in MXFP4, deployment needs roughly 1.5TB of memory and Moonshot’s recommended supernode of 64+ accelerators — this isn’t a laptop model. What the open-weights release does buy, even if you never download a shard yourself, is hosted-price competition (multiple inference providers typically undercut the first-party API within days of a major open-weights drop, as happened with DeepSeek V4), continuity insurance against a single vendor changing terms, and genuine third-party auditability of the KDA and AttnRes claims. I laid out a full pre-drop checklist — hosting prep, license clauses to check, and a day-by-day countdown — in my Kimi K3 open weights readiness checklist.

Where K3 Wins, Where It Doesn’t

FAQ

When exactly was Kimi K3 released?

Kimi K3 went live on July 16, 2026, across Kimi.com, Kimi Work, Kimi Code, and the API. Some outlets, including Moonshot’s own launch blog timestamp, cite July 17 — the gap reflects the rollout lag rather than a real discrepancy.

Is Kimi K3 actually open source?

It’s open-weight, not open-source in the full OSI sense — the trained weights will be freely downloadable, but training data and pipeline aren’t released. Full weights are promised by July 27, 2026, expected under a Modified MIT license.

How much does Kimi K3 cost?

The API charges $3.00 per million input tokens on a cache miss, $0.30 on a cache hit, and $15.00 per million output tokens, flat across the full 1M context. Consumer plans range from free (Adagio) to $199/month (Vivace).

Can I run Kimi K3 on my own hardware?

Not practically. Moonshot recommends supernodes of 64+ accelerators and roughly 1.5TB of memory even at MXFP4 precision. Most teams will access self-hosted K3 through a managed inference provider rather than local hardware.

Is Kimi K3 better than Claude Fable 5?

Not across the board. K3 leads on browsing, spreadsheet, and automation benchmarks and topped Arena’s Frontend Code leaderboard, but Fable 5 keeps a clear lead on FrontierSWE and GDPval-AA — the hardest engineering and knowledge-work evals. K3’s pricing is a fraction of Fable 5’s, though.

Bottom Line

Kimi K3 doesn’t dethrone the closed frontier — Moonshot says so itself, candidly, in its own launch post. What it does is compress the open-versus-closed gap to roughly a single model generation, attach a dated open-weights commitment to a near-frontier scorecard, and price the hosted version at a fraction of what Claude Fable 5 or GPT-5.6 Sol charge. My hands-on week found real rough edges — the always-max thinking effort, the proactiveness that oversteps scope, the cache-invalidation trap on model switches — but none of them are dealbreakers for a model you’re evaluating as a second source rather than a full migration.

If you’re already running a closed-model stack, wire K3 into your eval harness this week — the OpenAI-compatible API makes that cheap — and read the license the moment it lands on July 27. If budget is the driver, the cache economics alone make K3 worth piloting on high-volume agentic workloads today. Either way, this is the strongest open-weight challenger the frontier has seen yet, and it earned that with real numbers, not just a launch-day press cycle.

---

Related Reading

• Kimi K3 vs Claude Fable 5: Full Comparison
• Kimi Code K3 Setup, Plans, and Cache Discipline
• Kimi K3 in Kimi Code: Setup Guide and Plan Breakdown
• Kimi K3 Open Weights: July 27 Readiness Checklist
• Claude Fable 5 Review: Features, Pricing, Pros & Cons
• Claude Fable 5 vs ChatGPT 5.5
• Best GitHub Repos to Learn Claude Code in 2026
• Claude Code vs Cowork: Side-by-Side Test
• 11 Things Claude Code Can Do That Cursor Can’t
• I Let Claude Code Run My YouTube Channel for 30 Days