Kimi K2.7-Code Is Open-Source. Running It Yourself Is Another Story.

Last updated: June 2026

Kimi K2.7-Code is Moonshot AI's new open-weight coding model: a 1-trillion-parameter Mixture-of-Experts system released June 12, 2026, tuned for long-horizon software engineering and agentic tool use. The weights are on Hugging Face under a Modified MIT license. The API costs a fraction of what closed competitors charge. And almost nobody reading this can run it at home.

This site has spent years making one argument about ISP gateways: renting equipment you could own means paying forever for hardware you never control. AI coding tools run on the same rental logic, except the "modem" here weighs 340 gigabytes, and the memory needed to power it is caught in the worst DRAM market in a decade. K2.7-Code is the strongest case yet that you can own the model. It is also an honest lesson in what owning costs. Here is the full math.

What Moonshot Actually Shipped

K2.7-Code is a coding-focused build on top of Kimi K2.6, not a new base model. The official model card lists 1T total parameters with 32B activated per token across 384 experts (8 selected plus 1 shared), 61 layers, MLA attention, a 256K-token context window, and a 400M-parameter MoonViT vision encoder for image and video input. The weights ship in native INT4, using the same quantization-aware training method Moonshot introduced with K2 Thinking.

One design decision matters for anyone budgeting tokens: thinking is always on. The model forces reasoning mode and carries that reasoning across turns (preserve_thinking), and there is no instant mode.

The release cadence is the other story. K2 launched in July 2025, K2 Thinking in November, K2.5 in January 2026, K2.6 in April, and now K2.7-Code in June, which makes five major releases in under a year. Availability on day one: the Kimi API at platform.moonshot.ai with OpenAI- and Anthropic-compatible endpoints, the Kimi Code terminal agent, and full weights on Hugging Face with vLLM, SGLang, and KTransformers as the recommended inference engines. A "6x High-Speed Mode" is announced as coming soon.

The Benchmarks, With the Salt They Need

Moonshot published a six-benchmark table comparing K2.7-Code against its own K2.6, OpenAI's GPT-5.5, and Anthropic's Claude Opus 4.8. Here is the full table, because the parts left out of the announcement graphic are the most useful parts.

All figures are Moonshot-reported (model card, June 12, 2026). Kimi Code Bench v2 and Kimi Claw 24/7 Bench are Moonshot in-house benchmarks; Program Bench, MLS Bench Lite, MCP Atlas, and MCPMark are third-party, but all comparison runs here were executed by Moonshot, with GPT-5.5 in Codex and Opus 4.8 in Claude Code at maximum-effort settings. No SWE-Bench Verified scores were published at launch.

Read honestly, the closed flagships lead in 11 of the 12 head-to-head cells. The single win is MCPMark Verified, where K2.7-Code's 81.1 beats Opus 4.8's 76.4 on tool-use tasks across real Notion, GitHub, Filesystem, Postgres, and Playwright server environments. The generational jump over K2.6 is real on paper, with Moonshot's in-house coding benchmark rising from 50.9 to 62.0, an improvement of 21.8%.

So the headline is not "open beats closed." The headline is how much capability per dollar the open model now delivers, and that is a token-efficiency story.

Why 30% Fewer Thinking Tokens Is the Real Headline

Reasoning models bill you for deliberation. Every token a model spends thinking is metered the same as a token of output, so a model that overthinks simple problems is both slower and more expensive in production. Moonshot claims K2.7-Code completes coding tasks using roughly 30% fewer thinking tokens than K2.6 while scoring higher, which is the first time the K2 line has led a release with efficiency rather than raw capability.

The place this compounds is persistent agents. Moonshot built an in-house benchmark, Kimi Claw 24/7 Bench, specifically for multi-day agent work: 17 professional scenarios across 610 evaluation points, all executed through the OpenClaw harness. If you run an always-on agent setup like the one in our free local AI agent stack guide, token efficiency is the difference between a tool you use and a bill you monitor.

