TL;DR

Kimi K3 is Moonshot AI’s newly launched frontier-class model — a 2.8-trillion-parameter Mixture-of-Experts LLM with a 1-million-token context window, native vision, and a new hybrid-linear attention mechanism called Kimi Delta Attention (KDA). It went live on July 16, 2026, hit 1,640 points on Hacker News in 19 hours (the top HN post that day), and Moonshot has committed to releasing full open weights on July 27, 2026 — which would make it the largest open-weight LLM ever shipped, roughly 75% bigger than DeepSeek V4 Pro.

The pitch that got it there: an open model trading blows with Claude Fable 5, GPT-5.6 Sol, and Opus 4.8 on real coding and knowledge-work benchmarks — not on cherry-picked toy tasks. On the third-party Artificial Analysis GDPval-AA v2 benchmark (real-world tasks across 44 occupations), K3 scored 1,687 — third overall, behind only Claude Fable 5 Max (1,815) and GPT-5.6 Sol Max (1,747.8), and ahead of Opus 4.8 (1,600). On Terminal Bench 2.1 it hits 88.3 — a hair below GPT 5.6 Sol’s 88.8 and above every other tested model. On BrowseComp it hits 91.2, the highest of the group.

Key facts up front:

  • 2.8T total parameters, sparse MoE, 16 of 896 experts active per token (Stable LatentMoE framework)
  • 1,048,576-token context window (1M tokens)
  • Open weights promised July 27, 2026 — Moonshot’s K2 family shipped under Modified MIT; K3 is expected to follow
  • Kimi Delta Attention (KDA) — hybrid linear attention, up to 6.3× faster decode at million-token contexts
  • Attention Residuals (AttnRes) — selective depth retrieval, ~25% higher training efficiency at under 2% extra cost
  • Native vision — text, image, video in the same model
  • API pricing: $3/M input, $15/M output, $0.30/M cache-hit input (Moonshot reports >90% cache-hit rate on coding workloads)
  • OpenAI-SDK compatible, base URL https://api.moonshot.ai/v1, model id kimi-k3
  • HN reception: 1,640 points, 966 comments in under a day

If you have been waiting for an open model that can genuinely run a Claude Code / Codex-style long-horizon agent loop instead of just answering short prompts, this is the one worth paying attention to.

Who Built It and Why It Matters

Kimi K3 comes out of Moonshot AI — the Beijing-based startup founded by Yang Zhilin and backed by Alibaba, best known for the Kimi chatbot and for its Kimi K2 series that dominated the open-weight leaderboard through late 2025 and the first half of 2026. Moonshot closed a $500M Series C at a $4.3B valuation in January 2026, per TechCrunch, and public reporting from The Decoder said the round was explicitly earmarked for compute and K3 development.

The reason K3 matters is timing plus scale. Timing: it landed the day before WAIC 2026 in Shanghai, the biggest AI conference in China, and days after Thinking Machines released their Inkling open-weights model. Scale: at 2.8 trillion parameters K3 is roughly 75% larger than DeepSeek V4 Pro (~1.6T), per VentureBeat’s coverage citing Moonshot’s own comparison chart, and it is the first open model to cross the 2T-parameter line. For nine of the past twelve months, Moonshot’s models have set the upper bound of open-model sizes — K3 continues that streak with the widest margin yet.

Independent analyst reactions have been notable. VentureBeat framed it as “a watershed moment for the open-source AI movement”. Fortune described it as “pushing Chinese AI into Fable-level territory.” SiliconANGLE called it “the world’s largest open-weights model”. And Financial Times reported anonymous sources saying K3 is expected to match or surpass Anthropic’s Opus 4.8 on real workloads — which is exactly what the published benchmarks now confirm.

The Architecture: KDA, AttnRes, and 16-of-896 Sparsity

K3 is built on three architectural bets that together produce roughly 2.5× better scaling efficiency than Kimi K2, per Moonshot’s release notes.

1. Kimi Delta Attention (KDA). A hybrid linear attention mechanism that changes how information flows across sequence length. Traditional dense attention costs O(n²) — the reason 1M-token contexts have historically been slow and expensive. KDA is Moonshot’s answer: they claim up to 6.3× faster decoding in million-token contexts compared to their K2 baseline. The technique was previously published as open research on GitHub. Because KDA also poses new challenges for prefix caching, Moonshot has contributed a vLLM implementation upstream so open-source hosts can serve K3 efficiently.

