Kimi K3: Moonshot's 2.8T Flagship, Open Weights, 1M Context

TL;DR

Published launch day, July 16, 2026; last updated September 1, 2026 with the model-card architecture numbers (104B active), the Kimi K3 License terms, the low/high/max reasoning_effort levels, the Toolathlon-Verified score Moonshot added to the card on September 1, InferenceX B300 throughput, and the current Artificial Analysis provider spread.

Kimi K3 is Moonshot AI's flagship mixture-of-experts model, launched July 16, 2026. It has 2.8 trillion total parameters, 104 billion active per token, a 1M-token context window, native visual understanding, and a new architecture: Kimi Delta Attention (hybrid linear attention) plus Attention Residuals. Moonshot reports 81.2 on FrontierSWE and 88.3 on Terminal-Bench 2.1, and 1686 Elo on GDPval-AA v2 against Claude Fable 5's 1747 and Claude Opus 4.8's 1593. The weights shipped July 27 under the Kimi K3 License as a native MXFP4 checkpoint.

Kimi K3 at a Glance

Every row below comes from the Hugging Face model card, the checkpoint config, or Moonshot's platform pricing page, as of September 1, 2026.

What Is Kimi K3?

Kimi K3 is the successor to Moonshot AI's K2 line (K2.6 shipped April 2026 at 1T total / 32B active parameters; K2.7 Code followed in June and reached general availability inside GitHub Copilot). K3 nearly triples the total parameter count to 2.8T and more than triples active parameters to 104B, extends context from 200K to 1M tokens, and adds native visual understanding for images and video. Thinking is always enabled, with reasoning traces exposed as separate deltas in the streaming API.

The launch was API-first: kimi-k3 on Moonshot's OpenAI-compatible platform, with the consumer Kimi app exposing two tiers, K3 Max and K3 Cluster Max. The weights followed eleven days later, on July 27. Moonshot is reportedly raising at a $31.5 billion valuation on the back of the release, up from $20 billion in May 2026, and is consolidating its platform around K3: the older kimi-k2.5 and moonshot-v1 model series were closed to new users and sunset on August 31, 2026.

Before the official launch, a beta checkpoint codenamed "Kivine" ran anonymized on LM Arena, where early testers flagged two traits that carried into release coverage: elaborate, visually rich generations (interactive 3D scenes were a repeated example) and long runtimes on hard agent tasks.

Confirmed vs Leak Noise

K3 leaked for two days before it shipped, so early coverage mixed first-party facts with estimates. The weights release and six weeks of documentation updates have resolved nearly all of it. The split as of September 1:

Architecture: Kimi Delta Attention at 1M Context

K3 is the first Moonshot flagship built on Kimi Delta Attention (KDA), the hybrid linear attention mechanism from the Kimi Linear paper (arXiv 2510.26692, October 2025). The shipped model stacks 69 KDA linear-attention layers with 24 Gated MLA full-attention layers across 93 layers, roughly the paper's 3:1 interleave: linear layers handle local sequence structure cheaply, full-attention layers preserve global information flow. At matched scale in the paper, this cut KV-cache memory by up to 75% and delivered up to 6x decoding throughput at 1M-token context while matching or beating full-attention baselines on short-context, long-context, and RL-style post-training tasks. K3 pairs KDA with what Moonshot calls Attention Residuals.

The architecture is why the pricing is flat. Serving a 1M-token context with full attention means the KV cache, not the weights, dominates memory at long sequence length, which is why several competitors charge a long-context premium. Cut the cache 75% and the premium disappears from the cost structure. Whether serving economics at 2.8T actually work at $15/M output is Moonshot's bet.

The MoE side is where the scale lives. The model card describes a "Stable LatentMoE" design that routes each token to 16 of 896 experts plus 2 shared experts, for 104B active parameters out of 2.8T, and claims roughly 2.5x the scaling efficiency of K2. Hidden size is 7,168 with 96 attention heads, the vocabulary is 160K, and vision comes from a 401M-parameter MoonViT-V2 encoder. The checkpoint is natively MXFP4 quantization-aware trained from the SFT stage onward (MXFP4 weights, MXFP8 activations), so the shipped artifact is already a quantized model, not a BF16 model someone quantized afterward. Which precision path a provider serves is a real fidelity question; Moonshot ships a public conformance harness, Kimi-Vendor-Verifier, for exactly this.

