Kimi K3: 2.8T Parameters, 1M Context, Open Weights

The Release That Reset the Open-Weight Ceiling

On July 16, 2026, Moonshot AI shipped Kimi K3 and quietly moved the ceiling on what an openly released model is allowed to be. At 2.8 trillion total parameters, it is the first open model in the three-trillion-parameter class — roughly 75 percent larger than DeepSeek's V4 Pro at around 1.6 trillion, and larger than anything Meta, Mistral, or Alibaba has published. Full weights are scheduled for release by July 27, 2026.

The number itself is not the story. Parameter counts have been an unreliable proxy for capability since sparse architectures became standard, and Moonshot's own model activates just 16 of its 896 experts per token — about 1.8 percent of the pool. The story is what happened in the seventy-two hours after launch: Arena ranked K3 first in blind frontend coding evaluation at 1,679 points, ahead of Claude Fable 5. Shares of Chinese competitors Zhipu, MiniMax, and Z.ai fell 28.4, 15.6, and 28.4 percent respectively. Moonshot paused new subscriptions within 48 hours because its GPUs ran out of headroom. And by July 20, Axios was reporting that the Trump administration had revived an effort to restrict Chinese AI models inside U.S. borders, with K3 named as the catalyst.

That is a lot of consequence for a model whose weights nobody has downloaded yet.

This piece works through what K3 actually is, what the benchmark numbers support and what they do not, how the economics compare against Fable 5 and GPT-5.6 Sol, and why the July 27 weight drop is the date that determines whether any of this holds up.

What Moonshot Actually Built

Kimi K3 is a sparse Mixture-of-Experts multimodal reasoning model with a 1,048,576-token context window and native visual understanding. It ships with reasoning always on — Moonshot's launch API runs max thinking effort by default, with low- and high-effort modes promised in later updates.

The positioning is explicit and narrower than the headlines suggest. Moonshot describes K3 as a long-horizon agent model built to sustain extended engineering sessions, navigate large repositories, and orchestrate terminal tools with minimal human oversight. That is not a general-purpose chat assistant framing. It is a claim about a specific work shape: multi-hour, multi-step, tool-heavy tasks where the model is the operator rather than the responder.

Three architectural components carry the weight of that claim.

Kimi Delta Attention (KDA) is a hybrid linear-attention scheme designed to retain long-range state without paying full quadratic attention cost at every position. This is the mechanism that makes a million-token window economically serviceable rather than theoretically available.

Attention Residuals (AttnRes) replace standard residual connections. Instead of accumulating every prior layer output with uniform weighting, layers learn which earlier representations to retrieve. Moonshot describes it as a drop-in replacement delivering consistent scaling gains.

Stable LatentMoE handles the routing — 16 of 896 experts per token, with techniques intended to keep expert utilization balanced at a scale where routing collapse becomes a real failure mode.

Neither KDA nor AttnRes is a launch-day invention. Moonshot published both as open research prior to K3, with the Kimi Linear and KDA work and the Attention Residuals paper both available on arXiv. Together, the company claims roughly 2.5x improvement in scaling efficiency over Kimi K2 and up to 6.3x faster long-context decoding.

What is not yet verifiable is how the full recipe combines at 2.8T scale. The technical report is pending, and until it arrives alongside the weights, the architecture claims are descriptions rather than reproducible results.

Quantization-Aware Training from the SFT Stage

One detail deserves more attention than it has received. Moonshot begins quantization-aware training at the supervised fine-tuning stage, using MXFP4 weights and MXFP8 activations. The stated reason is broad hardware compatibility.

Read that in context. A Chinese lab operating under U.S. chip export restrictions is training a frontier model in a format designed to run across heterogeneous accelerator fleets. That is not a performance optimization. It is a supply-chain hedge baked into the training pipeline — and it is the same category of constraint-driven engineering that Bank of America analysts pointed to when they noted that architectural work plus large-scale pre-training can still deliver step-change gains for Chinese labs despite compute limits.

The Benchmark Picture — And Its Footnotes

This is where most coverage of K3 goes wrong, in both directions. The model is neither the Fable 5 killer that some headlines implied nor a benchmark-gamed vanity release. The honest reading requires separating three evidence tiers.

Tier One: Independent Evaluation

Artificial Analysis scores K3 at 57.1 on its Intelligence Index v4.1, ranking it fourth among 189 tested configurations — effectively the third model family. It trails GPT-5.6 Sol Max at 58.9 and Claude Fable 5 with Opus 4.8 fallback at 59.9, and sits roughly half a point behind Sol xhigh. The sub-indices are more informative than the composite: 76.2 on coding, 50.1 on agentic.

