Moonshot AI's Kimi K2.7 Code Hits 260 Tokens per Second on Agentic Coding

Moonshot AI just gave its flagship open-source coding model a serious shot of espresso. Kimi K2.7 Code, released on June 12, 2026, was already turning heads as a 1-trillion-parameter coding specialist. Three days later, Moonshot dropped a HighSpeed variant that pushes throughput to around 180 tokens per second on typical coding tasks, and up to 260 tokens per second on shorter inputs. That is roughly six times faster than the standard release, and it changes the economics of running large agentic coding pipelines in a meaningful way.

The model underneath the speed

K2.7 Code uses a Mixture-of-Experts (MoE) architecture with 1 trillion total parameters and 32 billion active parameters per token, available on Hugging Face under a Modified MIT License that permits commercial use with attribution. MoE is worth unpacking: instead of one massive dense network, the model is divided into 384 specialized sub-networks called "experts." For each token, a learned router picks a small subset to activate. Only a small fraction of the parameters are engaged for any given token, so you get the knowledge capacity of a trillion-parameter model with the per-token compute closer to a 32 billion parameter dense model.

The model supports a 256K context length and uses Multi-head Latent Attention (MLA). MLA, originally developed by DeepSeek, compresses the key-value cache (the memory structure that grows with conversation length) through learned projections. The MLA attention mechanism compresses the key-value cache using learned latent projections, which means you can actually fit that 256K context window in memory without needing an absurd amount of VRAM. That 256K window is large enough to hold multiple source files, their tests, configuration, and a long back-and-forth conversation all at once.

Kimi K2.7 Code uses a natively multimodal architecture that supports text, image, and video input, in addition to its coding and agentic capabilities. The vision side is handled by a 400M-parameter MoonViT encoder, handling image and video input in the same pipeline as text. In practice, this means you can drop a screenshot of a UI mockup or a recorded bug repro directly into the prompt and get back working code.

What actually changed from K2.6

Moonshot AI shipped Kimi K2.7-Code on June 12, 2026, a coding-focused successor to Kimi K2.6 that keeps the same 1T-parameter MoE architecture but retrains the reward model and data pipeline around real-world long-horizon software tasks. This is a post-training story, not an architecture story. Moonshot has been explicit about this: K2.7 Code is designed for long-horizon software engineering tasks, and for general use, K2.6 remains the recommended model in the family.

The headline efficiency gain is a 30% reduction in reasoning tokens compared to K2.6. Reasoning tokens are the internal "thinking" steps the model generates before producing its final answer. It reaches that higher performance while spending roughly 30% fewer "thinking" tokens than K2.6. In a world where autonomous coding runs can burn millions of output tokens, a 30% reduction in reasoning overhead is not a footnote -- it is a direct line item on the bill.

One hard constraint to know upfront: Kimi K2.7 Code does not support non-thinking mode and always runs with thinking enabled. Every request pays the reasoning cost. There is no fast, non-thinking path.

The benchmark picture, honestly

Moonshot's published numbers are directionally exciting. The numbers Moonshot published are: plus 21.8 percent on their Kimi Code Bench v2, plus 11.0 percent on Program Bench, plus 31.5 percent on MLS Bench Lite, and approximately 30 percent lower reasoning-token consumption than K2.6. On the competitive side, on Kimi Code Bench v2, K2.7 Code scores 62.0 versus GPT-5.5's 69.0 and Claude Opus 4.8's 67.4. On MLS Bench Lite (multi-language), K2.7 scores 35.1 -- nearly matching GPT-5.5 at 35.5.

The honest caveat: every single one of those numbers comes from Moonshot's own benchmark suites, not from SWE-bench Verified, SWE-bench Pro, Terminal-Bench 2.0, or any independent leaderboard. That is a real gap. Until third-party evals land, treat these numbers as directional signals, not verified facts. Run the model on your own codebase before making infrastructure decisions.

Where the model does have a credible third-party signal: K2.7-Code scored 81.1 on MCP Mark Verified, a suite that tests correct tool invocation through the Model Context Protocol. MCP (Model Context Protocol) is the emerging standard for connecting AI models to external tools like CI systems, file editors, and ticket trackers. An 81.1 on a verified MCP benchmark is a meaningful data point for teams building tool-heavy agents.

Where it shines, where it falls short

K2.7 Code is purpose-built for a specific class of tasks:

• Long-horizon software engineering -- multi-file refactors, complex debugging sessions, end-to-end feature implementation across many turns
• Agentic tool-use workflows -- CI checks, ticket updates, file edits chained in a single loop via MCP
• Multimodal coding inputs -- feeding wireframes, screenshots, or recorded bug repros directly into the coding prompt
• Large codebase analysis -- the 256K context window fits substantial repository slices in a single prompt

Where it is not the right pick: if you use K2.6 for general-purpose tasks, multimodal work, or agent swarms, keep K2.6 for those -- K2.7 is a coding specialist. The always-on thinking mode also means it is not the right model for latency-sensitive, short-turn interactions where you want an instant response.

Getting access and what it costs

There are three ways in:

1. Kimi Code Beta -- the terminal-first CLI agent, starting at $19 per month. The HighSpeed mode is rolling out to Beta Program members first. No invite is needed; joining the Beta Program gives you a chance at access.
2. Kimi API -- available on Moonshot's Kimi API at $0.95 per million input tokens and $4.00 per million output tokens. The API identifier is kimi-k2.7-code for standard and kimi-k2.7-code-highspeed for the fast variant. The API is fully compatible with the OpenAI SDK.
3. Self-hosted -- the weights are on HuggingFace under a Modified MIT license, accessible via Moonshot's API, and self-hostable with vLLM, SGLang, or KTransformers. For self-hosting at INT4 quantization, hardware requirements are 8x H200 GPUs (verified), or equivalent aggregate VRAM (~640 GB).

Calling the model via the Kimi API is a drop-in replacement for any OpenAI-compatible setup:

from openai import OpenAI
import os
client = OpenAI(
    api_key=os.environ["MOONSHOT_API_KEY"],
    base_url="https://api.moonshot.ai/v1"
)
response = client.chat.completions.create(
    model="kimi-k2.7-code-highspeed",
    messages=[
        {"role": "user", "content": "Refactor this function to use async/await..."}
    ]
)
print(response.choices[0].message.content)

The bigger picture: speed as the real unlock

K2.7-Code is the fifth major model release in the Kimi series since July 2025, when Moonshot shipped the original K2 base model. The pace is striking. And the HighSpeed variant signals something important about where the competitive pressure is heading: raw capability is table stakes now. The next frontier is throughput for agentic pipelines.

For teams running automated agentic workflows that batch large numbers of tasks, the speed gain matters as much as the price-per-token figure. At 180 tokens per second, a coding agent that previously took 10 minutes to complete a multi-step task now finishes in under 2 minutes. At scale, that is the difference between a workflow that runs overnight and one that runs in a lunch break.

The timing is notable: US export restrictions have blocked international access to Claude Fable 5, and K2.7-Code is already drawing comparisons to Fable-level performance in developer agent tests. The community reception from developers running real agent workloads is consistently positive, and the pricing and license make it accessible for both API and self-hosted deployments. Whether the independent benchmarks, when they arrive, confirm that story is the open question worth watching.