Benchmarks: Vendor Table, Then Independent Signal

The K3 column below is Moonshot-reported from the Hugging Face model card, at max reasoning effort and temperature 1.0. Competitor columns are the model card's own citations: Anthropic, OpenAI, Z.ai, and Artificial Analysis as of July 23, 2026. Launch-day skepticism on Hacker News centered on vendor-reported scores from open-weight-lineage models; treat the table as the vendor's framing and read the independent section after it.

Two footnotes from the model card change how to read the headline rows. The BrowseComp 91.2 uses a context-compaction strategy triggered at 300K tokens; with the full 1M window and no context management the score is 90.4, so the "single agent, no compression" framing from launch coverage is off by 0.8 points but directionally right. And the DeepSWE 67.5 is with the Kimi Code harness; the official DeepSWE leaderboard scores K3 at 67.3 with mini-SWE-agent. Competitor harnesses differ per row (Terminus 2 for Claude, Codex for GPT), so deltas of a few points are harness noise.

Independent signal, six weeks in

Independent testing settled about where day-one skeptics predicted: strong, one tier below the closed frontier. Artificial Analysis scores K3 60 on its Intelligence Index at max effort, tied with GLM-5.3 for the open-lineage lead and above GLM-5.2 (53) and DeepSeek V4 Flash (52). Running that index cost 130M output tokens, which is the always-on-thinking bill in one number. On Together AI's DeepSWE head-to-head, Fable 5 wins pass@1 69.9 to 68.5 while K3 leads at pass@2 and pass@4; the full breakdown is on Kimi K3 vs Claude Fable 5. Developers consistently praise one thing the closed frontier does not offer: fully exposed reasoning traces, which one Hacker News commenter called "far, far more informative" than Fable's opaque summaries for debugging agent behavior.

Throughput: What Kimi K3 Actually Runs At

A 2.8T model with 104B active parameters is bounded by memory bandwidth per token and by how much KV state each request drags along. The numbers below are the public measurements that exist as of September 1, 2026, with the workload and hardware each one assumes. They do not agree with each other, and they should not: per-user speed and per-GPU throughput trade against each other on every serving stack.

InferenceX on B300 (SemiAnalysis, measured)

InferenceX runs the AgentX agentic-coding trace, a long-context multi-turn workload, against vLLM in FP4 on NVIDIA B300 and sweeps concurrency. The interactivity target is what you promise each user; throughput per GPU is what you get to sell. Peak measured throughput across all configurations was 12,566 tokens per second per GPU.

Source: InferenceX, Kimi K3 on B300. Read the 100 tok/s row as the interactive-agent operating point: 4,051 tok/s per GPU is about 40 concurrent users per GPU at that speed. Halving the per-user target to 50 tok/s buys 1.5x the throughput; pushing to 200 tok/s costs half of it.

SGLang day-zero numbers (LMSYS, July 27, 2026)

SGLang's bring-up post reports about 113 tok/s at batch 1 before speculative decoding, and about 423 tok/s at batch 1 with DSpark, a draft model the team trained for K3, with a "ReplaySSM" trick that replays raw inputs into the KDA state instead of snapshotting it (roughly a 32x cut in draft-window memory). At the throughput end, one PP8 prefill worker feeding one TP8 decode node under prefill-decode disaggregation delivers 2,808 tok/s per GPU on the FP4 arm. The prefill and decode measurements were taken on 2x4 GB300. See speculative decoding for why the batch-1 gain shrinks as concurrency rises.

Hosted providers (Artificial Analysis, live)

The same weights land anywhere from 23 to 136 output tokens per second depending on who serves them. Artificial Analysis currently tracks 12 hosts: Nebius fastest at 136 tok/s, then Databricks 121, Fireworks 112, Baseten 104, Modal 102, Together 60, Parasail 56, Makora 41, Kimi first-party 38 (with a 3.71-second time to first token), DigitalOcean 37, and Bitdeer 23. That is a 5.8x spread on identical weights, which is the strongest argument for checking the Kimi-Vendor-Verifier leaderboard and a live speed table before committing volume.

Kimi K3 on Morph

