Kimi K2.7 Code Review: Moonshot Shipped a Leaner Specialist, Not a Smarter Model

Moonshot AI released Kimi K2.7 Code on June 12, 2026 with two claims: it cuts thinking tokens by roughly 30% versus K2.6, and it improves on K2.6 across six benchmarks. Five weeks later there is enough independent evidence to check both. The efficiency claim is not just confirmed — it is beaten. Artificial Analysis, running the identical harness on both models, found output tokens fell from 170M to 100M, a ~41% drop. The capability claim splits: on the same AA harness the general Intelligence Index fell, 44 to 42, while on DeepSWE — the one independent benchmark measuring the agentic coding this model was specialized for — K2.7 Code posts 31% against K2.6's 24%. Our own executed test adds the axis nobody else publishes: what a correct answer actually costs. This is the assembled picture: what Moonshot reported, what independent evaluators measured, and what we measured ourselves.

What Kimi K2.7 Code is

Kimi K2.7 Code is Moonshot AI's coding-focused model, released June 12, 2026 under a Modified MIT license with open weights on Hugging Face. The specs, confirmed across Moonshot's model card, its platform docs and OpenRouter:

• Architecture: ~1T total parameters, ~32B activated per token (MoE) — 384 experts, 8 selected per token, 1 shared expert. Plus MoonViT, a 400M-parameter vision encoder, so it accepts image input.
• Context window: 256K (262,144 tokens).
• Max output: 32,768 tokens by default — not 262,144. This trips people up constantly, because 262,144 is the context window, not the output cap. Moonshot's own quickstart is explicit: default to be 32k aka 32768.
• Model IDs: kimi-k2.7-code and kimi-k2.7-code-highspeed.

What Moonshot published — and quietly conceded

Moonshot published a six-row table comparing K2.7 Code against K2.6, GPT-5.5 and Claude Opus 4.8. Most coverage of this model reprints that table and stops. It is worth actually reading, because the interesting part is not the improvement over K2.6 — it is what the other two columns say.

Verbatim from Moonshot's Hugging Face model card, July 2026. Bold cells mark the best score in each row. Every number here was produced by Moonshot, in Moonshot's harness.

Read across the rows against Moonshot's own new model: GPT-5.5 beats K2.7 Code in all six. Opus 4.8 beats it in five of six. K2.7 Code wins exactly one comparison against Opus — MCP Mark Verified, 81.1 to 76.4 — and beats GPT-5.5 on nothing. Even MLS Bench Lite, the row with K2.7's biggest gain over K2.6 (+31.5% relative), still loses to both frontier models.

That is a vendor publishing a table where its new model loses eleven of twelve head-to-head comparisons on a benchmark suite it chose and ran itself. It is an unusually honest piece of marketing, and almost nobody covering this model has pointed it out.

One correction to a criticism that circulates about this table: it is not true that every benchmark is a Moonshot invention. Kimi Code Bench v2, Kimi Claw 24/7 Bench, Program Bench and MLS Bench Lite are Moonshot-created. But MCP Mark Verified is MCPMark, an independent academic benchmark of 127 expert-curated MCP tasks (arXiv 2509.24002) that Moonshot did not create. The accurate criticism is narrower and still fair: every score in this table is vendor-run and self-reported, whoever designed the benchmark.

What independent evaluators found

Here is where the story gets genuinely interesting, because the independent evidence exists — it is just scattered across an Artificial Analysis model page, its K2.6 page, the DeepSWE leaderboard and a kernel researcher's public run. Assembled, it does something none of those sources does alone: it splits Moonshot's pitch apart along a seam the launch post never mentions.

Artificial Analysis has evaluated K2.7 Code across nine public evals — GDPval-AA v2, τ³-Banking, Terminal-Bench v2.1, SciCode, Humanity's Last Exam, GPQA Diamond, CritPt, AA-Omniscience and AA-LCR — scoring it 42 on the Intelligence Index, ranked #6 of 97 (as of July 17, 2026). Crucially, it ran the identical index on K2.6. That gives us the exact generation-over-generation comparison Moonshot asks us to take on faith:

