# Kimi K2.7 Code: The Open Trillion-Parameter Coder, and the 594GB Reality of Running It Locally > Source: > Published: 2026-07-07 15:38:30+00:00 You can download Kimi K2.7 Code today. Moonshot AI released the weights in June under a near-MIT license, it tops most open-weight coding charts, and it is a genuinely capable agentic coder. Then you check what you just downloaded: about 594GB, even at the native 4-bit. That is more memory than the single largest computer you can buy holds, a 512GB Mac Studio, before you load one token of context. So for a local-LLM audience the interesting question is not "is it good." It is "what would it actually take to run, and should you bother?" We have not run this model first-hand. What follows synthesizes Moonshot's own docs, the Kimi K2 technical report, community reception, and the memory math, all linked at the end. ## What Moonshot says it is Kimi K2.7 Code is a [Mixture-of-Experts](https://vettedconsumer.com/mixture-of-experts-moe-explained-why-active-parameters-decide-what-runs-on-your-machine/) model with **1 trillion total parameters and 32 billion active per token** (384 routed experts, 8 selected plus 1 shared, across 61 layers). It uses MLA attention, ships a **256K-token** context, adds a small MoonViT vision encoder for image and video input, and, unusually, is released with **native INT4 weights** rather than the usual full-precision checkpoint. It is built on Kimi K2.6 and, per its config, shares that family's architecture, so the deployment path is the same. The license is a "Modified MIT": free to use and modify, with one added clause. If you put it in a commercial product with more than 100 million monthly active users or more than $20 million in monthly revenue, you have to display "Kimi K2.7 Code" in that product's interface. For anyone reading this, that is effectively MIT. ### The benchmarks, read carefully Moonshot's headline is a real jump over the prior version. On its own Kimi Code Bench v2, K2.7 Code scores **62.0, up from K2.6's 50.9** (a clean +21.8%), and it claims roughly 30% fewer "thinking" tokens to get there, which matters for latency and cost. But two things are worth stating plainly: **Every headline number is Moonshot's own.** Kimi Code Bench v2, Program Bench, MCP Atlas, and the rest are proprietary suites run by Moonshot. At launch there were no independent third-party results, and notably**no SWE-bench score was published for K2.7 at all**(K2.6 had a verified ~80% on SWE-bench Verified). Treat the scores as vendor claims until an outside lab reproduces them.**On Moonshot's own card, it still trails the closed frontier.** That same 62.0 sits below the GPT-5.5 (69.0) and Claude Opus 4.8 (67.4) figures Moonshot lists next to it, and the pattern repeats across their table. This is the strongest open coder in its class getting close, not a model that beats the best closed ones. ## The research behind it Kimi K2.7 Code has no paper of its own, but the family does: ["Kimi K2: Open Agentic Intelligence"](https://arxiv.org/abs/2507.20534?ref=vettedconsumer.com) (Kimi Team, Moonshot AI, 2025). Three ideas in it explain the model you are looking at, and two of them are exactly why a 1T model is not as un-runnable as it sounds: **MuonClip.** The report's headline is a training-stability trick (a "QK-Clip" that caps attention logits) that let Moonshot pre-train on 15.5 trillion tokens with, they report, zero loss spikes. That is the reason a 1T model this coherent exists at all.**MLA with fewer heads.** K2 uses Multi-head Latent Attention with 64 attention heads, deliberately cut from DeepSeek-V3's 128 because doubling them costs "an 83% increase in inference FLOPs" for only a 0.5 to 1.2% quality gain. The payoff for you: the KV cache stays tiny. A full 256K context adds only about 9 to 18GB, so the*weights*, not the context, are the memory wall.**High-sparsity MoE plus INT4.** 384 experts with 8 active means 32B of the 1T parameters do the work per token, keeping compute manageable. And the native INT4 weights come from quantization-aware training (Moonshot reports a "lossless 2x speed-up"), which roughly halves the footprint versus full precision, from ~2TB to ~594GB. ## What the community actually finds The reception is respectful but wary, and the wariness is about evidence, not the model. Because every benchmark is first-party, practitioners have been asking for real-world results. One Hugging Face thread titled "IS there any benchmark for REAL WORLD TASKS?" collected only "+1" replies and went unanswered by Moonshot. Reporting from VentureBeat (via roundups; the original 403s to us) floated a sharper reading: some of K2.7's gain may reflect "more straightforward behavior," writing real code where the older model leaned on library wrappers, rather than a clean capability jump, and it noted K2.7 was not submitted to DeepSWE, an independent benchmark with a much wider spread between models that would have separated it more clearly. On placement, community-run rankings (no single controlled harness behind them, so directional) tend to slot K2.7 Code around third among open weights, behind [GLM-5.2](https://vettedconsumer.com/glm-5-2-the-most-powerful-open-weight-model-yet-and-the-brutal-reality-of-running-it-locally/) and [MiniMax M3](https://vettedconsumer.com/minimax-m3-the-first-open-weight-multimodal-frontier-model-and-the-license-catch/), with its edge in tool-use-heavy agentic workflows and token efficiency rather than raw code generation. The recurring point from people who tried it: the one open coder they can *genuinely run* is Qwen3-Coder-Next (80B total, 3B active, Apache-2.0), a fraction of K2.7's size. Which brings us to the real story for this site. ## What it takes to run it locally Here is the memory reality, and it is unforgiving. The weights are the wall; thanks to MLA the 256K context barely registers. | Quant | Weight footprint | Notes | |---|---|---| | BF16 (full) | ~2 TB | Never used locally | Native INT4 (as released) | ~594 GB | The default checkpoint | | ~3-bit | ~450 GB | | | ~2-bit (quality floor) | ~325 to 360 GB | Smallest that stays usable | | ~1.8-bit (minimal) | ~230 to 245 GB | Noticeable quality loss | Weight sizes by quant. KV cache at full 256K context adds only ~9 to 18GB. The consequence: **no single consumer machine runs the native INT4 weights.** A maxed [Mac Studio M3 Ultra with 512GB](https://vettedconsumer.com/mac-studio-m3-ultra-the-local-ai-workhorse-buy-now-or-wait-for-m5/), the largest single box money can buy, sits below the ~594GB weights before any overhead. It can hold a 2-bit quant (~325 to 360GB) with room for a capped context, but that is a compromised version of the model. Everything realistic is a cluster, a server, or CPU RAM: | Setup | Speed | Rough cost | |---|---|---| | 384GB+ DDR5 CPU build (2-bit) | ~8 to 11 tok/s | ~$3,500 to 4,500 | | 4x | Realistic local paths. Speeds are single-config community reports; treat as directional. The smallest sane local setup is a 384GB DDR5 CPU build running a 2-bit quant at single-digit tokens per second, for around $4,000. The ~$40,000 four-Mac cluster is the only build that runs true native INT4 with full context at a workable ~25 tokens per second, and its own author called it "not something you'd buy specifically for AI." A single 24GB GPU with disk offload manages 1 to 2 tokens per second, which is not usable for coding. Set that against renting or calling the API. Moonshot's API runs roughly $0.95 per million input tokens and $4.00 per million output (verify current pricing before you rely on it). A developer burning a couple million output tokens a month pays single-digit dollars. A four- or five-figure rig, plus power, would take many years to break even, by which point it is obsolete. For occasional heavy local runs without owning hardware, renting an 8x-H200 node holds the FP8 weights with room for full context. The economics point one way for almost everyone. To put your own machine to the test (it will not fit, and that is the point), run the numbers through our [Can I run it? calculator](https://vettedconsumer.com/can-i-run-it/), use the [quant picker](https://vettedconsumer.com/quant-picker/) to see what a smaller model would take, and the [buy-vs-rent-vs-API calculator](https://vettedconsumer.com/cost-calculator/) to price the alternative. ## So, is it worth downloading? For roughly 99% of people, no, not to run locally. Kimi K2.7 Code is a legitimately strong open agentic coder with a permissive license and real engineering behind it (MLA, high-sparsity MoE, native INT4 training). But it is a rent-or-API model in practice: no single machine you can buy holds it, the realistic local build is a $4,000 rig at reading-pace speed, and the cost math against a few dollars of API a month is not close. If you want a capable coder you can genuinely run at home, a smaller open model like Qwen3-Coder-Next or a 30-billion-class coder is the realistic pick, and you can point our tools at it. Download K2.7 Code if you own a server-class rig or a cluster and want the open weights on your own metal. Otherwise, this is one to use, not to host. ## Sources and how we researched this We have not run this model first-hand; this synthesizes primary docs, the literature, and community reports. Specs and benchmarks are from the [Hugging Face model card](https://huggingface.co/moonshotai/Kimi-K2.7-Code?ref=vettedconsumer.com), its config.json, and Moonshot's release note; every benchmark is Moonshot's own and none were independently reproduced at launch. The architecture innovations are from the verified [Kimi K2 technical report](https://arxiv.org/abs/2507.20534?ref=vettedconsumer.com) (Kimi Team, arXiv:2507.20534), with the native INT4 quantization-aware training detail from the [Kimi K2-Thinking model card](https://huggingface.co/moonshotai/Kimi-K2-Thinking?ref=vettedconsumer.com). Community reception and the ~594GB / tokens-per-second figures come from MarkTechPost, VentureBeat (via roundups), and community hardware writeups; hardware numbers are single-configuration reports that will vary by quant, runtime, and build. ## Related guides [Mixture-of-Experts, explained](https://vettedconsumer.com/mixture-of-experts-moe-explained-why-active-parameters-decide-what-runs-on-your-machine/), why 32B active of 1T total is the number that matters[GLM-5.2](https://vettedconsumer.com/glm-5-2-the-most-powerful-open-weight-model-yet-and-the-brutal-reality-of-running-it-locally/)and[MiniMax M3](https://vettedconsumer.com/minimax-m3-the-first-open-weight-multimodal-frontier-model-and-the-license-catch/), the two open models ranked above it[How much VRAM you need for a 70B](https://vettedconsumer.com/how-much-vram-do-you-actually-need-to-run-a-70b-model-locally/), the capacity math, scaled down[The cheapest way to run a 70B locally](https://vettedconsumer.com/the-cheapest-way-to-run-a-70b-model-locally-in-2026-what-owners-actually-use/), for a model you can host