Morph serves morph-kimik3 on GB300 NVL72 racks. The Morph Models page describes the same coding job on two stacks: baseline serving grinds line by line while Kimi K3 on Morph snaps every edit in and settles at 100 tok/s. A latency-tuned SKU, morph-kimik3-fast, runs identical weights with prefill/decode disaggregation tuned for lower per-request latency. For a private endpoint sized to your own concurrency and speed target, use the dedicated inference calculator or the planner at the bottom of this page; the dedicated inference benchmarks page and LLM inference guide cover the serving-stack tradeoffs in general.

The Token Economics: Always-On Thinking at $15/M

K3's pricing reads mid-tier until you account for how it generates. Thinking mode cannot be disabled. reasoning_effort now accepts low, high, and max (launch docs listed only max), and the default is still max, so every request that does not set it pays for a full reasoning trace at $15/M output tokens. This is the same failure mode that makes cheap-per-token models expensive per task: GLM-5.3 burns tens of thousands of output tokens per Artificial Analysis task at max effort, and K3 defaults to max.

Day-one Hacker News math framed it directly: $3/$15 with $0.30 cache hits matches Anthropic's Sonnet-series pricing, which is expensive for a model from the open-weight lineage, and commenters noted GLM-5.2 delivers similar coding quality at roughly one-third the per-token price. The counterpoint from K3's defenders: if the GDPval-AA positioning holds under independent testing, Sonnet-tier pricing for near-Fable capability is underpriced, not overpriced. Both can be true; which one matters depends on whether your workload needs the top tier.

The flat 1M-context pricing is a genuine differentiator. Anthropic charges a premium above 200K input tokens and Google tiers Gemini pricing by context length; Moonshot charges $3/M whether you send 4K or 900K tokens. For long-context-heavy workloads (repo-scale analysis, long agent traces, document piles) that flatness changes the calculus more than the headline rate does.

Kimi K3 API: Pricing and How to Call It

Morph serves Kimi K3 on GB300 NVL72 racks as morph-kimik3, on the same OpenAI-compatible API as the rest of the open-model lineup, at $2.60/M input, $0.29/M cached, and $14.00/M output, under Moonshot list pricing on every leg:

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",
    reasoning_effort="high",  # low | high | max (default max)
    messages=[
        {"role": "user", "content": "Trace this race condition and propose a fix."},
    ],
)
print(resp.choices[0].message.content)

Moonshot's first-party API is OpenAI-compatible too: base URL https://api.moonshot.ai/v1, model kimi-k3. It supports streaming with separate reasoning and content deltas, structured JSON output with strict schema enforcement, tool calling with dynamic loading, vision inputs (base64 or uploaded file IDs), and a partial mode for prefix continuation. max_completion_tokens defaults to 131,072 and goes to 1,048,576. The examples below use the Morph endpoint; swap the base URL and model name for Moonshot's and they run unchanged.

Streaming: reasoning deltas arrive before content deltas

Moonshot's docs: "Streaming responses provide separate reasoning_content and final-answer content deltas." The reasoning field is non-standard, so read it with getattr rather than assuming the SDK types know about it:

stream = client.chat.completions.create(
    model="morph-kimik3",
    messages=[{"role": "user", "content": "Explain why the sky is blue."}],
    stream=True,
)

for chunk in stream:
    delta = chunk.choices[0].delta
    reasoning = getattr(delta, "reasoning_content", None)
    if reasoning:
        print(reasoning, end="", flush=True)   # thinking trace
    if delta.content:
        print(delta.content, end="", flush=True)  # final answer

Multi-turn: send the whole assistant message back

The rule from the K3 quickstart, verbatim: "For multi-turn conversations and tool calls, add the complete assistant message returned by the API to the next request. Do not keep only content." The simplest correct pattern appends the message object itself, which carries reasoning_content and any tool_calls along with it:

messages = [{"role": "user", "content": "Find the bug in this function: ..."}]

first = client.chat.completions.create(model="morph-kimik3", messages=messages)
assistant = first.choices[0].message

# Append the complete assistant message (content + reasoning_content + tool_calls).
# Do NOT rebuild it as {"role": "assistant", "content": assistant.content}.
messages.append(assistant)
messages.append({"role": "user", "content": "Now write the failing test for it."})

