Kimi K3

On July 16, 2026, Moonshot AI shipped Kimi K3, and the ceiling for open-weight models moved again. It is a 2.8-trillion-parameter Mixture-of-Experts model with a 1-million-token context window, and Moonshot says the full weights land on Hugging Face by July 27. In blind developer testing it took first place on the Frontend Code Arena leaderboard, ahead of Claude Fable 5. It costs $3 in and $15 out per million tokens. In the same week, Anthropic is moving Fable 5 to $10 in and $50 out and pulling it out of subscription plans. If you build with models, that gap is the story. Here is what K3 is, what it actually scores, and how to point your existing agent at it today.

TL;DR

• What it is: a 2.8T-parameter Mixture-of-Experts model (activates 16 of 896 experts per token), 1M-token context, native vision, always-on reasoning. Weights promised under an open license by July 27, 2026.
• Why it matters: it beats or trails the top closed US models by a hair on reported benchmarks, at roughly a third of Fable 5's price, with the weights promised for anyone to run.
• The catch: the headline scores are first-party, the weights were not public at launch, and self-hosting 2.8T parameters is a data-center job.

What Moonshot actually shipped

One definition first, because it drives the cost math. A Mixture-of-Experts (MoE) model splits its feed-forward layers into many small "expert" subnetworks and routes each token to only a few of them. K3 holds 2.8 trillion parameters on disk but fires only 16 of its 896 experts per token, so you get the capacity of a very large model at the inference cost of a much smaller one. That is the same bargain behind other big open MoEs like DeepSeek-V4 and Qwen3.5.

It takes text and images, carries a 1-million-token context window aimed at long-horizon coding and agent runs, and ships with an always-on reasoning mode Moonshot calls thinking mode. Pricing through the Kimi API is $3.00 per million input tokens and $15.00 per million output tokens, dropping to $0.30 per million on cached input. This is the same team behind Kimi K2.7 Code and Kimi K2.5, now aiming a general flagship at the very top of the table.

Benchmarks, with the usual asterisk

Every number below is reported by Moonshot or by third-party arenas at launch, not reproduced on our bench. Read them as a starting point, not a measurement. The pattern is consistent though: K3 sits in the same band as the best closed US models, and leads several of them on agentic coding.

On GDPval-AA v2, a test of real tasks across 44 occupations, K3 placed third overall, behind Fable 5 Max and GPT-5.6 Sol Max but ahead of Claude Opus 4.8. On AA-Briefcase, a private long-horizon agentic benchmark from Artificial Analysis, it climbed to second, past GPT-5.6 Sol Max and behind only Fable 5 Max. The one that got the most attention: Arena ranked K3 first on Frontend Code at 1,679 points in blind developer voting, ahead of Fable 5. Its overall Coding Index came in at 76.24. Independent testers report K3 leading on Terminal-Bench 2.1 and long-horizon SWE tasks, while Fable 5 keeps the edge on several other coding suites. Call it a tie at the frontier, which is the point: an open-weight model is now trading blows with the most expensive closed ones.

The part the leaderboards skip: freedom and price

Here is why builders are paying attention beyond the score. K3 has no classifier sitting between your call and the model, and no quiet routing to a weaker fallback. Developers comparing the two report that the model you call is the model you get. That is not marketing spin from Moonshot, it is a design difference you can feel on long agent runs.

Contrast that with how a refusal works on the closed side. Anthropic's own API documentation describes a stop_reason of refusal, and states plainly that on Claude Fable 5, safety classifiers return this stop reason as a normal HTTP 200 response, not an error. In practice that means a request can look like it succeeded while the work simply did not happen, and your error monitoring will not flag it unless you check the stop reason. For agent pipelines that run unattended, a silent refusal is worse than a loud one.

Then there is the bill. In the same window K3 launched, Anthropic is pulling included Fable 5 access for Pro, Max, and Team subscribers on July 19, and switching it to metered usage credits on July 20 at $10 per million input tokens and $50 per million output tokens. That is double the rate of Claude Opus 4.8 and the most expensive pricing Anthropic has ever listed for a generally available model. Max subscribers are not exempt. So the same week one lab put its frontier model behind a higher paywall, another put a comparable one in the open at a third of the price.

