Kimi K3 benchmarks, pricing, and how to start using it

Moonshot shipped the largest open-weight model anyone has released

Moonshot AI put out Kimi K3 on July 16, 2026. Total size is 2.8 trillion parameters, up from Kimi K2's 1 trillion, but the model only activates 16 of its 896 experts on any given request. That sparse routing is why Moonshot can call this the largest open-weight model shipped so far without the inference cost scaling with the full 2.8 trillion number.

The context window jumped from K2's 128,000 tokens to 1,048,576 tokens, an 8x increase. Input pricing moved from $0.60 to $3.00 per million tokens and output from $2.50 to $15.00, so K3 costs about 5x more to run than K2 per token. It is still cheaper than GPT-5.6 Sol's $5.00 and $30.00, and cheaper than Claude Opus 4.8's $5.00 and $25.00 on both ends. K3 also takes image input alongside text, so a single call can handle a screenshot of a stack trace or a UI mockup next to your prompt, not just plain text.

If you track which of these launches actually change what you should build with, browse live demand signals instead of guessing from headlines. This one is worth a closer look because the benchmark story is genuinely mixed, not a straight upgrade.

The number that actually matters: a 732 point jump over K2.6

Total parameter count and context window are easy to quote and easy to misread as the real story. The number that tells you whether K3 is actually a better coding agent is its score on Artificial Analysis' long-horizon agentic tracker: 1,547, a 732 point jump over Kimi K2.6. That tracker measures multi-step tasks where a model has to hold a plan across many tool calls, which is the exact shape of work a coding agent does inside a real repo, not a single-turn benchmark prompt.

Moonshot's own numbers put K3 at 67.5 on DeepSWE, 88.3% on Terminal-Bench 2.1, 81.2 on FrontierSWE, 77.8 on Program Bench, and 42.0 on SWE Marathon. Those are Moonshot's proprietary evaluation suites, so treat them as a first data point, not an independent audit.

What's actually new under the hood

The 1,048,576 token context window is not just a bigger buffer bolted onto the same architecture. Moonshot built K3 on two specific changes: Kimi Delta Attention, a hybrid linear attention mechanism, and a technique it calls Attention Residuals. Standard transformer attention gets quadratically more expensive as context grows, which is why most 1M-context models either get slow or get expensive fast. A hybrid linear attention layer keeps the cost per additional token closer to linear, which is the difference between a 1M context window you can actually afford to fill and one that exists mostly for marketing copy on a spec sheet.

The MoE routing is the other half of the story. K2's dense-ish setup activated 32 billion parameters out of 1 trillion, a 3.2% activation ratio. K3 activates 16 of 896 experts, and while Moonshot has not published the exact active-parameter count for K3, routing 16 out of 896 is a 1.8% activation ratio, tighter than K2's. That is most of why a model with 2.8x the total parameters of K2 only costs 5x more per token to run instead of scaling with the full parameter count.

The full picture against GPT-5.6 Sol and Claude Fable 5

Independent third-party tracking (Artificial Analysis, via kingy.ai's benchmark breakdown) gives a more useful cross-model read. Here is where K3 Max lands next to GPT-5.6 Sol Max and Claude Fable 5 Max on the same evaluations:

K3 wins SWE Marathon by 3 full points over Sol Max and 7 over Fable 5 Max, and it edges out Sol Max on AA-Briefcase, a private long-horizon knowledge-work benchmark. On the two Elo-style general benchmarks (GDPval-AA v2, and Artificial Analysis' overall Intelligence Index where K3 debuts at 57 against Sol's 59 and Fable 5's roughly 60), it trails both. Tom's Hardware also reported K3 ranking first in blind developer testing on the Frontend Code Arena, ahead of Fable 5, which lines up with the pattern: K3 is strong on long, structured coding work and weaker on general reasoning breadth.

How to call Kimi K3 right now

Weights are not public yet, but the API is live today at $3.00 input and $15.00 output per million tokens, with cached input at $0.30. The API is OpenAI-compatible, so if you already have code calling GPT models, switching the base URL and model string is close to the whole change.

Set your key once:

export MOONSHOT_API_KEY="your-key-here"

Install the SDK, the same one you'd use for OpenAI:

python3 -m pip install --upgrade "openai>=1.0"

Point the client at Moonshot's endpoint:

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",
    messages=[{"role": "user", "content": "Refactor this function for readability."}],
)
print(completion.choices[0].message.content)

Same call over curl if you're testing outside a script:

curl https://api.moonshot.ai/v1/chat/completions \
  --header "Authorization: Bearer $MOONSHOT_API_KEY" \
  --header "Content-Type: application/json" \
  --data '{
    "model": "kimi-k3",
    "messages": [{"role": "user", "content": "Refactor this function for readability."}]
  }'

