Kimi K3 vs K2: What Changed, What Broke, and When to Upgrade Your Routing

Kimi K3 landed on July 16, 2026. It is Moonshot AI's new flagship — a 2.8-trillion-parameter Mixture-of-Experts model with a 1M-token context window, a new reasoning_effort parameter that replaces the K2-era thinking object, and pricing at $3.00 / $15.00 per million input / output tokens. If you are routing production traffic through Moonshot's API today, the upgrade is not a drop-in swap: the reasoning control surface changed, the context window quadrupled, and the price jumped roughly 3× over K2.6.

We wrote this comparison because K3's launch broke three things in our own testing pipeline within an hour — all related to the thinking → reasoning_effort parameter change. This post covers exactly what differs, what breaks, when K3 is worth the cost premium, and how to keep K2.6 or K2.7 Code running alongside K3 with a fallback configuration.

Sources: Kimi K3 Pricing, retrieved 2026-07-17; Model Parameter Reference, retrieved 2026-07-17; BenchLM Kimi K3 Analysis, retrieved 2026-07-17; Artificial Analysis Kimi K3, retrieved 2026-07-17.

TL;DR Comparison Table

Sources: Kimi K3 Pricing, retrieved 2026-07-17; Model Parameter Reference, retrieved 2026-07-17.

What Changed: The Full API Diff

Reasoning Parameter: thinking → reasoning_effort

This is the breaking change. K2.6 uses a thinking object in the request body:

# K2.6 — thinking mode ON
response = client.chat.completions.create(
    model="kimi-k2.6",
    messages=[{"role": "user", "content": "Explain quicksort"}],
    extra_body={"thinking": {"type": "enabled"}},
)

K3 drops the thinking object entirely and uses a top-level reasoning_effort field:

# K3 — reasoning always on, effort level set explicitly
response = client.chat.completions.create(
    model="kimi-k3",
    messages=[{"role": "user", "content": "Explain quicksort"}],
    extra_body={"reasoning_effort": "max"},
)

Key differences:

1. K3 always reasons. There is no disabled mode. If you relied on thinking.type: "disabled" for faster, cheaper K2.6 responses, K3 does not offer that option.
2. Only "max" is supported today. Moonshot says more levels are coming, but for now every K3 call runs at maximum reasoning effort.
3. Passing thinking to K3 returns an error. Your existing K2.6 code will fail if you swap the model ID without removing the thinking parameter.

Source: Model Parameter Reference, retrieved 2026-07-17.

Context Window: 256K → 1M

K3 supports 1,048,576 tokens — four times K2.6's 262,144. Pricing is flat across the full window (no context-length tiers), which simplifies billing but means long-context calls at $3.00 input + $15.00 output can get expensive fast.

Tool Calling: required Now Supported

K3 adds tool_choice: "required" — K2.6 and K2.7 Code only support auto and none. If you have been working around the missing required mode with prompt engineering, K3 lets you enforce tool calls natively.

K3 also introduces two new capabilities not available in K2:

• Dynamic tool loading — load tools at inference time
• Tool choice constraints — fine-grained control over which tools the model can invoke

Source: Kimi K3 Pricing page — Model Description, retrieved 2026-07-17.

Fixed Parameters

Both K3 and K2.6/K2.7 Code lock most sampling parameters. K3 fixes temperature at 1.0, top_p at 0.95, n at 1, and both penalty parameters at 0. Passing any other value returns an error. This is unchanged from K2.6 in thinking mode, but K2.6 in non-thinking mode used temperature: 0.6 — a distinction that no longer exists since K3 always reasons.

Pricing Comparison

K3 is roughly 2.6–2.8× more expensive than K2.6 on a per-token basis. However, K3's automatic context caching at $0.30 per million cached tokens can offset this significantly for multi-turn conversations or large system prompts. If 70% of your input tokens hit cache, your effective input cost drops to ~$1.11 — comparable to K2.6.

For context, K3's pricing positions it in the same band as Claude Opus 4.8 ($15/$75 but with a larger output premium) and below GPT-5.6 Sol. It is substantially more expensive than DeepSeek V4 ($0.50/$2.00) or Qwen3.7-Max (¥2/¥8 per million tokens).

Sources: Kimi K3 Pricing, retrieved 2026-07-17; Artificial Analysis Kimi K3, retrieved 2026-07-17.

Benchmark Comparison

All benchmark data below is vendor-reported by Moonshot AI unless otherwise noted. Independent verification is still early — Artificial Analysis and Vals published initial evaluations on July 16, 2026.

Coding

Agentic and Knowledge Work

Independent Evaluations

Artificial Analysis rates K3 at 57.11 Intelligence Index, 76.24 Coding Index, and 50.07 Agentic Index — placing its intelligence "near Claude Opus 4.8 and GPT-5.5, behind Claude Fable 5 and GPT-5.6 Sol." Output speed is measured at 62 tokens/second with 1.99s time to first token.

Vals Index v1.2 scores K3 at 74.7 overall. LMArena places K3 at #1 on the Frontend Code Arena with 1679 Elo.

Sources: BenchLM Kimi K3 Analysis, retrieved 2026-07-17; Artificial Analysis Kimi K3, retrieved 2026-07-17.

