If you already ship with Kimi, the July 16, 2026 launch of Kimi K3 raises a practical question: should you upgrade, or keep Kimi K2.7 Code for coding workloads that already work? K2.7 Code is the coding-focused release in the K2 line. K3 is Moonshot’s new flagship: a much larger model with a new attention design and a 1M-token context window. This guide focuses on what changed and how to make a migration decision with your own workload.
Both models expose an OpenAI-compatible API, so you can send the same request to kimi-k3 and kimi-k2-7-code, then compare output quality, latency, and token spend before changing production code. You can do this side by side in Apidog.
TL;DR
- K3 is a larger, general-purpose flagship model. It is a 2.8T-parameter mixture-of-experts model, versus the roughly 1T-class K2 line that produced K2.7 Code.
- K3 supports 1,048,576 tokens of context. This matters for large repositories, long transcripts, tests, and logs.
- Its architecture is new, not only larger. K3 uses Kimi Delta Attention, Attention Residuals, and Stable LatentMoE, with 16 of 896 experts active per token.
- K3 has flagship pricing. Listed rates are $0.30/M cache-hit input, $3/M cache-miss input, and $15/M output.
- K3 is not the overall frontier leader. Moonshot says it still trails Claude Fable 5 and GPT-5.6 Sol overall.
- Migrate to K3 for large context, general reasoning, or long-running agents. Stay on K2.7 Code when narrow coding tasks already meet your quality and cost targets.
K2.7 Code and K3 solve different problems
Kimi K2.7 Code is the coding-focused member of the K2 lineage: K2, K2 Thinking, K2.5, K2.6, and K2.7 Code. It targets code generation, editing, and developer-agent tasks.
K3 is not simply the next coding release. It is Moonshot’s general flagship model, with coding as one capability among broader reasoning and long-horizon agent workflows.
That distinction should drive your choice:
- Choose K2.7 Code when your workload is narrow, code-centric, and already performs well.
- Evaluate K3 when your agents need more context, broader reasoning, or more reliable multi-step execution.
For exact K2.7 Code parameters, context, and pricing, see the Kimi K2.7 Code explainer.
What changed in K3
Scale: roughly 3× more total parameters
K3 is a 2.8T-parameter mixture-of-experts model. The K2 line was in the roughly 1T-parameter class.
However, do not interpret 2.8T total parameters as 2.8T parameters running for every token. MoE models activate only part of their total parameter set. Moonshot did not publish K3’s active-parameter count, but it did publish the expert-routing pattern: 16 of 896 experts are active per token.
Architecture: a new attention design
K3 introduces three named components:
- Kimi Delta Attention: a hybrid linear-attention mechanism designed to scale more efficiently with longer sequences than standard quadratic attention.
- Attention Residuals: Moonshot describes these as a drop-in replacement for standard residual connections.
- Stable LatentMoE: the MoE framework behind K3’s 16-of-896 expert activation.
Moonshot reports roughly 2.5× better scaling efficiency than Kimi K2. That means the change is architectural as well as a scale increase.
Context: 1M tokens
K3 supports a 1,048,576-token context window.
For coding workflows, this can change how you build agents. Instead of selecting a few relevant files, you can provide a much larger slice of a repository alongside tests, build output, logs, and previous tool results.
Use this capability carefully. A larger context window removes truncation pressure, but it does not eliminate the need to evaluate whether supplying more context improves results on your tasks.
Positioning: coding specialist to flagship generalist
K2.7 Code is a specialist. K3 is a general flagship model designed to handle long-running, multi-step work, including agentic coding.
Moonshot cites autonomous runs on difficult multi-step tasks, including a 48-hour chip-design run. Treat those examples as motivation to test K3 on your own workflow, not as proof that it will solve every long-running agent problem.
Pricing: cache behavior determines the real input cost
K3 lists:
| Token type | Listed price |
|---|---|
| Cache-hit input | $0.30 per million tokens |
| Cache-miss input | $3 per million tokens |
| Output | $15 per million tokens |
The important detail is the 10× difference between cache-hit and cache-miss input.
If your agent repeatedly reuses a large system prompt and repository context, effective input cost can move closer to the cache-hit rate. If every request has fresh context, you pay closer to the cache-miss rate.
Output tokens remain $15/M, so keep output verbosity under control when testing cost.
For the full calculation, see the Kimi K3 pricing guide.
Kimi K3 vs. Kimi K2.7 Code
| Dimension | Kimi K2.7 Code | Kimi K3 |
|---|---|---|
| Positioning | Coding-focused release in the K2 line | Flagship general model, strong at agentic coding |
| Generation | K2 lineage | New K3 generation |
| Total parameters | Roughly 1T-class K2 line | 2.8T total, MoE |
| Active parameters | Confirm in K2.7 Code documentation | Not published; 16 of 896 experts active |
| Attention design | K2-generation attention | Kimi Delta Attention + Attention Residuals |
| MoE framework | K2-generation MoE | Stable LatentMoE |
| Context window | Confirm in K2.7 Code documentation | 1,048,576 tokens |
| Model ID | kimi-k2-7-code |
kimi-k3 |
| API compatibility | OpenAI-SDK compatible | OpenAI-SDK compatible |
| Listed pricing | Confirm in K2.7 Code documentation | $0.30/$3 input, $15 output per M tokens |
| Open weights | See K2.7 Code coverage | Expected around July 27, 2026 |
| Independent signal | See K2.7 Code coverage | Artificial Analysis Intelligence Index: 57, #4 of 189 |
| Best fit | Narrow coding at a known cost | Large-context, long-horizon, general and coding work |
For precise K2.7 Code details, use the Kimi K2.7 Code explainer and the Kimi K2.7 Code API guide.
Where K3 sits relative to the frontier
Do not read “2.8T flagship” as “best model overall.”
Moonshot’s own launch post says K3 trails Claude Fable 5 and GPT-5.6 Sol overall. It is competitive on individual benchmarks and ahead on some, but Moonshot does not claim the overall lead.
Artificial Analysis ranks K3 at Intelligence Index 57, #4 of 189 models. It reports output speed of roughly 62 tokens per second, which is on the slower side for K3’s price tier.
Moonshot reports mixed coding-benchmark results:
| Benchmark | K3 | Claude Fable 5 |
|---|---|---|
| DeepSWE | 67.5 | 70.0 |
| Terminal-Bench 2.1 | 88.3 | 84.6 |
K3 wins some comparisons and loses others. That makes it a strong open-weight contender, not an automatic replacement for every frontier model.
Read Moonshot’s claims in the official Kimi K3 launch post, and compare them with the independent analysis in this Kimi K3 benchmarks breakdown.
When to migrate to K3
Migrate when one or more of these conditions apply:
- You hit context limits. Large repositories, whole-service refactors, long tool transcripts, tests, and logs exceed what K2.7 Code can comfortably process.
- Your tasks are long-horizon and agentic. Your agent executes many tool calls and needs to preserve state across a long run.
- You need reasoning beyond code generation. Your workflow combines implementation with planning, analysis, debugging, or document interpretation.
- You have high cache reuse. Shared system prompts and repeated repository context can make K3’s cache-hit input pricing more attractive.
When to stay on K2.7 Code
Stay on K2.7 Code when these conditions describe your workload:
- Your tasks are narrow coding tasks and quality is already sufficient.
- You are cost-sensitive and have little cache reuse. One-shot requests with fresh context pay K3’s cache-miss input rate.
- Interactive latency is more important than maximum capability. Benchmark K3 before assuming that the larger model will feel faster.
- Self-hosting is a requirement. K3 weights were expected around July 27, 2026, so verify the actual release on Moonshot’s Hugging Face page before planning around them.
Practical migration examples
CI code-fix bot on a mid-sized repository
If your bot already passes tests, stays within context limits, and is cost-effective on K2.7 Code, do not migrate by default.
Your action plan:
- Keep
kimi-k2-7-codeas the production default. - Collect failures caused by missing context, weak planning, or multi-step errors.
- Test K3 only against those failure cases.
- Migrate if the quality gain justifies the latency and token cost.
Autonomous refactor agent on a large monorepo
This is a stronger K3 use case.
K3 can potentially hold more source files, tests, configuration, logs, and tool history in a single context. Its design also targets longer agent runs that modify multiple files over multiple steps.
Your action plan:
- Build a benchmark set from completed and failed refactors.
- Include repository context, test failures, and expected acceptance criteria.
- Run both models with identical prompts and tools.
- Measure patch correctness, test pass rate, total runtime, and total token cost.
- Route large-refactor tasks to K3 only if it consistently improves outcomes.
For implementation guidance, see the Kimi K3 coding walkthrough and the Kimi K3 API guide. For the older model lineage, see the K2.6 explainer.
How to A/B test K2.7 Code and K3
Because both models are OpenAI-SDK compatible, the core migration change is typically the model ID.
Start with two otherwise identical requests:
from openai import OpenAI
client = OpenAI(
api_key="YOUR_MOONSHOT_API_KEY",
base_url="YOUR_MOONSHOT_ENDPOINT",
)
base_request = {
"messages": [
{
"role": "system",
"content": "You are a senior engineer. Return a minimal, tested patch.",
},
{
"role": "user",
"content": "Fix the failing test and explain the root cause.",
},
],
"temperature": 0,
}
k27_result = client.chat.completions.create(
model="kimi-k2-7-code",
**base_request,
)
k3_result = client.chat.completions.create(
model="kimi-k3",
**base_request,
)
Keep these inputs fixed between runs:
- System prompt
- User prompt
- Temperature
- Tool definitions
- Repository context
- Test commands
- Maximum output tokens
Then compare the results across three categories.
1. Output quality
Measure quality using production criteria, not subjective preference:
- Did the patch compile?
- Did it pass the relevant tests?
- Did it introduce regressions?
- Did it modify only necessary files?
- Did it follow repository conventions?
- Did it complete the requested task without retries?
2. Latency
Record:
- Time to first token
- Total response duration
- Tool-call round trips
- End-to-end task duration
K3’s reported speed is roughly 62 tokens per second, so latency may matter for interactive developer tools.
3. Token cost
Track:
- Cache-hit input tokens
- Cache-miss input tokens
- Output tokens
- Number of retries
- Total cost per successful task
A model that costs more per request can still cost less per completed task if it reduces retries or failed agent runs. Measure both.
Apidog can make this comparison easier without writing a separate test harness:
- Save the K2.7 Code request in a project.
- Duplicate it.
- Store the model ID in an environment variable.
- Set one request to
kimi-k2-7-codeand the other tokimi-k3. - Keep prompts, parameters, and tools identical.
- Inspect streaming responses, tool-call payloads, latency, and token usage.
You can download Apidog for this workflow. If you work from an editor, the Apidog inside VS Code integration keeps API testing close to your code.
The bottom line
K3 is a real generation change over K2.7 Code:
- Roughly 3× the total parameters: 2.8T
- A new attention and MoE architecture
- A 1M-token context window
- A shift from coding specialist to flagship generalist
It also has higher listed pricing and does not claim to beat Claude Fable 5 or GPT-5.6 Sol overall.
Use K3 when large context, general reasoning, or long-horizon agents are requirements. Keep K2.7 Code when it already meets your coding quality target at a cost and latency profile you prefer.
The implementation path is simple: run both model IDs against your real prompts, record quality, latency, and effective token cost, then route tasks based on measured results.
Frequently asked questions
Which model is better for coding?
K2.7 Code is tuned specifically for coding and can be a cost-effective option for narrow developer tasks. K3 is a general flagship model that is also strong at long-horizon agentic coding and has a much larger context window.
For large-repository, multi-step agent tasks, K3 has the structural advantage. For narrow coding tasks that K2.7 Code already handles well, K2.7 Code may be the better spend.
Is Kimi K3 more expensive than K2.7 Code?
K3 lists $0.30/M cache-hit input, $3/M cache-miss input, and $15/M output. Whether it costs more per completed task depends on cache reuse, output length, retries, and task success rate.
Because both models are OpenAI-SDK compatible, switching is mostly a model-ID change followed by prompt and performance testing.
Is Kimi K3 open source?
Not on launch day. Moonshot said full model weights were expected around July 27, 2026. Until those weights are available, treat self-hosting as gated on the actual release.
Is K3 better than Claude Fable 5 or GPT-5.6 Sol?
According to Moonshot’s own blog, no: K3 trails both overall. It is competitive or ahead on selected benchmarks, and Artificial Analysis ranks it at Intelligence Index 57, #4 of 189 models.
K3 is a strong open-weight contender, but not the outright frontier leader.
Top comments (0)