Kimi K2: Moonshot AI’s Trillion-Parameter Open-Weight Agentic Model

Kimi k2 is Moonshot AI’s open-weight, trillion-parameter Mixture-of-Experts (MoE) model family, first shipped in July 2025 and iterated through a rapid cadence of releases that reached the current multimodal flagship, Kimi K2.6, by mid-2026. Every variant shares one blueprint: a 1-trillion-parameter model that activates only 32 billion parameters per token, published under a permissive Modified MIT license with the full weights on Hugging Face. Moonshot built the series around one thesis — that frontier-grade agentic behaviour (long-horizon tool use, coding, and autonomous task orchestration) can be delivered as open weights rather than a closed API. That is why it matters: Kimi K2 is the clearest existence proof that an openly downloadable model can trade blows with GPT-5.x, Claude Opus, and Gemini 3.x on the coding and agent benchmarks that enterprises actually care about.

What this covers: the Kimi K2 lineage, the MoE architecture and MuonClip training recipe, sourced benchmark numbers, licensing, self-hosting hardware, honest limitations, and how K2 stacks up against DeepSeek, Qwen, and closed frontier models.

Lineage and context

Moonshot AI is a Beijing-based lab founded in 2023, and the Kimi K2 series is its bet on scaling a specific optimizer-plus-MoE recipe rather than chasing raw dense-parameter counts. The original Kimi K2 (internally K2-0711) landed in July 2025 as a 1T-total / 32B-active MoE, documented in the “Kimi K2: Open Agentic Intelligence” technical report (arXiv:2507.20534). It shipped as a non-thinking instruct model that nonetheless posted competitive agentic and coding scores, which was the surprise: strong tool use without an explicit long chain-of-thought.

The family then moved quickly. K2-0905 (September 2025) extended the usable context window from 128K to 256K tokens and sharpened coding behaviour. Kimi K2 Thinking, released 6 November 2025, was the pivotal step: it added an explicit reasoning mode, native INT4 quantization-aware training, and the ability to chain 200-300 sequential tool calls without human intervention. It was, at release, the strongest model from a China-based lab on several agentic evaluations.

From there Moonshot pushed into multimodality. Kimi K2.5 (“Visual Agentic Intelligence”, arXiv:2602.02276, February 2026) folded in a vision encoder and unified thinking and instant modes. The current flagship, Kimi K2.6, extends that lineage into long-horizon coding, coding-driven UI design, and swarm orchestration of up to 300 sub-agents. A coding-specialized sibling positioned as K2.7-Code also circulates through third-party inference providers, but K2.6 is the general-purpose flagship and the model whose card carries Moonshot’s headline numbers.

The through-line matters for anyone evaluating the family. The architecture barely changed across these releases — Moonshot’s HF card for K2.6 explicitly states it “has the same architecture as Kimi K2.5,” which in turn inherits the original K2 topology. What changed is data, post-training, modality, and context length. That makes the architecture section below durable: it describes essentially every shipped Kimi K2 to date.

Architecture

At the core, kimi k2 is a sparse Mixture-of-Experts transformer. The published figures for the current K2.6 flagship — which match the original K2 blueprint — are precise and worth stating exactly.

Total parameters: 1 trillion (the Hugging Face safetensors index reports ~1.1T params including embeddings and the vision tower).
Activated parameters per token: 32 billion. Only these are computed on each forward pass, which is the entire point of the sparse design.
Layers: 61 transformer layers, of which 1 is a dense (non-MoE) layer and the rest are MoE layers.
Experts: 384 routed experts, with the router selecting the top 8 per token, plus 1 shared expert that is always active.
Attention: Multi-head Latent Attention (MLA) with 64 attention heads and a 7,168-dimension attention hidden state.
Expert width: 2,048-dimension MoE hidden state per expert.
Activation: SwiGLU feed-forward blocks.
Vocabulary: 160K tokens.
Context length: 256K tokens on the current flagship (the original K2 shipped at 128K).

Two design choices deserve mechanism-level attention. First, the routing. With 384 experts and only 8 selected per token, Kimi K2 is a high-sparsity MoE — the ratio of total-to-active parameters (roughly 31x) is aggressive. High sparsity buys enormous representational capacity for a fixed inference FLOP budget, but it stresses the router: with so many experts, load balancing and avoiding “dead” experts become central training concerns. The single always-on shared expert is the pressure valve here; it absorbs the common, general-purpose computation so the routed experts can specialize.

