TL;DR Kimi K2.7 Code is Moonshot AI’s open coding model built for agentic software engineering. It improves on K2.6 across published coding and agentic benchmarks, uses roughly 30% fewer thinking tokens, keeps the same 256K context window, and is priced far below frontier models like GPT-5.5 and Claude Opus 4.8. The trade-off: it’s not a general-purpose model. Use it for coding workflows, and stick with K2.6 for writing, analysis, and non-coding tasks.

Most model upgrades trade cost for performance. You get better outputs, and you pay more to get them. Kimi K2.7 Code does the opposite. It scores higher than Kimi K2.6 on every published benchmark while using roughly 30% fewer thinking tokens to get there.

For developers running it through an API, that's not a minor footnote. Fewer output tokens at the same sticker price means a lower effective cost per completed task.

Kimi K2.7 Code is Moonshot AI's latest open-weight release, and it's built specifically for coding. This post covers what's new, what the benchmarks actually show, how the pricing works, and when it makes sense to switch from K2.6.

Building with K2.7 Code? Convert the model’s responses into interactive UI components with OpenUI Cloud, no frontend rebuild required.

Build Your AI Agent With Kimi K2.7

What is Kimi K2.7 Code?

Kimi K2.7 Code is a coding-focused, open-source AI model built by Moonshot AI, the Beijing-based company behind kimi.com. It's not a general-purpose upgrade to K2.6. Moonshot AI is explicit about this: use K2.7 Code for coding tasks, and use K2.6 for writing, analysis, and general-purpose work.

A few key things to know upfront:

Always-on thinking mode. K2.7 Code has no non-thinking mode. If you disable thinking in the Kimi Code product, it automatically falls back to K2.6.
Open weights. The model is available on HuggingFace at moonshotai/Kimi-K2.7-Code under a Modified MIT license.
Agentic by design. It's built for multi-step coding workflows, reading repos, editing files, running tools, debugging across sessions, not single-turn completions.

Architecture

Spec	Detail
Total parameters	1 trillion (MoE)
Active parameters per token	32B
Context window	262,144 tokens (256K)
Attention mechanism	Multi-head Latent Attention (MLA)
Vision encoder	MoonViT (400M params)
Input modalities	Text, image, video
Weights	HuggingFace: `moonshotai/Kimi-K2.7-Code`

The architecture carries forward the K2 family's Mixture-of-Experts design: a trillion parameters total, but only 32B activate per token, which keeps inference costs lower than the headline size suggests. The 256K context window makes it practical for long agentic sessions with large codebases.

Kimi K2.7 Code Benchmarks

Here's the full performance data Moonshot AI published at launch.

Coding Benchmarks

Benchmark	K2.6	K2.7 Code	GPT-5.5	Claude Opus 4.8
Kimi Code Bench v2	50.9	62.0 (+21.8%)	69.0	67.4
Program Bench	48.3	53.6 (+11.0%)	69.1	63.8
MLS Bench Lite	26.7	35.1 (+31.5%)	35.5	42.8

Agentic Benchmarks

Benchmark	K2.6	K2.7 Code	GPT-5.5	Claude Opus 4.8
Kimi Claw 24/7 Bench	42.9	46.9	52.8	50.4
MCP Atlas	69.4	76.0	79.4	81.3
MCP Mark Verified	72.8	81.1	92.9	76.4

What the numbers show: K2.7 Code improves meaningfully over K2.6 across every metric. On MLS Bench Lite, it's up 31.5%. On Kimi Code Bench v2, it's up 21.8%.

What the numbers don't show: K2.7 Code still trails GPT-5.5 and Claude Opus 4.8 on most benchmarks. The story here isn't that it beats the frontier — it closes the gap substantially while using fewer tokens to do it.

One important caveat: Kimi Code Bench v2 and Kimi Claw 24/7 Bench are in-house benchmarks created by Moonshot AI. In-house benchmarks should always be read alongside independent third-party evaluations.

The Real Story: Thinking Token Efficiency

Reasoning models have a well-documented problem with overthinking. They'll burn thousands of tokens working through problems that don't require extended reasoning, and those tokens show up on your invoice.

K2.7 Code cuts thinking-token usage by approximately 30% compared to K2.6, while posting higher scores across every benchmark. That combination is what makes this release interesting.

Here's why it matters specifically for agentic coding workflows:

Lower cost per completed task. On K2.7 Code, output tokens (where most of the API cost lives at $4.00/M) are generated more economically. You're not paying for reasoning steps that don't contribute to the output.
More headroom in long sessions. A 256K context window fills up faster when the model is verbose in its reasoning chain. Shorter thinking sequences mean more room for actual code, test output, and tool responses.
Faster interactive responses. In sessions where you're iterating on a file or debugging incrementally, thinking latency compounds. Trimmer reasoning means quicker turns.
Better behavior in multi-step agents. When K2.7 Code is one node in a larger agentic pipeline, token efficiency at each step affects the total runtime and cost of the full workflow. A 30% reduction in thinking tokens, repeated across many steps, compounds noticeably.

This doesn't mean K2.7 Code thinks less carefully. The benchmark improvements suggest the opposite: it reaches better answers through tighter reasoning. The 30% figure is Moonshot's, measured on their workloads, so you'll want to run your own traffic through both models and compare output-token totals before drawing conclusions about your specific use case.

Kimi K2.6 vs Kimi K2.7 Code: What Actually Changed

K2.6, Kimi's previous open-source release, was a general-purpose model with strong coding capabilities. K2.7 Code is a focused fork — Moonshot AI explicitly recommends K2.6 for anything outside of coding.

