Moonshot AI Unveils Kimi K2.7-Code: A Leap Forward with +21.8% Boost on Kimi Code Bench v2 Over K2.6

Moonshot AI launched Kimi K2.7-Code this week. It’s a specialized coding and agentic model. The model weights are available on Hugging Face under a Modified MIT license. You can also access it via the Kimi API and Kimi Code.

K2.7-Code is built for complex, long-running software engineering tasks rather than casual conversation. It can plan, make edits, execute tools, and debug through multiple steps. Moonshot has paired the model with a subscription-based coding platform.

Kimi K2.7-Code

K2.7-Code uses a Mixture-of-Experts architecture. It has 1 trillion total parameters but only activates 32 billion per token. The setup includes 384 experts, with 8 chosen per token plus 1 shared expert. It features 61 layers, one of which is a dense layer.

The attention mechanism uses MLA, and the feed-forward network relies on SwiGLU. A MoonViT vision encoder contributes an additional 400 million parameters for handling image and video inputs. The model comes with built-in INT4 quantization. Its context window supports 256K tokens (262,144).

Two important limitations to note: Thinking mode is always required — turning it off triggers an API error. Sampling settings are locked at temperature 1.0, top_p 0.95, n 1, and penalties 0.0. The default maximum output length is 32,768 tokens.

You can self-host the model using vLLM, SGLang, or KTransformers. The Hugging Face repository is substantial, taking up around 595 GB of disk space. This is designed for server-grade deployments, not for running on a laptop.

Benchmark

The Moonshot team shared results across six benchmarks. They compared K2.7-Code with K2.6, GPT-5.5, and Claude Opus 4.8. K2.7-Code outperforms K2.6 on every metric. The biggest improvement in coding is on Kimi Code Bench v2, jumping from 50.9 to 62.0.

K2.7-Code does edge out Opus 4.8 on MCP Mark Verified, scoring 81.1 compared to 76.4. It also comes close to GPT-5.5 on MLS Bench Lite. K2.7-Code was tested in Kimi Code CLI, GPT-5.5 in Codex xhigh, and Opus 4.8 in Claude Code xhigh.

Reasoning-Token Efficiency: A Cost Claim, Not Just Quality

The Moonshot team claims roughly 30% fewer reasoning tokens are used compared to K2.6. They describe this as “less overthinking.”

Reasoning tokens are billed as output tokens on most pricing plans. Agentic coding workflows involve hundreds or thousands of steps. Every plan, retry, and verification incurs the thinking cost again. A 30% reduction adds up significantly over a long session.

This improvement shows up in three ways simultaneously. First, reduced output-token cost per task. Second, quicker steps, which improves the experience in interactive CLI sessions. Third, more steps can fit within the context window before hitting limits.

Use Cases With Examples

• Large-scale repository refactors are the primary use case. Direct the agent at a failing test suite. It reads through files, makes changes across multiple modules, and re-runs tests until they all pass.
• Code reviews are another strong fit. Provide a pull request diff and request a risk analysis. The 256K context window can accommodate large diffs, logs, and related files all at once.
• MCP tool-use workflows are a third good match. K2.7-Code scored 81.1 on MCP Mark Verified. That benchmark evaluates correct tool calls through the Model Context Protocol. Examples include CI checks, ticket updates, and file edits all within a single loop.
• Long-context analysis is a fourth use case. The model handles text, image, and video inputs. Documentation, screenshots, and a recorded reproduction can all be included in one prompt.

Marktechpost’s Interactive Explorer

A Minimal Quickstart

The Kimi API is compatible with the OpenAI SDK. The model identifier is kimi-k2.7-code. Don’t try to override the fixed sampling parameters, or the request will fail.

import os
from openai import OpenAI

# Base URL and key per the Kimi API docs at platform.moonshot.ai
client = OpenAI(
    api_key=os.environ.get("MOONSHOT_API_KEY"),
    base_url="
)

messages = [
    {"role": "system", "content": "You are a coding agent."},
    {"role": "user", "content": "Refactor utils.py to remove duplicate code."},
]

resp = client.chat.completions.create(
    model="kimi-k2.7-code",
    messages=messages,
    max_tokens=32768,  # default cap; also the maximum
    # thinking is enabled by default and cannot be disabled.
    # temperature (1.0), top_p (0.95), n (1), and penalties (0.0) are
    # fixed server-side. Passing any other value returns an error.
)

msg = resp.choices[0].message
print(msg.content)

# Multi-step tool calls: append the full assistant message so that
# reasoning_content is preserved. Dropping it errors on the next turn.
# messages.append(msg.model_dump())

Two tool-use guidelines come from the documentation. Retain reasoning_content from the current turn within the conversation context. And set