by Moonshot AI

Kimi K2.7 Code HighSpeed review, pricing and limits

Moonshot's low-latency serving mode for Kimi K2.7 Code, its agentic coding fine-tune of the K2.6 base model.

Best for
Agentic coding loops with heavy tool use
Not for
Procurement processes requiring an audited SWE-bench or GPQA score
  • Beta
  • Open weights

Should you use Kimi K2.7 Code HighSpeed?

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.

Best for

  • Agentic coding loops with heavy tool use 81.1 on MCP Mark Verified, ahead of Claude Opus 4.8, plus interleaved thinking preserved across multi-turn tool calls.
  • Cost-sensitive, high-volume coding agents 30% fewer reasoning tokens than K2.6 at nearly the same per-token price, plus a cheaper OpenRouter rate.
  • Teams that want to self-host an open-weight coding model Modified MIT License, native INT4 weights with vLLM/SGLang/KTransformers support cut VRAM roughly in half.

Not for

  • Procurement processes requiring an audited SWE-bench or GPQA score Moonshot has not submitted K2.7 Code to any independently audited benchmark suite as of June 2026.
  • Regulated deployments needing published safety documentation No system card, refusal-policy disclosure, or jailbreak-resistance figure exists for this release.
  • General-purpose writing, chat, or analysis Moonshot itself recommends the base K2.6 model for non-coding work.

Kimi K2.7 Code HighSpeed pricing

Input, per 1M tokens
$0.95/1M
Output, per 1M tokens
$4.00/1M
Cached input, per 1M tokens
$0.19/1M
Pricing model
per-token
Free tier
No

What a real job costs

JobInputOutputTotal
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.

Cost examples

Daily coding agent (1M tokens in / 200K out)
$1.75
100K-token codebase review
$0.50
Multi-turn tool-calling session (200K in / 50K out)
$0.39

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.

Self-hosting requirements

Min vram gb
512
Self-hosted
Yes
Recommended GPU
8x NVIDIA H200 SXM5 (or equivalent) for FP8; roughly half for native INT4

What Kimi K2.7 Code HighSpeed can do

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.

What goes in and what comes out

Reads

  • text
  • image
  • video
  • tool-calls
  • code

Writes

  • text
  • tool-calls
  • code

Capabilities

  • Function callingSupported
  • Structured outputSupported
  • Tool useSupported
  • Video inputSupported
  • VisionSupported
  • Audio inputNot supported
  • Audio outputNot supported
  • Code executionNot supported
  • Web browsingNot supported
Reasoning modes
always-on-thinking
Long context recall
unverified

Key features

  • 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.

Known limitations

  • No independently audited SWE-bench Verified, SWE-bench Pro, LiveCodeBench, or GPQA Diamond score published as of late June 2026: only Moonshot's own Kimi Code Bench v2, Program Bench and MLS Bench Lite numbers exist.
  • No native audio input or output; must be paired with a separate ASR/TTS model for voice workflows.
  • Sending a request with thinking explicitly disabled silently falls back to K2.6 instead of returning an error, which can mask which model actually served a response.

Who it is for

  • Teams running autonomous coding agents with heavy MCP tool use
  • Cost-sensitive engineering orgs running high-volume agentic coding workloads
  • Infra teams that want to self-host an open-weight coding model on their own GPUs
  • Developers already using Kimi Code CLI as their agent framework

Supported languages

  • English
  • Chinese
  • Spanish
  • French
  • German
  • Japanese
  • Korean

Kimi K2.7 Code HighSpeed benchmarks

Standout result

180-260 tok/s

HighSpeed mode output throughput on coding completions

Source: Moonshot AI HighSpeed mode announcement, June 15, 2026

Where it sits

MeasureThis modelRankMedian
Blended price (3:1)$ per 1M tokens$1.71/M#52 / 105peer median $1.71/M

Ranks are against GA models on Hokai that publish the same figure; ties share a rank.

Benchmark scores

  • MCP Mark Verified vendor-reported · 12 Jun 202681.1
  • Kimi Code Bench v2 vendor-reported · 12 Jun 202662
  • Program Bench vendor-reported · 12 Jun 202653.6
  • MLS Bench Lite vendor-reported · 12 Jun 202635.1

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.

Strengths and limits

Strengths

  • Its MCP tool-invocation reliability held up across five different environments in the same third-party benchmark, not just a single integration test.
  • The Modified MIT License permits most commercial use with no subscription fee at all, a real advantage against closed, API-only coding models.
  • Cuts reasoning-token overhead enough to matter on long agentic coding sessions, without raising the per-token price much over the previous generation.
  • MCP Mark Verified score of 81.1 beats Claude Opus 4.8's 76.4 on tool-invocation reliability across Notion, GitHub, Postgres, Filesystem and Playwright environments.
Show 3 more
  • HighSpeed mode reaches roughly 180 tokens/sec on median coding completions and up to 260 tokens/sec on short-context requests, about 6x the standard K2.7 Code serving speed.
  • Roughly 30% fewer reasoning tokens per task than K2.6, lowering effective cost on reasoning-heavy coding workloads at nearly the same per-token price.
  • Open weights under a Modified MIT License with native INT4 quantization-aware-trained weights, cutting self-hosting VRAM roughly in half versus FP8.

