62.0 points versus 50.9 points on the Kimi Code Bench v2 — a leap of almost 22 percent within a single model generation. Such numbers are rare for iterative updates. Yet that is exactly what Moonshot AI has achieved with the release of Kimi K2.7 Code. The new model positions itself as a specialized, agentic coding system and succeeds Kimi K2.6, improving significantly across several key benchmarks.
Kimi K2.7 Code is aimed specifically at developers who don’t just want code generated, but who want complex, multi-step programming tasks automated. With a Mixture-of-Experts architecture, a 256K context length, and noticeably more efficient token usage, Moonshot AI sends a clear signal in the race for agentic developer tools.
Table of Contents
Key Takeaways
- Kimi K2.7 Code scores 62.0 points on the Kimi Code Bench v2, a 21.8 percent improvement over K2.6 (50.9 points).
- The model is built on a Mixture-of-Experts architecture with 1 trillion total parameters, of which only 32 billion are active per token.
- The context length is 256K tokens, enabling long codebases and complex project structures.
- According to Moonshot AI, Kimi K2.7 Code requires around 30 percent fewer “thinking tokens” than its predecessor, making it more efficient.
- The model is accessible via Kimi Code and the Kimi API, with transparent, usage-based pricing.
What Is Kimi K2.7 Code?
Kimi K2.7 Code is an open-source model from Moonshot AI, developed specifically for agentic coding. Unlike classic language models that primarily generate text or isolated code fragments, Kimi K2.7 Code is designed to independently solve multi-step tasks: it can analyze code, identify bugs, plan solution paths, and implement them step by step.
The term “agentic” describes the model’s ability to not just react to individual prompts, but to independently steer longer workflows. This is especially relevant for software development, where individual tasks are often accompanied by multiple dependent steps — debugging a program, writing tests, and then optimizing the code.
Important for context: Kimi K2.7 Code comes exclusively from Moonshot AI and should not be confused with models from other providers such as OpenAI, Anthropic, or Google. The architecture, training, and product strategy follow Moonshot’s own technical approach.
The Technical Foundations of Kimi K2.7 Code
At the core of Kimi K2.7 Code is a Mixture-of-Experts (MoE) architecture. This design uses the strengths of multiple specialized “expert” networks, activated depending on the input. This allows a very large model to run efficiently without computing all parameters for every single request.
The concrete specs at a glance:
| Total Parameters | 1 trillion |
| Activated Parameters per Token | 32 billion |
| Context Length | 256K tokens |
| Architecture | Mixture-of-Experts (MoE) |
| License Model | Open Source |
This combination of a massive overall model and a comparatively lean activation per request allows high model quality to be paired with practical computing costs. The 256K token context length is especially relevant for software projects: it lets the model keep entire repositories, long documentation, or extensive test files in view at once, instead of processing information piecemeal.
Kimi K2.7 Code in Benchmark Comparison
The performance of Kimi K2.7 Code becomes especially clear in direct comparison with its predecessor, K2.6. Moonshot AI tested the new model on three key benchmarks covering different aspects of programming.
| Benchmark | Kimi K2.6 | Kimi K2.7 Code | Improvement |
| Kimi Code Bench v2 | 50.9 | 62.0 | +21.8% |
| Program Bench | 48.3 | 53.6 | +11.0% |
| MLS Bench Lite | 26.7 | 35.1 | +31.5% |
The biggest jump is on MLS Bench Lite, with a gain of 31.5 percent. This benchmark suggests Kimi K2.7 Code makes especially strong progress on tasks related to machine learning and data-driven software development. The Kimi Code Bench v2, which measures general coding ability, also shows a substantial 21.8 percent improvement.
“The improvements of Kimi K2.7 Code over K2.6 are not just marginal — they reflect a clear technological leap in agentic coding capability.”
Program Bench, which focuses more on classic programming tasks, shows the comparatively most moderate but still clearly measurable improvement at +11.0 percent. Overall, all three benchmarks point in the same direction: Kimi K2.7 Code solves more complex tasks more reliably than its predecessor.
Efficiency as a Core Feature of Kimi K2.7 Code
Beyond raw performance gains, Moonshot AI places particular emphasis on efficiency with Kimi K2.7 Code. According to the product description, the model requires around 30 percent fewer so-called “thinking tokens” than K2.6.
Thinking tokens are the tokens a model uses internally for intermediate reasoning steps before delivering a final answer. The more such tokens are needed, the higher the compute time and cost per request typically are. A 30 percent reduction translates in practice into:
- Faster response times at comparable task complexity
- Lower operating costs for API users with similar output
- More efficient use of available compute resources
This efficiency gain is especially relevant for developers deploying Kimi K2.7 Code in production environments, such as for automated code reviews, continuous integration, or longer-running agentic workflows where many requests must be processed in a short time.
Availability and Access to Kimi K2.7 Code
Kimi K2.7 Code is available to developers through two main channels: the Kimi Code platform and the Kimi API. Both access paths serve different usage scenarios.
Kimi Code offers a ready-to-use interface for developers who want to use the model for coding tasks without their own infrastructure. The Kimi API, on the other hand, is suited for teams who want to integrate Kimi K2.7 Code into their own applications, development environments, or automated pipelines.
Pricing Structure in Detail
Kimi K2.7 Code pricing follows a usage-based model:
| Input (Cache Miss) | $0.95 per million tokens |
| Output | $4.00 per million tokens |
This pricing structure follows the common model for large language models, distinguishing between input and output tokens. “Cache miss” refers to requests where no prior computations can be reused — in such cases, the full input cost applies. For developers, this means recurring or similar requests can potentially be cheaper if caching mechanisms kick in.
The fact that Kimi K2.7 Code is available as an open-source model also expands the options for organizations that run their own infrastructure or want to make specific customizations, even though usage-based API access remains the most direct path to production use.
Who Is Kimi K2.7 Code For?
Given the characteristics described, a clear user profile emerges for Kimi K2.7 Code:
- Development teams with complex codebases — thanks to the 256K context length, larger projects can be processed in a single pass.
- Teams focused on machine learning — the significant improvement on MLS Bench Lite points to stronger capabilities in this area.
- Companies with a high degree of automation — the reduced number of thinking tokens lowers costs at high request volumes.
- Open-source-friendly organizations — open availability allows flexibility in integration and customization.
For individual developers or smaller projects, Kimi K2.7 Code also offers a low-barrier entry point via Kimi Code, without the need for dedicated server infrastructure.
Context: Why Kimi K2.7 Code Matters
The development of agentic coding models marks a shift in how software is built. While earlier models primarily served as autocomplete or aids for individual lines of code, Kimi K2.7 Code aims to take on longer, independent work steps. The measured improvements across all three benchmarks — Kimi Code Bench v2, Program Bench, and MLS Bench Lite — suggest that Moonshot AI specifically focused this model generation on practical applicability for real development tasks, not just theoretical performance figures.
The combination of high benchmark performance, reduced resource consumption through fewer thinking tokens, and open availability as an open-source model makes Kimi K2.7 Code a notable step within the current landscape of agentic AI systems for software development.
Conclusion
Kimi K2.7 Code shows how agentic coding models can advance significantly within a single generation. With improvements of up to 31.5 percent over predecessor K2.6, a powerful Mixture-of-Experts architecture, and a 256K token context length, Moonshot AI delivers a model built for both complex development tasks and resource-conscious production use.
Developers interested in agentic coding solutions should take a close look at the concrete benchmark figures and the transparent pricing structure of Kimi K2.7 Code. Anyone already working with K2.6 should consider migrating to K2.7 Code, especially if efficiency and longer context processing are priorities. The sensible next step is to evaluate your own use cases against the available benchmarks and test the model via Kimi Code or the Kimi API in a concrete project.