So Moonshot's efficiency claim is not just corroborated — it is beaten, on somebody else's harness. K2.7 Code needed ~41% fewer output tokens than K2.6 to complete the same nine evaluations. Moonshot's careful wording was approximately 30% on average for thinking tokens; the independent number is larger.

42 versus 44. On general capability, the independent index says K2.7 Code came out slightly behind its predecessor, while Moonshot's table shows it improving in all six of its own rows. That is not a catastrophe — two points is a small gap and K2.7 Code is still #6 of 97 — but it contradicts the shape of the vendor story.

Except on the one axis this model was actually built for. DeepSWE, an independent long-horizon agentic coding benchmark of 113 tasks across 91 repositories, lists K2.7 Code at 31% (±1%) on its July 16, 2026 board — 13th of 15 models, far below GPT-5.6-sol's 73% and Claude Opus 4.8's 59%. But DeepSWE's own launch post scored K2.6 at 24% (±2%). Same benchmark, same evaluator: K2.7 Code is meaningfully better at the agentic coding it was specialized for. Carry one caveat — K2.6 is not on the current board, so this is a cross-snapshot comparison rather than a same-run one like AA's, and it deserves less weight for that reason.

A third independent signal cuts the other way. Researcher Elliot Arledge ran K2.7 Code on KernelBench-Hard, a public GPU kernel optimization benchmark, against K2.6. The MoE kernel result regressed from K2.6's 0.222 to 0.157, and two of its kernels died on its own bugs before the 45-minute clock ran out. But his read adds a nuance worth carrying: on five of six problems, K2.7 Code wrote real Triton kernels where K2.6 had leaned on library wrappers. His summary — K2.7 is more honest but not more capable — is a sharper description of this model than anything in the launch materials.

Two claims, three verdicts

Put all three evidence classes in one place and the picture resolves. To our knowledge this table does not exist anywhere else — the published coverage of this model has exactly one of these columns, never all three.

Vendor figures from Moonshot's model card. Independent figures from Artificial Analysis (read 7/17/2026), DeepSWE (7/16/2026 board; K2.6 figure from DeepSWE's launch post), Vals AI (7/14/2026) and Elliot Arledge's public KernelBench-Hard run. First-party from our nine-task executed benchmark, July 2026.

The verdict splits three ways, not two. Moonshot's efficiency story holds up under independent scrutiny and then some. Its improves on K2.6 story holds on the one independent benchmark that measures what this model was specialized for — agentic coding, 24% to 31% on DeepSWE — and fails on the broader general-capability index, 44 down to 42. K2.7 Code is a leaner specialist: better at the narrow thing, slightly worse at everything else, and much cheaper to run either way.

That is not a scandal — it is what specialization looks like when a vendor is honest enough to publish a table its own model mostly loses. A coding model that thinks 41% less and gets better at coding while shedding a little general capability is a legitimately useful thing to ship. It is just not the uncomplicated across-the-board upgrade the launch implied.

Our own executed test

We ran K2.7 Code alongside 12 other models on nine coding tasks where every answer is executed against hidden tests — generate the code, run it, score pass or fail. No self-reported anything. Full method: how we test.

Our contribution to the token-efficiency question is a different axis from Artificial Analysis's. AA compared K2.7 Code against itself, one generation back. We compared it against the field:

At 272 reasoning tokens per task, K2.7 Code is the second-leanest of the nine models that reason at all — behind only GPT-5.5 (176) and running at roughly 37% of DeepSeek V4-Pro's 732. This is a cross-vendor result, and it corroborates AA's within-family result from a completely different angle: the leanness shows up against its own predecessor and against the rest of the field.

What a correct answer actually costs

This is the axis no independent source publishes, and it is the one that decides real deployments. Ten of our 13 models scored a perfect 9/9. Correctness is table stakes on standard coding tasks. What separates them is an 88x cost spread for identical output.

Selected rows from our 13-model run, July 2026. Cost = real measured token usage x list price, extrapolated to 1,000 tasks. Full field and the three models that scored below 9/9 — DeepSeek V4-Pro, Grok 4.3 and StepFun 3.7 Flash, all at 8/9: the complete coding cost benchmark.

