What Is Kimi K3? Moonshot's 2.8T Open Flagship

Moonshot AI shipped Kimi K3 on July 16, 2026, and called it “the world’s first open 3T-class model.” That is a big claim, so let’s separate the marketing from the engineering. K3 is a 2.8-trillion-parameter Mixture-of-Experts model with a 1 million token context window, a fresh attention stack, and a pricing sheet aimed squarely at coding teams. It went live the same day across Kimi.com, Kimi Work, Kimi Code, and the Kimi API, with full weights promised by July 27, 2026. This guide is the hub for everything you need to evaluate it: what it is, how it’s built, what it costs, where it ranks, and who should actually use it.

TL;DR: what is Kimi K3?

Kimi K3 is Moonshot AI’s flagship large language model, released July 16, 2026. It uses a 2.8T-parameter Mixture-of-Experts design that activates 16 of 896 experts per token, ships a 1,048,576-token (1M) context window, and is served through the API model ID kimi-k3. Pricing is $0.30 per million cache-hit input tokens, $3.00 per million cache-miss input tokens, and $15.00 per million output tokens. On the independent Artificial Analysis Intelligence Index it scores 57 and ranks #4 of 189 models. Moonshot’s own launch post says K3 still trails Claude Fable 5 and GPT-5.6 Sol, so it’s best read as the strongest open model near the frontier, not the frontier itself. Full open weights are expected around July 27, 2026.

Why Kimi K3 matters right now

Every few months a Chinese lab ships a model that resets expectations for what you can run without a proprietary API contract. Kimi K3 is that model for mid-2026. The headline is not raw benchmark supremacy. It’s the combination of frontier-adjacent quality, an aggressive cache-hit price, and a promise to release the full weights within eleven days of launch. If that promise holds, K3 becomes the most capable model you can self-host, which changes the math for anyone weighing an API bill against a GPU cluster.

If you build with LLM APIs, the practical question is simple: can you point your existing OpenAI-style client at kimi-k3 and get useful output without rewriting your stack? The answer is yes, because Moonshot ships an OpenAI-SDK-compatible API. That also means you can test and debug K3 calls in the tools you already use. Apidog treats any OpenAI-compatible endpoint as a first-class request, so you can send a streaming chat completion to kimi-k3, inspect the server-sent events token by token, and watch tool calls resolve before you wire the model into production code.

This post is the pillar for the wider Kimi K3 cluster. For deep dives, jump to the Kimi K3 API guide, the Kimi K3 pricing breakdown, or the Kimi K3 benchmarks analysis. Here, we cover the whole picture.

The identity: Moonshot’s most capable model

Moonshot AI positions K3 as “our most capable model,” a step up from the Kimi K2 line that many developers already know. If you’ve used Kimi K2 or the coding-focused Kimi K2.7 Code, K3 is the next generation of that lineage, rebuilt from the attention layer up. The claim that draws the most attention is “the world’s first open 3T-class model.” Two words in that phrase matter.

“Open” is a near-future fact, not a launch-day one. At release, K3 is available through hosted products and the paid API, and Moonshot committed to releasing “full model weights by July 27, 2026.” So if you’re planning a local deployment, treat open access as a scheduled event roughly a week and a half after launch, not something you can download on day one.

“3T-class” refers to scale. At 2.8 trillion total parameters, K3 sits in the same weight class as the largest proprietary systems, even though only a fraction of those parameters activate on any given token. That sparse activation is what keeps inference affordable, and it’s the reason the pricing looks the way it does.

Architecture: what’s new under the hood

K3 is not a bigger copy of K2. Moonshot rebuilt the core with several named techniques, and the design choices explain both the quality gains and the throughput numbers.

Kimi Delta Attention (KDA). This is a hybrid linear attention mechanism that Moonshot describes as an efficient foundation for scaling attention. Linear-style attention keeps memory and compute growth in check as context lengths climb, which is what makes a 1M-token window practical rather than theoretical.

Attention Residuals (AttnRes). Moonshot presents this as a drop-in replacement for standard residual connections. The stated goal is to selectively retrieve representations across the depth of the network, so information from earlier layers stays reachable deeper in the stack. In plain terms, it helps the model hold onto context instead of washing it out layer by layer.

