Moonshot AI's Kimi K2.7 Code Cuts Reasoning Tokens 30% While Beating Claude

Moonshot AI just dropped Kimi K2.7 Code, a coding-specialized agentic model that builds directly on K2.6 with a sharper focus: finish more complex software engineering tasks, follow instructions reliably across very long contexts, and do it all while spending roughly 30% fewer tokens on internal reasoning. That last part is not a minor footnote. In agentic workflows, thinking tokens are billed as output tokens, and they compound across every step of a long run.

Kimi K2.7 Code appeared on Hugging Face on June 12, 2026. It is a 1-trillion-parameter Mixture-of-Experts model with 32 billion parameters active per token, 384 experts, and a 256K-token context window, released under a Modified MIT license. The weights are fully open and self-hostable, making it one of the largest open-weight coding models available right now.

The efficiency angle is the real story

Reasoning models have a well-known problem: they overthink. Before every tool call or code edit, they generate an internal chain-of-thought that can run into thousands of tokens, even for simple tasks. In a multi-step agentic session that spans hundreds of tool calls, that overhead stacks up fast.

The most operationally interesting improvement is roughly 30% lower reasoning-token usage than K2.6, framed by Moonshot as "less overthinking." In an agentic coding session that runs hundreds or thousands of steps, that overhead compounds: every plan, every retry, every verification pass pays the thinking tax again. Across all three coding benchmarks, K2.7 Code achieves higher scores than K2.6 while consuming fewer tokens on each one. For developers, this efficiency compounds across every task: faster responses in interactive coding sessions, lower API costs in production, and agent workflows that complete more work within the same context budget.

Benchmark numbers: big jumps over K2.6, still trailing GPT-5.5

On coding benchmarks, K2.7 Code shows substantial gains over K2.6: +21.8% on Kimi Code Bench v2 (62.0 vs 50.9), +11.0% on Program Bench (53.6 vs 48.3), and +31.5% on MLS Bench Lite (35.1 vs 26.7). On the agentic side, on Kimi Claw 24/7 Bench, MCP Atlas, and MCP Mark Verified, K2.7 Code improves by roughly 10% over K2.6.

One result that drew particular attention: K2.7 Code beats Claude Opus 4.8 on MCP Mark Verified, scoring 81.1 versus 76.4. MCP Mark Verified measures real-world tool use across environments like Notion, GitHub, Filesystem, Postgres, and Playwright, so this is a practically meaningful win. That said, in Moonshot's own table, K2.7 Code does not beat GPT-5.5 on any of the six listed benchmarks. And all current numbers are entirely self-reported, and there are no independent SWE-bench scores yet.

What it is built for

Real-world software engineering rarely ends in a single step. Tasks like refactoring a codebase, implementing a feature across multiple files, or debugging over long agent sessions require a model to follow instructions reliably across extended contexts, and to carry a task through to completion. K2.7 Code is not a general-purpose model. Moonshot explicitly recommends K2.6 for writing, analysis, and conversation, while K2.7 Code is the pick for anything that looks like a coding workflow.

Practical use cases where it shines:

• Long autonomous coding sessions with many tool calls (refactors, multi-file features, debugging loops)
• MCP-based agent pipelines that need reliable tool use across real environments
• Repository-scale tasks that need the full 256K context window
• High-volume API integrations where the 30% token reduction directly cuts costs
• Self-hosted deployments where data residency matters

One important constraint

Kimi K2.7 Code forces thinking and preserve_thinking as True. There is no non-thinking mode. It always operates in thinking mode, preserving full reasoning content across multi-turn conversations. In Kimi Code, if you disable thinking, the request is automatically routed to K2.6 instead. This is a deliberate architectural choice, not a missing feature, but it means you cannot use this model for latency-sensitive tasks that need instant responses.

Architecture under the hood

K2.7 Code is built on a Mixture-of-Experts architecture with 1 trillion total parameters and 32 billion activated parameters per token. The model supports a 256K context length and uses Multi-head Latent Attention (MLA). It also includes MoonViT, a 400M-parameter vision encoder. MLA is an attention mechanism designed to reduce the memory footprint of the key-value cache during inference, which matters a lot when you are running long agentic sessions. K2.7 Code has the same architecture as Kimi K2.5 and K2.6, so the deployment method can be directly reused.

Kimi K2.7 Code adopts the same native INT4 quantization method as Kimi K2 Thinking. Community GGUF quantizations are already available on Hugging Face for use with Ollama, LM Studio, Jan, and llama.cpp.

How to access it and what it costs

There are two ways in:

• Kimi Code CLI / IDE plugin at kimi.com/code: K2.7 Code is now the default model with thinking enabled. Subscription plans run from $15/month (Moderato) to $159/month (Vivace) under annual billing, with weekly refreshed usage quotas.
• Kimi API at platform.kimi.ai: per-token billing with the model ID kimi-k2.7-code. Cached input is $0.19/1M tokens, cache-miss input is $0.95/1M tokens, and output is $4.00/1M tokens.

At $0.95 per 1M input tokens and $4.00 per 1M output tokens, it is roughly 5x cheaper than Claude Opus 4.8. The platform uses the OpenAI API format, which makes it easier to drop into existing application architectures that already speak OpenAI-compatible API patterns. For self-hosting, the model supports deployment via vLLM, SGLang, and KTransformers, and is released under a Modified MIT License.

What the community is saying

Reaction has been positive but measured: praise for open-sourcing a near-frontier coding model and for the MCP tool-use result, interest in the token-efficiency gain, and a recurring "show me independent benchmarks" caution since all current numbers are first-party. Teams running long autonomous sessions care more about the ~30% reduction in reasoning tokens than about a benchmark point or two, since it shows up directly in their monthly spend. The skepticism is fair. Until independent evaluations land on something like SWE-bench, the benchmark story is Moonshot grading its own homework.

The open-weight release is arguably the most durable part of this announcement. A 1T-parameter coding model that you can self-host, quantize, and drop into your own infrastructure, at API prices that undercut the closed frontier by a wide margin, is a meaningful option for teams that care about cost control or data residency. Whether the benchmark gains hold up in your actual codebase is the question worth testing.