What is Kimi K2.7 Code? Moonshot AI's coding model, explained

Where Kimi K2.7 Code sits in Moonshot's lineup

Moonshot AI is the lab behind the Kimi model family, positioned with the tagline "seeking the optimal conversion from energy to intelligence." It ships a free consumer chat app and a metered developer API, and it has been shipping open weights alongside that API rather than treating openness as an afterthought. Kimi K2.7 Code is the latest release in that line, built directly on top of Kimi K2.6, Moonshot's prior flagship.

The naming is a deliberate narrowing, not a rebrand. Moonshot has been explicit that K2.6 remains the better choice for general conversation, and K2.7 Code is scoped specifically to long-horizon software engineering: planning a change, editing across many files, running tools, checking the result, and looping back when something breaks. That's a materially different job than answering a question in one pass, and it's the same distinction that separates a chatbot from an AI agent loop more generally, one response versus a chain of steps that can recover from its own mistakes.

It comes in two flavors that share the same weights: kimi-k2.7-code, the standard model, and kimi-k2.7-code-highspeed, tuned for roughly 180 tokens/second (up to 260 tok/s on short contexts) at exactly double the price on every tier. Both keep the full 256K-token context window.

Inside the model: why a 1 trillion-parameter model doesn't cost like one

The headline spec looks intimidating: 1 trillion total parameters. But Kimi K2.7 Code is a Mixture-of-Experts (MoE) model, which means it never actually runs all of itself at once. Every token gets routed to a small subset of 384 available "experts", specifically 8 selected per token plus 1 shared expert, and only that subset does the work. The result is 32 billion activated parameters per token, roughly 3% of the total, which is the entire reason a trillion-parameter model can run at $4.00 per 1M output tokens instead of at prices reserved for models that size used to demand.

The rest of the architecture: 61 layers, Multi-head Latent Attention, SwiGLU activation, native INT4 quantization, is inherited wholesale from K2.6, which is why Moonshot's own model card says "the deployment method can be directly reused." It also carries a 400M-parameter MoonViT vision encoder, so the model reads images and, experimentally through the official API, video alongside text and code. A pull request diff, a screenshot of a broken UI, and a recorded bug repro can all sit in the same 256K-token prompt.

The one setting you can't change: thinking is mandatory

Here's the design decision that shapes everything about using this model: Kimi K2.7 Code will not let you disable its thinking mode. The thinking API parameter defaults to {"type": "enabled"}, and setting it to anything else returns an error. Temperature is locked at 1.0, top_p at 0.95, and both penalty parameters at 0.0, again, overriding any of them errors rather than silently ignoring the value.

Moonshot's own quickstart docs frame this as deliberate: forcing preserve_thinking=True retains the model's full reasoning content across turns, which the company says "enhances performance in coding agent scenarios." The tradeoff is control. Most competing coding models let you dial reasoning depth up for a hard problem and down for a trivial one; Kimi K2.7 Code doesn't give you that lever. Every request pays the full thinking cost, whether the task is a one-line fix or a repo-wide refactor.

That constraint extends into tool use. The official quickstart requires that reasoning_content from the model's prior tool-call turn stay in context through a multi-step loop, or the API throws an error, and tool_choice only accepts auto or none. It's the same Model Context Protocol-style tool-calling pattern most agentic coding tools now use, just with less room to improvise around it.

What actually changed versus K2.6

Moonshot published six benchmark comparisons against K2.6, GPT-5.5, and Claude Opus 4.8, each run in its own agent harness (Kimi Code CLI, Codex xhigh, and Claude Code xhigh respectively).

Two things stand out. K2.7 Code improves on K2.6 across every single row, which is a cleaner story than most point releases manage. And it has exactly one outright win against the frontier field: 81.1 on MCP Mark Verified, beating Claude Opus 4.8's 76.4, a benchmark that specifically tests correct tool invocation through MCP across Notion, GitHub, filesystem, Postgres, and Playwright environments. Everywhere else, GPT-5.5 and Opus 4.8 lead, sometimes by a wide margin.

The other headline claim is efficiency, not capability: Moonshot reports roughly 30% fewer reasoning tokens than K2.6 on average, framed internally as "less overthinking." The logic is real: reasoning tokens bill as output tokens, an agentic run can chain hundreds of steps, and a cut that compounds across that many steps should show up as a real bill reduction. Whether it actually does once real accounts start spending against it is a genuinely contested question in the community right now, worth its own read in the full Kimi K2.7 Code review rather than a paragraph here.

