Moonshot AI's Kimi K2.7 Code HighSpeed Hits 260 Tokens per Second

Kimi Code, Moonshot AI's terminal-first coding agent, just graduated its fastest inference mode out of beta. K2.7 Code HighSpeed is now generally available to all Allegretto and higher-tier subscribers, no beta program application required. After three weeks of limited access, the gates are open.

Same model, different gear

HighSpeed and standard Kimi K2.7 Code are the same underlying model with the same outputs and the same 262,144-token context window. HighSpeed trades a higher per-token price for lower latency and higher throughput. Think of it as a serving-infrastructure upgrade rather than a new model.

K2.7 Code HighSpeed delivers an output speed of approximately 180 tokens/s on coding tasks with median-length inputs, and up to 260 tokens/s in short-context scenarios. That makes it roughly 6x faster than the standard tier.

What K2.7 Code actually is

K2.7 uses a Mixture-of-Experts (MoE) architecture with 1 trillion total parameters and 32 billion active per token -- the same skeleton as K2.5 and K2.6, but with substantial optimizations focused on coding, agentic tool use, and token efficiency. MoE means the model routes each token through a small subset of specialist sub-networks rather than activating everything at once, keeping inference costs manageable despite the trillion-parameter scale.

External benchmark evaluations show that Kimi K2.7 Code significantly improves instruction compliance and long-horizon coding performance compared to K2.6, while reducing overthinking tendencies by 30% on average. Reducing overthinking means the model spends fewer tokens reasoning before it answers, which matters a lot when you are paying per output token.

The model has a 256K token context window, supports text, image, and video input via a 400M-parameter MoonViT vision encoder, and is released under a Modified MIT License on Hugging Face permitting commercial use with attribution.

Benchmark picture

On Moonshot's internal benchmarks: Kimi Code Bench v2 scored 62.0, up 21.8% from K2.6's 50.9; Program Bench hit 53.6, up from 48.3; and MLS Bench Lite (multi-language: Python, Rust, Go) jumped 31.5% to 35.1. These are all company-reported numbers, so treat them as directional signals rather than ground truth.

On MCP Mark Verified -- a benchmark measuring correct tool invocation via the Model Context Protocol -- K2.7 scored 81.1, beating Claude Opus 4.8's 76.4. MCP (Model Context Protocol) is the standard that lets AI agents call external tools like file systems, databases, and APIs. Beating Opus 4.8 on tool-use accuracy is the headline number worth watching.

K2.7 is not the best model on any single benchmark. It is the best value model for agentic coding workflows that involve tool use, long-running agents, and cost-sensitive scaling.

Where it falls short

• K2.7 has mandatory thinking mode that cannot be disabled. Sampling parameters are also locked at temperature 1.0 and top_p 0.95, giving you less control over output determinism than competitors offer.
• On SWE-Bench Verified, DeepSeek V4 Pro scores approximately 91.2% vs K2.7's 60.4%.
• The core efficiency argument rests entirely on five proprietary benchmarks that Moonshot designed and ran itself.
• Multi-step function calling must replay the assistant message with its reasoning_content field intact, which requires extra care in agentic loop implementations.

How to enable it

In the Kimi Code CLI, run /model and select kimi-for-coding-highspeed. For third-party tools like Claude Code, Roo Code, or OpenCode, you configure it via the official docs. The API model ID is kimi-k2.7-code-highspeed.

If you are calling the API directly, the Kimi API is fully compatible with OpenAI's API format. Here is the minimal setup:

from openai import OpenAI
client = OpenAI(
    api_key="YOUR_KIMI_API_KEY",
    base_url="https://api.kimi.com/coding/v1",
)
response = client.chat.completions.create(
    model="kimi-k2.7-code-highspeed",
    messages=[{"role": "user", "content": "Refactor this function to be async"}],
)
# HighSpeed still thinks -- access reasoning separately
print(response.choices[0].message.reasoning_content)
print(response.choices[0].message.content)

What it costs

There are two ways in:

• Subscription (Kimi Code): Paid monthly pricing is $19 for Moderato, $39 for Allegretto, $99 for Allegro, and $199 for Vivace. HighSpeed is available on Allegretto and above, and consumes 3x the credits of Standard mode per request.
• API (pay-as-you-go): Input tokens are billed at $0.95 per 1M tokens on a cache miss, or $0.19 per 1M tokens on a cache hit. Output tokens are billed at $4.00 per 1M for the standard model and $8.00 per 1M for the HighSpeed variant.

Thinking is always on, and reasoning tokens are billed as output tokens -- so budget accordingly. On long agentic runs, reasoning tokens can represent a significant fraction of total output.

When to reach for HighSpeed

Speed at this scale is not just a comfort feature. For teams running automated agentic workflows that batch large numbers of tasks, the speed gain matters as much as the price-per-token figure. Concretely, HighSpeed is the right call when:

• You are running multi-step agentic loops where each turn waits on the model before proceeding
• You are doing interactive coding sessions where latency breaks flow
• You are processing a batch of short, independent tasks where 260 tok/s makes a real wall-clock difference
• Latency justifies the higher cost -- for long, complex prompts where the speed delta shrinks, Standard is the better-value option

The bigger picture

K2.7-Code is the fifth major model release in the Kimi series since July 2025. K2 Thinking followed in November 2025, K2.5 arrived in January 2026, and K2.6 landed in April 2026. The pace places Moonshot among a cohort of Chinese AI labs iterating faster than most Western closed-source competitors.

K2.7-Code is the backbone of Kimi Code, available at the same $19-per-month subscription tier that Anthropic charges for Claude Code. Moonshot is running the same model-plus-subscription playbook that has defined the developer tools market, betting that open-weight infrastructure paired with a polished CLI can convert cost-conscious engineering teams away from closed alternatives.

K2.6 topped OpenRouter's weekly LLM leaderboard in April 2026 -- a ranking based on actual API routing decisions by developers, not self-reported scores. Whether K2.7 HighSpeed sustains that momentum depends on whether the speed gains hold up in real production workloads. The weights are open, the pricing is public, and the CLI is a one-line install -- so you can answer that question yourself.