Last updated: July 2026
Key Takeaways
- Kimi K3 took the #1 spot on Arena.ai's Frontend Code Arena on July 16, 2026 with 1,679 points, ahead of Claude Fable 5 (1,631) and GPT-5.6 Sol (1,618). Moonshot AI says the full model weights ship by July 27.
- At 2.8 trillion parameters, K3 is the largest open-weight model ever announced. Scaled from published K2-family builds, even aggressive quantizations will likely land between roughly 650GB and 1TB — past every consumer hardware ceiling, including a 512GB Mac Studio.
- Open weights at #1 still restructures the market for everyone: hosting price competition, no deprecation risk, jurisdiction choice, and a distillation pipeline that eventually reaches hardware you already own.
On July 16, Moonshot AI's Kimi K3 debuted at the top of Arena.ai's Frontend Code Arena, ahead of the closed flagship models from Anthropic and OpenAI. An open-weight model now holds the #1 slot on a major coding leaderboard, and the announcement dominated the AI news cycle within hours.
Most of that coverage stops at the leaderboard. The more useful question starts after it: Moonshot says the full 2.8-trillion-parameter weights will be public by July 27. Free to download is not the same as possible to run. Here is the honest math on what K3 demands from hardware, what you can realistically do on weights day, and why the release matters even if you never download a single shard.
Kimi K3 Just Took #1 on the Frontend Code Arena
The numbers first. Kimi K3 entered the Frontend Code Arena at 1,679 points, a 48-point lead over Claude Fable 5 at 1,631, with GPT-5.6 Sol third at 1,618. That is a 17-place jump from Moonshot's previous model, Kimi K2.6, which sat at #18. K3 ranked first in six of the board's seven domains — Brand and Marketing, Reference-Based Design, Data and Analytics, Consumer Product, Simulations, and Content Creation Tools — and second only in Gaming, where Fable 5 kept the lead.
What the board measures matters as much as the ranking. The Frontend Code Arena produces Elo-style ratings from human preference votes on head-to-head frontend coding tasks: real evaluators see two outputs and pick the one they prefer. That makes it a strong signal for design taste and practical frontend output, and a weak proxy for verified correctness on software engineering test suites. Both things can be true at once.
Some precision is also worth keeping. Open models have claimed individual coding benchmarks before — Z.ai's GLM-5.1 took the top SWE-Bench Pro score in April. And early third-party testing keeps the closed flagships ahead elsewhere: launch-day reports place Claude Fable 5 and GPT-5.6 Sol in front of K3 on Terminal-Bench 2.1. One leaderboard is a data point, not a verdict. It is, however, a data point that did not exist before: the top of a widely watched coding board is no longer reserved for models you can only rent.
What a 2.8-Trillion-Parameter Open Model Looks Like
Per Moonshot's technical blog, Kimi K3 is the first open model to reach 2.8 trillion parameters. The architecture introduces Kimi Delta Attention (KDA) and Attention Residuals (AttnRes), designed to move information more cleanly across long sequences and deep model stacks, and a Stable LatentMoE framework that activates 16 of 896 experts per token. Moonshot claims the combined changes deliver roughly 2.5 times the scaling efficiency of Kimi K2. The context window is 1 million tokens, input is natively multimodal, and thinking mode is always on. The number Moonshot has not published is the active parameter count per token; press estimates range from 40 billion to 100 billion, and the company says the technical report will land alongside the weights.
| Specification | Kimi K2.6 | Kimi K3 |
|---|---|---|
| Total parameters | 1 trillion | 2.8 trillion |
| Active parameters per token | 32 billion | Not yet disclosed |
| Expert routing | 8 of 384 routed, plus 1 shared | 16 of 896 (Stable LatentMoE) |
| Context window | 256K tokens | 1M tokens |
| License | Modified MIT | Not yet published |
| Weights availability | Released | By July 27, 2026 |
K2.6 figures from Moonshot's published documentation. K3 figures from Moonshot's July 2026 launch materials; the full technical report is pending.
The pricing tells its own story. K3's API launched at $3 per million input tokens and $15 per million output tokens (July 2026 launch pricing), which independent analyst Simon Willison notes makes it the most expensive model a Chinese lab has released to date — and puts it in the same tier as Anthropic's Sonnet series. It is still roughly a third of Claude Fable 5's June 2026 list rates of $10 input and $50 output, a gap we covered in detail when Kimi K2.7-Code shipped. Moonshot is no longer discount-pricing its flagship. That is what pricing confidence looks like.
One demonstration from the launch materials is worth a line. In a 48-hour continuous autonomous run, K3 completed the full design pipeline for a small functional chip — 4 square millimeters, timing convergence at 100 MHz — using open-source electronic design automation tools, as reported by VentureBeat from Moonshot's technical materials. It is a company-staged demo, not an independent result, but it signals where the long-horizon agent focus is aimed.
The license is the open item that matters most for this site's readers. Moonshot has not published K3's license terms. Every K2-family release used a Modified MIT license, and K2.7 carries a monthly-active-user clause on commercial deployments, a restriction we flagged in our open-source LLM roundup. Until the K3 model card is live, treat "open weights" as a description of availability, not of terms. Check the license before you build on it commercially.
The Honest Hardware Math: Can You Run Kimi K3 at Home?
Nobody outside Moonshot and its inference partners has the weights yet, so every size below is an estimate. The closest published reference points are the quantized builds of the 1-trillion-parameter K2 family, which Unsloth documents in detail: full precision requires roughly 610GB on disk (the K2 family ships its MoE weights in native INT4), the dynamic 2-bit build runs about 350GB, and the most aggressive dynamic 1.8-bit build lands near 240GB.
K3 has 2.8 times the parameters. If the release follows K2's precision pattern, straightforward scaling puts the full weights around 1.7TB, a 2-bit-class build near 1TB, and even the most aggressive 1.8-bit-class quantization somewhere around 650GB to 700GB.
| Build type | K2 family (1T, published) | Kimi K3 (2.8T, estimated) |
|---|---|---|
| Full precision (native INT4 MoE) | ~610GB | ~1.7TB |
| Dynamic 2-bit class | ~350GB | ~950GB-1TB |
| Dynamic 1.8-bit class | ~240GB | ~650-700GB |
K3 figures are estimates that scale Unsloth's published K2-family build sizes by parameter count. Final sizes depend on architecture details Moonshot will publish in the K3 technical report.
The rule for local inference has not changed: your total memory — VRAM plus system RAM, or unified memory on a Mac — needs to meet or exceed the build size, or the system falls back to disk offloading and speed collapses below one token per second. A 24GB GPU paired with 256GB of system RAM, the floor that ran K2's smallest quant at roughly 10 tokens per second, does not reach K3's smallest likely build. A 512GB Mac Studio does not reach it either. The realistic floor is a multi-GPU workstation — K2.7's 339GB 2-bit build needed four RTX PRO 6000-class cards, and K3's equivalent needs roughly triple that memory — or a server-class machine with 1TB of RAM running CPU inference at single-digit tokens per second. That is not a home setup. It is a rack line item.
Memory is only half the problem. Kimi Delta Attention, Attention Residuals, and Stable LatentMoE are new architecture components, and new architectures take time to land in llama.cpp, Ollama, and LM Studio. When DeepSeek shipped its new V4 architecture in April, mainline llama.cpp support was still pending weeks later, as we documented in our DeepSeek V4-Flash hardware reality check, which left early local runs to pinned forks and patched builds. Moonshot says it is working directly with inference partners and open-source maintainers ahead of the K3 release to make sure the model launches reliably across the ecosystem, which is the right move. Even so, expect a gap between weights day and turnkey local tooling.
What You Can Actually Do on July 27
Path one: use it hosted. Kimi's own API serves K3 at the launch rates above, and third-party hosts listed the model on day one. The tradeoff is the one this site exists to flag: hosted inference routes your prompts through the provider's servers, under the provider's privacy policy and jurisdiction — Moonshot's included. For some workloads that is fine. For the documents that made you interested in local AI in the first place, it is the entire question.
Path two: wait for the ecosystem. Once architecture support merges upstream, quantization publishers have historically shipped calibrated turnkey builds within days to weeks, and distilled or pruned variants tend to follow. This is the quiet payoff of open weights: the 2.8T checkpoint no consumer can run becomes the teacher for models that fit in 16GB.
Path three: run what fits today. Open models in the 8GB-to-128GB range are genuinely good now, and waiting for K3 costs you nothing. Our guide to the best local AI models by VRAM tier maps what runs at every memory level, from an 8GB laptop to a 384GB workstation.
Why Open Weights at #1 Matters Even If You Never Download Them
It would be easy to read "you cannot run it" as "this does not concern you." That is the wrong conclusion, for three structural reasons.
First, price competition. When a closed model tops a leaderboard, one company sets the price of access. When an open-weight model tops it, any host with sufficient hardware can serve the same weights, and margins compress across the board. K3's own launch pricing already undercuts the closed flagship it displaced, and third-party hosting will push effective rates lower still.
Second, permanence. Closed models get deprecated on the vendor's schedule, and your workflow goes with them. Released weights cannot be recalled. As we wrote when DeepSeek's V4 family shipped, open weights mean the local option stays permanently yours to exercise, even when today's hardware means most people cannot exercise it yet. The option itself has value, and it does not expire.
Third, jurisdiction choice. With open weights, an organization decides where inference happens — a US host, an EU host, or its own rack behind its own firewall. That choice simply does not exist for closed models, at any price.
There is also a trajectory worth naming. In April, DeepSeek V4-Pro at 1.6 trillion parameters became the largest open-weight model ever released. Eleven weeks later, that ceiling moved to 2.8 trillion. The open ecosystem's largest models are now scaling on the same slope as the closed frontier, and the #1 slot on a major coding leaderboard is no longer something you can only rent.
Keep the ledger honest, though. The license is unpublished. Every benchmark beyond the Arena result is currently Moonshot-self-reported, pending the technical report. And a preference leaderboard measures taste, not verified correctness. July 27 is the date those claims turn into checkable artifacts — which is, in the end, the entire point of open weights.
Frequently Asked Questions
Is Kimi K3 free to use?
Partly. The model is available through Moonshot's Kimi app and API, with API access priced at $3 per million input tokens and $15 per million output tokens at launch (July 2026). The model weights themselves will be free to download by July 27, but downloading them and having hardware that can run them are very different things.
What hardware do you need to run Kimi K3 locally?
Based on estimates scaled from the K2 family's published builds, the smallest practical quantizations will likely need roughly 650GB to 1TB of combined memory, and full precision around 1.7TB. No consumer machine qualifies. The realistic minimum is a multi-GPU workstation or a server with 1TB of RAM running slow CPU inference. Exact requirements will firm up when Moonshot publishes the technical report and the weights land.
When do the Kimi K3 weights release?
Moonshot says the full model weights will be released by July 27, 2026, with the technical report covering architecture, training, and evaluations published alongside them.
Is Kimi K3 better than Claude?
It depends on the task, and the honest answer has parts. K3 leads the Frontend Code Arena, a human-preference leaderboard, where it beat Claude Fable 5 by 48 points and won six of seven domains. Fable 5 kept the Gaming domain, and launch-day third-party testing still places Fable 5 and GPT-5.6 Sol ahead on Terminal-Bench 2.1. K3 offers a 1M-token context window and open weights; Claude offers closed but production-hardened tooling. Neither model wins everywhere.
What license will Kimi K3 use?
Unconfirmed as of publication. Every Kimi K2-family release used a Modified MIT license, and K2.7 includes a monthly-active-user clause on large commercial deployments, so a similar structure is plausible — but check the official model card when the weights ship before building anything commercial on it.
What can I run at home instead?
Plenty. Consumer-class open models have improved fast, and a capable local setup does not require a rack. A modern machine with 16GB of RAM runs solid small models today, and a dedicated always-on box is affordable — our mini PC guide for local AI covers hardware tiers and secure network setup, including how to keep an AI box properly isolated on your home network.