second = client.chat.completions.create(model="morph-kimik3", messages=messages)
print(second.choices[0].message.content)

Replayed reasoning_content counts toward prompt tokens, which Moonshot's thinking-model docs state plainly ("historical thinking content keeps occupying the context window and is billed accordingly"). That is what the cached-input rate is for. On Morph, prompt caching is keyed by a per-conversation prompt_cache_key in the request body (or the same id in an x-session-id header), so every turn that replays the same prefix bills at $0.29/M instead of $2.60/M; see the caching docs. On Moonshot, caching is automatic once the previous request's prompt exceeds 256 tokens, as long as the prefix stays byte-identical.

Sources: Moonshot platform pricing (flat pay-as-you-go, no context-length tiering, unchanged since launch); OpenRouter model listing. Morph rates are read from the same pricing constants that bill the API. Since the weights opened, a dozen providers serve K3 with real spread in throughput and price (Artificial Analysis lists Makora at $2.55/$12.75, Bitdeer at $2.66/$13.30, DigitalOcean at $2.85/$14.25); check the live provider tables and the Vendor Verifier leaderboard before committing volume.

Where Are the Weights?

Out since July 27, 2026. Moonshot released Kimi K3 on Hugging Face (moonshotai/Kimi-K3) under the Kimi K3 License, eleven days after the API launch, as a native MXFP4 checkpoint with an accompanying technical report. The K2-family precedent held on timing but not on license name: K2 shipped under "Modified MIT", K3 ships its own text. It grants MIT-style rights with two conditions. A Model-as-a-Service business with more than $20 million in revenue over any consecutive 12 months needs a separate agreement with Moonshot before commercial use, and any product with more than 100 million monthly active users or $20 million in monthly revenue must display "Kimi K3" in its UI. Internal use is exempt from both. vLLM and SGLang shipped day-zero support for the Kimi Delta Attention architecture, so the standard serving stacks ran it from week one.

Two details matter before you deploy it. First, the checkpoint is natively MXFP4 quantization-aware trained: MXFP4 weights with MXFP8 activations, so "the shipped checkpoint" is already a quantized artifact, and the community requants circulating on Hugging Face (NVFP4A16, W4AFP8, GGUF) are a second quantization on top. Second, the repo has had exactly three commits since release day: a community evaluation-results update the same day, an encoding_k3.py fix on August 20, and the Toolathlon-Verified score on September 1. The weight tensors themselves have not been revised, so a provider that pulled on July 27 serves the current weights. Moonshot publishes Kimi-Vendor-Verifier, a conformance harness that scores hosts on OCRBench, MMMU Pro Vision, BEAM (1M), and DeepSWE plus pre-flight checks on API parameters and tool-call schemas; its public leaderboard currently lists Moonshot, Fireworks, Baseten, Together, Inferact (the vLLM reference), Nebius, and Modal, with DeepSWE scores between 0.658 and 0.695.

The footprint is a different weight class than anything in the K2 line: even in native MXFP4 a 2.8T-total model is a multi-node deployment, and a hypothetical BF16 dequant would run roughly 5.6TB before KV cache. For comparison, GLM-5.3 at 753B is about 465 GB as an NVFP4 checkpoint and fits one 8-GPU node. Morph runs K3 on GB300 NVL72 racks; see the throughput section above.

Kimi K3 vs GLM-5.3 and DeepSeek V4 Flash