Getting it: API pricing and self-hosting

Moonshot's official rate card, direct from the model pricing page:

For comparison, Claude Opus 4.8 runs $5.00/$25.00 per 1M input/output tokens with a 1M-token context window, closed-weight. That gap is the whole commercial pitch for K2.7 Code: cheaper by a wide margin, at the cost of trailing on raw benchmark quality.

There's no free API tier; access opens once you've cumulatively recharged $1 (Tier0: 3 requests/minute, 500K tokens/minute). Rate limits scale with cumulative spend up to Tier5 at $3,000 recharged (1,000 concurrency, 10,000 RPM). Third-party hosts on OpenRouter like DeepInfra undercut Moonshot's own rate by 20-25% on input tokens, though generally at lower throughput and uptime than Moonshot's own endpoint.

The other path is self-hosting, since the weights are genuinely open under that Modified MIT License, not an API-gated "open" label. Full BF16 precision runs to roughly 610GB, server-class hardware, not a laptop job. Community quantization changes that math: Unsloth's Dynamic 2-bit quant shrinks the model to around 325GB, a 48% reduction, running at 40+ tokens/second on a well-specced workstation rig. Twenty-four community-quantized variants are already listed on Hugging Face, compatible with vLLM, llama.cpp, LM Studio, Jan, and Ollama.

What early users are actually saying

The reaction split fast along a predictable line. On the positive side, one r/AI_Agents thread put it well:

"Kimi K2.7 Code does not feel like a giant leap in a flashy way. It feels like a better default for long coding jobs that need to keep going..."

Kimi K2.7 Code feels more useful than flashy, r/AI_Agents

A commenter on r/LLMDevs framed the bigger-picture read: "K2.7 Code feels like another signal that open coding models are moving from leaderboard toys into workflow economics." That's a fair way to read the MCP Mark Verified win and the price gap together, this isn't the smartest model in the field, but it's a real, usable one at a fraction of the cost.

The friction is specific and recurring rather than the usual "it's not as smart as Claude" grumbling: a wave of threads report token and credit consumption that runs opposite to Moonshot's own -30% efficiency claim, alongside some hallucination complaints against the K2.6 baseline. Since the weights are open, r/LocalLLaMA commenters have also pushed back on trusting Moonshot's self-reported bar charts at all: "Just download and run whatever benchmark you want." That's a genuinely different kind of scrutiny than a closed model ever gets, and it's healthy. The full breakdown of that efficiency-claim gap, with the specific threads and numbers, is in the Kimi K2.7 Code review.

Where it fits if you're choosing a coding model

If you're actively comparing options rather than just trying to understand this one release, the field around Kimi K2.7 Code splits into three lanes. Closed frontier models, GPT-5.5 and Claude Opus 4.8, lead on raw benchmark quality on most of Moonshot's own six comparisons, at several times the price. Open-weight peers like Qwen3-Coder sit in the same self-hostable, budget-friendly category as K2.7 Code, without a head-to-head benchmark against it in Moonshot's own numbers. And the agent-harness layer on top, Claude Code, OpenAI Codex, or Cursor, is a separate decision from which underlying model powers it; K2.7 Code is already documented to run inside several of these via agent-support configs. Our Kimi K2.7 Code alternatives roundup lines up eight of these options against each other on price and benchmarks if that's the decision you're actually trying to make.

Try eesel

I build eesel's AI teammates, and the sparse-activation idea underneath Kimi K2.7 Code, routing to only the part of the system a specific task actually needs, is the same principle behind how a well-built support agent should behave. eesel doesn't re-read your entire knowledge base and reason from zero on every ticket; it learns your solved tickets and docs on day one, then routes each new conversation to the specific context and tool calls that ticket actually requires, a refund lookup, an order status check, an escalation rule, not a fresh general-purpose reasoning pass every time.

That's also why we never ship a resolution number we haven't simulated against a customer's own historical tickets first, the same discipline this whole model-release cycle keeps proving out: a vendor's benchmark and your actual account rarely match perfectly on the first try, whether the vendor is Moonshot or us. eesel connects to Zendesk, Freshdesk, HubSpot, and 100+ other tools, bills per resolved ticket at $0.40 rather than per seat, and you can try eesel free with $50 of usage before committing a budget to it.