Second, MLA. Multi-head Latent Attention compresses the key-value cache into a low-rank latent representation rather than storing full-width K and V tensors per head. This is the same lineage of attention popularized by DeepSeek, and it is what makes a 256K context window tractable on a model this large — the KV cache, not the weights, is usually the binding memory constraint at long context. For a mechanistic contrast of how a rival lab tunes the same idea, see our DeepSeek V4 architecture and benchmarks deep dive.

It is worth being concrete about why MLA matters at this scale. A conventional multi-head attention layer caches one key and one value vector per head per token; at 64 heads, 61 layers, and a 256K context, that cache balloons into the hundreds of gigabytes and quickly dwarfs the activated weights. MLA instead projects keys and values down into a shared low-rank latent that is cached once and expanded on the fly during attention. The practical payoff is that long-context inference stays memory-bound by something you can actually fit, which is precisely what an agentic model needs — a 300-step tool-use trajectory accumulates an enormous context, and a model that falls over at 64K tokens cannot sustain that kind of run regardless of how clever its reasoning is.

The single dense layer at the bottom of the stack is also a deliberate choice rather than an accident. Placing one non-MoE layer early gives every token a shared, fully-dense transformation before routing begins, which stabilizes the representations the router sees and reduces the chance of pathological early-layer routing collapse. It is a small structural detail, but it is the kind of thing that separates a MoE that trains cleanly from one that thrashes.

On modality, the current flagship is natively multimodal. A 400M-parameter MoonViT vision encoder handles image and video input, feeding visual tokens into the same transformer stack that processes text. This is a bolt-on vision tower rather than a from-scratch multimodal pretraining regime, but it is integrated enough that K2.6 posts real numbers on vision benchmarks (more on that below). The original 2025 K2 was text-only; multimodality arrived with the K2.5 generation.

One architectural detail that is easy to miss: the model ships natively in INT4. The weights you download are already quantization-aware-trained to 4-bit, not a post-hoc compression. That shapes both the memory math and the deployment story, and I return to it in the access section.

Training

The headline training fact is the optimizer. Kimi K2 was pre-trained on 15.5 trillion tokens using MuonClip, Moonshot’s modification of the Muon optimizer. This is the most technically interesting part of the whole project, and it is well documented in the arXiv technical report.

Muon is a token-efficient optimizer that updates weight matrices using an orthogonalized version of the gradient (via a Newton-Schulz iteration), rather than the per-element adaptive scaling of Adam-family methods. The intuition is that treating a weight matrix as a geometric object — and taking a step that is well-conditioned across all its singular directions — extracts more learning per token than Adam’s coordinate-wise rescaling. In Moonshot’s telling, that token efficiency is a big part of why K2 could be trained to frontier quality on a 15.5T-token budget rather than needing far more data. But the same aggressive, spectrally-large updates that make Muon efficient are exactly what create instability at trillion-parameter scale.

The failure mode that emerged was attention logit explosion. During training, the maximum attention logits climbed past a magnitude of 1,000, a symptom of the query and key projection matrices growing spectral norms large enough to make the attention softmax numerically unstable. Once logits get that large, the softmax saturates, gradients through attention vanish or spike, and a training run that has consumed enormous compute can diverge — the classic reason trillion-parameter training is treated as a dark art.

MuonClip’s fix is QK-Clip, a weight-clipping mechanism applied after each optimizer update. Rather than touching the forward or backward pass, QK-Clip rescales the query and key projection weights whenever the observed maximum logit for a head exceeds a threshold τ (reported as τ = 100). Because it uses the observed maximum logit as a guiding signal, it clamps only the heads that are actually misbehaving. The reported result is a training loss curve that stays smooth across all 15.5T tokens with “no observable spikes,” and the maximum logits decay back to a normal operating range on their own as training proceeds — without ever re-tuning τ. That stability at scale is the load-bearing engineering claim of the whole Kimi K2 program.

Post-training is where the “agentic” branding is earned, though Moonshot discloses less here than about the optimizer. The reported recipe combines large-scale agentic data synthesis — generating and filtering tool-use trajectories at scale — with supervised fine-tuning and a reinforcement-learning stage that uses a self-critique rubric reward (the model judging its own outputs against structured criteria) alongside verifiable rewards where a ground-truth check exists. The exact data mixture, RL algorithm details, and compute budget are not fully disclosed and should be treated as undisclosed rather than inferred.

