Kimi K2.7 Code high-speed version is live, with output speed soaring to 200 TPS

Moonshot has slipped another new thing into the Kimi open platform. In mid-June, someone in the developer community linux.do noticed that platform.kimi.com had added a model ID called kimi-k2.7-code-highspeed. Running it showed output speeds between 150–200 tokens/s, which is a full 3 to 4 times faster than the standard kimi-k2.7-code.

The official channels didn’t really promote this—there’s only a single line casually mentioned on the promo page. But for people actually using Kimi as a Coding Agent, this update feels even more impactful than last month’s K2.7 Code launch itself.

Not a new model, but a new channel

Let’s clarify: kimi-k2.7-code-highspeed isn’t a newly trained model. It’s essentially a high-speed inference channel for the K2.7 Code MoE base—same trick Moonshot used last September when they launched kimi-k2-turbo-preview for K2-0905. The model weights are unchanged; what’s different is the underlying inference stack: more aggressive speculative decoding, more efficient KV cache reuse, deeper batch scheduling optimization, plus dedicated high-bandwidth GPU resources.

According to the figures Moonshot released for K2 Turbo, that version output at 60–100 tokens/s. This time, the K2.7 Code high-speed version pushes the upper limit to 200 tokens/s, nearly doubling. This suggests that over the past half-year from 0905 until now, they’ve made serious advances on the inference side—this isn’t just parameter tuning.

In actual testing, several people on linux.do have given consistent feedback: short-context scenarios can sustain over 180 TPS, while long-context (128K+) drops to 130–150 TPS. Still, compared to the standard version’s 40–50 TPS “slow squeeze,” this is a qualitative leap.

Why coding models especially need this speed

Here’s a pain point that many non-developers don’t notice: Coding Agents are extremely sensitive to single-output latency.

If you ask ChatGPT to write a poem, outputting slowly is fine—you just read it once and you’re done. But Coding Agents are different—they operate as a tool call loop: model generates code → tool executes → returns results → model generates next step. Tools like Claude Code, Cursor Agent, and Cline, when running slightly more complex tasks, may involve dozens of model round-trips in a single session. If each round-trip takes 30 seconds just for the model to output, the whole task drags to over 10 minutes.

Kimi K2.7 Code boasts a 256K context and 300 tool calls—these stats are indeed useful for Agent scenarios, but only if the speed keeps up. The original 40–50 TPS speed means even a moderately large refactor task can leave you staring at the screen in despair. Anthropic’s Claude Sonnet now runs at 80–100 TPS, and Gemini 3 Flash is even more impressive at 250 TPS—Kimi was lagging in this area.

Now, raising K2.7 Code to the 200 TPS range basically makes the strongest, cheapest domestic coding model also competitive in speed. That’s a big deal for teams that want domestic solutions without compromising Agent experience.

The K2.7 Code model is worth a look on its own

Since we’ve brought up the high-speed version, let’s look back at the K2.7 Code itself. Moonshot calls this “the strongest current coding model,” with an output price of ¥27 per million tokens. That’s mid-range domestically, but more than an order of magnitude cheaper than Claude Sonnet 4.5.

Architecture-wise, the K2 series follows the Mixture-of-Experts (MoE) route: total parameters 1 trillion, active parameters 32 billion. K2.7 Code builds on K2.6 with reinforcement training specifically for real software engineering tasks—SWE-bench Verified is its main battleground.

Key capabilities:

• 256K context window—same as K2.6 and K2.5. Enough for reading whole projects in Agent workflows, though still smaller than Gemini’s 1M+ window.
• Token Enforcer—guarantees 100% correct JSON output for tool calls. Very useful; anyone who’s done Function Calling knows how frustrating format errors can be.
• Fully compatible with Anthropic API—can plug directly into Claude Code, with WebSearch Tool support. A Moonshot staple—reducing migration costs so Claude users can switch painlessly.
• Automatic Context Caching—repeated prompt sections are automatically cached; cache-hit price is only $0.16 per million tokens (even lower in RMB). In Agent scenarios with system prompts of thousands of tokens, this can save a lot.

The cost of high-speed: accuracy and price