One real gotcha: K3 always runs in thinking mode, and it uses a different parameter than K2.x did. Don't reuse your K2 thinking config.

completion = client.chat.completions.create(
    model="kimi-k3",
    reasoning_effort="max",
    messages=[{"role": "user", "content": "Plan a migration from 5 microservices to 3."}],
)

reasoning_effort currently only supports max, the default. Moonshot says more levels are coming, so this is a field you'll want to revisit once lower-effort tiers ship, since max on every call is also the most expensive way to use a 1M-context model.

What changes on July 27

Once weights land on Hugging Face, the practical difference is self-hosting for teams that need data to stay in-house, plus whatever fine-tuning ecosystem shows up around a 2.8 trillion parameter open checkpoint. Even at 4-bit quantization, a 2.8 trillion parameter MoE checkpoint is well over a terabyte on disk, so this is a multi-node serving job, not a single-GPU weekend project. If you're already running vLLM or SGLang for other open-weight models, the serving command shape once the repo is live will look like this:

vllm serve moonshotai/Kimi-K3 \
  --tensor-parallel-size 8 \
  --max-model-len 1048576

That command will not work until Moonshot actually publishes the checkpoint on July 27, but the flags are the real ones you'll set: tensor parallelism across however many GPUs you have, and the full 1,048,576 token context length if your hardware can hold it.

Switch if, stay if

Switch to K3 if your workload is long-horizon coding or agentic work where SWE Marathon and Terminal-Bench style multi-step tasks are the actual job, and you want a cheaper API than GPT-5.6 Sol without giving up the 1M context window. At $3.00 and $15.00 per million tokens it beats Sol's $5.00 and $30.00 on both ends while matching or beating it on 3 of the 5 benchmarks above.

Stay on what you have if you're already on Kimi K2 and cost is the binding constraint, K3 is roughly 5x more expensive per token than K2. Stay if you need the single highest general intelligence score today, Fable 5 and Sol both beat K3 on GDPval-AA v2 and the Intelligence Index by 80 to 90 points. And stay if self-hosting is the actual reason you wanted an open-weight model, since the weights are not downloadable until July 27.

If you're weighing a full migration rather than a one-off task, run the same 10 or 20 prompts through both models before committing. A 3 point win on Program Bench or a 732 point Elo jump on a tracker you don't actually use tells you less than watching K3 handle your own repo's longest-running task end to end.

Where this shows up if you're shipping an agent product

Clawsmith already tracks a live signal on this exact demand: a terminal AI coding agent thread that hit 1,274 points and 618 comments on Hacker News, with the top complaints being that existing tools still send prompts to the cloud even when a local model is configured, and that a terminal tool using over 1GB of RAM is unacceptable. An open-weight 2.8 trillion parameter model with a real coding benchmark lead is exactly the kind of building block that thread is asking for, once it's actually downloadable. The signal is free to read on Clawsmith, and the $25/mo builder tier (pricing) is what turns a signal like that into an agent-ready brief you can hand a coding agent.

For the next model launch worth actually switching for, not just reading about, check the model launches archive.