The catch is the one noted above: thinking cannot be disabled. Every call pays some reasoning overhead, including calls that do not need it. For high-volume trivial requests, a forced-thinking model is the wrong shape no matter how efficient its thinking is.

The License Fine Print

The "Modified MIT" label deserves a precise reading, so we pulled the license file itself. It is the standard MIT license with exactly one added condition: if a commercial product or service built on the model exceeds 100 million monthly active users or US$20 million in monthly revenue, it must prominently display "Kimi K2.7 Code" in its user interface.

For an individual, a homelab, or any business below those thresholds, the license behaves like ordinary MIT: self-host it, modify it, build on it, sell with it, no fees and no gates. That makes this one of the most permissive licenses attached to any frontier-adjacent model, and considerably lighter than the use-restriction clauses on some competing open releases. It is still not vanilla MIT, and teams shipping at scale should read the clause before building a brand on top of it.

Rent vs. Own: Three Ways to Use K2.7-Code

Rent the platform: Kimi Code

Kimi Code is Moonshot's terminal and IDE coding agent, and K2.7-Code is now its default engine. Membership plans are listed from $19 per month as of June 2026, with a beta program for early access to upcoming models. This is the same model-plus-subscription playbook Anthropic runs with Claude Code: the model is the product, the agent is the storefront.

Rent the tokens: the API

Per Moonshot's pricing page in June 2026, the API costs $0.19 per million cached input tokens, $0.95 per million on cache misses, and $4.00 per million output tokens. The structural detail that matters more than the numbers: the endpoints are OpenAI- and Anthropic-compatible, so pointing an existing tool at K2.7-Code is a base-URL and model-string change, not a rewrite. That is what anti-lock-in looks like in practice.

On launch day, no third-party inference providers were serving the model yet. Based on K2.6's pattern, expect OpenRouter-class hosts within days, which matters because you then choose where the open weights run, including providers in your own jurisdiction.

Own it: self-hosting

The weights are free, the license is permissive, and the recommended engines (vLLM, SGLang, KTransformers) are documented. Self-hosting genuinely makes sense for three groups: teams with data-residency or air-gap requirements, operations with sustained heavy token volume where API costs compound, and builders who need full control of the inference stack. For everyone else, the next section explains why renting wins.

The 340GB Problem: Running a 1T Model at Home

Mixture-of-Experts models have a memory truth that marketing numbers obscure: 32B "activated" parameters does not mean 32B in memory. The router can call any of the 384 experts on any token, so all 1T parameters must be loaded. Memory is the constraint, not compute.

The sizes, using sibling model K2.6 as the reference since Moonshot confirms K2.7-Code shares the identical architecture: roughly 2TB in FP16, about 610GB for the shipped native-INT4 weights, and 340GB for Unsloth's Dynamic 2-bit GGUF, which wants 350GB+ of combined RAM and VRAM for usable speeds. The near-lossless 4-bit build needs around 600GB. One-bit experiments on earlier K2 releases reached 247GB, but 1-bit and 3-bit builds for K2.6 were withheld pending quality scores. K2.7-specific community quants had not been published at the time of writing; expect them within days, with 340GB as the realistic floor.

Capacity and speed figures derive from K2.6 documentation (Unsloth) and community deployment guides; K2.7-Code shares the same architecture per Moonshot's model card. A 16-core CPU build at the 2-bit quant has been reported around 8-12 tokens per second.

Until late 2025, the budget answer to that table was simple: skip the GPUs and stack server RAM. The DRAM market closed that door. Per 3DCenter tracking data reported by Notebookcheck this spring, average DDR5 pricing sits roughly 4x above its July 2025 baseline, with only a single-digit easing in the latest month. TechRadar's market tracking shows 64GB DDR4 kits climbing from near $150 to the $400-600 range over the same period, and industry estimates cited by Tom's Guide project data centers consuming around 70% of the world's high-end memory supply in 2026.

