Kimi K3 vs K2.7 Code: Is the Upgrade Worth It for Coding?

Last updated: October 9, 2026. Prices, context windows and vision support re-verified against Moonshot's docs and OpenRouter.

Upgrade to Kimi K3 when your coding agent needs more than 256K tokens of working context or runs multi-hour loops; keep Kimi K2.7 Code as the default worker for bounded coding tasks. On Moonshot's API, K3 costs $3 input and $15 output per million tokens against K2.7 Code's $0.95 and $4, so a workload that fits in K2.7's window has to get measurably better results on K3 to justify roughly 3x the bill.

What Changed on October 9, 2026#

• K2.7 Code accepts images and video too. An earlier version of this post said K2.7 Code had no native vision. Moonshot's K2.7 Code quickstart documents image and video input, with a multimodal tool-calling example. Vision is no longer the dividing line; context size, long-horizon stamina, and price are.
• K3 now bills cache writes. Moonshot's pricing page lists cache writes at $3 per million tokens for the default 5-minute TTL and $6 for the 1-hour TTL, with cache hits at $0.30. K2.7 Code lists cache hits at $0.19 and no separate write charge.
• Third-party K3 prices spread out. OpenRouter now lists 20 K3 providers, from $0.49 to $4.50 per million input tokens and $12 to $22.50 output. Moonshot, Fireworks, Modal, Baseten and Amazon Bedrock list the $3/$15 rate there. The access guide tracks every route.
• Independent benchmarks arrived. Artificial Analysis, as shown on OpenRouter, scores K3 (max) at 85.0 on Terminal-Bench 2.1, below Moonshot's own 88.3. Z.ai's model card puts GLM-5.3 at 88.2 on the same benchmark, so the open-weights lead is now a rounding error.

What Changed on August 1, 2026#

Kimi K2.7-Code arrived as a focused, efficient coding model. A month later, Kimi K3 changed the shape of the comparison. It is much larger, holds up to 1 million tokens, and is designed for long agent runs that mix terminals, screenshots, research, and code. Two things landed since the original July 17 version of this post:

• K3's weights shipped on July 27 as promised - the 2.8T-parameter model (104B active) is on Hugging Face in native MXFP4 4-bit form with the MoonEP inference stack open sourced alongside it. The open-weights reality is now known, and it is datacenter-scale: roughly 1.5TB of VRAM at native MXFP4, with a 2-bit quant at about 1TB. See the K3 weights analysis and the access guide with verified prices.
• Third-party hosting routes opened up. Beyond Moonshot's API at $3/$15, K3 was served at launch on Together, Fireworks, Modal, SiliconFlow, and OpenRouter with a $0.30 cache-read rate, per the open-weights showdown. Third-party prices have since moved; see the October 9 notes above.

That does not make K2.7 obsolete. For many coding tasks, the older model is still the more economical tool.

Kimi K3 vs K2.7 at a glance#

Prices were checked July 17, 2026 and re-verified against Moonshot's pricing page on October 9, 2026. K3 costs more than three times as much on uncached input and nearly four times as much on output through Moonshot's API.

Choose K3 for visual and repository-scale work#

K3's clearest advantage is not a few points on a code benchmark. It is room: room to keep screenshots, logs, and a large repository in one loop for hours.

Both models accept images and video on Moonshot's API, so the question is not whether the model can see. It is how long it can keep looking. For frontend work, game development, CAD, and browser automation, a loop that captures a screenshot every iteration burns context quickly, and K3's 1M window holds four times what K2.7 Code's 256K does. Moonshot also publishes vision benchmarks for K3 (MMMU-Pro 81.6 without tools, OmniDocBench 91.1 on its model card) and demos of it generating interactive 3D experiences, capturing live screenshots, and refining the result. Our vision-in-the-loop explainer covers what that workflow changes for frontend agents.

The 1M-token window also gives K3 room for large repositories, long test histories, design references, and research material. If your agent repeatedly loses earlier decisions or requires aggressive context pruning, K3 is worth testing.

Keep K2.7 for bounded coding tasks#

K2.7 remains a good fit for code generation, bug fixes, refactors, and terminal tasks where the relevant context fits inside 256K. It is cheaper, its weights have been available for months, and the ecosystem has documented deployment paths.

The pricing gap compounds quickly. One million input tokens plus 100,000 output tokens costs about $1.35 on K2.7 at Moonshot's listed rates. The same uncached workload costs about $4.50 on K3. If the larger model does not improve completion quality enough to avoid retries or human intervention, the upgrade is wasted spend.

Third-party routes narrow that gap. The cheapest K3 endpoint on OpenRouter on October 9 listed $0.49 input and $13 output per million tokens, which puts the same workload near $1.79. Check each endpoint's quantization, uptime, and data terms before routing production traffic to the cheapest one.

K2.7 also remains the safer self-hosting choice today. K3's weights are out, but the footprint answers the infrastructure question with a number most teams cannot meet: 1.5TB of VRAM at native MXFP4 is roughly 8x B200-class GPUs at the limit, and realistically 16x once you account for context and throughput. Individual developers and most startups are priced out; this is a cloud-provider or well-funded-lab deployment.

Benchmark claims need the same caution for both#

Moonshot reports that K3 performs competitively with its strongest comparison model on several kernel-optimization tasks. The numbers include a widely cited one: Terminal-Bench 2.1 at 88.3 on Moonshot's own harness, plus agent benchmark scores (MCPMark-Verified 94.5, ProgramBench 77.8, SWE-Marathon 42.0) that land at or above the closed frontier on most axes. These are useful signals, but the maker-reported figures deserve the same caution as any launch data.

