Kimi K3 vs Kimi K2.7 Code: What Moonshot's New Flagship Changes

Kimi K3 is Moonshot AI's newest model, and it lands directly above Kimi K2.7 Code in the lineup. K2.7 Code has been the go-to open model for agentic software engineering; K3 is the generational step up, a larger model with a much longer context window, native vision, and a reasoning dial that replaces K2.x's on-or-off thinking mode. If you're already running K2.7 Code, the practical question is what K3 buys you and when the extra capability is worth the extra cost.

TL;DR

Kimi K3 is the more capable model and the new default on AI Space: 2.8 trillion parameters, a 1M-token context window, native visual understanding, and always-on reasoning you can turn up or down per request. Kimi K2.7 Code is the leaner, cheaper flagship, a one-trillion-parameter model built single-mindedly for coding, with well-confirmed results on SWE-bench and agentic tool use, and lower cost per token. Lead with K3 when you want the strongest output, the longest context, or vision input; keep K2.7 Code for high-volume agent loops where cost and throughput matter more than the last increment of capability. Both run on AI Space through one OpenAI-compatible API.

Kimi K3 overview

Kimi K3 is built at a larger scale than anything else Moonshot has shipped: 2.8 trillion total parameters, served on AI Space with a 1M-token context window. That context is the headline change day to day, it's four times K2.7 Code's 256K, enough to hold a large repository, a long agentic history, and reference material in the same request without eviction.

Under the hood, K3 uses what Moonshot calls Kimi Delta Attention, a hybrid linear-attention design with attention residuals. The point of that architecture is to keep long-context processing affordable: linear-style attention scales more gently as the context grows, which is what makes a 1M window practical to serve rather than merely advertised. K3 is natively multimodal, so it takes image input alongside text: screenshots, diagrams, and UI mockups are first-class rather than something you have to describe in prose.

The other shift is how reasoning works. K2.x had a binary thinking mode; K3 replaces it with a reasoning_effort parameter you set per request, up to a "max" setting for the hardest problems. Reasoning is always on, but you control how much of it you pay for. That gives you a single lever to trade latency and cost against depth without switching models. K3 also supports token caching, tool use with tool_choice, and streaming.

Kimi K2.7 Code overview

Kimi K2.7 Code is Moonshot's frontier coding model and, until K3, the strongest open coder in the lineup. It's a one-trillion-parameter mixture-of-experts model with 32 billion parameters active per token, thinking-only (there's no non-reasoning mode), and natively multimodal with a vision encoder. On AI Space it runs with a 256K-token context window.

For coding specifically it has the better-confirmed track record. It's reported at around 60.4 on SWE-bench Verified, a high-water mark among open models at its announcement, and it posts strong agentic tool-use numbers, including 81.1 on MCP Mark Verified, ahead of some leading proprietary models. Its function-calling is polished: nested schemas, parallel tool calls, and clean recovery from tool errors, which is exactly what custom coding agents and CI-integrated automation lean on. It remains an excellent, cost-efficient choice, and for a lot of high-volume work it's the right one.

Head-to-head

A note on coding numbers: Moonshot's model page for K3 doesn't publish SWE-bench or LiveCodeBench figures yet, so we won't print one for it. K2.7 Code's numbers are well-supported and shown above. Treat K3 as the more capable model by scale, architecture, and positioning (the strongest coder on AI Space) rather than by a benchmark we can't yet confirm.

How to pick

Reach for Kimi K3 when:

• The task is hard (dense refactors, tricky generation, long multi-step reasoning) and you want the best output an open model can give you
• You need the long context: whole-repo analysis, large document sets, or agent runs that accumulate a lot of history
• The work involves images (screenshots, diagrams, UI mockups), where native vision earns its place
• You want one model and one reasoning_effort dial to cover both quick answers and deep work

Reach for Kimi K2.7 Code when:

• You're running many agents or many steps and want lower cost per token
• The work is well-scoped coding where K2.7's confirmed strength is plenty
• Throughput and predictable cost matter more than the last increment of capability

For a lot of teams the answer is to keep both: K3 for the hardest work and anything that needs the long context or vision, K2.7 Code for the high-volume agent loops around it. On AI Space that's a model-field change, not a re-architecture.

Running both on AI Space

Both models are available through AI Space's OpenAI-compatible API on one subscription. List them in your provider config and switch with the picker:

"models": {
  "kimi-k3": { "name": "Kimi K3" },
  "kimi-k2.7-code": { "name": "Kimi K2.7 Code" }
}

In code it's the model field: kimi-k3 or kimi-k2.7-code. Both run on Cloudflare's network across the US, UK, Germany, Japan, and Australia, so your code stays on infrastructure you trust rather than Moonshot's origin servers, and both bill at flat monthly rates (Starter $25, Pro $125) with per-user spend ceilings rather than open-ended per-token pricing.

If you're weighing K3 against the other flagship, see Kimi K3 vs GLM-5.2, or against the proprietary frontier in Kimi K3 vs Claude Opus 4.8. For the full lineup, see our roundup of the best open-source coding models in 2026. Get started with AI Space and run both on Cloudflare's global network.