The trend under all of this is not subtle. The frontier you can actually own, run, fine-tune, and audit is increasingly being set in the open, and right now a lot of it is being set by Chinese labs: Moonshot, DeepSeek, Qwen, Z.ai. You do not have to cheer for any flag to notice that open weights change your options. When the model is yours, nobody reprices it out from under you or reroutes it mid-run.

Run it in about 10 minutes

You do not have to wait for the weights to try K3. Point any OpenAI-compatible client at the Kimi API and you are calling it in one request.

# Kimi K3 via the Moonshot API (OpenAI-compatible endpoint).
# Get a key at platform.moonshot.ai, then:
export MOONSHOT_API_KEY="sk-..."

curl https://api.moonshot.ai/v1/chat/completions \
  -H "Authorization: Bearer $MOONSHOT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kimi-k3",
    "messages": [
      {"role": "user", "content": "Build a single-file browser desktop: draggable windows, a taskbar, and a working clock. Vanilla HTML, CSS, and JS only."}
    ]
  }'

Because the endpoint is OpenAI-compatible, you can also drop it straight into your existing coding agent. Set the base URL and model, keep everything else.

# Reuse any OpenAI-style SDK; just swap the base_url and model.
from openai import OpenAI

client = OpenAI(
    api_key="sk-...",              # your Moonshot key
    base_url="https://api.moonshot.ai/v1",
)

resp = client.chat.completions.create(
    model="kimi-k3",
    messages=[{"role": "user",
               "content": "Refactor this repo's auth module and add tests."}],
)
print(resp.choices[0].message.content)

A browser desktop clone, a full HTML mockup of an old operating system UI, a from-scratch web app: these long, single-shot build tasks are exactly where a 1M-token context and cheap output tokens pay off. Give K3 the whole spec in one prompt and let it run. Once the weights land on July 27, the same jobs move to your own hardware if you have the memory for it.

Limitations and gotchas

• Weights were not public at launch. Moonshot promised them "by July 27" under an open license, following its Modified MIT pattern on earlier Kimi releases, but at launch there was no confirmed checkpoint on Hugging Face. Verify the real repo and LICENSE when it appears.
• Benchmarks are first-party or arena-reported, not independently reproduced. Treat the table above as a vendor and community claim.
• It is enormous. At 2.8T parameters, self-hosting is a multi-node, data-center job even after quantization. This is not a laptop model, and it will not be for a long time.
• Until the weights drop, you are calling a China-hosted API. For sensitive code or data, read the Kimi terms and route accordingly.
• No safety classifier cuts both ways. Great for uninterrupted agent runs, but you own more of the guardrail decisions yourself.

Who should use it

Use K3 if you want frontier-class coding and agent performance without frontier pricing, you value calling a model that does not silently refuse or downgrade, and you want the option to run the weights yourself when they land. It is a strong fit for long agent jobs, large-repo work, and anyone whose bill just doubled when Fable 5 left their plan.

Hold off if you need a checkpoint you can self-host today (wait for July 27 and confirm it), if you require independently reproduced benchmarks before you trust a number, or if your data cannot leave your jurisdiction and the hosted API is your only option for now. For a smaller open coding model you can actually run this week, Kimi K2.7 Code or GLM-5.2 are the saner starting points.

Sources and further reading

• Moonshot: official Kimi K3 announcement
• VentureBeat: Moonshot releases Kimi K3
• Tom's Hardware: 2.8T Kimi K3 tops Frontend Code Arena
• OpenRouter: Kimi K3 API and benchmarks
• Anthropic docs: the refusal stop reason (HTTP 200 on Fable 5)
• BleepingComputer: Fable 5 subscription access and the July 19 cutoff
• Android Authority: Fable 5 metered credits at $10 / $50

Tested on: not independently benchmarked. Kimi K3 is a 2.8T-parameter MoE and was hosted-API only at the time of writing (weights promised for 2026-07-27), which is beyond our local bench. Every benchmark here is Moonshot-reported or arena-reported; pricing and access details are drawn from the sources linked above.
Date checked: 2026-07-18