Kimi K3 Just Killed the AI Subscription Era

The headline number is not the story

On July 27, Moonshot AI publishes the full weights of Kimi K3 under a Modified MIT license. The spec sheet reads like a flex: 2.8 trillion parameters, a context window of one million tokens, and the title of largest open-weight model ever released, roughly 75% bigger than DeepSeek V4 Pro.

But the size is bait. The real story is a shift in who controls access to frontier-level intelligence. For three years, the best models lived behind an API. You paid rent, the landlord set the terms, and if the vendor repriced the endpoint or quietly changed the model's behavior, your product absorbed the damage.

Open weights break that arrangement. Once the files are public, no lab can take the capability back. That single fact changes the economics for everyone, including people who will never download a single shard.

The spec sheet at a glance

Spec

Value

Parameters

2.8 trillion

Experts

896 total, 16 active per token

Context window

1,048,576 tokens

License

Modified MIT

Weights release

July 27

Size vs DeepSeek V4 Pro

~75% bigger

Scaling efficiency vs K2

~2.5x

Pricing

Rate

Input (cache hit)

$0.30 / 1M tokens

Input (cache miss)

$3.00 / 1M tokens

Output

$15.00 / 1M tokens

How a 2.8T model avoids a 2.8T bill

A dense model of this size would be unusable. Running every parameter on every token is the wall that all trillion-scale models hit: too slow, too expensive, no way around the physics.

K3 sidesteps it with an aggressive Mixture-of-Experts design. Inside the model live 896 specialist sub-networks. On any given token, only 16 of them fire. You get the stored knowledge of 2.8 trillion parameters while paying the inference cost of a model a fraction of that size.

This is sparsity, and K3 leans on it harder than any open model before it. K2 proved the approach worked. K3 turns it into the core bet.

Two research papers that did the heavy lifting

Two architectural changes make the rest possible, and both were published as open research before the model shipped, which earned Moonshot credibility with researchers before a single benchmark appeared.

The first is Kimi Delta Attention, a hybrid linear attention mechanism. Standard attention costs grow quadratically as context gets longer, which is why million-token windows usually stay in marketing decks. KDA scales differently, and that difference is the only reason a 1M window exists at a price anyone can actually pay.

The second is Attention Residuals, a replacement for standard residual connections. Moonshot credits it with the consistent scaling gains, letting them build deeper models without the usual degradation. By their own numbers, the combination delivers roughly 2.5x the scaling efficiency of K2.

What one million tokens kills

Most of the retrieval infrastructure in production AI exists as a workaround. Chunking, embeddings, vector databases, RAG pipelines: all of it compensates for models that can't hold enough in working memory at once.

A million tokens changes the default. An entire codebase goes into a single prompt. A year of internal documents. Fifty video transcripts. Everything sits in attention simultaneously, and the model reasons across the whole corpus instead of stitching together retrieved fragments and hoping the seams hold.

Native vision widens the input surface further. Screenshots, whiteboard photos, architecture diagrams and charts are readable in the same context as the code and text around them. It is no accident that K3's strongest benchmark wins came in front-end coding: the model sees the design and writes the implementation inside one context window.

The pricing table that matters more than benchmarks

The listed rates: $0.30 per million input tokens on a cache hit, $3.00 on a cache miss, $15.00 per million output tokens, with a context of 1,048,576 tokens.

The cache number is the one to stare at. Moonshot reports cache hit rates above 90% in long coding sessions. Think about what an agent actually does: it rereads the same repository over and over for hours. Without caching, it pays full input price on every pass. With it, the cost of a long session collapses roughly 4x.

Long-horizon agents live or die on exactly this math. K3 is built for sessions that run for hours with minimal supervision, navigating a repo, orchestrating terminal tools, checking its own work. The pricing structure is the product.

The catch nobody should skip

K3 has no economy mode. Reasoning is permanently on and fixed at maximum. Independent testers watched it burn over 13,000 thinking tokens on a trivial SVG request, roughly $0.25 for a throwaway query.

The lesson is routing. Quick, cheap, high-volume calls belong on smaller models. K3 earns its cost only when context size and task complexity justify always-on reasoning. Using it as a general-purpose chat endpoint is setting money on fire.

Plugging it in takes five minutes

The API is OpenAI-compatible. Swap the base_url and the key, keep your existing code:

1from openai import OpenAI
2import os
3
4client = OpenAI(
5    api_key=os.environ["MOONSHOT_API_KEY"],
6    base_url="https://api.moonshot.ai/v1",
7)
8
9completion = client.chat.completions.create(
10    model="kimi-k3",
11    messages=[{"role": "user", "content": "Introduce Kimi K3 in one sentence."}],
12)
13print(completion.choices[0].message.content)

Reasoning is configured through a top-level field, currently accepting only "max":

1completion = client.chat.completions.create(
2    model="kimi-k3",
3    reasoning_effort="max",
4    messages=[{"role": "user", "content": "Prove that the square root of 2 is irrational."}],
5)
6print(completion.choices[0].message.content)

Streaming works the standard way, with reasoning arriving in a separate delta field so you can render the thinking and the answer independently:

1stream = client.chat.completions.create(
2    model="kimi-k3",
3    messages=[{"role": "user", "content": "Explain why the sky is blue."}],
4    stream=True,
5)
6
7for chunk in stream:
8    delta = chunk.choices[0].delta
9    reasoning = getattr(delta, "reasoning_content", None)
10    if reasoning:
11        print(reasoning, end="", flush=True)
12    if delta.content:
13        print(delta.content, end="", flush=True)

Vision input takes base64-encoded images alongside text in the same message. This is the screenshot-to-code workflow in its entirety:

1import base64
2from pathlib import Path
3
4image_data = base64.b64encode(Path("landing.png").read_bytes()).decode()
5
6completion = client.chat.completions.create(
7    model="kimi-k3",
8    messages=[
9        {
10            "role": "user",
11            "content": [
12                {
13                    "type": "image_url",
14                    "image_url": {"url": f"data:image/png;base64,{image_data}"},
15                },
16                {"type": "text", "text": "Rebuild this landing page in HTML and Tailwind."},
17            ],
18        }
19    ],
20)
21print(completion.choices[0].message.content)

Why this reaches people who never touch the weights

Here is the honest part: almost nobody will self-host 2.8 trillion parameters. Even with sparsity, the hardware bill sits far beyond hobbyist range, and beyond most companies too.

That was never the point. Public weights put a ceiling on what closed labs can charge for comparable capability. Third-party hosts will race each other to serve K3 at commodity margins, the same dynamic that played out with every major open release before it. Prices across the whole market drift toward the open baseline.

The benefit reaches you through the invoice of whatever provider you already use, whether or not you ever download a file.

A practical playbook

Feed it whole things. Complete repositories for review, full contract folders, an entire content library. Stop chunking what no longer requires chunking.

Run it long. Queue multi-hour engineering sessions and check results later. The cache eats the cost of every reread.

Point a camera at problems. Screenshot a landing page and ask for the rebuild. Photograph a whiteboard and ask for the implementation.

Keep trivial traffic off it. A model that always reasons at max is the wrong tool for quick, high-volume calls. Route those elsewhere and save K3 for work that deserves it.

The ten-day countdown

For three years the frontier was something you rented, on terms you didn't set, at prices that could change without warning.

On July 27 it becomes a file. And a file, unlike a subscription, is something you own.