Kimi K3.1 Pro: Open Weights, 1M Context, $2/$10 — the Budget Agentic-Coding Model
On 23 October 2026, Moonshot AI launched Kimi K3.1 Pro — the first model in its K3.1 series, a post-trained version of Kimi K3 with substantially more post-training compute. The headline numbers: a one-million-token context window, $2 per million input tokens and $10 per million output, and — from 4 November 2026 — the full model weights on Hugging Face for anyone to download. On Moonshot's own benchmark table it sits within a point of Claude Opus 5.5, at half the list price.
That is the pitch. The reality is more interesting: a 1.56-terabyte download no laptop can run, a licence that is open weights rather than open source, thinking tokens that bill as output, and benchmarks that all come from Moonshot itself. This post works through all of it.
What Kimi K3.1 Pro Is
Kimi K3.1 Pro is Moonshot AI's flagship model, built first for agentic work — long, multi-step jobs where a model plans the work, calls tools, reads the results and keeps going without a human holding its hand. It is natively multimodal (text and image input) and live in Kimi.ai, the Kimi mobile apps, Kimi Work, Kimi Code and the Kimi API. A faster variant, Kimi K3.1 Pro Highspeed, serves the same model roughly two to three times faster at double the price, according to Moonshot.
K3.1 Pro succeeds Kimi K3, which still costs $3/$15 on Moonshot's API — so the new flagship is one-third cheaper than the model it replaces on every rate, which is unusual. Moonshot's bet is clear: it wants K3.1 Pro to be the default agentic-coding model for developers who cannot justify Claude Opus prices.
One thing to know before you start: the reasoning cannot be switched off. Kimi K3.1 Pro thinks before it answers, and that thinking is part of every request — wasted money on short, simple questions, and the point for the long coding jobs the model is built for. Moonshot has also signalled the end of the older K2 series: closed to new users on 31 October 2026, and planned for retirement by the end of December.
The Price, Line by Line
Here is the price in full, from Moonshot's API pricing page, read on 24 October and 9 November 2026. All rates are US dollars per million tokens, excluding tax, flat across the whole million-token window — no long-context surcharge.
| Rate (per 1M tokens) | Kimi K3.1 Pro | Kimi K3.1 Pro Highspeed | Kimi K3 (for comparison) |
|---|---|---|---|
| Input | $2.00 | $4.00 | $3.00 |
| Output | $10.00 | $20.00 | $15.00 |
| Cached input | $0.20 | $0.20 | $0.30 |
| Cache write, 5 minutes | $2.00 | $4.00 | — |
| Cache write, 1 hour | $4.00 | $8.00 | — |
First, the cache: when a request reuses a prompt prefix already read, those tokens bill at $0.20 per million — a tenth of the input price — on both variants. Caching is automatic, with a default lifetime of five minutes and a one-hour option per call; a five-minute cache write costs the same as input, a one-hour write double. Second, batch jobs bill at 60% of the standard price — $1.20 input and $6.00 output — for work that does not need an immediate answer.
The model is pay as you go, unlocking after a top-up of at least $1. The API is OpenAI-compatible — model IDs kimi-k3.1-pro and kimi-k3.1-pro-highspeed, at api.moonshot.ai/v1; Kimi Code uses k3.1-pro — and is also routed through OpenRouter and the Vercel AI Gateway, where third-party hosts sometimes undercut Moonshot's list price.
Microsoft added Kimi K3.1 Pro to its Foundry catalogue on 5 November 2026, at $2.30 input, $0.23 cached input and $11.50 output per million tokens — a 15% premium over Moonshot's own API, which is the price of staying inside Azure. Amazon Bedrock added the Highspeed variant on 6 November 2026: $4.00/$20.00 globally, cache reads $0.20, 30-minute cache writes $5.00; in the US and India, $4.40/$22.00. For a Pakistani developer the practical point is simple: Moonshot's own API is the cheapest route.
The Thinking-Token Catch
The $2/$10 sticker price is real, but it is not the whole bill. Kimi K3.1 Pro is a reasoning model: it thinks before it answers, and the tokens it spends thinking bill as output, at $10 per million. Long-horizon agents are heavy on thinking: a coding agent that plans a refactor, runs tests and tries again can easily spend far more tokens thinking than writing the answer.
Take a small example. A request with 100,000 uncached input tokens and 10,000 output tokens costs $0.20 plus $0.10 — $0.30. Now the same job as an agent task: the same input, but 100,000 thinking tokens before the 10,000-token answer. The bill is $0.20 input, $1.00 thinking and $0.10 output — $1.30, more than four times as much, and the thinking does almost all of the damage. At the State Bank of Pakistan rate of Rs 276.60 per dollar (13 November 2026), that is about Rs 360 against about Rs 83 — approximate, but the ratio is the lesson.
This is not a flaw in Kimi specifically — every reasoning model bills this way, including Claude Opus 5.5 — and at half the list price, the same thinking-heavy job still costs half as much on Kimi as on Opus. But the "$2/$10" headline understates what an agent run costs. Budget on total tokens — input, thinking and output together — and watch the thinking share on your first real jobs before committing to a monthly figure.
A Million Tokens of Context
Kimi K3.1 Pro's context window is 1,048,576 tokens — one million, in round numbers, the same size as Kimi K3's. It is the full window for every API customer, with no cheaper tier and no surcharge for using all of it. In the Kimi app, the full million-token chat is only on the more expensive membership plans, so the API is the way to get the whole window without a subscription.
What does a million tokens hold? Roughly 700,000 to 750,000 words of English text — about ten average novels, or a medium-sized codebase with its documentation. The useful question is not how much fits but how well the model uses it: a model that reads a million tokens but forgets page one is worse than a model with a smaller window and a better memory. K3.1 Pro is built for this test — long documents, whole repositories, multi-file refactors — and its agentic design is meant to keep track of the work across a long session.
Two honest limits. First, the cache makes long context cheap only when the prompt prefix repeats: a new million-token document costs full input price the first time, and only the repeats bill at $0.20. Second, output is still the expensive direction — a million tokens in is $2, a million out is $10, and a long agent run can generate far more output, thinking included, than the document it started from.
The Model Under the Hood
Under the hood, Kimi K3.1 Pro is a mixture-of-experts model: 2.8 trillion parameters in total, with 104 billion active for each token, 896 experts of which 16 are selected per token. The weights are stored in MXFP4 — a four-bit floating-point format — with MXFP8 activations, and the model was trained with quantization in mind, so the four-bit weights are the format it was built around. A 401-million-parameter vision encoder, MoonViT-V2, handles image input.
In plain language: the model is enormous in total, but only a small slice works on any single token, which is how a 2.8-trillion-parameter model can be served at all. The four-bit weights are why the download is 1.56 terabytes rather than five or six — and why there is no full-precision version: Moonshot published only the MXFP4 weights, with no bf16 sibling and no FP8 build. What you download is what Moonshot serves, at the same precision.
That precision choice matters for anyone planning to fine-tune: you start from a four-bit model, and fine-tuning a four-bit model is a different job from fine-tuning a full-precision one. The licence allows it — the question is whether your tooling supports it at this size, and for most teams the honest answer is that the API, not self-hosting, is where this model will actually be used.
Open Weights, Not Open Source
This is the part most coverage gets wrong: Kimi K3.1 Pro is open weights, not open source. Hugging Face files the repository under license:other, named kimi-k3.1-pro. The licence is a custom document — a modified MIT-style licence with conditions — not Apache 2.0, not MIT, and not anything on the Open Source Initiative's list. Calling the model "open source" is incorrect, and it matters, because the conditions decide who can actually use it commercially.
The main condition is for hosts. If you run a Model as a Service business — giving a third party access to model inference or fine-tuning — and your combined revenue with affiliates exceeds $20 million over any consecutive 12 months, you must enter a separate agreement with Moonshot AI before using the software or its derivatives for any commercial purpose. Internal use is exempt.
A second condition covers large products: a commercial product built on the model with more than 100 million monthly active users, or more than $20 million in monthly revenue, must display the name prominently on the user interface. Read the licence file before any commercial use, and check your twelve-month revenue against the $20 million line — it is measured on the whole corporate group, not the model alone, and once it trips, the separate agreement covers any commercial purpose, not just API traffic.
| Who you are | What the licence means for you |
|---|---|
| Solo developer or small team | Download, self-host, fine-tune and build products freely; internal use is exempt |
| Startup selling a product that uses the model | Fine — the clause covers selling access to the model, not embedding it in a product |
| Company hosting the model as an API service | Free until group revenue passes $20M over 12 months; then a separate Moonshot agreement is required |
| Product with 100M+ monthly users or $20M+ monthly revenue | You must display the model's name prominently |
None of this is unusual for a frontier open-weight release in 2026 — Meta's Llama licences carry similar conditions — but it is why the accurate phrase is "open weights". The weights are open in the sense that anyone can download them; they are not open in the sense that a large hosting business can resell access without Moonshot's say-so.
The 1.56 TB Download: Who Can Actually Run It
Moonshot kept its promise: the full weights went live on Hugging Face on 4 November 2026, in moonshotai/Kimi-K3.1-Pro (created 2 November), public and ungated by that evening. The download is 96 safetensors files totalling about 1.56 terabytes. That size decides who can actually run it.
The blunt answer is: almost nobody at home. Holding the weights needs well over 1.5 terabytes of fast memory — a multi-GPU server, not a laptop and not a single gaming graphics card. A well-equipped workstation with 128 GB of RAM is an order of magnitude short. This is a data-centre model, not a practical route for a solo developer.
For a solo developer or a small team, the API is the realistic route: the full million-token window for everyone, no subscription, a $1 top-up. The weights matter most to three groups — cloud providers and inference companies that will host the model, research teams that want to study or fine-tune a frontier model, and companies that must run it inside their own infrastructure for privacy or compliance. If you are none of those, the open weights are a reassurance about the model's future, not a file you need.
Benchmarks — Moonshot's Own Numbers
Every figure here comes from Moonshot itself — the launch post of 23 October 2026 and the model card. No benchmark a vendor publishes about its own model is neutral; these are Moonshot's claims about its own work, not independent measurements.
| Benchmark (Moonshot's own figures) | Kimi K3.1 Pro | Claude Opus 5.5 | GPT-6 Astra |
|---|---|---|---|
| Terminal-Bench 4.0 | 65.7% | 66.4% | 58.2% |
| Kimi Code Bench 3.0 (Moonshot internal) | 61.2% | — | — |
| Kimi Code Bench 3.0, Kimi K3 | 55.95% | — | — |
The headline is Terminal-Bench 4.0, real terminal tasks in the Claude Code harness: Kimi scores 65.7%, against 66.4% for Claude Opus 5.5 and 58.2% for GPT-6 Astra — near-parity with the most expensive coding model, at half its list price. On Moonshot's internal Kimi Code Bench 3.0, K3.1 Pro scores 61.2%, against 55.95% for Kimi K3. Across the full table, Kimi scores above Opus 5.5 on 16 of the 37 non-internal rows where both have a score.
Read the table with its limits in mind. Terminal-Bench is a benchmark Moonshot chose to headline, and vendors headline the benchmarks they win. Kimi Code Bench is Moonshot's own internal benchmark. And the comparison that matters most for a buyer — the same task, run by an independent party, on both models, at the same cost — does not exist in Moonshot's materials. That is normal for a launch, and it is why the next section exists.
The Independent Checks So Far
At launch, no independent evaluation was available — and the first checks arrived within days, which is fast for a frontier model. Three are worth naming, with their limits attached.
Artificial Analysis scored Kimi 55 on its Intelligence Index, at $2.11 per index task, in model pages read on 24 October 2026 — the day after launch. That puts the model fourth on the index at the time, at a cost per task level with Kimi K3's $2.00. It is the single most useful number in this post for anyone comparing models: a top-four intelligence score at about two dollars a task.
On 3 November 2026, Joachim Schaeffer and Tilman Räuker of R40 Research published a behavioural audit that ran Kimi K3.1 through 63 of Terminal-Bench 4.0's 66 tasks, three attempts each, reading the reasoning rather than just counting passes — the first independent run of the model on the benchmark Moonshot headlined. SuperCLUE's November leaderboard, updated 5 November, lists K3.1 Pro first among its ranked models at 61.46.
One gap remains: nothing published so far scores the checkpoint files now on Hugging Face. The evaluations above ran the hosted model, through Moonshot's API or a partner's. Nobody has yet published an independent score for the weights anyone can now download, and the released checkpoint may not behave identically to the hosted model. If you plan to self-host, treat the hosted benchmarks as a guide, not a promise, and run your own evaluation before you commit.
Where You Can Use It
It is live in Kimi.ai, the Kimi mobile apps, Kimi Work, Kimi Code and the Kimi API — the same model everywhere. The API is the most flexible route: OpenAI-compatible, pay as you go, full context for everyone, Highspeed for jobs where latency matters more than price.
Beyond Moonshot, the model is on Microsoft Foundry (5 November 2026), Amazon Bedrock (Highspeed, 6 November 2026), OpenRouter and the Vercel AI Gateway, and the open weights mean third-party hosts are already listing it — some below Moonshot's list price. That host ecosystem is the real prize of the release: within weeks, the model stopped being a single vendor's product and became a model anyone can serve.
Kimi K3.1 Pro vs Claude Opus 5.5: the Honest Comparison
The comparison every buyer will make is with Claude Opus 5.5, and on list price it is simple: Opus costs $4/$20 per million tokens — exactly double Kimi's $2/$10. On Moonshot's own Terminal-Bench 4.0 numbers, Kimi scores 65.7% against Opus's 66.4% — less than a point behind, at half the price. On the Artificial Analysis index, Kimi scores 55 at $2.11 per task; Opus, 59 at about $10.04. The price gap is much larger than the performance gap, whichever measurement you trust.
But the comparison is not only about the benchmark table. Opus 5.5 is a closed model from Anthropic, with its safety systems, tool ecosystem and long record of independent evaluation. Kimi K3.1 Pro is an open-weight model from Moonshot, a Chinese company, with a custom licence, a four-bit-only release, and benchmarks that are mostly its own. The choice is not only about dollars per token: it is about who you trust with your code, whose safety and data policies you accept, and whether you need the model inside your own infrastructure. Kimi wins the price argument clearly. Opus wins the track-record argument, for now.
Who Should Use It, and Who Should Skip It
Kimi K3.1 Pro is the right model for a developer or small team running long coding jobs — multi-file refactors, codebase-wide questions, test-and-fix loops — that wants near-frontier performance without paying Claude Opus prices. It is also right for a team that wants to self-host a frontier model, and for anyone building an agent that reads long documents or whole repositories. The window, the cache pricing and the open weights all point the same way: this is a model for long work, not for short answers.
Skip it if your work is short questions and quick answers — the reasoning you cannot switch off will cost you money for thinking you did not need. Skip self-hosting unless you have the hardware and the team to run a 1.56-terabyte model; the API is the route for almost everyone. And if your company is near the $20 million revenue line, or your product near 100 million monthly users, get the licence read by a lawyer before you build on the weights. The model is cheap. A licence dispute is not.
Frequently Asked Questions
Is Kimi K3.1 Pro open source?
No. It is open weights, not open source, under the custom Kimi K3.1 Pro License — not Apache 2.0 or MIT, and Hugging Face tags it license:other. Companies running a Model as a Service business with over $20 million in combined revenue over 12 months need a separate Moonshot agreement before commercial use.
How much does Kimi K3.1 Pro cost?
On Moonshot's API: $2 per million input tokens, $10 per million output, $0.20 per million cached input. Highspeed costs $4 and $20. Microsoft Foundry charges $2.30 and $11.50; Amazon Bedrock's Highspeed variant costs $4 and $20 globally.
Can I run Kimi K3.1 Pro on my laptop?
No. The weights are a 1.56-terabyte download in 96 files, needing well over 1.5 terabytes of fast memory — a multi-GPU server, not a laptop. For a solo developer the API is the realistic route.
How big is the context window?
1,048,576 tokens — one million, roughly 700,000 to 750,000 words of English text. The full window is available to everyone on the API, with no long-context surcharge; in the Kimi app it is only on pricier plans.
Is Kimi K3.1 Pro better than Claude Opus 5.5?
On Moonshot's own numbers, nearly: 65.7% against 66.4% on Terminal-Bench 4.0, at half the price. Artificial Analysis scored Kimi 55 at $2.11 per task, against Opus's 59 at about $10.04. Kimi is close on performance and far cheaper — but most benchmarks so far are Moonshot's own, and Opus has the longer independent track record.
What is Kimi K3.1 Pro Highspeed?
The same model served roughly two to three times faster, according to Moonshot, at double the price: $4/$20 per million tokens, cached input still $0.20. Choose it when latency matters more than cost; it is the variant Amazon Bedrock hosts.
Where can I try Kimi K3.1 Pro?
On Kimi.ai, the Kimi mobile apps, Kimi Work and Kimi Code, or through the Kimi API (kimi-k3.1-pro), which unlocks after a $1 top-up. It is also on Microsoft Foundry, Amazon Bedrock, OpenRouter and the Vercel AI Gateway; the weights are on Hugging Face as moonshotai/Kimi-K3.1-Pro.
Conclusion
Kimi K3.1 Pro is the most interesting model launch of the autumn: it breaks the link between frontier performance and frontier pricing. Near-parity with Claude Opus 5.5 on Moonshot's own terminal benchmark, at half the list price; a million-token window for everyone on the API; and the full weights published on Hugging Face, on the date promised. The independent scores since point the same way, even if none yet scores the released checkpoint itself.
The honest limits are part of the story. The weights are 1.56 terabytes and four-bit only, so almost nobody will run them at home. The licence is open weights, not open source, and the $20 million revenue line decides who can resell access. Thinking tokens bill as output, so the real cost of an agent run is higher than the $2/$10 headline. None of that makes the model a bad choice — it makes it a choice to make with open eyes: the budget agentic-coding model, for long work, at half the price of the model it chases, and the first frontier model of its generation you can download, study and host yourself.
By Umar Farooq, Tech Know.


0 Comments