The agentic post-training is the part worth dwelling on, because it is what makes the “agentic model” label more than branding. Training a model to be genuinely good at multi-step tool use is not the same as teaching it to answer questions well. The reported approach synthesizes trajectories — sequences of think, call a tool, observe the result, decide the next action — at scale, then filters them for the ones that actually reached a correct outcome. The reinforcement-learning stage then rewards not just final answers but the process, using a self-critique rubric where the model scores its own intermediate steps against structured criteria, supplemented by verifiable rewards (unit tests passing, a search returning the right fact) wherever a ground-truth signal exists. This is why K2’s tool-augmented benchmark scores outrun its closed-book reasoning scores: the training objective was, quite literally, effectiveness-with-tools, not eloquence-without-them.

The tokenizer deserves a brief note too. K2 uses a 160K-token vocabulary — larger than the 32K-100K range common a couple of years ago — which improves compression on code and multilingual text, meaning fewer tokens per program or document. For coding and agentic workloads that stream large files and tool outputs through the context window, a fatter vocabulary is a quiet efficiency win: more useful content fits in the same 256K budget, and per-token API costs stretch further.

The K2 Thinking generation added two things on top. It introduced native INT4 quantization-aware training (QAT), so the model learns to operate at 4-bit precision from within training rather than being compressed afterward — Moonshot reports this yields roughly 2x faster inference and about half the GPU memory with negligible quality loss. And it added test-time scaling: an explicit thinking mode that lets the model reason across hundreds of interleaved tool calls. The K2.5 and K2.6 generations then layered multimodal pretraining and further agentic RL on the same foundation. Total training compute for any specific variant is not officially published and any FLOP figure you see quoted elsewhere should be read as an estimate.

Capabilities and benchmarks

Here I separate what is solidly sourced from what is marketing. The numbers below for K2.6 come directly from Moonshot’s own Hugging Face model card evaluation table; the peer scores in that table are Moonshot’s own reproductions or cited official numbers, so read them as the vendor’s framing, not an independent leaderboard. Where a benchmark was re-run by Moonshot rather than cited from an official source, I note it.

The strongest, most defensible way to read Kimi K2’s trajectory is to look at how the coding and agentic numbers climbed release over release, because those are the benchmarks with the least room to hand-wave.

Coding. The original 2025 K2 posted 65.8 on SWE-bench Verified in non-thinking mode — already a strong open-weight number at the time. K2 Thinking pushed SWE-bench Verified to a reported 71.3. The current K2.6 flagship reports 80.2 on SWE-bench Verified (averaged over 10 runs, per the card), 58.6 on SWE-bench Pro, 76.7 on SWE-bench Multilingual, 89.6 on LiveCodeBench v6, and 66.7 on Terminal-Bench 2.0. That SWE-bench Verified figure sits within a point of the Claude Opus 4.6 (80.8) and Gemini 3.1 Pro (80.6) numbers Moonshot lists alongside it.

Agentic and search. K2 Thinking reported 44.9% on Humanity’s Last Exam with tools and 60.2% on BrowseComp. K2.6 reports 54.0 on HLE-Full with tools and 83.2 on BrowseComp (rising to 86.3 with its agent-swarm setup). It also reports 92.5 F1 on DeepSearchQA and 73.1 on OSWorld-Verified. The eye-catching claim is horizontal scaling: up to 300 sub-agents executing 4,000 coordinated steps in a single autonomous run. These agentic numbers are the ones most sensitive to harness and tool configuration, so treat cross-model comparisons cautiously — for a framework-agnostic view of what these evaluations actually measure, see our explainer on SWE-bench, GAIA, and Tau-bench agent benchmarks.

Reasoning and knowledge. K2.6 reports 90.5 on GPQA-Diamond, 96.4 on AIME 2026, 92.7 on HMMT Feb 2026, and 34.7 on HLE-Full without tools (rising to 54.0 with tools). The original K2 reported 81.1 on MMLU-Pro and 66.1 on Tau2-bench in non-thinking mode, useful as a lineage anchor.