The evaluation cost Artificial Analysis $2,709.75 in total, or $0.9541 per completed index task. That figure is itself a finding — it tells you K3 is a model to route selectively rather than default to.

Arena's frontend coding leaderboard is the second independent signal, and the strongest one for Moonshot. K3 debuted at #1 with a 1,679 score, ahead of Fable 5, ranking first in six of seven frontend domains with a 76 percent win rate in blind developer testing. That is real users preferring K3's generated interfaces without knowing which model produced them.

Tier Two: Vendor-Reported Benchmarks

Moonshot's launch table is more expansive and requires more care. Selected results, all as reported by Moonshot:

Moonshot ran K3 at maximum reasoning, temperature 1.0, top-p 1.0. The company is unusually direct about the hierarchy — its own launch post concedes that K3 still trails Fable 5 and GPT-5.6 Sol on overall performance.

The Harness Problem

Now the footnote that matters more than any individual row. These are not controlled head-to-heads. K3 ran on KimiCode. Competitors ran on their own best harnesses — Claude Code, Codex, Terminus-2. Some competitor scores came from their vendors. Fable 5 requests rejected under Anthropic's usage policy fell back to Opus 4.8. A few evaluations used modified hardware or tasks.

An agent benchmark does not measure a model. It measures a system: model plus prompt plus tools plus retry logic plus timeout plus permissions plus context management. The magnitude of that effect is documented and large. Claude Opus 4.8 scores 69.2 percent on SWE-bench through Anthropic's own scaffold and 51.9 percent on Scale AI's standardized SEAL board — a 17.3-point gap on the same model. Gemini 3.1 Pro shows a 26.4-point spread between verified and standardized scores.

Against that backdrop, a 1.0-point lead on Program Bench or a 0.1-point lead on SpreadsheetBench 2 is noise.

There is one useful internal control. On DeepSWE, K3 scores 67.5 with KimiCode and 67.3 with the benchmark's common mini-SWE-agent harness. A 0.2-point delta on the same model across two harnesses is reassuring for that specific task — though it does not generalize to benchmarks where no such comparison was run.

What the Numbers Actually Support

Strip the noise and a defensible reading emerges.

Coding is the clearest strength. K3 lands within half a point of GPT-5.6 Sol on Terminal-Bench 2.1, leads the displayed field on Program Bench, and wins SWE Marathon by seven points over Fable 5 in Moonshot's setup — the last being the most interesting result, since SWE Marathon uses 20 realistic tasks with multi-hour runs, hidden checks, network restrictions, and exploit scans. Long-horizon capability is exactly what Moonshot claims to have built.

Agentic knowledge work is competitive but not dominant. K3 beats Opus 4.8 on GDPval-AA v2 and trails both Fable 5 and Sol. It sits effectively tied with the top group on MCP Atlas and SpreadsheetBench 2.

FrontierSWE is a clean loss: 81.2 against Fable 5's 86.6.

General reasoning is the weakest area. K3's 43.5 on Humanity's Last Exam trails Fable 5 at 53.3 and Opus 4.8 at 49.8 — a near-ten-point gap against Fable that no harness argument explains away.

Vision is frontier-level without being uniformly best. K3 edges Fable 5 on MMMU-Pro and leads OmniDocBench by a wide margin, while Sol takes several other visual evaluations.

And one signal that benchmarks do not capture: early users consistently report that K3's conversational polish and subjective response quality still trail Fable 5 and Sol, and that it is meaningfully slower than Western frontier models. Benchmark parity and product parity are different things.

The Economics Are the Real Disruption

K3's API pricing is $3 per million cache-miss input tokens, $0.30 per million cached input tokens, and $15 per million output tokens.

Two comparisons frame what that means.

Against Western frontier models, it is a structural undercut. Fable 5 runs $50 per million output tokens. K3 delivers same-band performance on a meaningful slice of coding and agentic work at 30 percent of that output cost. When a model debuts with running costs roughly a third of Western frontier equivalents for comparable results on the tasks enterprises actually run, procurement teams notice — and 2026 has been a year of AI cost scrutiny, with Uber limiting developer AI use and multiple companies retiring the internal AI-adoption leaderboards they were championing in late 2025.

Against Chinese peers, K3 is expensive. Z.ai's GLM-5.2 runs $4.40 per million output tokens. DeepSeek V4 runs $0.87. Moonshot is not competing on price within its own market; it is competing on capability and pricing accordingly. That is a meaningful shift in posture for a Chinese lab.

Against its own predecessor, the jump is steep. Kimi K2.6 costs $0.95 per million cache-miss input and $4 per million output. K3 is more than three times the output price. It is not a drop-in upgrade for routine traffic.