Stable LatentMoE. This is the Mixture-of-Experts routing layer, and it’s where the “2.8T total, small active” story lives. K3 has 896 experts and activates 16 of them per token, using what Moonshot calls Quantile Balancing to keep routing stable during training. Sparse activation means the model can carry trillions of parameters of knowledge while only paying the compute cost of a much smaller network at inference time.

Moonshot also references supporting components including Per-Head Muon, a Sigmoid Tanh Unit (SiTU), and Gated MLA, plus MXFP4 weights with MXFP8 activations for quantization.

Kimi K3 specs at a glance

Here’s the snapshot to bookmark. Every figure below comes from Moonshot’s launch post or the independent Artificial Analysis listing.

That table is the fast answer for most “spec check” searches. For a line-by-line cost model against your own token volume, the Kimi K3 pricing guide runs the numbers.

The 1M context window, and why cache-hit pricing is the real story

A 1,048,576-token context window puts an entire codebase, a long research corpus, or a multi-hour transcript inside a single prompt. That’s table stakes at the frontier now, but the way K3 prices long context is what makes it interesting for real workloads.

Look at the input pricing again: $0.30 per million tokens on a cache hit versus $3.00 on a cache miss. That’s a 10x gap. Moonshot’s inference stack, which it calls Mooncake disaggregated inference, reportedly delivers a cache-hit rate above 90% on coding workloads. If your usage pattern reuses a large shared context, a long system prompt, a big file tree, a fixed instruction block, most of your input tokens bill at the cheap rate. For agentic coding loops that resend the same repository context on every step, that difference compounds fast. This is the lever that makes K3 competitive on cost even though its per-token output price sits in normal frontier territory.

The tradeoff shows up in speed. Artificial Analysis measured K3 at about 62 tokens per second of output, below the median of 72.7 for reasoning models in its price tier. Time to first token is around 1.99 seconds, which is a touch better than the tier median. So K3 is a “think hard, stream steadily” model rather than a snappy one, and its default reasoning setting leans toward maximum thinking effort. If latency matters more than depth for your use case, benchmark it against a faster tier before committing.

Honest positioning: strong, open, not the outright frontier

This is the part of the story that too many launch write-ups skip. Moonshot itself drew the line clearly. The official Kimi K3 launch blog states that while K3 “still trails the most powerful proprietary models, Claude Fable 5 and GPT 5.6 Sol,” it “demonstrated frontier-level performance across our evaluation suite.” Read that twice, because it’s a rare piece of candor from a model vendor.

The independent numbers back up the nuance. On the Artificial Analysis Intelligence Index, K3 scores 57 and ranks #4 out of 189 models. That index blends nine evaluations covering agentic tasks, coding, science, and reasoning, so a top-five placement is a genuine signal, not cherry-picking. But #4 also means three models sit ahead of it, and Moonshot names two of them.

So how should you frame K3? It’s the strongest open-weight model near the frontier, and among the most capable models you can run without a proprietary contract once the weights land. It is not the single best model in the world, and you shouldn’t market it that way to your stakeholders. If you need the absolute ceiling on a hard reasoning task, the closed frontier still wins. If you need frontier-adjacent quality with an open path and a low effective price, K3 is a serious contender. For a head-to-head on where it lands against the closed leaders, see Kimi K3 vs Claude Opus 4.8 and Kimi K3 vs GPT-5.6 Sol.

Where you can use Kimi K3 today

K3 launched across Moonshot’s full product surface on day one. Here’s the availability matrix.

If you live in the terminal, Kimi Code is the coding-agent entry point; our Kimi Code CLI walkthrough covers the setup pattern from the K2 era, and the K3 flow is similar. If you want to compare the coding behavior against the previous champion in that lineage, Kimi K3 vs Kimi K2.7 Code is the direct matchup. And if you’d rather not pay at all while you evaluate, how to use Kimi K3 for free covers the no-cost paths.

Capabilities the API exposes

For developers, the model is only half the story. The API surface decides what you can build. K3’s endpoint supports the features you’d expect from a serious agentic model:

• Context caching (the mechanism behind that $0.30 cache-hit rate)
• Tool calls and tool-choice constraints
• JSON mode and structured output
• Partial mode for controlled completions
• Internet search
• Dynamic tool loading
• Configurable reasoning effort, including a “max” setting

That feature set means K3 slots into agent frameworks, structured-extraction pipelines, and function-calling apps without special handling. The base URL follows Moonshot’s established pattern, the OpenAI-compatible Kimi endpoint (confirm the exact base URL on platform.kimi.ai before you hardcode it, since the console moved to the new domain at launch). Point your OpenAI client at that endpoint, set the model to kimi-k3, and your existing tool-calling code should work. The full request-and-response walkthrough lives in the Kimi K3 API guide.

Testing kimi-k3 before you ship it

Here’s the part where a model spec becomes a working integration. Before you drop kimi-k3 into an agent loop, you want to see exactly what the endpoint returns: how tokens stream, whether tool calls fire in the shape you expect, and how the model behaves at max reasoning effort. That’s an API testing job, not a prompt-engineering one.

This is where Apidog earns its place in the workflow. Because K3 speaks the OpenAI protocol, you can add its chat-completions endpoint as a request in Apidog, store your key as an environment variable so it never lands in a shared collection, and fire a call with stream: true. Apidog renders the server-sent event stream so you can read the delta chunks as they arrive, which is the fastest way to confirm your streaming parser will handle K3’s output. When you send a request with tools defined, you can inspect the exact tool_calls payload the model returns and validate the arguments against your schema before a single line of agent code runs.

Frequently asked questions

What is Kimi K3? Kimi K3 is Moonshot AI’s flagship large language model, launched July 16, 2026. It’s a 2.8-trillion-parameter Mixture-of-Experts model with a 1M-token context window, served through the API model ID kimi-k3 and Moonshot’s consumer and developer products. Moonshot describes it as “the world’s first open 3T-class model.”

How many parameters does Kimi K3 have? K3 has 2.8 trillion total parameters and uses Mixture-of-Experts routing that activates 16 of 896 experts per token. Moonshot has not published an exact active-parameter count, so avoid quoting a specific active-billion figure as fact. The precise number they released is “16 of 896 experts.”

How much does the Kimi K3 API cost? Pricing is $0.30 per million cache-hit input tokens, $3.00 per million cache-miss input tokens, and $15.00 per million output tokens. Moonshot’s Mooncake inference reportedly hits a cache-hit rate above 90% on coding workloads, so effective input costs run low on repetitive, context-heavy tasks. The full model is in the pricing breakdown.

Is Kimi K3 open source? Not on launch day. Moonshot committed to releasing full model weights by July 27, 2026. Until then, you access K3 through the hosted products and the paid API. After the weights land, you’ll be able to self-host, which is the basis for the “open 3T-class” description.

Is Kimi K3 better than Claude Fable 5 or GPT-5.6 Sol? No, and Moonshot says so directly. The launch post states K3 “still trails the most powerful proprietary models, Claude Fable 5 and GPT 5.6 Sol,” while calling its performance frontier-level. On the Artificial Analysis Intelligence Index it scores 57 and ranks #4 of 189, so it’s near the top but not first.

Can I use Kimi K3 with the OpenAI SDK? Yes. Moonshot’s API is OpenAI-SDK compatible. Point your client at the OpenAI-compatible Kimi endpoint (confirm the exact base URL on platform.kimi.ai), set the model to kimi-k3, and your existing chat-completions and tool-calling code should work. You can verify the request and response shapes in Apidog before wiring it into your app.

How fast is Kimi K3? Artificial Analysis measured about 62 output tokens per second, below the price-tier median of 72.7, with a time to first token near 1.99 seconds. K3 favors depth over speed, and its default reasoning setting uses maximum thinking effort. Benchmark it against a faster model if latency is your constraint.

How does Kimi K3 compare to Kimi K2.7 Code? K3 is the next-generation flagship above the K2 line, with a rebuilt attention stack and roughly 2.5x better scaling efficiency than K2 per Moonshot. K2.7 Code remains a strong coding-specific option. The direct comparison lives in Kimi K3 vs Kimi K2.7 Code.