Kimi K2.7 Code lands at $1.34 per 1,000 tasks — mid-pack. It sits between Nemotron 3 Ultra ($1.07) and Claude Sonnet 5 ($1.67), costs about a third of Claude Opus 4.8 ($4.05) and roughly a sixth of GPT-5.5 ($8.83) for the identical 9/9. It is also about 13x more expensive than Qwen3 Coder Next, which scored the same 9/9 at $0.10.

The latency figure needs the same discipline. Our 10.4s per task is host-dependent, not a property of the model. Artificial Analysis measures 46.8 tokens/sec on Kimi's own API — #51 of 97, and low for open-weight models of its size — while third-party hosts do better. If you benchmark this model on a fast host and get a very different number, that is expected. Pick the host, then measure.

The gap that remains

One thing genuinely is still missing: SWE-bench Verified. Moonshot did not publish one, and the model is absent from the Vals AI SWE-bench Verified leaderboard as of its 7/14/2026 update — five weeks post-release. For reference, that board currently reads: Claude Fable 5 95.00%, Claude Opus 4.8 88.60%, Grok 4.5 86.60%, GPT-5.5 82.60%, Claude Opus 4.7 82.00%, Gemini 3.5 Flash 78.80%. No Kimi entry.

So the honest framing of the gap is narrow, not sweeping. It is not true that nobody has independently tested this model — Artificial Analysis has, across nine public evals including GPQA Diamond and Terminal-Bench v2.1, and DeepSWE has it on its board at 31%. It is true that the single most-cited agentic coding benchmark still has no entry for it. Expect that to change; a K2.7 Code SWE-bench Verified result could land any week and date this section.

Operational constraints worth knowing

Before you wire this into anything, four things in Moonshot's docs will surprise you:

• Thinking mode cannot be disabled. The API throws an error if you try. You are paying for reasoning tokens on every single call, including trivial ones — which is precisely why the 272-tokens-per-task leanness matters commercially rather than academically.
• Temperature is fixed at 1.0, top_p at 0.95, and n at 1. Any other value errors. If your pipeline relies on temperature 0 for reproducibility, or on n > 1 for sampling, it will not port over unchanged.
• Max output is 32,768 tokens, not the 262,144 context window. Budget your generations accordingly.
• Benchmark conditions were not apples-to-apples. Moonshot ran K2.7 Code through its own Kimi Code CLI at temp 1.0 / top_p 0.95 / 262,144 context, while GPT-5.5 ran in Codex xhigh and Opus 4.8 in Claude Code xhigh. Different harnesses, different scaffolds. Another reason to treat that six-row table as directional.

Who should actually use it

A decision rule, given everything above:

• Use K2.7 Code if you need its specific bundle: 256K context, Modified MIT open weights you can self-host, image input, and lean reasoning that keeps long agentic loops from compounding into a large bill. On a repeated-context agent, Moonshot's cache-hit rate ($0.19/M) makes this genuinely cheap — see the pricing breakdown.
• Move from K2.6 for cost and for agentic coding — not for general capability. The independent evidence is split: DeepSWE improved 24% → 31%, while AA's general Intelligence Index slipped 44 → 42 and KernelBench-Hard's MoE kernel regressed. If your workload is general reasoning rather than long coding loops, this is not an upgrade.
• Do not use it for cheap standard coding. Cheaper models hit the same 9/9. Qwen3 Coder Next did it at $0.10 to K2.7's $1.34.
• Do not use it for hard frontier work. Moonshot's own table has GPT-5.5 beating it in all six rows and Opus 4.8 in five of six, and DeepSWE puts it 13th of 15 at 31% against GPT-5.6-sol's 73%.
• Compare it against its actual peers — the open-weights field, not the frontier. See Kimi vs DeepSeek and the best open-source LLMs of 2026. For how the K2 family's reasoning behaves generally, see Kimi K2 Thinking.

The broader lesson generalizes past this model. When a vendor gives you a generational-improvement claim and an efficiency claim in the same launch post, they are not equally checkable and they do not have to be equally true — and the improvement claim is rarely true uniformly. Here the efficiency claim survived independent scrutiny and got better; the improvement claim turned out to be true on the narrow axis the model was specialized for and false on the broad one. The only way to know which is which is to look for someone who ran both models on the same harness — and, where nobody has, to run it yourself.

FAQ