Moonshot AI Releases Kimi-k2.7-code: Open-Weights Coding Model with 256k Context and Multimodal Reasoning

Performance & Benchmarks

Moonshot AI reports that kimi-k2.7-code improves substantially over K2.6 across several coding and software-engineering benchmarks. The strongest reported gain is on Kimi Code Bench v2, where kimi-k2.7-code delivers a +21.8% improvement over K2.6. That benchmark is especially relevant because it is Moonshot’s own coding benchmark and likely reflects the kinds of software tasks the company is optimizing for: code generation, debugging, repository reasoning, and tool use.

The model also improves by +11% on Program Bench and +31.5% on MLS Bench Lite compared with K2.6. Those numbers suggest broad gains across both traditional program-level coding tasks and more complex software-engineering scenarios. Perhaps just as important for production systems, Moonshot reports 30% fewer tokens used during internal reasoning versus K2.6. For agentic workloads that run long chains of tool calls, test-generation loops, and self-correction steps, that reduction can translate into faster runs and lower inference cost.

• +21.8% improvement on Kimi Code Bench v2 vs K2.6
• +11% improvement on Program Bench vs K2.6
• +31.5% improvement on MLS Bench Lite vs K2.6
• 30% fewer tokens used on internal reasoning vs K2.6
• 256k context window with long-thinking support
• Native text, image, and video input support
• ToolCalls, JSON Mode, Partial Mode, and automatic context caching

API Pricing

Moonshot AI’s verified API pricing for kimi-k2.7-code is $0.95 per million input tokens, $0.19 per million input tokens on cache hit, and $4.00 per million output tokens. The verified context window for pricing is 262,144 tokens, which aligns with the advertised 256k context window. The cache-hit input price is especially important for long-context coding agents, because repository indexing, repeated file scans, and multi-turn debugging sessions can reuse the same prompt context across many calls.

Developers should treat kimi-k2.7-code as a premium coding model rather than a low-cost chat model. At $4.00 per million output tokens, it is best suited for high-value software tasks such as architectural refactoring, multi-file debugging, test generation, agent planning, and production code review. For repetitive or latency-sensitive workloads, Moonshot’s separate 6x High-Speed mode is expected to arrive soon, while the open-weights release gives teams another path for self-hosting or custom deployment.

• Input price: $0.95 per million tokens
• Input cache-hit price: $0.19 per million tokens
• Output price: $4.00 per million tokens
• Pricing context window: 262,144 tokens
• Automatic context caching supported
• 6x High-Speed mode coming soon
• Beta program available for early access to future updates

Use Cases

kimi-k2.7-code is best suited for developer workflows where context depth and reasoning quality matter more than raw chat throughput. The most obvious use case is coding assistance inside IDEs: generating code, explaining errors, rewriting modules, writing tests, reviewing pull requests, and producing structured patch suggestions. Partial Mode is particularly useful here because IDEs can render incremental model output while the model continues reasoning.

• Repo-level code generation and refactoring across large files and directories
• Agentic coding workflows with ToolCalls and long-running reasoning loops
• Automated test generation, debugging, and root-cause analysis
• RAG over large codebases, API docs, logs, and design specifications
• Multimodal development tasks using screenshots, UI videos, diagrams, or product demos
• Structured JSON outputs for CI/CD bots, code-review pipelines, and ticketing systems
• Enterprise AI IDE integrations through Kimi Code IDE and API access

Getting Started

Developers can access kimi-k2.7-code through Moonshot AI’s API, via HuggingFace for open-weight deployment, and inside Kimi Code IDE. For API integrations, teams should start by enabling context caching where repeated repository context is likely to be reused. This is especially important for long-context agent loops, where the same files, specifications, or test outputs may be referenced repeatedly across multiple tool calls.

A practical first workflow is to use kimi-k2.7-code for high-value tasks rather than every autocomplete request. Start with repository-level debugging, test creation, pull-request review, or architecture analysis. Use JSON Mode when the model output must be consumed by another system, ToolCalls when the agent needs to inspect files or run commands, and Partial Mode when building interactive developer tools that need streaming responses.

• Download open weights from HuggingFace for self-hosting or custom deployment
• Use the Moonshot AI API for managed inference and caching
• Integrate with Kimi Code IDE for AI-assisted development
• Enable JSON Mode for structured outputs consumed by CI/CD systems
• Use ToolCalls for agent workflows that need external tools or file operations
• Join the beta program for early access to future kimi-k2.7-code updates
• Watch for the upcoming 6x High-Speed mode for latency-sensitive coding workloads

API Pricing — Input: $0.95 / Output: $4.00 / Context: 262,144 tokens

Sources