The same AI buildout that produced this model made the memory needed to run it scarce. The weights are free. The memory is not.

For nearly every reader, the right local-AI move is unchanged: build for the models that fit. Our local AI hardware guide covers the GPU and memory tiers in detail, and our mini PC roundup for local AI covers the turnkey boxes. If you want one upgrade that moves the needle for local coding models, the renewed RTX 3090's 24GB of VRAM remains the budget workhorse for the 14B-32B class.

Check Price on Amazon: NVIDIA RTX 3090 24GB (Renewed)

And whether or not a K2-class model ever lands on your desk, modern open-model libraries are measured in hundreds of gigabytes per model. Fast multi-terabyte NVMe storage is the quiet prerequisite of local AI in 2026.

Check Price on Amazon: Samsung 990 EVO Plus 2TB

What This Means for the Open vs. Closed Race

K2.7-Code is the second frontier-adjacent open coding stack to ship in two months, following DeepSeek's V4 release in April. The pattern: open releases no longer ship as bare weights. They arrive with platform economics attached (subscription CLIs, SDK-compatible endpoints, aggressive token pricing), competing on the full stack rather than the license alone.

That pricing is the pressure point. Day-one coverage from Handy AI framed the launch directly against Claude Fable 5's $10 input / $50 output per-million list rates (June 2026), against which Moonshot's $0.95 / $4.00 reads as roughly a tenth of the cost. On Moonshot's own table the closed models still score higher, so the question every closed vendor now has to answer is not "are we better" but "are we better by enough, on this task, at this multiple."

And the sovereignty point, stated plainly: any hosted API routes your code through that vendor's servers, Moonshot's included. Open weights change who the host is: Moonshot, a third-party provider in your jurisdiction, or your own hardware. Whoever controls the weights controls the agent. For the first time in this category, that can be you, if you can afford the memory.

Frequently Asked Questions

Is Kimi K2.7-Code free?

The weights are free to download under a Modified MIT license. Moonshot's hosted API costs $0.19 per million cached input tokens, $0.95 per million on cache misses, and $4.00 per million output tokens, and Kimi Code subscription plans are listed from $19 per month (Moonshot pricing page, June 2026). Self-hosting carries no license cost but requires server-class hardware.

Can I run Kimi K2.7-Code on a gaming PC or a 64GB machine?

No. The smallest published quantization of its identical-architecture sibling, K2.6, is 340GB and needs roughly 350GB of combined RAM and VRAM for usable speeds. A 64GB machine is excellent for 14B-32B coding models; it is an order of magnitude short of K2-class.

How does Kimi K2.7-Code compare to Claude Code?

They are different layers: Claude Code is an agent product, while K2.7-Code is a model that ships with its own agent, Kimi Code. On Moonshot's published table, Claude Opus 4.8 leads K2.7-Code on five of six benchmarks, and K2.7-Code wins MCPMark Verified at 81.1 versus 76.4. Independent third-party results were not yet available at launch. The clearest difference today is price per token, not capability.

What does the Modified MIT license actually require?

Everything standard MIT allows, plus one condition: commercial products or services built on the model that exceed 100 million monthly active users or US$20 million in monthly revenue must prominently display "Kimi K2.7 Code" in their interface. Below those thresholds, it behaves like ordinary MIT.

What is the cheapest way to try it today?

Hosted access: Kimi Code plans from $19 per month, or pay-as-you-go API access at platform.moonshot.ai at the June 2026 rates listed above. Because the endpoints are OpenAI- and Anthropic-compatible, most existing coding tools can point at the model by changing a base URL and a model string.

When will smaller quantized versions be available?

Community GGUF quantizations had not been published at the time of writing. K2.6's quants arrived within days of its release and the architecture is identical, so expect the same pattern, with roughly 340GB as the practical floor unless 1-bit builds clear quality testing.