
by Moonshot AI
Moonshot's low-latency serving mode for Kimi K2.7 Code, its agentic coding fine-tune of the K2.6 base model.
K2.7 Code HighSpeed fits teams running autonomous coding agents with heavy tool use who want lower latency without an audited SWE-bench score to justify the pick. It cuts reasoning-token usage roughly 30% versus the K2.6 base model, lowering real-world cost on long agentic sessions, though Moonshot itself still recommends K2.6 for general-purpose writing work.
| Job | Input | Output | Total |
|---|---|---|---|
| Summarise a 20-page PDF | $0.028 | $0.0040 | $0.033 |
| Support reply | $0.0019 | $0.0012 | $0.0031 |
| One coding agent run | $0.190 | $0.080 | $0.270 |
Budgets: 20-page PDF = 30k in / 1k out · Support reply = 2k in / 300 out · Coding agent run = 200k in / 20k out. Computed from the vendor's per-token prices at render time; cached-input discounts are not applied.
Moonshot's native Kimi API prices HighSpeed mode at $0.95 per 1M input tokens and $4.00 per 1M output tokens, with cached input discounted to $0.19 per 1M. OpenRouter carries the same model cheaper, at $0.74 input and $3.50 output per 1M tokens. There's no subscription tier: self-hosting the open weights avoids per-token billing but needs roughly 1TB of GPU memory for the FP8 build.
Kimi K2.7 Code HighSpeed scores 81.1 on MCP Mark Verified, beating Claude Opus 4.8's 76.4 on the same tool-calling test. It's Moonshot AI's fast-serving mode for its 1-trillion-parameter open-weight coding model, reaching roughly six times the throughput of standard K2.7 Code on coding completions.
Reads
Writes
HighSpeed serving mode
Reaches roughly 180 tokens/sec on median coding completions and up to 260 tokens/sec on short bursts, about 6x the throughput of standard K2.7 Code.
262,144-token context window
Compressed with Multi-head Latent Attention (MLA) so self-hosted deployments can keep enough KV cache headroom for long agentic sessions.
Always-on interleaved thinking
Extended thinking is always active and carries over between tool calls in a single session, so multi-step coding tasks don't lose their reasoning thread.
Native MoonViT vision encoder
A 400M-parameter encoder handles image and video input natively, without a separate captioning step before the coding model sees them.
Native INT4 quantization
Quantization-aware-trained INT4 weights ship alongside FP8, roughly halving self-hosting VRAM with vLLM, SGLang, and KTransformers serving support.
HighSpeed mode output throughput on coding completions
Source: Moonshot AI HighSpeed mode announcement, June 15, 2026| Measure | This model | Rank | Median |
|---|---|---|---|
| Blended price (3:1)$ per 1M tokens | $1.71/M | #52 / 105 | peer median $1.71/M |
Ranks are against GA models on Hokai that publish the same figure; ties share a rank.
A benchmark is an exam, not the job. Scores transfer unevenly between tasks, so weigh the one closest to your workload and read every figure with its source.
| Model | Lab | Context | In / out per 1M | Reads and writes |
|---|---|---|---|---|
| Moonshot AI | 262K | $0.95 / $4 | text, image, video, code → text, code | |
| Moonshot AI | 262K | $0.95 / $4 | text, image, video, code → text, code | |
| Z.ai | 1M | $1.40 / $4.40 | text → text | |
| Anthropic | 1M | $5 / $25 | text, image, pdf → text |
Training data
Fine-tuned from the Kimi K2.6 base checkpoint on coding and agentic tool-use data; Moonshot has not published a K2.7 Code-specific training data cutoff or data-mix disclosure.
| Name | Endpoint | Auth |
|---|---|---|
| Kimi API Platform | https://platform.kimi.ai/docs/guide/kimi-k2-7-code-quickstart | API Key |
| OpenRouter | https://openrouter.ai/moonshotai/kimi-k2.7-code | API Key |
| Cloudflare Workers AI | https://developers.cloudflare.com/workers-ai/models/kimi-k2.7-code/ | Cloudflare API Token |
Let thinking stay enabled
Do not set thinking: false in the request body.
K2.7 Code always runs with thinking on; disabling it silently reroutes the request to K2.6 instead of erroring.
Preserve thinking across multi-turn tool calls
Set preserve_thinking: true when chaining tool-calling turns.
Keeps interleaved reasoning coherent across long-horizon coding sessions instead of resetting context each turn.
Disabling thinking silently falls back to K2.6
K2.7 Code always runs with extended thinking enabled. A request that explicitly sets thinking to false does not error, it gets silently served by the K2.6 model instead.
Workaround: Never disable thinking in requests meant for K2.7 Code, and check the model field in the API response to confirm which model actually answered.
HighSpeed mode is beta-gated
The HighSpeed serving mode announced June 15, 2026 is rolling out first to the Kimi Code Beta channel and may not be reachable from every API key or region.
Workaround: Check platform.kimi.ai for beta access before hardcoding the HighSpeed model id into a production routing config; fall back to standard K2.7 Code if the request errors.
No independent benchmark submission
Moonshot has not submitted K2.7 Code to SWE-bench Verified, SWE-bench Pro, LiveCodeBench, or GPQA Diamond. Only Moonshot's own Kimi Code Bench v2, Program Bench, and MLS Bench Lite scores are public.
Workaround: Run your own eval on a representative slice of your workload before routing production traffic away from an audited competitor model.
Vendor-reported throughput varies widely by provider
Moonshot's own HighSpeed figures are 180-260 tokens/sec, while third-party provider Crusoe reports over 430 tokens/sec on its own optimized inference stack for the same weights.
Workaround: Benchmark tokens/sec on your actual inference provider rather than assuming Moonshot's published numbers, since serving-side optimization accounts for most of the variance.
kimi-k2.7-code-highspeed · 15 Jun 2026
HighSpeed serving mode added, ~180-260 tokens/sec, rolled out to Kimi Code Beta.
kimi-k2.7-code · 12 Jun 2026
Initial release, fine-tuned from K2.6. +21.8% Kimi Code Bench v2, +11.0% Program Bench, +31.5% MLS Bench Lite, 30% fewer reasoning tokens.
kimi-k2.6 · 20 Apr 2026
Predecessor base model, general-purpose K2 release.
HighSpeed mode costs $4.00 per 1M output tokens and $0.95 per 1M input tokens on Moonshot's own API, with a discounted $0.19 per 1M for cache hits. OpenRouter carries the same model for less, $3.50 output and $0.74 input per 1M tokens. There's no subscription plan: it's pay-per-token on both routes, or free of per-token cost entirely if you self-host the Modified MIT-licensed weights.
There's no free plan for Kimi K2.7 Code HighSpeed on Moonshot's hosted API. The weights are open under a Modified MIT License, though, so you can run the model yourself without paying Moonshot anything beyond your own GPU costs. Community GGUF conversions are also available via Unsloth on Hugging Face if you'd rather run a lighter build than the official FP8 or INT4 releases.
GLM-5.2 is the closest open-weight rival, with stronger audited benchmark coverage but no native HighSpeed-style low-latency serving mode. Claude Opus 4.8 is the closed-source alternative worth considering if you need a published system card and broader benchmark coverage like Terminal-Bench, at a higher per-token price. Both lack K2.7 Code HighSpeed's combination of open weights, native INT4 self-hosting, and MCP Mark Verified tool-call score.
GLM-5.2 currently holds the stronger position on independently audited coding suites, since Moonshot has not put K2.7 Code through any third-party benchmark. Where K2.7 Code HighSpeed pulls ahead is tool-call reliability on MCP Mark Verified and serving speed, plus a friendlier self-hosting VRAM footprint thanks to native INT4 weights. For a team choosing on audited proof alone, GLM-5.2 is the safer pick; for one already running an MCP-heavy agent stack, K2.7 Code HighSpeed's throughput and tool-score edge matter more.
The fastest path is an API key from Moonshot's Kimi platform, since HighSpeed mode currently needs Kimi Code Beta access before you can call the highspeed model id. Teams that would rather skip a beta waitlist can call the standard K2.7 Code model through OpenRouter or Cloudflare Workers AI with no beta gate. Self-hosting starts with pulling the FP8 or INT4 weights from Hugging Face and serving them with vLLM, SGLang, or KTransformers on a GPU node sized for the model.
Kimi K2.7 Code HighSpeed is a fast-inference variant of Kimi K2.7 Code, the coding-focused release Moonshot AI shipped on June 12, 2026 as a fine-tune of its Kimi K2.6 base. The HighSpeed mode itself followed three days later, on June 15, 2026, rolling out first to the Kimi Code Beta channel. Architecturally it is unchanged from K2.6: a Mixture-of-Experts transformer with 1 trillion total parameters and 32 billion activated per token, 61 layers, 384 experts with 8 routed plus 1 shared expert per token, Multi-head Latent Attention (MLA) for KV cache compression, SwiGLU activations, and a 160K vocabulary. A MoonViT vision encoder gives it native image and video input alongside text, and the context window carries over unchanged from K2.6 at 256K (262,144) tokens.
Moonshot has not submitted K2.7 Code to any independently audited benchmark suite as of late June 2026. The only numbers on the table are Moonshot's own Kimi Code Bench v2, where K2.7 Code scores 62.0 versus K2.6's 50.9 (a 21.8% relative gain), Program Bench at 53.6 versus 48.3 (+11.0%), and MLS Bench Lite at 35.1 versus 26.7 (+31.5%). On MCP Mark Verified, a third-party tool-invocation benchmark covering Notion, GitHub, Postgres, Filesystem, and Playwright environments, K2.7 Code scores 81.1, ahead of Claude Opus 4.8's 76.4 on that specific test, though Opus 4.8 leads on broader coding suites like Terminal-Bench 2.1. Its closest open-weight rival, GLM-5.2, holds a stronger position on audited benchmarks at 62.1% on SWE-bench Pro, so K2.7 Code's real edge is token efficiency and tool-call reliability rather than raw solve rate.
The defining change from K2.6 is a roughly 30% cut in reasoning-token usage per task, which lowers effective cost on reasoning-heavy coding workloads even though the per-token price is nearly identical. K2.7 Code always runs with extended thinking enabled; a request sent with thinking explicitly disabled is silently rerouted to K2.6 rather than erroring; interleaved thinking is preserved across multi-turn tool-calling sessions for coherent long-horizon coding runs.
The HighSpeed mode is a serving-side optimization, not a retrained model: Moonshot reports substantially faster output on median-length coding completions and bursts even higher on short-context requests, roughly six times the throughput of the standard K2.7 Code deployment. Third-party inference provider Crusoe reports over 430 output tokens/sec running K2.7 on its own optimized stack, which shows the ceiling is provider-dependent rather than fixed by the model.
K2.7 Code HighSpeed is priced per token on Moonshot's native Kimi API, with a cheaper rate available through OpenRouter. The model is also live on Cloudflare Workers AI and the Vercel AI Gateway. Exact rates and self-hosting cost comparisons are broken out below.
Weights are published under a Modified MIT License on Hugging Face and GitHub: free for research and most commercial use, with an attribution clause that kicks in for very large-scale commercial deployments, the same style of condition Moonshot has used since the original K2 release. Self-hosting the FP8 weights needs roughly 1TB of HBM, realistically an 8x H200 SXM5 node, leaving enough headroom for KV cache at full context with small batches. Moonshot also ships native INT4 weights trained with quantization-aware training rather than post-hoc quantization, cutting VRAM roughly in half with minimal quality loss; vLLM, SGLang, and KTransformers are the officially recommended INT4 serving engines.
An independent academic evaluation of the prior K2.5 model found it had a lower overrefusal rate and higher willingness to cooperate with borderline requests than GPT-5.2 and Claude Opus 4.5, a pattern that may carry over until Moonshot publishes its own K2.7 assessment. Training data cutoff is unconfirmed for K2.7 Code specifically; K2.6's was reported at approximately April 2025, though Moonshot never verified that figure itself.
Specifications on this page (context window, token prices, benchmark scores, licence) are read from Moonshot AI's own model card and documentation. The verdict is Hokai's reading of them, not the provider's claim.