The pattern across these families is instructive. K2’s tool-augmented scores are consistently near or at the front of the pack, while its tools-off reasoning scores (34.7 on HLE without tools) sit clearly behind the closed frontier. That gap is the honest fingerprint of an agentic model: it is optimized to be effective when it can search, run code, and iterate, rather than to be a pure closed-book reasoner. For the workloads Moonshot targets — coding agents, research assistants, autonomous operators — that is the right trade, but it means K2 is not the model you reach for when you need a single-shot, no-tools answer to a hard reasoning question. Its vision numbers (79.4 on MMMU-Pro) tell a similar story: solid and useful, clearly behind the best dedicated multimodal frontier models, and a reminder that the MoonViT tower is a capable add-on rather than the model’s center of gravity.

Here is the consolidated table of sourced K2.6 figures with the peers exactly as Moonshot presents them.

Benchmark	Kimi K2.6	Claude Opus 4.6	Gemini 3.1 Pro	GPT-5.4
SWE-bench Verified	80.2	80.8	80.6	—
SWE-bench Pro	58.6	53.4	54.2	57.7
LiveCodeBench v6	89.6	88.8	91.7	—
Terminal-Bench 2.0	66.7	65.4	68.5	65.4*
HLE-Full (with tools)	54.0	53.0	51.4	52.1
BrowseComp	83.2	83.7	85.9	82.7
GPQA-Diamond	90.5	91.3	94.3	92.8
AIME 2026	96.4	96.7	98.3	99.2
MMMU-Pro (vision)	79.4	73.9	83.0*	81.2

Asterisk marks scores Moonshot re-evaluated rather than cited from an official report. Source: moonshotai/Kimi-K2.6 model card. Peer numbers reflect each vendor’s strongest reported reasoning-effort setting.

Contamination and caveats. Three honest warnings. First, these are vendor-reported numbers on a vendor-chosen configuration (thinking mode, temperature 1.0, 262K context); independent reproductions frequently land a few points lower because harness, tool access, and prompt templates differ. Second, benchmarks like AIME 2026 and HMMT 2026 are recent enough that data-contamination risk is lower than for older sets, but SWE-bench Verified has been public long enough that memorization of specific patches is a live concern for every model on this table, not just K2. Third, “with tools” scores conflate model capability with the quality of the surrounding agent scaffold — a strong number there is partly a statement about Moonshot’s harness. None of this makes the numbers fake; it makes them numbers that need context.

Access and deployment

There are two ways to run kimi k2, and the choice is genuinely open in a way it is not for closed frontier models.

Hosted API. Moonshot serves the model at platform.moonshot.ai with OpenAI- and Anthropic-compatible endpoints, so most existing client code works by swapping the base URL and key. The API exposes both thinking and instant modes, plus preserve-thinking for multi-turn coding agents. On price, third-party trackers and providers report the K2.6 flagship at roughly $0.95 per million input tokens and $4.00 per million output tokens, with cached input around $0.15-0.16 per million — the prior K2.5 was cheaper at a reported ~$0.60 / $3.00. Treat these as reported provider pricing rather than a figure I can confirm from Moonshot’s own rate card; verify current numbers before you budget. Even at the higher tier, that is a large discount to comparable closed frontier models, which is the commercial pitch.

Open weights. The full weights ship on Hugging Face under the Modified MIT License. That license is standard MIT with a single added clause: if you deploy the model (or a derivative) in a product exceeding 100 million monthly active users or generating more than USD 20 million in monthly revenue, you must display “Kimi K2” prominently in the product UI. Below those thresholds it behaves as ordinary MIT — commercial use, modification, and redistribution with no royalties. For the overwhelming majority of teams, it is effectively unrestricted.

Self-hosting hardware. This is where the trillion-parameter reality bites. Because the weights ship natively as INT4 QAT, the download is roughly 594 GB, and you need on the order of 640 GB of aggregate VRAM once you account for the KV cache and runtime overhead. The configuration Moonshot and the community converge on is 8x H200 (141 GB each, ~1.13 TB total), which leaves comfortable headroom for long contexts. An 8x H100 (80 GB each, 640 GB total) node is the tight practical minimum and is best kept to shorter contexts. Running the model at FP16 is possible but roughly quadruples the memory footprint to ~2 TB and buys little given the native-INT4 design — the INT4 path is the intended one, not a compromise.

Inference stack. Moonshot officially supports three engines: vLLM (high-throughput OpenAI-compatible serving), SGLang (structured generation and multi-turn optimization), and KTransformers. The transformers requirement is >=4.57.1, <5.0.0. Throughput and latency depend heavily on batch size, context length, and how many experts your requests activate, so treat any single tokens-per-second figure with suspicion; the honest planning number is “budget an 8x H200 node per production replica and load-test with your own traffic.”