The cached-input tier is where the real leverage sits. At $0.30 per million, cache hits cost a tenth of misses, and Moonshot's Mooncake disaggregated serving infrastructure — which separates prefill and decode across distinct node pools — reports over 90 percent cache hit rates on coding workloads. For teams sending stable repository context and long system prompts on every request, that changes the arithmetic substantially.

Worked examples at list price: 100K input plus 10K output runs $0.45 uncached, $0.18 cached. One million input plus 20K output runs $3.30 uncached, $0.60 cached. The catch is output. K3 reasons by default, reasoning tokens count toward usage, and long trajectories can erase cached-input savings entirely.

Pricing across all providers is moving weekly right now. Verify current rates before building a cost model on any of these figures.

The Infrastructure Reality Check

The subscription pause tells you more about K3 than most of the benchmark table does.

On July 19, Moonshot announced it was temporarily halting new subscriptions after demand pushed close to capacity limits within 48 hours of launch, prioritizing compute for existing members and promising to reopen in batches. The post drew over seven million views. Moonshot also announced plans to split membership into separate tiers for web and code compute.

The optics were rough. The same weekend, Anthropic extended Claude Code limits through August 19 and shipped Fable on Max — extending access while Moonshot stopped selling seats.

Self-hosting will not be a workaround for most organizations. A four-bit weight calculation puts K3 at roughly 1.4 to 1.5 TB for weights alone at full precision, or around 600 GB in INT4 form — before runtime buffers, expert routing overhead, vision components, and KV or recurrent state. Moonshot recommends supernode deployments of at least 64 accelerators, keeping expert-parallel routing traffic inside a single high-bandwidth interconnect domain.

Sparse activation reduces compute per token. It does not reduce the requirement to store and communicate 2.8 trillion parameters. "Open weights" here means a datacenter project, not a workstation download.

There is a strategic read on this. Moonshot builds the largest open-weight model in the world, releases the weights publicly, and lets the global developer community absorb serving load that China's constrained chip supply chain cannot. The open release is not only an ideological position. It is capacity arbitrage.

Access Paths and the Model-ID Trap

K3 is reachable through five routes today.

Kimi.com and mobile apps provide direct chat and agent access, subject to the subscription pause. Kimi Work, version 3.1.0 or later on Windows and Apple silicon, is Moonshot's desktop knowledge-work environment with browser automation, K3 Swarm, cron scheduling, and finance APIs. Kimi Code is the terminal coding agent — select K3 via /model. The Kimi API is an OpenAI-compatible Chat Completions endpoint at https://api.moonshot.ai/v1. Third-party hosts include OpenRouter and Cloudflare Workers AI.

The model IDs differ by surface and this trips people up constantly:

• Official API: kimi-k3

• Kimi Code: k3

• OpenRouter: moonshotai/kimi-k3

Kimi Code plan tiers also gate context. Andante does not support k3 at all. Moderato supports it up to 256K. Allegretto and above unlock the full 1M window.

A minimal API call:

bash

curl https://api.moonshot.ai/v1/chat/completions \
  -H "Authorization: Bearer $MOONSHOT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kimi-k3",
    "messages": [
      {"role": "system", "content": "You are a careful software engineer."},
      {"role": "user", "content": "Review this migration plan and identify rollback risks."}
    ],
    "stream": true
  }'

Because the endpoint is OpenAI-compatible, the JavaScript SDK works with a base URL swap:

javascript

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.MOONSHOT_API_KEY,
  baseURL: "https://api.moonshot.ai/v1",
});

const response = await client.chat.completions.create({
  model: "kimi-k3",
  messages: [
    { role: "user", content: "Map the architecture of this repository." },
  ],
  stream: true,
});

for await (const chunk of response) {
  process.stdout.write(chunk.choices[0]?.delta?.content ?? "");
}

The API is stateless. Send the conversation history you want K3 to reason over, preserve reasoning content across multi-step tool calls if the endpoint returns it, and budget for both reasoning and final-answer output tokens.

One Million Tokens: Capacity Is Not Comprehension

Cloudflare documents K3's exact limit at 1,048,576 tokens. That is enough for a large repository, hundreds of ordinary documents, or a very long agent trajectory in a single request.

Moonshot's own footnote on BrowseComp is the most useful thing in the entire launch package, and almost nobody has quoted it. With context compaction triggered at 300K, K3 scores 91.2. With the full 1M window and no context management, it scores 90.4.

