Fact-checked: August 4, 2026 · Model status: active coding specialist · Evidence level: official documentation and model card; not independently benchmarked by Kimi AI Guide.
Kimi K2.7 Code is Moonshot AI’s open-weight model built specifically for long-horizon software engineering. Its Global Kimi API ID is kimi-k2.7-code, it has a 262,144-token context window, and the official hosted API accepts text, image and video. Thinking is mandatory: K2.7 Code does not offer a non-thinking mode.
For coding at a lower token price than K3, K2.7 Code is the strongest fit in Kimi’s current lineup. For the highest overall capability or a 1M context window, consider Kimi K3. For mixed general-purpose tasks and optional non-thinking responses, consider Kimi K2.6.
Kimi K2.7 Code at a glance
| Field | Verified value |
|---|---|
| Current status | Active |
| Model release recorded by Kimi Code | June 12, 2026 |
| Global Kimi API model IDs | kimi-k2.7-code, kimi-k2.7-code-highspeed |
| Kimi Code model IDs | kimi-for-coding, kimi-for-coding-highspeed |
| Official open-weight repository | moonshotai/Kimi-K2.7-Code |
| Architecture | Mixture of Experts with MLA attention and MoonViT vision encoder |
| Total / activated parameters | 1T / 32B |
| Context window | 262,144 tokens |
| Hosted API input | Text, image and video |
| Thinking | Always enabled |
| Non-thinking mode | Not supported |
| Tool calling | Supported, with documented constraints |
| License | Modified MIT |
Sources: Kimi’s K2.7 Code API guide, official model card and Kimi Code release notes.
What is Kimi K2.7 Code designed to do?
K2.7 Code is optimized for tasks that extend beyond one generated snippet: exploring a repository, implementing changes across files, debugging, running tools, recovering from errors and continuing until an engineering objective is complete.
Moonshot describes it as a K2.6-based model with improved instruction following, task completion and reasoning-token efficiency on long-horizon coding workflows. The company reports about 30% lower thinking-token use on average than K2.6. That figure comes from the vendor’s evaluation; Kimi AI Guide has not reproduced it.
The model is natively multimodal. Its MoonViT encoder can bring screenshots and other visual evidence into coding-agent workflows—for example, inspecting a rendered interface before making another code change. Actual success still depends on the agent harness, tools, environment, permissions and validation loop.
Model architecture and context
| Specification | Official value |
|---|---|
| Total parameters | 1 trillion |
| Activated parameters | 32 billion |
| Layers | 61 |
| Experts / selected per token | 384 / 8 |
| Context length | 256K (262,144 tokens) |
| Attention mechanism | Multi-head Latent Attention (MLA) |
| Vision encoder | MoonViT, 400M parameters |
The parameter count is a technical description, not a workload-level quality score. K2.7 Code and K2.6 share the same listed scale and architecture, while their post-training and intended use differ.
A 256K window can hold a substantial amount of code and conversation history, but repository size on disk does not translate directly into tokens. Agent tools may selectively retrieve files, discard tool output or compact earlier turns. Record those choices when comparing models because they can change the result as much as the advertised context limit.
Thinking is required
K2.7 Code always runs with thinking enabled on the Kimi API and Kimi Code. The Global API guide documents these request constraints:
thinkingmust remain enabled; disabling it returns an error.- temperature is fixed at
1.0. top_pis fixed at0.95.nis fixed at1.- presence and frequency penalties are fixed at
0.0. - during multi-step tool use, the previous assistant message’s
reasoning_contentmust remain in context. tool_choiceis limited toautoornonein the documented K2.7 flow.
The model card also says preserve-thinking mode is forced. That makes full-message history handling important: a client that removes reasoning fields is not running the intended multi-turn setup.
In Kimi Code, turning thinking off does not produce a non-thinking K2.7 response. The official model documentation says such a request is routed to K2.6 instead. A comparison that ignores that fallback could attribute a K2.6 result to K2.7 Code.
Multimodal support and caveats
The official hosted API supports text, images and video. Kimi documents PNG, JPEG, WebP and GIF images, plus several common video containers. It recommends images no larger than 4K and video no larger than 1080p because higher resolutions add processing time without improving the model’s understanding.
Important implementation limits include:
- public image URLs are not supported in the documented hosted flow; use base64 or uploaded files;
- request bodies must remain within the platform size limit;
- large or repeatedly referenced media should be uploaded rather than embedded every time;
- image and video token use is dynamic and should be estimated before an expensive request;
- the open-weight model card describes video chat as experimental and supported only by the official API at the time of publication.
Do not assume that a self-hosted or third-party K2.7 endpoint reproduces the official hosted video pipeline.
Kimi K2.7 Code API pricing
Official list prices checked August 4, 2026:
| Model ID | Cache-hit input / 1M | Cache-miss input / 1M | Output / 1M | Context |
|---|---|---|---|---|
kimi-k2.7-code | $0.19 | $0.95 | $4.00 | 262,144 |
kimi-k2.7-code-highspeed | $0.38 | $1.90 | $8.00 | 262,144 |
Prices exclude applicable taxes. Automatic context caching can reduce the rate for eligible reused input, but it does not make all repeated requests cache hits.
Kimi describes HighSpeed as the same model served faster, at approximately 180 output tokens per second and up to 260 tokens per second in short contexts. Those speeds are vendor estimates, not our measurements. Kimi also warns that constrained resources can make the experience fluctuate. The HighSpeed API prices are twice the standard rates.
Cost example
At standard K2.7 prices, 500,000 cache-miss input tokens plus 50,000 output tokens costs approximately $0.675 before tax: $0.475 input + $0.20 output.
This excludes retries, additional agent turns and paid tools. See Kimi API pricing for a fuller billing explanation.
Kimi API versus Kimi Code
These are separate access routes:
Global Kimi API
- Model ID:
kimi-k2.7-code. - High-speed ID:
kimi-k2.7-code-highspeed. - Pay-as-you-go token billing through the API Platform.
- OpenAI-compatible endpoint and account-level rate limits.
Kimi Code membership
- Standard ID:
kimi-for-coding. - High-speed ID:
kimi-for-coding-highspeed. - Uses membership quota and Kimi Code keys/base URLs, not the Global API balance.
- Standard K2.7 is documented as available to all members; HighSpeed requires Allegretto or above as of August 4, 2026.
Membership prices and quotas can change independently from API token rates. Review Kimi membership pricing rather than combining the two products in one cost calculation.
Open weights and self-hosting
Moonshot publishes K2.7 Code at Hugging Face under the Modified MIT License. The model card recommends vLLM, SGLang and KTransformers deployment paths and lists native INT4 quantization.
The model still has one trillion total parameters. Self-hosting requires serious hardware and serving expertise, even when quantized. Chat templates, reasoning-field support, multimodal preprocessing and agent harnesses can produce meaningful differences from the official API.
If a third-party provider says it serves K2.7 Code, verify the exact model version, quantization and inference configuration before treating its output as equivalent to Moonshot’s hosted service.
Vendor-reported benchmark results
Moonshot’s official K2.7 Code model card compares it with K2.6. The raw scores below are vendor-reported and have not been reproduced by Kimi AI Guide.
| Benchmark | K2.6 | K2.7 Code |
|---|---|---|
| Kimi Code Bench v2 | 50.9 | 62.0 |
| Program Bench | 48.3 | 53.6 |
| MLS Bench Lite | 26.7 | 35.1 |
| Kimi Claw 24/7 Bench | 42.9 | 46.9 |
| MCP Atlas | 69.4 | 76.0 |
| MCP Mark Verified | 72.8 | 81.1 |
The card says both Kimi models ran through Kimi Code CLI with thinking enabled, temperature 1.0, top-p 0.95 and a 262,144-token context. Kimi Code Bench v2 and Kimi Claw 24/7 Bench are in-house evaluations. MCP Mark Verified was human rechecked by the Kimi team and benchmark owner but was described as not yet open-sourced in the model card.
These results support the vendor’s claim that K2.7 improved over K2.6 under its evaluation setup. They do not establish that K2.7 beats every model, agent or deployment on your codebase.
When K2.7 Code is the right choice
Consider K2.7 Code for:
- multi-file feature implementation and refactoring;
- debugging that requires repeated terminal or test-tool use;
- codebase questions requiring a long context;
- visual frontend iteration using screenshots;
- coding agents where preserved reasoning and tool history are supported;
- cost-sensitive coding workloads that do not need K3’s 1M window.
Consider K2.6 for general writing, conversation or mixed workflows where thinking sometimes needs to be disabled. Consider K3 for tasks that exceed 256K context or benefit from the current flagship’s broader capability.
Important limitations
- K2.7 Code cannot disable thinking, so simple requests may use more reasoning than necessary.
- Its 256K capacity does not guarantee accurate reasoning across every token.
- Tool-calling quality depends on schemas, the harness, execution results and recovery logic.
- Preserve-thinking requirements make client compatibility important.
- HighSpeed throughput is vendor-reported and can fluctuate; faster model output does not accelerate external tools.
- Video behavior can differ outside the official hosted API.
- Official benchmark results mix public and in-house evaluations.
- Generated code can be insecure, incomplete or wrong and must be reviewed and tested.
Our independent testing status
We have not yet run a logged-in K2.7 Code comparison. No latency, success-rate, cost or code-quality statement on this page is presented as our own result.
A valid future test will preserve the repository snapshot, task specification, acceptance tests, model ID, client and version, context policy, tool permissions, thinking history, number of attempts, token use, cost, wall-clock time and final diff. We will publish failures as well as successes. See our testing methodology.
Frequently asked questions
What is the Kimi K2.7 Code API model ID?
Use kimi-k2.7-code on the Global Kimi API. Kimi Code uses kimi-for-coding; the identifiers and billing systems are different.
Does Kimi K2.7 Code have a non-thinking mode?
No. Thinking is mandatory. On Kimi Code, disabling thinking routes the request to K2.6 rather than running K2.7 without reasoning.
How large is the K2.7 Code context window?
The official API lists 262,144 tokens. The useful amount available to an agent can be lower after system prompts, tool definitions, output allowance and client-side compaction.
Is K2.7 Code multimodal?
Yes. The official API supports text, image and video input. Video is described as experimental and official-API-only in the open-weight model card, so third-party behavior requires verification.
Is K2.7 Code better than K3?
Not universally. K2.7 is a lower-cost coding specialist. K3 is Kimi’s current flagship, has a 1M context window and targets broader frontier tasks. Test both on the workload and budget that matter to you.