The relevant comparison set is the open-lineage frontier Morph serves today: GLM-5.3 (Z.ai's August 14 post-training upgrade of the 753B GLM-5.2 base; the official repo was gated at launch, a public ModelOpt NVFP4 checkpoint is what ships), DeepSeek V4 Flash (284B total / 13B active, MIT), and K3. GLM-5.2 is the same base as 5.3 and is covered on GLM-5.2 vs Kimi K3. The summary six weeks in: K3 posts the strongest agentic numbers of the set and ties GLM-5.3 on the independent index, at 3x to more than 20x the per-token price, with native vision as its unique capability.

Benchmark caveat: the Terminal-Bench row spans two versions. Moonshot and DeepSeek report 2.1; Z.ai reports GLM-5.3 on 3.0, a harder suite where GLM-5.2 scored 4.6, so the 28.3 is not comparable to the 88.3. Every score is self-reported by its vendor; the Artificial Analysis row is the one apples-to-apples number. What is not noise: the price gap. DeepSeek V4 Flash on Morph costs $0.1234375/M input and $0.3475/M output, about 2% of K3's output rate, and GLM-5.3 ties K3 on the independent index at under a third of K3's per-token price. K3's case rests on vision, the 1M flat window, and the agentic rows where it leads.

For the previous Moonshot generation, see Kimi K2.5 and agent swarms. For the models Morph serves on custom codegen kernels, see Morph Models: GLM-5.3, GLM-5.3-Flash, and DeepSeek V4 Flash.

Kimi K3: Pros and Cons

When to Use Kimi K3

Use K3 when the workload is long-horizon and context-heavy: single-agent research over large document sets (the BrowseComp setup), repo-scale analysis that genuinely needs several hundred thousand tokens in one window, or multimodal tasks where GLM-5.3 and DeepSeek V4 Flash are disqualified for lacking vision. The flat 1M pricing makes it the cheapest way to actually use a million tokens of context in one call, even though its per-token rate is the highest of the open lineage.

Skip it when the workload is high-volume codegen where per-task cost dominates. At $15/M output with max-effort reasoning by default, an agent loop that runs thousands of tasks a day costs an order of magnitude more on K3 than on DeepSeek V4 Flash or GLM-5.3-Flash, and GLM-5.3 matches it on the independent index for a third of the price. Set reasoning_effort to low or high before concluding K3 is too slow or too expensive; the default is max. Teams running open models at real volume should also weigh serving quality: the same weights land anywhere from 23 to 136 tok/s across hosts depending on quantization, speculative decoding setup, and caching, which is where Morph's codegen-tuned serving earns its keep on the models it runs.

FAQ

What is Kimi K3?

Moonshot AI's flagship MoE model, launched July 16, 2026: 2.8T total parameters, 104B active, 1M-token context, native vision, built on Kimi Delta Attention and Attention Residuals. Available as kimi-k3 via API, as K3 Max / K3 Cluster Max in the Kimi app, and as open weights on Hugging Face since July 27.

How much does the Kimi K3 API cost?

$3/M input tokens, $0.30/M on cache hits, $15/M output tokens on Moonshot, flat at any context length. Morph serves the same model as morph-kimik3 at $2.60/M input, $0.29/M cached, and $14.00/M output.

How fast is Kimi K3?

Between 23 and 136 output tok/s across the 12 hosts Artificial Analysis tracks; Moonshot's own API measures 38 tok/s. InferenceX measured 4,051 tok/s per B300 GPU at 100 tok/s per user with vLLM in FP4. Morph describes K3 on its GB300 NVL72 racks as settling at 100 tok/s.

Is Kimi K3 open source?

The weights are open, since July 27, 2026, on Hugging Face (moonshotai/Kimi-K3) under the Kimi K3 License: MIT-style terms plus a separate-agreement clause for Model-as-a-Service businesses over $20M in 12-month revenue and a UI attribution clause above 100M monthly users or $20M monthly revenue. Shipped as a native MXFP4 QAT checkpoint with a technical report and day-zero vLLM and SGLang support.

Is Kimi K3 better than GLM-5.3?

They tie at 60 on the Artificial Analysis Intelligence Index. K3 adds native vision and a flat-priced 1M window; GLM-5.3 costs under a third as much per token. Against GLM-5.2, K3 leads on agentic benchmarks (88.3 vs 82.7 on Terminal-Bench 2.1 per Moonshot's card) and on the AA index (60 vs 53).

Can I run Kimi K3 in Claude Code or Cline?

Yes. Morph's endpoint speaks both the OpenAI API and the Anthropic Messages API, so Claude Code runs morph-kimik3 by pointing ANTHROPIC_BASE_URL at https://api.morphllm.com; setup is on the Kimi K3 API page. Any OpenAI-compatible client also works against https://api.moonshot.ai/v1 with model kimi-k3. Keep the always-on reasoning in mind: agent loops that fire many small calls pay max-effort reasoning on each one unless you lower reasoning_effort.

What happened to the 2.5T parameter figure?

That was the pre-launch leak number. The shipped spec in Moonshot's platform documentation and the Hugging Face model card says 2.8 trillion, with 104 billion active.