Read that carefully. Moonshot's own data shows the model performs better when you actively manage context than when you dump a million tokens into it. The window is capacity, not a retrieval guarantee. Position, document structure, and reasoning budget all affect what the model actually uses.

Practical guidance that follows from this:

• Put stable instructions and repository context at the front of the prompt so automatic caching can reuse the prefix.

• Start a fresh Kimi Code session when switching models or reasoning effort — switching invalidates the existing cache.

• Give files clear names and delimiters, then require K3 to cite paths or document IDs in its output so you can audit retrieval.

• Test retrieval at the beginning, middle, and end of your context before trusting a million-token production workflow.

• Do not send a million tokens because you can. Retrieval, summarization, and scoped sub-agents are usually cheaper and always easier to debug.

Independent long-context evaluation of K3 has not been published. Treat the window as unverified capacity until it has.

Washington Reacts

The policy response arrived faster than the weights.

Axios reported on July 20 that the Trump administration is weighing restrictions on cutting-edge Chinese AI models inside U.S. borders, with K3 explicitly cited as the accelerant. The mechanisms under discussion include Entity List designations for the labs behind leading Chinese models — which could bar Americans from possessing or using those models without a license — federal procurement rules, and public pressure campaigns. On July 21, Treasury Secretary Scott Bessent announced the federal government would examine Chinese open-source models for intellectual property theft, with possible sanctions on firms found to have taken IP from American companies.

No formal policy has been proposed. No enforcement mechanism has been defined. The scope remains unresolved.

The enforceability problem is structural and worth stating plainly. Every tool under consideration was designed for a world where AI arrives as a service — you restrict the vendor, the cloud, or the API. Once weights are published on July 27, anyone with sufficient hardware can download and run K3 without any U.S. cloud in the loop. Chip export controls work because fabs are physical and few. Weights are files.

A narrowly scoped restriction on federal systems, cleared facilities, or defense-adjacent workloads would be both enforceable and defensible — the provenance and integrity of a model handling classified or critical-infrastructure work genuinely matters, and unvetted foreign weights in those contexts is a legitimate concern. A blanket ban on a publicly downloadable file is a different proposition entirely.

The counterargument from critics is that restriction pushes developers toward domestic providers, concentrating the market and reducing competitive pressure on U.S. labs — the opposite of what an innovation policy should do. Both sides here have obvious interests. American labs benefit commercially from restrictions on a cheaper competitor. Chinese labs and open-source advocates benefit from framing any restriction as protectionism. Neither framing is disinterested, and the security question underneath is real regardless of who is making the argument.

There is also an awkward timing problem for the administration. Federal officials reportedly pressed Anthropic to pull its latest Claude releases for over two weeks after Amazon raised cybersecurity concerns — the Fable 5 and Mythos 5 export-control episode that ran from June 12 to June 30. Constraining domestic frontier releases while a Chinese lab publishes weights at a larger scale is not the sequencing anyone in Washington would have chosen.

What This Means for Silicon Valley

Kimi adoption in the U.S. predates K3, which is why the reaction was as sharp as it was.

Cursor used Kimi to help build Composer 2, its coding agent. DoorDash delegates lower-level work to Kimi K2.6, per CTO Andy Fang. Thinking Machines used Kimi K2.5 to generate early post-training data for Inkling, its 975B open-weight model released July 15. Reporting attributed to The Information says Microsoft is evaluating K3 for possible Copilot workloads and preparing Azure availability — no deployment or savings figure is publicly confirmed.

That is the pattern that matters. Chinese open-weight models have already moved from curiosity to production dependency inside American AI companies, mostly for cost-sensitive tiers of work. K3 extends that pattern upward into work that previously required a Western frontier model.

Moonshot's business position reflects it. The company raised roughly $2 billion in May at a valuation over $20 billion, backed by Alibaba and Tencent, with annual recurring revenue reported above $200 million by its financial advisor.

The Practical Decision Framework

For teams evaluating K3 right now, the honest routing recommendation is specialist escalation, not default.

Route to K3 for frontend generation, very large repository context, autonomous terminal work, long-horizon agent runs, document-heavy research, and multimodal iteration. The Arena frontend result, the SWE Marathon lead, the BrowseComp and OmniDocBench numbers, and the million-token window all point at the same work shape.

Route to Fable 5 when Humanity's Last Exam, DeepSWE, GDPval, and FrontierSWE results map to your workload, when general reasoning depth matters more than coding throughput, or when a mature managed coding ecosystem and predictable capacity are worth the price premium.

Route to GPT-5.6 Sol for the strongest DeepSWE, Terminal-Bench, GPQA, and MMMU-Pro numbers and the Codex ecosystem.