When to Stay on K2.6 / K2.7 Code vs. Switch to K3

Pick K3 if:

• You need 1M-token context. K2.6 caps at 256K. If your use case involves large codebases, long documents, or extensive conversation history, K3 is the only Kimi option.
• You need tool_choice: "required". K2.6 does not support it.
• You prioritize frontier coding quality. K3's coding benchmarks show substantial improvements over K2.6, particularly on long-horizon agentic coding tasks.
• You need the strongest agentic reasoning. The GDPval-AA Elo jump from 1190 (K2.6) to 1668 (K3) is enormous.

Stay on K2.6 if:

• Cost matters more than peak quality. K2.6 is 2.6–2.8× cheaper. For high-volume routing where K2.6-quality reasoning is sufficient, the savings add up.
• You need non-thinking mode. K2.6 supports thinking.type: "disabled" for faster, cheaper completions without reasoning chains. K3 always reasons.
• Your code uses the thinking parameter. Until you refactor, K2.6 is the path of least resistance.

Stay on K2.7 Code if:

• You need a code-specialized model at K2 prices. K2.7 Code is tuned for coding agent workflows and is cheaper than K3.
• You use Preserved Thinking. K2.7 Code requires keep: "all" thinking mode, which preserves reasoning_content across multi-turn conversations — a pattern not yet documented for K3.

OpenAI-compatible means a provider exposes a chat-completions endpoint whose request and response shape matches the OpenAI API contract closely enough that an unmodified OpenAI SDK call works against it after swapping three values: API key, base URL, and model name. The minimum surface in practice is POST /v1/chat/completions with messages, model, and an OpenAI-shaped streaming response.

Migration Checklist: K2.6 → K3

1. Change the model ID: kimi-k2.6 → kimi-k3
2. Remove the thinking parameter. K3 does not accept it. Remove any extra_body={"thinking": {...}} from your calls.
3. Add reasoning_effort. Pass extra_body={"reasoning_effort": "max"} — this is the only value currently supported.
4. Handle reasoning_content in responses. K3 may return reasoning_content in assistant messages. If your code parses or stores assistant messages, ensure it handles this field.
5. Update tool_choice usage. If you previously could not use required, you now can. If you were passing required and catching errors, remove the error handling.
6. Adjust cost budgets. Expect ~2.8× higher output costs. Factor in cache hit rates — if you have repetitive system prompts or contexts, K3's $0.30 cached-input rate helps.
7. Test context length handling. K3 supports 1M tokens. If your truncation logic was tuned for 256K, update it.

# Before (K2.6)
response = client.chat.completions.create(
    model="kimi-k2.6",
    messages=messages,
    extra_body={"thinking": {"type": "enabled"}},
)

# After (K3)
response = client.chat.completions.create(
    model="kimi-k3",
    messages=messages,
    extra_body={"reasoning_effort": "max"},
)

Routing K3 Through TheRouter

TheRouter currently routes multiple Kimi K2 models — including moonshot/kimi-k2.6 and moonshot/kimi-k2.7-code — through the Moonshot provider. K3 routing support depends on when the model is added to the routing table.

If you are using TheRouter's model fallback configuration, you can set up K3 as the primary model with K2.6 as fallback. This lets you try K3 for quality-sensitive tasks while keeping K2.6 as a cost-effective backup:

# Example fallback config (conceptual)
primary: kimi-k3
fallback:
  - kimi-k2.6
  - kimi-k2.7-code

TheRouter routes OpenAI-compatible requests through configured providers — the base_url and model-ID mapping handle the rest. When K3 is available in the routing table, you switch model IDs and TheRouter handles the upstream call.

Note: K3 routing availability in TheRouter depends on when the model is added to the models configuration. Check the Moonshot provider page for current model availability.

Open Weights: K3 Weights Coming July 27

Moonshot announced that K3 full model weights will be released by July 27, 2026. K2.6 is already available as open weights on Hugging Face. Once K3 weights ship, self-hosting becomes an option — though serving a 2.8T MoE model requires substantial infrastructure compared to K2.6's 1T.

FAQ

Q: Can I use K2.6 and K3 in the same application? Yes. They are separate model IDs (kimi-k2.6 and kimi-k3) on the same API endpoint (https://api.moonshot.ai/v1). You can route different requests to different models based on your needs.

Q: Will K2.6 be deprecated now that K3 is out? Moonshot has not announced a K2.6 deprecation date as of July 17, 2026. Given the different price points and use cases, both models may coexist for some time.

Q: Is K3 available on DashScope or other Chinese cloud platforms? As of launch, K3 is available via the Moonshot API at platform.kimi.ai. Third-party availability (DashScope, SiliconFlow, etc.) has not been announced.

Q: Why does K3 only support reasoning_effort: "max"? Moonshot says more effort levels are coming. The current limitation means K3 always runs at maximum reasoning intensity — there is no way to reduce reasoning for faster or cheaper responses.

---

This comparison is current as of July 17, 2026. K3 launched one day before publication — independent benchmarks and third-party availability are still emerging. We will update this post as more data becomes available.