Independent numbers now exist, and they run lower. Artificial Analysis scores K3 (max) at 85.0 on Terminal-Bench 2.1, and Z.ai reports GLM-5.3 at 88.2 on its own run, one tenth of a point behind K3's vendor number. Moonshot's model card still omits SWE-bench Verified, so compare against your own tasks rather than one leaderboard.

K2.7's launch had the same limitation: impressive maker-reported improvements with incomplete independent coverage. The responsible comparison is a task suite built from your own repository:

1. Select 20 representative issues across debugging, refactoring, tests, and UI work.
2. Give both models the same tools and time limits.
3. Measure accepted patches, wall time, token cost, test pass rate, and human corrections.
4. Run visual tasks separately so K3's native vision has a fair chance to matter.

One blended score hides the reason you would pay for K3.

A practical routing strategy#

Use K2.7 as the default worker for bounded, text-first coding. Escalate to K3 when the task crosses one of three thresholds:

• The relevant working set does not fit comfortably inside 256K.
• Success depends on screenshots, diagrams, or video frames across many iterations, where visual evidence piles up past 256K.
• The agent must sustain a multi-hour loop across research, code, execution, and evaluation.

This keeps K3's higher price attached to the workloads that can benefit from its architecture. It also avoids turning a model launch into an all-or-nothing migration. On the API side, the $0.30 cache-read rate makes repeated-context agent loops on K3 noticeably cheaper than the uncached numbers suggest. If your loop pauses longer than five minutes between calls, Moonshot's 1-hour TTL costs $6 per million tokens to write, so model it against your real prompt churn before the routing decision. Our model routing recipes show how to wire the escalation.

When to wait#

Wait if you need self-hosting on anything below server-class hardware or stable low-latency serving from a managed provider. Independent benchmarks have started to arrive and sit a few points under Moonshot's figures. The K3 technical report and serving guidance have landed, and they confirm the datacenter footprint. For most teams, K3 should enter the routing table before it replaces anything. Let measured task outcomes decide whether it earns more traffic.

FAQ#

Is Kimi K3 replacing K2.7-Code?#

K3 is the new flagship, but K2.7 remains useful for cheaper, bounded coding tasks and for teams that need downloadable weights that fit on manageable hardware. K3's 2.8T weights are open, but self-hosting them is a datacenter project (~1.5TB VRAM at native MXFP4).

Does Kimi K3 have a larger context window?#

Yes. K3 supports 1 million tokens compared with K2.7-Code's 256K window.

Is Kimi K3 cheaper than K2.7?#

No. At Moonshot's pricing, K3 costs $3/M uncached input and $15/M output, with $0.30 cache hits. K2.7 Code costs $0.95/M input, $0.19/M cache hits, and $4/M output. On OpenRouter, K3 endpoints ranged from $0.49 to $4.50 input and $12 to $22.50 output on October 9, 2026, so a cheap third-party K3 route can come close to K2.7's first-party price.

Which model is better for frontend coding?#

Both accept screenshots, so K2.7 Code handles ordinary component work with visual checks. K3 is the stronger pick for long visual loops: its 1M window holds far more screenshots and logs, and Moonshot publishes vision benchmarks and vision-in-the-loop demos for it.

Does Kimi K2.7 Code support images?#

Yes. Moonshot's K2.7 Code quickstart documents image input (png, jpeg, webp, gif) and video input, including a multimodal tool-calling example. Images must be base64-encoded or uploaded as files; public image URLs are not supported.

Is Kimi K3 open weights?#

Yes, with a license. Moonshot released the 2.8T K3 weights on Hugging Face on July 27, 2026 under a custom Kimi K3 License: free for most use, with a separate commercial agreement required for model-as-a-service businesses above $20M aggregate revenue over any 12 consecutive months. The MoonEP inference stack and AgentEnv eval environment are open sourced too.

Official Sources#

Sources#

• Kimi K3 official launch post - fetched July 17, 2026, re-verified July 31, 2026
• Kimi K3 API quickstart - fetched July 17, 2026, re-verified October 9, 2026 (reasoning effort, cache TTLs)
• Kimi API pricing - K3 and K2.7 Code rates, cache writes and hits (fetched October 9, 2026)
• Kimi K2.7 Code quickstart - image and video input, 256K context (fetched October 9, 2026)
• Kimi K3 weights on Hugging Face - 2.8T MXFP4 release, license terms, benchmark table (verified July 31, 2026, re-checked October 9, 2026)
• Kimi K3 on OpenRouter - 20 provider endpoints and prices, Artificial Analysis scores (fetched October 9, 2026)
• GLM-5.3 model card - Terminal-Bench 2.1 comparison table (fetched October 9, 2026)
• Kimi K2.7-Code developer guide - reviewed July 17, 2026
• Kimi API platform - fetched July 17, 2026

Continue Reading#

• Kimi K3 Weights Land on HuggingFace - the 2.8T open release, benchmarks, licensing terms
• Where to Access Kimi K3 - every provider route with verified prices
• Kimi K3 Developer Guide - the model itself, in depth
• Open-Weights Coding Showdown - K3 vs GLM-5.2 vs DeepSeek V4 vs Qwen3
• Model Routing Recipes to Cut AI Spend - tiering K3 with cheaper workers
• Kimi K3 in GitHub Copilot - using K3 without leaving Copilot