Kimi K3 Release: Specs, Pricing, API & When to Switch

Yesterday you were still reading teasers and “2.5T / 1M” rumor tables. Today the model picker has a real button: Kimi K3 is on the Kimi API Platform.

If you’re staring at that button thinking do I flip everything to K3 before lunch? — short answer: no. Use K3 when the job is hard and long. Keep K2.7 Code for day-to-day shipping in the IDE, and K2.6 when you want a cheaper, proven long agent.

Here’s the release-day pick in one breath:

• Hard multi-domain work + you keep hitting 256K walls → try kimi-k3
• Writing/fixing software in Kimi Code, Claude Code, Cline, RooCode → stay on kimi-k2.7-code first
• Long autonomous chores that already work on K2.6 → don’t “upgrade” only for the logo

This site is independent of Moonshot. Specs and prices below track the official docs; the judgments (who should switch, how the bill behaves, what the pre-launch noise got wrong) are ours. Re-check platform.kimi.ai before you spend real money.

What actually shipped (in plain English)

Moonshot’s public card says K3 is the most capable flagship so far: about 2.8 trillion parameters, a 1M-token context window (how much text/code it can hold in one go — think multi-package repos and fat research packs, not a single chat bubble), native vision (images and video in the API), and thinking that stays on.

The API name you’ll wire is kimi-k3. Docs put it on the usual OpenAI-compatible path (https://api.moonshot.ai/v1) with MOONSHOT_API_KEY.

Two architecture names show up: Kimi Delta Attention and Attention Residuals. You don’t need to implement either. Read them as product signal: Moonshot is selling a generation jump aimed at long sessions, not “K2.x plus three benchmark points.” Earlier research (Kimi Linear / KDA) was about serving long context more efficiently; on release day, the user-facing promise is simply 1M that is meant to be usable, plus always-on reasoning.

Quick facts (scan later)

Still thin on the public card: active (routed) parameters per token, a full open-weight license story, and a same-page independent leaderboard. Don’t invent those; wait for a technical report if you need serving math.

How this updates last week’s story

If you read our release-eve brief or the which-model guide, a few lines need a mental patch:

So the trailer became a ticket. It did not automatically become the only movie you should watch.

Why K3 is not “delete K2.7 Code”

Moonshot is shipping a portfolio, not a single ladder where the newest SKU wins every click.

• K2.7 Code is still the coding specialist — instruction-heavy IDE/CLI loops, Kimi Code, coding agents, a highspeed variant when latency matters. Context stays in the 256K class. Thinking stays on, but the product story is “finish the PR.”
• K2.6 is still the general long agent that already spent months in production narratives: multi-step tools, broad chores, multimodal general work at a lower list price band than K3.
• K3 is the flagship general intelligence tier: bigger memory, always-max reasoning (for now), premium price, meant for frontier-ish mixes of engineering + knowledge work + deep reasoning.

Our take: K3 is a supervisor / hard-problem model, not a free upgrade for autocomplete. If your pain is “the model keeps losing the repo after 200k tokens of logs,” K3 is the interesting button. If your pain is “make this TypeScript compile in Claude Code,” K2.7 Code is still the boring correct answer.

What the price is really saying

Official USD list (per 1M tokens):

Three judgments we care about more than the table itself:

1. Output is 5× cache-miss input. Always-on thinking means you pay for “thinking out loud” as well as the final answer. Treat K3 like a project budget, not a tab you leave open for small talk.
2. Cache hits are 10× cheaper than misses on input. Reusing the same system prompt / repo digest is not a nice-to-have — it’s the difference between “flagship we can afford” and “why is the bill on fire.”
3. No length tiers, but tokens still scale. 50K and 500K prompts share the same unit rates; the 1M window does not mean “1M is free.”

Rough portfolio sense-check (list prices move; this is orientation, not a contract): K2.6 / K2.7 Code have sat in a much lower band on the same platform (on the order of ~$1 input / ~$4 output class). K3’s $3 / $15 is premium on purpose. You should feel a capability or context reason before you make it the default.

Capabilities that change how you work (not how you recite docs)

1M memory for real sessions. Useful when one thread must hold a monorepo slice, policy pack, or multi-hour agent state. Most chat users will never fill a million tokens — and that’s fine. The feature is for the people who were already breaking 256K.

Always-on thinking. Don’t send the old K2.x thinking object. Use top-level reasoning_effort: "max" (only level today). In multi-turn and tool loops, send back the full assistant message, including reasoning and tool calls — stripping to content alone will bite you.

Vision in the same loop as code. Screenshots, UI recordings, diagrams — same session as tools and long context. Public image URLs aren’t the documented path; plan for base64 or uploaded ms:// files.

Agent surface. Tools, tool_choice, dynamic tool loading, structured JSON Schema, partial continuations, Formula official tools. Platform currently warns that web search is being updated — don’t bet a production workflow on it this week.

Minimal call shape:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["MOONSHOT_API_KEY"],
    base_url="https://api.moonshot.ai/v1",
)

completion = client.chat.completions.create(
    model="kimi-k3",
    reasoning_effort="max",
    messages=[{"role": "user", "content": "Summarize the risk of migrating our default model to K3."}],
)
print(completion.choices[0].message.content)

Sampling knobs like temperature / top_p are documented as fixed — omit them instead of fighting the API.

What should you do this week?

Common mistakes

• “Newest flagship = best at everything.” Wrong SKU thinking. Flagship depth ≠ best latency or best coding agent UX.
• “1M means I should paste the whole company.” You’ll pay for it; start with the smallest context that still works, then grow.
• “Thinking off for cheap drafts.” You can’t on K3 right now — only "max".
• “Replace K2.7 Code in Kimi Code tomorrow.” Product lines still diverge; watch official Kimi Code defaults before you force the ID.
• Ignoring cache. Same repo prefix every turn without stable prefixes is the expensive way to run a flagship.

FAQ (short)

Is it officially out? Yes — listed, documented, priced, callable as kimi-k3.

Open weights? We’re not treating third-party blurbs as a Moonshot promise. Check Moonshot’s own research / HF channels before you plan self-host.

Does it replace K2.7 Code? No. Portfolio: general flagship vs coding specialist.

Bottom line

K3 clears the bar we set on the release eve: real API name, real 1M window, real price. The smart move is not “everyone to K3,” it’s put K3 on the jobs that justify premium reasoning and huge memory, keep K2.7 Code for shipping PRs, and keep K2.6 where a cheaper long agent already delivers.

Next reads: K3 status · what we thought before GA · model chooser (patch mentally for GA) · K2.7 Code · K2.6.