Route to K2.6, GLM-5.2, or DeepSeek V4 when throughput and unit economics dominate and you do not need the last few points of capability. K3 at $15 per million output is not the value play.

Whatever you route where, measure task completion rate and total cost per completed task rather than per-token price. A model that finishes the job in one pass at $15 per million output beats a model that needs four attempts at $4.

Also weigh the routing risk that comes with the policy uncertainty. If your deployment depends on hosted K3 access through a U.S. cloud, procurement restrictions could disrupt it. If it depends on self-hosted weights, it probably will not — but the self-hosting bar is 64 accelerators.

For anyone running agent fleets across multiple model providers, this fragmentation is exactly the operational problem that agent observability tooling exists to solve. Open Mission Control, an open-source dashboard for monitoring AI agent sessions across providers, is one option for teams that need visibility into which model is handling which task and what it is costing — the repository is at github.com/ParashDev/open-mission-control with a live demo at openclaw-mission-control.dplooy.com.

Limitations Worth Stating Plainly

Nine things that are genuinely unresolved as of publication:

1. Weights are not public. Every architecture and reproducibility claim is currently unverifiable.

2. The detailed benchmark set is vendor-assembled, with mixed harnesses, varied context management, model fallbacks, and inconsistent hardware.

3. Independent evaluation is early. Artificial Analysis has measured the hosted API; weight-level reproduction has not happened.

4. Capacity is constrained. Subscriptions were paused within 48 hours; rate limits and latency may shift quickly.

5. Output is expensive. At $15 per million, always-on reasoning can consume the cached-input advantage.

6. Self-hosting is a datacenter project, not a local deployment.

7. The million-token window is untested independently, and Moonshot's own data suggests active compaction beats raw context.

8. Privacy varies by route. Kimi.com, the Moonshot API, OpenRouter, Cloudflare, and future self-hosted deployments have materially different data paths and policies.

9. The product surface is inconsistent. Model IDs, reasoning controls, and plan-tier context limits differ across API, Kimi Code, and third-party hosts.

Moonshot deserves some credit here — the launch materials included three candid limitations, which is more disclosure than most frontier launches offer.

What to Watch Next

July 27 is the date that settles this. The weight release package will reveal the license terms, the checkpoint format and file manifest, the tokenizer, the exact architecture dimensions, the active parameter count, the vision components, supported quantizations, working vLLM and SGLang commands, and the minimum viable hardware configuration. Moonshot says vLLM support for KDA prefix caching ships alongside the model. The license is currently reported as Modified MIT, which is not the same as MIT and will need reading closely.

The technical report should arrive with the weights and will determine whether the KDA and AttnRes scaling claims survive scrutiny.

Independent benchmark reproduction is the real test. When third parties run K3 through standardized harnesses — SEAL-style boards, mini-SWE-agent, the public DeepSWE leaderboard that had not yet added K3 at launch — the vendor table gets validated or it does not.

Long-context evaluation by independent testers will show whether the million-token window holds up at position, and whether the compaction finding generalizes.

The policy trajectory. Whether any restriction materializes, and whether it lands narrowly on federal and defense-adjacent systems or broadly on commercial use, will shape U.S. enterprise adoption more than any benchmark.

Capacity and pricing. Whether Moonshot reopens subscriptions at scale, whether Azure or other major clouds pick up hosted K3, and whether third-party providers undercut Moonshot's own list price once weights circulate.

Bottom Line

Kimi K3 is not a Fable 5 killer, and Moonshot has not claimed it is — the company's own launch post concedes that K3 trails both Fable 5 and GPT-5.6 Sol on overall performance. The Humanity's Last Exam gap is real, FrontierSWE is a clean loss, subjective quality lags, and it is slower.

What K3 is, and this is the part that matters: the first model to enter the frontier band while being scheduled for open release at unprecedented scale. It leads a blind frontend preference test against Fable 5. It wins SWE Marathon on long-horizon work. It ranks fourth of 189 configurations on an independent intelligence index. It does this at 30 percent of Fable 5's output price, with a million-token window, from a lab operating under chip export restrictions.

For most teams today, the right move is a controlled pilot: route your hardest coding, largest-repository, and visual-agent work to K3, keep a cheaper model underneath for routine traffic, measure completed tasks rather than tokens, and wait for July 27 before making any architectural commitment that depends on self-hosting.

The larger point is not about one model. Kimi K3 is evidence that the gap between the best closed model and the best open one has compressed to something measured in single benchmark points on a meaningful subset of production work. That compression, not the 2.8 trillion parameters, is what Washington is actually reacting to — and it is the variable every AI infrastructure decision made in the next twelve months will need to account for.