Up to 260 tokens per second. Six times faster than standard. The same K2.7 Code model - Moonshot AI's most capable coding model to date - now served at extreme throughput for teams who need real-time agentic speed. 30% fewer reasoning tokens than K2.6. Now rolling out to Kimi Code Beta, API developers, and Business users.
Kimi K2.7 Code HighSpeed is a high-throughput serving variant of Kimi K2.7 Code - the identical model weights, optimized at the infrastructure layer for maximum output speed. There is no capability trade-off: HighSpeed uses the same trillion-parameter MoE architecture, the same MoonViT 400M vision encoder, the same mandatory thinking mode, and produces identical quality outputs. The only difference is how fast those outputs arrive.
Released on June 15, 2026 - three days after the base K2.7 Code release on June 12 - HighSpeed was Moonshot's direct response to developer feedback that agentic coding workflows are bottlenecked by model throughput. When an AI agent runs hundreds of steps autonomously, each token generated in chain-of-thought reasoning and code output adds latency that compounds across the entire session. At 180–260 tokens per second, those bottlenecks largely disappear.
Access is rolling out to Kimi Code Beta Program members, Kimi API developers, and Kimi Business users in order. No invite is required - joining the Beta Program gives you access as capacity becomes available. Moonshot has stated they are actively expanding infrastructure to serve more users.
kimi-k2.7-code-highspeedKimi K2.7 Code - the model HighSpeed serves at extreme throughput - was released on June 12, 2026 as Moonshot AI's most capable coding model to date. It is a coding-focused, agentic successor to K2.6, built on the same 1T-parameter MoE architecture but retrained with a new reward model and data pipeline optimized specifically for long-horizon software engineering tasks.
The architecture retains what made K2.6 exceptional: 1 trillion total parameters with 32B active per token across 384 experts (8 selected + 1 shared) in 61 layers. Multi-Head Latent Attention (MLA) handles long contexts efficiently; SwiGLU activations power the feed-forward path. The MoonViT 400M vision encoder adds full multimodal capability - text, image, and video input are all supported natively.
What changed from K2.6: K2.7 Code was specifically tuned to reduce overthinking by ~30% - its reward model was trained to produce correct code with fewer intermediate reasoning tokens, without sacrificing output quality. This makes it simultaneously more efficient and faster, even before the HighSpeed serving infrastructure is applied.
K2.7 Code is currently available on the official Kimi API and on Cloudflare Workers AI (@cf/moonshotai/kimi-k2.7-code). Model weights are on HuggingFace under a Modified MIT License. Existing K2.6 deployment patterns (vLLM, SGLang, KTransformers) work with K2.7 Code with a simple model ID swap.
Kimi K2.7 Code - and by extension K2.7 Code HighSpeed - operates with thinking mode permanently enabled. Unlike K2.6, which supported a non-thinking instant mode, K2.7 Code removes this option entirely. The API will return an error if you attempt to disable thinking. This is a deliberate design choice, not a limitation.
Moonshot's rationale: for the long-horizon software engineering tasks K2.7 Code targets, the reasoning chain is load-bearing. Allowing it to be skipped for "fast" responses introduced instability in agentic multi-step workflows - the model would take shortcuts that became evident only after several hundred steps. The mandatory thinking guarantee means every K2.7 Code response is backed by the same quality of reasoning, regardless of task length.
The tradeoff is straightforward: you cannot make cheap, no-reasoning calls to K2.7 Code. Every request reasons first. However, the 30% reduction in reasoning tokens versus K2.6 significantly narrows this cost premium - and HighSpeed's throughput advantage ensures those reasoning tokens arrive faster than ever.
reasoning_content - full chain-of-thought in every responseIf your K2.6 integration used non-thinking (instant) mode with thinking: False in extra_body, this parameter is ignored on K2.7 Code - the model always thinks. Review your token budget assumptions before migrating production workloads, as every request will incur reasoning token usage. Use the reported 30% efficiency gain to estimate your revised cost model.
HighSpeed is more than a faster server - it combines the throughput breakthrough with K2.7 Code's fundamental improvements over K2.6 in coding quality, tool use, and token efficiency.
~180 tok/s on median coding tasks, up to 260 tok/s on shorter-context inputs. Delivered by Moonshot's optimized HighSpeed serving infrastructure - not a different model, not a lighter variant. Same quality, dramatically faster delivery.
180–260 tok/s · Production gradeK2.7 Code produces correct code with ~30% fewer thinking tokens than K2.6 on average. For agentic sessions running hundreds of steps, this compounding saves translate to meaningfully lower API costs and faster completion times - before HighSpeed throughput is even applied.
30% efficiency gain · Compounds at scaleK2.7 Code scores 81.1 on MCP Mark Verified - beating Claude Opus 4.8's 76.4. Model Context Protocol tool use is a primary focus: correct invocation of Notion, GitHub, Filesystem, Postgres, and Playwright tools in CI/CD and agent loop workflows.
81.1 MCP Mark · Beats Opus 4.8MoonViT 400M encoder enables native multimodal input. Upload screenshots, design mockups, diagrams, or video recordings alongside code and documentation. K2.7 Code reads all of them simultaneously in a single prompt - critical for UI debugging and visual debugging workflows.
MoonViT 400M · Text + Image + Video256K tokens (~192,000 words) of context - equivalent to a large enterprise codebase or an entire library of documentation. Shared across all K2.7 Code access paths. HighSpeed preserves the full context length; no degradation from the standard model.
256K context · Unchanged from K2.7Kimi's API is fully OpenAI-compatible. Change two lines in any existing integration: base_url and model. The HighSpeed model ID is kimi-k2.7-code-highspeed. Streaming, function calling, tool use, and structured outputs all work identically to OpenAI's format.
Moonshot published six benchmark results comparing K2.7 Code against K2.6, GPT-5.5, and Claude Opus 4.8. Important context: every benchmark listed here is a Moonshot proprietary suite - Kimi Code Bench v2, Program Bench, MLS Bench Lite, MCP Atlas, MCP Mark Verified, and Kimi Claw 24/7 Bench are all designed and administered by Moonshot. No independent results on SWE-bench Verified, LiveCodeBench, GPQA Diamond, or Terminal-Bench 2.0 had been published at launch. Use these numbers as directional indicators, not independently verified scores.
| Benchmark | K2.7 Code | vs K2.6 | GPT-5.5* | Claude Opus 4.8* | Visual |
|---|---|---|---|---|---|
| Kimi Code Bench v2 | 62.0 | +21.8% | 69.0 | 67.4 | |
| Program Bench | 53.6 | +11.0% | - | - | |
| MLS Bench Lite | 35.1 | +31.5% | 35.5 | 42.8 | |
| MCP Atlas | 76.0 | ~+10% | - | - | |
| MCP Mark Verified | 81.1 | ~+10% | - | 76.4 (K2.7 leads) | |
| Kimi Claw 24/7 Bench | ~+10% vs K2.6 | +10% | - | - |
*GPT-5.5 ran in Codex xhigh mode; Claude Opus 4.8 ran in Claude Code xhigh mode; K2.7 Code ran in Kimi Code CLI. Different compute configurations - comparisons are directional only. All benchmarks are Moonshot proprietary. As of June 15, 2026, no independent SWE-bench Verified, LiveCodeBench, or GPQA Diamond results exist for K2.7 Code.
Every published benchmark for K2.7 Code is run by Moonshot on Moonshot-designed suites. This is common practice but worth acknowledging explicitly. Test K2.7 Code against your own actual workloads before drawing conclusions from the numbers above. The 30% token efficiency gain is the metric most likely to reflect consistently across diverse real-world tasks.
The HighSpeed variant uses an identical API surface to K2.7 Code standard - the only change is the model string. Any existing K2.7 Code integration can switch to HighSpeed by changing one line. The API lives at platform.kimi.ai and is fully OpenAI SDK compatible.
Direct access to HighSpeed via Moonshot's API. Get your key at platform.kimi.ai. Model ID: kimi-k2.7-code-highspeed. Standard K2.7 Code: kimi-k2.7-code. Cached input: $0.19/1M. Miss input: $0.95/1M (standard).
HighSpeed is rolling out to Kimi Code Beta Program members first. Join at kimi.com/code/beta - no invite required. Members in the Beta Program get access as capacity becomes available. The Kimi Code CLI uses K2.7 Code as its default model as of June 12, 2026.
Beta Program · No invite neededK2.7 Code is available on OpenRouter at ~$0.72/1M input · $3.49/1M output via 13+ providers. Routes automatically for best uptime. HighSpeed variant availability on OpenRouter depends on individual provider support.
13+ providers · Auto-routingK2.7 Code is available on Cloudflare Workers AI as @cf/moonshotai/kimi-k2.7-code. Use via Workers AI binding, REST API, or OpenAI-compatible endpoint. Cached input: $0.19/1M.
Kimi K2.7 Code HighSpeed is priced at a premium over the standard K2.7 Code tier - reflecting the dedicated high-throughput serving infrastructure. Both variants significantly undercut closed-source models at equivalent capability levels. Kimi Code membership plans start at $19/month and provide included model access without per-token billing.
For long agentic sessions where reasoning tokens dominate cost, K2.7 Code's 30% reduction in thinking tokens offsets a significant portion of the HighSpeed premium. A session that previously consumed ~2 million reasoning tokens with K2.6 will consume roughly ~1.4 million with K2.7 Code. At HighSpeed pricing ($8.00/1M output), that's a saving of ~$4.80 per session - before accounting for the time value of faster completion. Run the math against your actual workload to determine which tier optimizes your specific cost-speed trade-off.
The HighSpeed variant is most valuable when token throughput is a meaningful bottleneck - typically agentic workflows with many steps, interactive developer tools, and any context where wait time directly impacts workflow efficiency.
Multi-step agentic sessions (debugging, refactoring, feature implementation) run faster start-to-finish. At 180 tok/s, a 1,000-token reasoning chain arrives in ~5.5 seconds vs ~30s at standard speed.
Automated code review, test generation, and PR analysis in CI pipelines. HighSpeed ensures K2.7 Code completes before pipeline timeouts - critical for synchronous review gates.
Real-time pair programming in Kimi Code CLI or IDE integrations. At sub-second first-token latency, the interaction feels like a live pair rather than a waiting room.
Workflows invoking MCP tools (GitHub, Notion, Filesystem, Postgres) with many sequential calls benefit directly - each step's reasoning and output arrives faster, reducing total session time.
Processing large codebases file-by-file or function-by-function in parallel agentic workflows. HighSpeed makes per-file analysis fast enough to complete full repository scans in minutes.
Synchronous review of commits and PRs as they land. HighSpeed throughput enables < 10 second analysis turnaround on typical commit diffs - fast enough for blocking developer workflows.
From the original K2 release in July 2025 to K2.7 Code HighSpeed in June 2026 - Moonshot AI shipped six major updates in twelve months, consistently iterating faster than any closed-source frontier lab over the same period.
1T MoE, 32B active, 128K context, MuonClip optimizer, zero training instability on 15.5T tokens. Modified MIT License. Sets the open-source agentic baseline. SWE-bench: 65.8%.
Interleaved chain-of-thought and native tool calls, up to 300 sequential steps. Native INT4 QAT for 2× speed. Tencent CodeBuddy integrates as core model. temperature=1.0.
MoonViT 400M for native multimodal (images + video). 256K context. Agent Swarm v1: 100 parallel sub-agents, 4.5× speedup. SWE-bench 76.8%. Cursor Composer 2 built on K2.5.
262K context. Agent Swarm v2: 300 sub-agents, 4,000 steps. Claw Groups. Document-to-Skill. SWE-bench 80.2%, BrowseComp Swarm 86.3%. Non-thinking (instant) mode available.
Coding-focused retraining of K2.6. Mandatory thinking mode. −30% reasoning tokens vs K2.6. +21.8% Kimi Code Bench v2. MCP Mark 81.1 (beats Opus 4.8). Open weights HuggingFace.
Same K2.7 Code model, optimized high-throughput serving infrastructure. ~180 tok/s median, up to 260 tok/s peak. Rolling out to Kimi Code Beta, API developers, Kimi Business. API: kimi-k2.7-code-highspeed.
Positioned as the open-weight speed leader for coding: frontier-competitive quality at a fraction of closed-source cost, with the highest raw throughput of any publicly available coding model as of June 2026.
| Model | K2.7 Code HighSpeed Moonshot AI · Jun 2026 |
K2.7 Code Std Moonshot AI |
GPT-5.5 OpenAI |
Claude Opus 4.8 Anthropic |
K2.6 Moonshot AI |
|---|---|---|---|---|---|
| Speed & Throughput | |||||
| Token throughput (approx) | 180–260 tok/s | ~30–50 tok/s | ~60–80 tok/s | ~50–70 tok/s | ~40–60 tok/s |
| Speed vs K2.7 standard | 6× faster | 1× | ~1.5× | ~1.3× | 1× |
| Model Capabilities | |||||
| Parameters (total / active) | 1T / 32B | 1T / 32B | ~200B | ~200B | 1T / 32B |
| Context window | 256K | 256K | 400K (1M Pro) | 200K | 262K |
| Vision / multimodal | ✓ MoonViT 400M | ✓ | ✓ | ✓ | ✓ |
| Thinking mode | Always on | Always on | Optional | Optional | Switchable |
| Open weights | ✓ Modified MIT | ✓ | ✗ | ✗ | ✓ |
| Pricing (approximate) | |||||
| Input $/1M tokens | $1.90 | $0.95 | $5.00 | $15.00 | $0.60 |
| Output $/1M tokens | $8.00 | $4.00 | $30.00 | $75.00 | $4.00 |
| vs GPT-5.5 output cost | 3.75× cheaper | 7.5× cheaper | - | 2.5× more | 7.5× cheaper |
| Key Benchmarks (Kimi Code Bench v2 - vendor-reported) | |||||
| Kimi Code Bench v2 | 62.0 | 62.0 | 69.0* | 67.4* | 50.9 |
| MCP Mark Verified | 81.1 | 81.1 | - | 76.4 (lower) | ~73 |
*Competitor benchmark scores from Moonshot's first-party table - GPT-5.5 in Codex xhigh mode, Opus 4.8 in Claude Code xhigh. Not directly comparable to standard API mode. All Kimi Code Bench results are Moonshot proprietary. Throughput figures are approximate and vary by task length and load.
Every published benchmark for K2.7 Code - Kimi Code Bench v2, Program Bench, MLS Bench Lite, MCP Atlas, MCP Mark Verified - is a Moonshot-designed and Moonshot-administered suite. No SWE-bench Verified, LiveCodeBench, Terminal-Bench 2.0, or GPQA Diamond results exist as of June 15, 2026. Treat published scores as vendor-reported and directional.
First-party onlyMoonshot explicitly noted that HighSpeed capacity is constrained at launch. The experience may fluctuate - throughput could vary significantly under high load, and access may be rate-limited more aggressively than standard. Capacity is actively expanding, but plan for variability in production until the rollout stabilizes.
Limited capacity initiallyThinking mode is permanently enabled. Every request reasons before responding - there is no cheaper, faster path for simple or trivial queries. For teams that used K2.6's instant mode for lightweight calls, this represents a meaningful cost increase. The 30% efficiency gain helps but doesn't fully offset for simple workloads.
Always reasons firstK2.7 Code has a 256K context window - slightly shorter than K2.6's 262K. For the overwhelming majority of workflows this is irrelevant, but teams whose sessions reliably approach 260K+ tokens should account for this regression or maintain a K2.6 fallback for extremely long-context tasks.
256K vs 262K in K2.6Kimi K2.7 Code HighSpeed delivers up to 260 tokens per second - the fastest serving tier for any open-weight frontier coding model. Join the Beta Program or access via API today.