2. Attention Residuals (AttnRes). A drop-in replacement for residual connections that changes how representations flow across model depth rather than across sequence length. Moonshot describes it as “selectively retrieving representations across depth rather than accumulating them uniformly,” and reports ~25% higher training efficiency at under 2% extra cost. Also previously published as open research.

3. Stable LatentMoE with Quantile Balancing. The sparsity story. K3 activates 16 out of 896 routed experts per token — a much sparser ratio than K2’s 32-of-384. At that sparsity, expert-collapse and load-balancing become the dominant scaling problems. Moonshot’s fix is Quantile Balancing, which derives expert allocation directly from router-score quantiles rather than using a heuristic auxiliary loss. Combined with Per-Head Muon (Muon optimizer per attention head), SiTU activations, and Gated MLA, this is what lets K3 hit the parameter count without catastrophic quality loss.

For serving, K3 uses quantization-aware training from the SFT stage, with MXFP4 weights and MXFP8 activations for broad hardware compatibility. Moonshot recommends supernode configurations with 64+ accelerators for full-throughput serving — this is not a “run it on your MacBook” model, at least until the community produces GGUF quantizations post-July 27.

A Minimal API Call (You Can Run This Today)

The API is live now — you don’t need to wait for weights. K3 is compatible with the OpenAI Python SDK against Moonshot’s base URL:

from openai import OpenAI
import os

client = OpenAI(
    api_key=os.environ["MOONSHOT_API_KEY"],
    base_url="https://api.moonshot.ai/v1",
)

completion = client.chat.completions.create(
    model="kimi-k3",
    reasoning_effort="max",
    messages=[{
        "role": "user",
        "content": "Refactor this Python function to be async-safe: ..."
    }],
)
print(completion.choices[0].message.content)

Four API rules to know before you port existing Kimi K2 code:

  1. reasoning_effort only accepts "max" at launch. Low- and high-effort modes are coming in later releases. Do not pass the old K2.x thinking parameter — it will error.
  2. temperature, top_p, and n are fixed. Omit them entirely. Trying to override them fails.
  3. max_completion_tokens defaults to 131,072 and reaches the full 1,048,576 ceiling. If you’re doing long-horizon coding, set it explicitly high.
  4. In multi-turn and tool-use flows, return the complete assistant message. Partial history — including trimming past reasoning traces — breaks the model’s ability to sustain long-context reasoning.

The model id is also available on OpenRouter as moonshotai/kimi-k3 if you want to A/B it against Claude and GPT without setting up a separate account.

Benchmarks: Do the Numbers Hold Up?

Moonshot’s published benchmark table is unusually direct — including where K3 loses. Every K3 row uses reasoning_effort=max, with harness noted per benchmark (KimiCode, Claude Code, or Codex).

BenchmarkKimi K3Fable 5 (w/ fallback)GPT 5.6 SolOpus 4.8GLM-5.2
DeepSWE67.570.073.059.046.2
Program Bench77.876.877.671.963.7
Terminal Bench 2.188.384.688.884.682.7
FrontierSWE81.286.671.366.767.3
SWE Marathon42.035.039.040.013.0
BrowseComp91.288.090.484.3—
Automation Bench30.829.129.727.212.9
GPQA-Diamond93.592.694.191.091.2
HLE-Full43.553.344.549.8—
MMMU-Pro81.681.283.078.9—
OmniDocBench91.189.885.887.9—

K3 leads on: Program Bench, SWE Marathon, BrowseComp, Automation Bench, and OmniDocBench.

K3 trails on: DeepSWE (behind GPT 5.6 Sol), FrontierSWE and HLE-Full (behind Fable 5), MMMU-Pro and Terminal Bench 2.1 by tiny margins.

Two important caveats. “With fallback” for Fable 5 means requests Anthropic’s usage policy refuses get routed to Opus 4.8 — a real deployment optimization but not a pure model comparison. And BrowseComp used context compaction at 300K tokens; without that context management K3 scores 90.4 instead of 91.2.