Spec	K2.6	K2.7 Code
Primary use case	General-purpose (coding, writing, analysis)	Coding and agentic tasks only
Thinking mode	Thinking and non-thinking modes	Thinking always on (no non-thinking mode)
Context window	256K	256K
Architecture	MoE, 1T params, 32B active	Same
Multimodal input	Text, image, video	Text, image, video
Open source	Yes	Yes

The biggest gains in K2.7 Code show up on long-horizon tasks: multi-file changes, refactoring across an extended session, debugging that requires holding a lot of context. That's also where the thinking-token efficiency advantage compounds most visibly.

If your workflow includes a mix of coding and general tasks, you'd likely run both models, K2.7 Code for the engineering layer and K2.6 for everything else.

Kimi K2.7 Code: Pricing

There are two ways to access K2.7 Code: through a Kimi Code subscription or directly via the Moonshot API.

Kimi Code Subscription Plans

Plan	Price (monthly billing)
Moderato	~$19/month
Allegretto	~$39/month
Allegro	~$99/month
Vivace	~$199/month

Plans are quota-based. Kimi Code quota refreshes weekly, not monthly, and unused quota doesn't carry over. The Kimi Code quota is separate from the general membership quota pool.

Kimi API (Per-Token)

Token type	Price per million tokens
Input (cache miss)	$0.95
Input (cache hit)	$0.19
Output	$4.00
Context window	262,144 tokens

The cache hit price of $0.19 per million input tokens is worth calling out for teams running high-volume agent workflows. When your agent repeatedly sends the same system prompt or large context block, the effective input cost drops sharply. For long sessions with stable context, you're paying a fraction of the headline input rate.

The output price at $4.00/M is where most of the cost lives on a reasoning model, and it's where K2.7 Code's thinking-token efficiency makes a real difference over K2.6.

API Pricing Comparison

Model	Input (per 1M tokens)	Output (per 1M tokens)
Kimi K2.7 Code	$0.95	$4.00
Claude Opus 4.8	$5.00	$25.00
GPT-5.5	$5.00	$30.00

K2.7 Code's API pricing is competitive against the proprietary frontier models, particularly once prompt caching is factored in. The trade-off is scope: it's explicitly a coding model, not a general-purpose one.

How to Access Kimi K2.7 Code

You have three options:

Kimi Code product (subscription). Access K2.7 Code through the Kimi Code CLI or VS Code extension on a paid Kimi membership tier.
Moonshot API. Call the model via kimi-k2.7-code on platform.kimi.ai. The API is OpenAI-compatible, so swapping in K2.7 Code from K2.6 is a one-line model ID change in most existing workflows.
Self-host. Download the weights from HuggingFace (moonshotai/Kimi-K2.7-Code) and serve with vLLM, SGLang, or KTransformers. Given the 1T parameter size, you'll need substantial hardware. The weights are free to download under the Modified MIT license.

OpenUI Cloud and K2.7 Code

Teams building AI agents with K2.7 Code can use OpenUI Cloud to convert model responses into interactive UI components without rebuilding their frontend. See how it fits into your stack.

Explore OpenUI Cloud Today

FAQs: Kimi K2.7 Code

What is Kimi K2.7 Code?

Kimi K2.7 Code is an open-source, coding-focused AI model from Moonshot AI. It's a specialised fork of Kimi K2.6 built for agentic software engineering tasks, with a 256K context window and always-on thinking mode. It uses approximately 30% fewer thinking tokens than K2.6 while scoring higher on Moonshot's coding benchmarks.

What's the difference between Kimi K2.7 Code and K2.6?

K2.6 is a general-purpose model with strong coding capabilities. K2.7 Code is a specialised coding fork. Moonshot AI recommends using K2.6 for writing, analysis, and non-coding tasks, and K2.7 Code for software engineering and agentic coding workflows. K2.7 Code has no non-thinking mode, while K2.6 supports both thinking and non-thinking modes.

Does Kimi K2.7 Code support image input?

Yes. K2.7 Code includes the MoonViT vision encoder with 400M parameters and supports text, image, and video input.

Is thinking mode required in Kimi K2.7 Code?

Yes. Thinking mode is always on in K2.7 Code. If you attempt to disable it within the Kimi Code product, the system falls back to K2.6 automatically.

What is the context window for Kimi K2.7 Code?

Kimi K2.7 Code has a context window of 262,144 tokens, commonly referred to as 256K.

How much does Kimi K2.7 Code cost via API?

Input tokens cost $0.95 per million for cache miss or $0.19 per million for cache hit. Output tokens cost $4.00 per million. Verify current pricing at platform.kimi.ai/docs/pricing/chat-k27-code before committing a budget, as promotional pricing is common.

Is Kimi K2.7 Code open source?

Yes. The weights are available on HuggingFace at moonshotai/Kimi-K2.7-Code under a Modified MIT license. You can self-host with vLLM, SGLang, or KTransformers.

Related articles

May 2026 Security Incident

Why We're Open Sourcing OpenUI

AI Copilots: A Complete Guide to Intelligent Assistance

What Are AI Agents: Types, Capabilities, and Real-World Use

ChatKit: What It Is, What It Isn’t, and Where C1 Fits In

PowerPoint Automation Reimagined with C1 Artifacts API

The Future of AI Interfaces is Generative

MCP UI: Making AI Apps Interactive

What Is AG-UI and Why It Matters for AI-Native User Interfaces

How to design AI-Native Conversational Interfaces : From Templates to Generative UI

GPT 5 vs. GPT 4.1

How to Build Generative UI Applications

Implementing Generative Analytics with Thesys and MCP

Evolution of Analytics: From Static Dashboards to Generative UI

Why Generating Code for Generative UI is a bad idea

Building the First Generative UI API: Technical Architecture and Design Decisions Behind C1

How we evaluate LLMs for Generative UI

Generative UI vs Prompt to UI vs Prompt to Design

Generative UI: What It Is and Why It Matters