Context caching economics. One under-appreciated lever on the hosted API is automatic context caching. Because agentic workloads replay a large, mostly-static prefix — system prompt, tool schemas, retrieved documents — on every step, cached input tokens billed at roughly $0.15-0.16 per million (versus the ~$0.95 cache-miss rate) can dominate the cost profile of a long-running agent. In practice this means the effective price of a K2 agent depends far more on how much of your context is cacheable than on the sticker input rate. Teams that structure prompts to maximize prefix reuse routinely see the majority of their input tokens billed at the cached tier, which is what makes the model economically viable for always-on background agents rather than just one-shot calls.

Modes and latency. The current flagship exposes both a thinking mode (temperature 1.0 recommended, for hard reasoning and agentic runs) and an instant mode (temperature ~0.6, for latency-sensitive turns), plus a preserve-thinking option that carries full reasoning content across turns to help multi-step coding agents. The latency trade is the obvious one: thinking mode spends output tokens on reasoning before it answers, so it is slower and more expensive per turn but materially stronger on the benchmarks above. For interactive UX you will often route easy turns to instant mode and reserve thinking mode for the steps that need it — a routing decision the OpenAI-compatible API makes straightforward.

Limitations, safety, and failure modes

Kimi K2 is impressive, but a durable reference has to be specific about where it breaks.

Sparse-MoE serving cost. The 32B-active headline is real for FLOPs, but you still have to hold the full trillion parameters in memory. That means the floor for self-hosting is an 8-GPU node, full stop. There is no single-GPU or single-consumer-card path to the real model; sub-100 GB “Kimi K2” builds you see are heavily lossy community quantizations, not the shipped weights. For many teams the practical answer is the API, which quietly reintroduces the vendor dependency that open weights were supposed to remove.

Agentic reliability degrades over long horizons. The 200-300 tool-call and 300-sub-agent claims describe capability ceilings under favourable conditions, not reliability floors. In practice, error compounding across dozens of steps — a wrong file edit, a misread tool result — remains the dominant failure mode for every model in this class, K2 included. The longer the autonomous run, the higher the odds it silently goes off the rails, and K2’s own strong BrowseComp numbers coexist with real-world reports of agents that loop or hallucinate tool outputs.

Reported-vs-reproduced gap. Because the flagship numbers come from Moonshot’s own harness in thinking mode, independent evaluations tend to come in lower. If your workload can’t run the model in its most expensive configuration (full thinking, 262K context, high token budgets), you should expect meaningfully lower real-world quality than the card implies.

Safety and governance. As an open-weight model, K2 ships without the server-side guardrails a closed API can enforce — anyone can fine-tune the safety behaviour out. Public third-party evaluation (including a December 2025 NIST/CAISI assessment of K2 Thinking) framed it as the most capable PRC-origin model at the time while still trailing leading US models on some safety-relevant axes. For regulated deployments, the open weights are an advantage (you can inspect and control them) and a responsibility (the guardrails are now yours to build).

Provenance and data disclosure. Moonshot is transparent about the optimizer and architecture but not about the pretraining data composition. If data provenance, copyright exposure, or regional data-handling matters to your compliance posture, the undisclosed corpus is a genuine unknown you have to price in.

Quantization is not optional the way it usually is. With most models, INT4 is a lever you pull to save memory at some quality cost, and you can always fall back to FP16 for maximum fidelity. K2 inverts that: the weights are trained at 4-bit, so INT4 is the reference implementation and FP16 is the unusual, expensive path that buys little. That is efficient, but it also means the community’s usual “just run it at higher precision to debug a quality regression” move does not straightforwardly apply, and third-party sub-4-bit quantizations diverge from the intended numerics faster than they would for an FP16-native model. Teams that care about bit-exact reproducibility across providers should validate with Moonshot’s vendor-verification tooling rather than assuming two INT4 deployments behave identically.

How it compares

The useful comparison is not “which model wins a leaderboard” but “which model fits a specific job.” Below, K2.6 is measured against DeepSeek (the other high-sparsity open MoE lineage), Qwen (the other major open Chinese family), and a closed frontier model as the quality ceiling. For the closed-model reasoning-and-latency trade-off in particular, our Gemini 3.5 Flash architecture and benchmarks breakdown is a useful companion.