The third-party read is even more favorable. On Artificial Analysis GDPval-AA v2 — the private benchmark measuring real-world tasks across 44 occupations and 9 industries — K3 came in third overall at 1,687 points, ahead of Opus 4.8 (1,600) and behind only the two top proprietary flagships. Artificial Analysis also measured Moonshot’s endpoint at 62 output tokens/sec and 1.99 seconds to first token — respectable, though independent hosts serving the weights will likely beat that after July 27.

Community Reactions

The HN thread (48935342) hit 1,640 points and 966 comments in 19 hours — top of the site all day on launch. Three consistent themes from the discussion:

“The open-weight-versus-closed gap is now measured in weeks, not model generations.” Multiple commenters noted that if the July 27 weight drop actually happens on schedule, K3 will be the first open-weight model to sit within striking distance of Claude and GPT on published benchmarks at the same time as those flagships are current. The K2 → Claude gap was months; K3 → Fable 5 looks like weeks.

“1M context that actually reasons is different from 1M context that just fits.” A recurring skeptical thread: past long-context models could ingest a million tokens but lost coherence past ~200K. Early users testing K3 on repo-scale problems (the I–Love–Q reproduction case that reviewed 20+ papers, implemented a full numerical pipeline, and generated 3,000+ lines of Python in ~2 hours) reported meaningfully better long-horizon coherence than K2. The 6.3× KDA decode speedup makes 1M contexts economically usable, not just theoretically supported.

“The pricing might matter more than the weights.” At $0.30/M cache-hit input, K3 is one of the cheapest frontier-class models to run. Moonshot reports >90% cache-hit rates on coding workloads — meaning the effective input cost on a long-running agent loop is closer to $0.30/M than $3/M. That’s roughly 10× cheaper than Claude on cache hits and competitive with GPT-5 mini pricing at frontier quality. For agent stacks that burn tens of millions of input tokens per day, this is the real headline.

There is also the healthy skepticism from the coding-agent contingent, who noted that until the weights are actually on Hugging Face and running on independent inference stacks, all we have are Moonshot’s own numbers and a private Artificial Analysis evaluation. Wait for July 27 before rewriting your production stack.

Honest Limitations

Real gotchas from Moonshot’s own docs and the first 24 hours of community testing:

  1. Weights are not out yet. Moonshot has committed to July 27, 2026, ten days from launch. Until then, K3 is API-only via Moonshot, OpenRouter, and Kimi Code. Do not build critical infrastructure assuming self-hostability until the weights land.
  2. reasoning_effort only supports max at launch. Low- and high-effort modes are coming later. This means every request pays for maximum thinking — great for accuracy, expensive for high-volume workloads.
  3. Not a laptop model. Even at 16-of-896 sparsity, active parameters are large enough that Moonshot recommends supernode configurations with 64+ accelerators for production serving. Community GGUF quantizations will follow the weight drop, but running K3 locally on consumer hardware is unrealistic without significant compression.
  4. Fixed sampling. temperature, top_p, and n are all locked. If your existing app relies on temperature tuning for creativity control, K3 will feel more deterministic than K2.
  5. HLE-Full and FrontierSWE trail Fable 5 meaningfully. On the hardest human-expert reasoning and highest-tier SWE tasks, Claude Fable 5 is still ahead. K3 is competitive on 80% of workloads; Anthropic still has the top of the distribution.
  6. API pricing is flat, not tiered by context length. Good news for short prompts, but it means K3 is not cheaper than K2 on typical workloads — the savings come from the >90% cache-hit rate in agent loops, not from raw per-token price.

None of these are dealbreakers. K3 shipped 8 months after K2 with roughly 2.8× the parameters, a new attention family, and near-frontier benchmarks — a genuinely fast open-weight cycle.

How Kimi K3 Compares to the Alternatives

vs Claude Fable 5 / Opus 4.8: K3 wins on price, ties on most benchmarks, and loses on the very top of the reasoning distribution (HLE, FrontierSWE). If you can wait for the weights and self-host, K3 is dramatically cheaper. If you need the last 5% of quality on frontier reasoning, Fable 5 is still first.

vs GPT-5.6 Sol: K3 wins on BrowseComp, Program Bench, Automation Bench, OmniDocBench. GPT wins on DeepSWE, Terminal Bench 2.1 (barely), MMMU-Pro (barely). Real-world it’s a coin flip; pick the cheaper endpoint for your traffic.

