Kimi K2.7 Code Guide: Fewer Thinking Tokens, Same Price

Kimi K2.7 Code is not a new generation. It is the K2.6 architecture tuned for one job, and the model card makes the trade visible: thinking is forced on, there is no instant mode, and the benchmarks it publishes centre on code and tool use.

That framing is useful. It means the right question is not whether K2.7 Code is better than K2.6, but whether your workload is coding-shaped enough to benefit from a specialist. For agent loops that write and run code, the answer is often yes, and the reason is token efficiency more than benchmark scores.

A specialist cut of the K2 line

K2.7 Code arrived in June 2026; OpenRouter lists it from 12 June. The model card describes the same skeleton as the rest of the family: a mixture-of-experts model with 1T total parameters and 32B active, 61 layers, 384 experts with eight routed and one shared, MLA attention and a 256K context window. It keeps the MoonViT vision encoder, so screenshots and images still work as input.

The weights are on Hugging Face under Moonshot's Modified MIT licence, the name it has used for every K2 release. As with K2 and K2.5, that means MIT plus one clause: a commercial product above 100 million monthly active users or $20 million in monthly revenue must display Kimi K2.7 Code prominently in its interface. Open-weight model licences compared covers how that differs from plain MIT.

Moonshot's Kimi K2.7 Code page lists API pricing of $0.95 per million input tokens on a cache miss, $0.19 on a cache hit and $4.00 per million output tokens. K2.6 is listed at the same $0.95 input and $4.00 output, with a slightly cheaper $0.16 cache hit, which makes the comparison between the two unusually clean. On OpenRouter, K2.7 Code is listed at about $0.67 input and $3.35 output per million tokens at the time of writing.

Thirty percent fewer thinking tokens is the headline

Moonshot says K2.7 Code uses about 30 percent fewer thinking tokens on average than K2.6. At identical per-token prices, that is a direct cut in the output bill on reasoning-heavy work, before any difference in quality.

Agent loops are where this compounds. A coding agent that reasons before each of fifty tool calls pays for that reasoning fifty times, and reasoning tokens are billed as output at the higher rate. Trimming a third of them changes the cost of a run more than most price cuts do. The token cost of reasoning models covers why output tokens dominate these bills, and cost per agent run covers how to measure it.

Treat the 30 percent as an average from Moonshot's own runs. Your number depends on task mix, so measure output tokens per completed task on your own work rather than trusting the figure.

Reading Moonshot's benchmark table honestly

The model card compares K2.6, K2.7 Code, GPT-5.5 and Claude Opus 4.8. The K2.6 to K2.7 Code movement is consistent across all six rows:

• Kimi Code Bench v2: 50.9 to 62.0. This is an in-house benchmark.
• Program Bench: 48.3 to 53.6.
• MLS Bench Lite: 26.7 to 35.1.
• Kimi Claw 24/7 Bench: 42.9 to 46.9. Also in-house.
• MCP Atlas: 69.4 to 76.0.
• MCP Mark Verified: 72.8 to 81.1.

Three things temper that. Two of the benchmarks are Moonshot's own. The closed models were run in their own harnesses, Codex and Claude Code, while the Kimi models ran in Kimi Code CLI, so the cross-vendor columns are not like-for-like. And on every row at least one of GPT-5.5 and Opus 4.8 still scores higher; the only closed-model figure K2.7 Code beats is Opus 4.8 on MCP Mark Verified. The fair summary is a clear in-family improvement that narrows the gap to the closed frontier without closing it. Vendor-claimed vs independent benchmarks covers how much weight to give tables like this.

Thinking is always on

K2.7 Code has no instant mode. The model card says thinking and preserved thinking are forced on, Moonshot's quickstart says the API returns an error if you try to disable thinking, and the recommended sampling is temperature 1.0 with top-p 0.95.

That has two consequences. Every request pays for some reasoning, so K2.7 Code is the wrong model for trivial completions, renaming, or one-line answers. And because thinking is preserved across turns, check that your client returns the full assistant message, reasoning included, rather than stripping it, or multi-turn behaviour may differ from what Moonshot tested.

K2.7 Code, K2.6 or K3

• Pick K2.7 Code for agentic coding: multi-file changes, test-fix loops and MCP-heavy tool use, where reasoning is needed and token efficiency pays back on every step.
• Pick K2.6 for mixed workloads, non-coding tasks, and anything where an instant mode saves money. See the K2.6 guide.
• Pick K3 when a failed run costs more than the tokens. It activates about three times as many parameters per token, 104B against 32B, so expect it to cost more to serve. The K3 guide covers whether that is worth it.

A sensible pattern is to route by task: K2.6 for chat and quick edits, K2.7 Code when the agent is about to run a long coding loop. Both share the 256K window and the same API shape, so the router is a model-name switch.

How to decide

Take fifteen real coding tasks from your history, run each through K2.6 and K2.7 Code on the same harness and starting commit, and record three numbers: whether the diff is mergeable, output tokens, and wall-clock time. With identical prices, the comparison reduces to quality and tokens. How to benchmark LLMs on your own work has the harness setup.