As usual, high-speed versions aren’t free lunches. Moonshot hasn’t said whether the highspeed version compromises accuracy, but industry experience suggests that to push speed 3–4×, they likely used some of these tactics:

1. More aggressive speculative decoding—a small draft model generates candidate tokens, the large model verifies. Theoretically no loss in accuracy, but draft hit rate affects speed ceilings.
2. Lower numerical precision—converting some computations from BF16 to FP8 or even INT8. Occasionally causes anomalies in long contexts.
3. Sparse attention optimization—MoE models already have room in expert routing; making sparsity more aggressive sacrifices some long-range dependency capacity.
4. Dedicated clusters—just more hardware, newer GPUs (e.g., H200 / B200); this is purely paying for speed without accuracy loss.

The community hasn’t yet seen benchmark comparisons for K2.7 Code high-speed—if anyone tests, it’s highly recommended to run SWE-bench to check score differences. If the gap is within 1–2 points, the high-speed version is a no-brainer; if over 5 points, choose depending on task type.

Pricing-wise, K2 Turbo’s high-speed version was about 4× the standard’s price. For K2.7 Code high-speed, the open platform is still doing a limited-time promotion; official pricing will likely be clear after that ends. Even at 4× price, ¥27 × 4 = ¥108 per million tokens is still cheaper than Claude Sonnet.

The domestic coding model speed race

Zooming out, Kimi’s launch of a high-speed version signals that domestic models are now competing not just on model capability but also engineering delivery capability.

Over the past year, DeepSeek V3.2, Tongyi Qwen3-Coder, Zhipu GLM-Coder, and Step-Code have all made moves in the coding arena. But most models still lag headliners in API speed. By pushing K2.7 Code high-speed to 200 TPS, Kimi hits a new balance of “strong model + cheap price + fast speed.”

Practical impacts for developers:

• Running Claude Code-like Agent tools requiring Anthropic API compatibility can now be swapped to K2.7 Code high-speed with minimal experience difference.
• Teams building their own Coding Agents can make K2.7 Code high-speed the primary inference path, keeping Claude/Gemini as backups—overall costs drop significantly.
• Long-duration Agent tasks (300+ tool calls) become truly usable—previously, at 40 TPS, 300 steps meant over an hour; now it’s possible in 15–20 minutes.

Access and usage tips

Access works the same—standard OpenAI-compatible format, change the model name to kimi-k2.7-code-highspeed. If you already use K2.6 or K2.7 Code standard, it’s practically just one line of code change.

For multi-model scenarios, aggregation platforms like OpenAI Hub already support Kimi series models, including this high-speed version. One key can call GPT, Claude, Gemini, DeepSeek, Kimi, all directly in China—handy for developers doing model A/B testing or fallback strategies without having to apply for quotas, do compliance, or pass KYC individually.

Practical suggestions:

1. Benchmark with standard first, then switch to high-speed—your current task’s pass rate is the baseline. If high-speed drops beyond tolerance, mix them—use standard for long task planning, high-speed for code generation/execution.
2. Enable Context Caching—Agent system prompts are usually long and fixed; with cache hits, the unit price drops to 1/30, combined with high-speed the cost-effectiveness is maximized.
3. Use Token Enforcer with Function Calling—tool call error rates directly determine whether the task completes. Kimi provides hard guarantees here, more reliable than just prompt-based format enforcement.
4. Don’t overuse the 256K context—in long contexts, high-speed slows down and attention’s effective information density is diluted. For most tasks, 32K–64K is enough; use full context only when reading an entire repo.

A quick assessment

Moonshot didn’t hold press conferences or make big announcements this time—just put the model on the open platform and let developers find it. Looking at the whole K2 series, their strategy has been clear: good models, aggressive pricing, API aligned with Anthropic, coding as the main battleground.

K2.7 Code high-speed isn’t revolutionary, but it turns “domestic coding models are good enough” from a slogan into a measurable reality. 150–200 TPS output speed, plus 256K context, Anthropic API compatibility, automatic caching—these engineering abilities are enough for a serious Coding Agent team to run a production environment without relying on overseas models.

If you previously excluded Kimi from your main lineup because of speed, it’s worth re-evaluating now.

References

• linux.do - KIMI API上线kimi-k2.7-code-highspeed: First community discussion, includes actual speed tests and model ID information