vs DeepSeek V4 Pro: K3 is 75% larger and Moonshot’s benchmark chart shows a consistent lead. DeepSeek still has the lead on public academic benchmarks that emphasize compact expert use, and V4 Pro is currently the easier model to run on a small cluster.

vs Kimi K2.7 Code: K3 replaces K2 across the board. K2’s 32-of-384 MoE and 256K context are strictly worse on paper — and Moonshot’s own comparison shows K3 is ~2.5× more compute-efficient. If you’re already using K2, migrating to K3 is straightforward (same base URL, drop the thinking parameter, add reasoning_effort="max").

vs Thinking Machines Inkling: Both landed the same week and both are open-weights. Inkling is smaller and targeted at a different niche (community said “focused open weights, safety-first framing”). K3 is the scale play; Inkling is the safety-and-alignment play. Complementary rather than competing.

FAQ

Q: When can I download the Kimi K3 weights?

July 27, 2026 — 10 days after launch, per Moonshot’s official release notes. Expected to land on Hugging Face under a Modified MIT license, matching the K2 family. Until then, K3 is API-only via Moonshot’s platform, OpenRouter (moonshotai/kimi-k3), and Kimi Code.

Q: How much does Kimi K3 cost via the API?

Flat pricing, no context-length tiering: $3 per million input tokens, $15 per million output, and just $0.30 per million cache-hit input tokens. Moonshot reports over 90% cache-hit rates on typical coding workloads, so the effective input cost on an agent loop is closer to $0.30/M. There is also a top-up rebate through August 12, 2026 offering up to 30% back in vouchers for API credits of $1,000 or more.

Q: What is Kimi Delta Attention (KDA) and why does it matter?

KDA is a hybrid linear attention mechanism Moonshot developed to replace quadratic self-attention at long contexts. It changes how information flows across sequence length and delivers up to 6.3× faster decoding at million-token contexts compared to K2. In practical terms: 1M-token workflows that were theoretically possible on K2 but economically painful become genuinely affordable on K3.

Q: Can I run Kimi K3 locally?

Not yet. Weights aren’t out until July 27, and Moonshot recommends supernode configurations with 64+ accelerators even after the weight drop. Community GGUF quantizations will follow (like they did for K2), but expect a lag of a few weeks. This is not a MacBook-friendly model at launch.

Q: Is Kimi K3 better than Claude Fable 5 or GPT-5.6 Sol?

Not overall — but competitive. K3 leads on 5 of 11 published benchmarks (Program Bench, SWE Marathon, BrowseComp, Automation Bench, OmniDocBench) and trails on 6 (mostly by tiny margins). On the third-party Artificial Analysis GDPval-AA v2 real-world benchmark it comes in third, ahead of Opus 4.8 and behind only Fable 5 Max and GPT-5.6 Sol Max. The value proposition is “near-frontier quality at open-weight prices,” not “beats the frontier.”

Q: Does Kimi K3 support vision and video?

Yes — natively. Text, images, and video are handled in the same model rather than bolted-on adapters. Moonshot demoed “vision in the loop” workflows where K3 iterates between code and live screenshots for game dev, frontend, and CAD tasks. It also scored 91.1 on OmniDocBench, the highest of any tested model on document parsing.

Q: How does K3 fit into Claude Code / Codex / Aider workflows?

K3 is OpenAI-SDK compatible via base_url="https://api.moonshot.ai/v1" and model id kimi-k3. Any coding agent that already talks to an OpenAI-compatible endpoint (Aider, OpenClaw, Continue, most Cursor forks) can point at Moonshot with an API key. Claude Code and Codex don’t natively support external endpoints today, but OpenRouter (moonshotai/kimi-k3) is a common integration point.

Q: Is Kimi K3 open-source or open-weights?

Open-weights, not open-source. Moonshot has committed to publishing the model weights on July 27 under a Modified MIT license (following the K2 family precedent). Training data, training code, and full architecture papers are not part of the release. This is the standard open-weight pattern — enough to self-host and fine-tune, not enough to reproduce training from scratch.

Sources

Kimi K3 is the most consequential open-weight AI release of July 2026 — a 2.8T-parameter MoE that trades blows with frontier proprietary models on published benchmarks, ships with genuinely usable 1M-token contexts via KDA, and prices agent loops at roughly one-tenth the cost of Claude. If Moonshot ships the weights on July 27 as promised, this is the model to build your open-stack agent infrastructure around.