Kimi K2.7 Code

Moonshot AI shipped Kimi K2.7 Code on June 12, 2026, and the pitch is refreshingly un-flashy: roughly the same coding quality as before, but it thinks about 30 percent less. In an era where every agent run bills you for thousands of "thinking" tokens, a model that reaches the same answer with fewer of them is a cost story, not a benchmark story. That is the honest way to read this release, because the benchmarks here are all Moonshot's own, and at least one outlet's testers say they do not hold up. Here is what it is, what to believe, and how to run it.

What it is

Kimi K2.7 Code is a coding-specialized variant built on the K2.6 base from Kimi's maker, the Beijing lab Moonshot AI. It is a big sparse Mixture-of-Experts model: 1 trillion total parameters with about 32 billion active per token, 384 experts (eight routed plus one shared), and a 256K-token context window. (Mixture-of-Experts means only a slice of the network runs per token, so you pay storage for the whole thing and compute for a fraction.) It takes text, image, and video input, reasoning is always on, and it ships under a Modified MIT license that allows commercial use, with a clause to credit Kimi if you cross 100 million monthly users or 20 million dollars a month in revenue.

The actual story: fewer thinking tokens

The headline number Moonshot stands behind is the 30 percent cut in thinking tokens versus K2.6, and it is confirmed on the official model card. Why care? A long agentic coding run is a loop: the model reads, plans, calls a tool, reads the result, plans again, dozens or hundreds of times. Each think step burns output tokens you pay for. Trim 30 percent off the reasoning at the same answer quality and you have cut the cost and the latency of every step, which compounds across a multi-hour job. For anyone running agents at scale, that matters more than one more point on a leaderboard.

Benchmarks, with a real warning

Here is where you need to be careful. Moonshot published only its own bespoke benchmarks. The standard public ones builders trust, SWE-Bench Verified, SWE-Bench Pro, Terminal-Bench, LiveCodeBench, are not on the model card. The numbers below are first-party.

All figures self-reported by Moonshot on bespoke benchmarks; standard SWE-Bench and Terminal-Bench scores were not published. A SWE-Bench Verified figure of 78.2 circulates on aggregator sites but appears in no primary source. Treat everything here as vendor-reported and unverified.

And the skepticism is on the record: VentureBeat reported that practitioners who tried it say the benchmarks "do not check out," noting the model was not submitted to any independent leaderboard. So the credible claim is the token reduction (cost), not a coding crown.

Limitations and gotchas

• It is not local. A 1T-parameter MoE keeps all experts resident; even native INT4 weights are roughly 500GB or more, so realistically you need a multi-GPU node (think 8x H200). The "runs on 2x A100" claims floating around are wrong.
• Benchmarks are first-party only and disputed. Verify on your own tasks before trusting any number.
• Reasoning is always on; there is no fast non-thinking mode, though making that thinking cheaper is the whole point of this release.
• No first-party Ollama tag yet; community GGUF quants exist (Unsloth), but at this size they need serious memory.

Who should use it

Use it if you run long, tool-heavy coding agents and your bill is dominated by reasoning tokens; the cheaper thinking is a real, compounding saving, and the Modified MIT license lets you self-host or fine-tune. Most teams will hit it through Moonshot's API (about $0.95 per million input tokens, $4.00 output, with cheap cache hits) rather than standing up a 1T model. If you want a model with independently verified coding scores, wait for third-party numbers or reach for GLM-5.2, which at least sits on public leaderboards.

Run it in about 10 minutes

Realistically, the API is the 10-minute path; self-hosting a 1T model is not.

# Fastest: the OpenAI-compatible Moonshot API. Set MOONSHOT_API_KEY first.
curl https://api.moonshot.ai/v1/chat/completions \
  -H "Authorization: Bearer $MOONSHOT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"kimi-k2.7-code","messages":[{"role":"user","content":"Refactor this function and add tests."}]}'

# Self-host the native INT4 weights on a multi-GPU node with vLLM
vllm serve moonshotai/Kimi-K2.7-Code --tensor-parallel-size 8

Point it at a coding harness like OpenCode and give it a real multi-step task, then watch the token counter. The whole reason to pick this model over its siblings is what that counter does, so that is the thing to measure.

Sources and further reading

• Kimi K2.7 Code model card (Hugging Face)
• Moonshot resource page
• Modified MIT license
• VentureBeat: practitioners on the benchmarks

Tested on: not independently tested. Kimi K2.7 Code is a 1T-parameter MoE that needs a multi-GPU node even at INT4, beyond our bench. Every benchmark here is Moonshot-reported on bespoke tests; independent reviewers (VentureBeat) are skeptical, and standard SWE-Bench and Terminal-Bench numbers were not published.
Date checked: 2026-06-26