Use case	Kimi K2.6	DeepSeek (V-series)	Qwen (flagship)	Closed frontier (Opus / Gemini)
Autonomous coding agents	Excellent — top-tier SWE-bench, native long-horizon tool use	Strong, similar MoE lineage	Strong, broad ecosystem	Best-in-class reliability, at premium price
Self-hosted, air-gapped deploy	Yes — open weights, INT4, 8x H200	Yes — open weights	Yes — open weights, wide size range	No — API only
Cost-sensitive high volume	Very good — low $/MTok vs closed	Very good, often cheapest	Very good, many small variants	Weakest — most expensive
Multimodal + vision agents	Good — MoonViT vision, agentic swarms	Varies by variant	Strong vision line-up	Best raw multimodal quality

The takeaways. On kimi k2 vs deepseek, the two are architectural cousins — both high-sparsity MoE with latent attention — and the practical choice usually comes down to which lab’s current release is freshest and whichever posts better numbers on your eval, not a fundamental capability gap. Against Qwen, K2’s edge is agentic and long-horizon coding depth; Qwen’s edge is the breadth of model sizes, including small variants K2 simply doesn’t offer. Against closed frontier models, K2 trades a few points of peak reliability for open weights, self-hostability, and a large cost advantage. If you need the single most reliable agent and price is no object, a closed model still wins; if you need control, cost, and something within striking distance of the frontier, K2 is one of the strongest open options in 2026.

Frequently Asked Questions

What exactly is Kimi K2 and who made it?

Kimi K2 is a family of open-weight large language models built by Moonshot AI, a Beijing-based lab. Every variant is a 1-trillion-parameter Mixture-of-Experts model that activates 32 billion parameters per token. The line began in July 2025 with the original K2 and progressed through K2 Thinking (November 2025) and the multimodal K2.5 to the current K2.6 flagship. It is designed specifically for agentic workloads — coding, tool use, and autonomous multi-step task execution — and is distributed under a permissive Modified MIT license.

How big is Kimi K2 and how many parameters are active?

The model is 1 trillion total parameters, with the Hugging Face weights indexing around 1.1T including embeddings and the vision tower. Only 32 billion parameters are active per token, routed through 8 of 384 experts plus 1 always-on shared expert across 61 layers. This high-sparsity design gives the capacity of a massive model at the inference cost of a mid-sized one. The trade-off is memory: you still must hold the full trillion parameters in VRAM to serve it.

What are Kimi K2’s best benchmark scores?

Per Moonshot’s own K2.6 model card, headline figures include 80.2 on SWE-bench Verified, 89.6 on LiveCodeBench v6, 90.5 on GPQA-Diamond, 54.0 on Humanity’s Last Exam with tools, and 83.2 on BrowseComp. These are vendor-reported numbers in the model’s strongest configuration (thinking mode, 262K context), so independent reproductions may land a few points lower. The clearest signal is the release-over-release climb in coding scores, from 65.8 on SWE-bench Verified in the original 2025 K2 to 80.2 in K2.6.

Is Kimi K2 really open source and free to use commercially?

The full weights are downloadable from Hugging Face under a Modified MIT License. That is standard MIT with one clause: products exceeding 100 million monthly active users or USD 20 million in monthly revenue must display “Kimi K2” in their UI. Below those thresholds it is effectively unrestricted — commercial use, modification, and redistribution are all permitted with no royalties. Note that “open weights” is not the same as fully open source: the training data composition and full training code are not disclosed.

What hardware do I need to self-host Kimi K2?

Because the weights ship natively as INT4 (quantization-aware trained), the download is about 594 GB and you need roughly 640 GB of aggregate VRAM after accounting for the KV cache. The recommended configuration is an 8x H200 (141 GB) node totalling ~1.13 TB; an 8x H100 (80 GB) node at 640 GB is the tight minimum, best for shorter contexts. Supported inference engines are vLLM, SGLang, and KTransformers. There is no realistic single-GPU path to the real model.

How does Kimi K2 compare to DeepSeek?

They are architectural cousins: both are high-sparsity Mixture-of-Experts models using latent attention, both ship as open weights, and both target strong coding and reasoning at low serving cost. In practice the choice comes down to which lab’s most recent release posts better numbers on your specific evaluation and which pricing you prefer, rather than a structural capability gap. K2’s distinguishing emphasis is long-horizon agentic behaviour and swarm orchestration; DeepSeek’s lineage often competes hardest on raw cost-efficiency.

Kimi K2 Explained: Architecture, Training, and Benchmarks (2026)