Limits

  • SWE-bench Verified, SWE-bench Pro, LiveCodeBench, and GPQA Diamond scores are all missing for this specific release, only Moonshot's own in-house numbers are public.
  • No system card has been published for this release, so refusal policy, jailbreak resistance, and agentic-misuse evaluations are all undocumented.
  • HighSpeed mode is beta-gated to the Kimi Code Beta channel and may not be available on every account.

Kimi K2.7 Code HighSpeed alternatives

ModelLabContextIn / out per 1MReads and writes
Kimi K2.7 Code HighSpeed This pageMoonshot AI262K$0.95 / $4text, image, video, code → text, code
Kimi K2.7-CodePick HighSpeed if lower per-token latency in an agentic coding loop matters; pick standard K2.7-Code if the Kimi Code Beta channel isn't available on your account.Moonshot AI262K$0.95 / $4text, image, video, code → text, code
GLM-5.2Pick GLM-5.2 for an independently audited SWE-bench Pro score; pick K2.7 Code HighSpeed for stronger tool-invocation reliability and native INT4 self-hosting weights.Z.ai1M$1.40 / $4.40text → text
Claude Opus 4.8Pick Claude Opus 4.8 for broader audited coding benchmarks and a published system card; pick K2.7 Code HighSpeed for open weights and per-token pricing well under Opus 4.8's.Anthropic1M$5 / $25text, image, pdf → text

Kimi K2.7 Code HighSpeed specs

Context window
262K tokens
Max output
49K tokens
Tokens per second
180 tok/s
Architecture
Transformer (Mixture-of-Experts)
Mixture of experts
Yes
Parameters
1T total, 32B activated per token
VRAM requirements
~1TB HBM for FP8 (8x H200 SXM5 class node); roughly half that for native INT4 weights

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.

Weight formats

  • FP8
  • INT4 (native, QAT)
  • GGUF (community)

API endpoints

NameEndpointAuth
Kimi API Platformhttps://platform.kimi.ai/docs/guide/kimi-k2-7-code-quickstartAPI Key
OpenRouterhttps://openrouter.ai/moonshotai/kimi-k2.7-codeAPI Key
Cloudflare Workers AIhttps://developers.cloudflare.com/workers-ai/models/kimi-k2.7-code/Cloudflare API Token

SDKs

  • Python
  • TypeScript

Prompting patterns

Show 2 prompting patterns
  • 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.

Known quirks

Show 4 known quirks
  • 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 facts

Safety posture
Permissive
Released
15 Jun 2026
Current version
kimi-k2.7-code-highspeed
Family
Kimi K2
Variant
Code
Deployment
API · Self-hosted · Cloudflare Workers AI · OpenRouter
Licence
Modified MIT License (commercial use permitted; attribution required for large-scale commercial deployment) · Open weights
Data retention
Not publicly disclosed by Moonshot AI for this release.

Content restrictions

  • No published system card; content restriction policy is undocumented for this release.

Safety controls

Rlhf
Yes
Red teaming
not disclosed
System prompt
Yes
Constitutional AI
No
Content filter API
No
Moderation endpoint
No

Data governance

Iso 27001
No
Soc2 type2
No
GDPR compliant
No
HIPAA eligible
No
Eu AI act classification
not disclosed

Version history

  • 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.

What changed

  • Release HighSpeed serving mode added source
  • Release Kimi K2.7 Code initial release source

Questions about Kimi K2.7 Code HighSpeed

How much does Kimi K2.7 Code HighSpeed cost in 2026?

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.

Can you use Kimi K2.7 Code HighSpeed without paying?

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.

What are Kimi K2.7 Code HighSpeed's closest competitors?

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.

Is Kimi K2.7 Code HighSpeed better than GLM-5.2?

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.

How do you get started with Kimi K2.7 Code HighSpeed?

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.

About Kimi K2.7 Code HighSpeed

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.

Read the full background

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.

Sources and guides

More AI Models on Hokai

  • Gemini 3.5 Flash CyberGemini 3.5 Flash Cyber (Google DeepMind, 2026) is a gated fine-tune of Gemini 3.5 Flash for finding and patching vulnerabilities inside CodeMender.
  • MAI-Code-1.1-FlashMicrosoft released MAI-Code-1.1-Flash in August 2026 as a small-tier coding model for GitHub Copilot, adding native vision input and a large context window.
  • Gemini 3.8 Flash CyberGemini 3.8 Flash Cyber (Google DeepMind, Sept 2026) reports 86.2% on CyberGym and is limited to vetted Fairwind Program defenders; Gemini 4 Argon now sits above it.
  • Mellum2.1Mellum2.1 is JetBrains' open mixture-of-experts model, post-trained with reinforcement learning to work inside code repositories as an agent.
  • GLM-5.3GLM-5.3 is Z.ai's text-only flagship for agentic coding and security work, with a 1M-token context, a live API and open weights.