Kimi K3.1 Pro: Benchmarks, Real Cost and Open Weights 2026

What Moonshot's new open-weight flagship really scores, what it costs per finished task, and what "weights by November 4" means for anyone who wants to run it.

On October 23, 2026, Kimi K3.1 Pro launched at 55 on the Artificial Analysis Intelligence Index, three points behind Claude Opus 5.5. Four days later the same model scored 46. Nothing about the model had changed. The ruler had: Artificial Analysis replaced its index with a harder version built mostly on private test sets, and the open-weight model that had looked like a near-tie with the frontier was suddenly 12 points behind it - Artificial Analysis.

That is the problem with every headline you have read about this launch. Kimi K3.1 Pro is genuinely one of the strongest models anyone can buy access to, it costs half the per-token price of Claude Opus 5.5, it drew more than a thousand points on Hacker News, and Moonshot has promised to publish the full weights. It is also one of the slowest frontier endpoints measured, a heavy token spender, a model whose weights did not exist publicly when most reviews were written, and a product from a company at the center of two government disputes. A single score or a single price tells you almost nothing here. You need the structure underneath.

This guide breaks down what Kimi K3.1 Pro actually is, which benchmarks hold up under independent testing and which do not, the real cost per task rather than the sticker price, the license and hardware you should expect when the weights land, and how it stacks up against Claude Opus 5.5, GPT-6.1 Sol, Gemini 4 Argon, DeepSeek V4.1 Flash and GLM-5.3. It is written for people who decide which model their product or their agents run on, and it explains every term as it goes.

Contents

1. What Kimi K3.1 Pro Actually Is
2. Moonshot's Benchmark Sheet, Read Carefully
3. The Score That Moved: Why 55 Became 46
4. Price: Sticker Rate vs Cost per Finished Task
5. Open Weights: What "By November 4" Really Means
6. Running It Yourself: Hardware, Hosting and Break-Even
7. Kimi K3.1 Pro vs the Field
8. Trust, Compliance and Geopolitics
9. Where It Wins and Where It Fails
10. How to Use It: API, Coding Agents and Routing
11. The Future Outlook

Before the details, here is the whole decision on one scorecard. The table ranks Kimi K3.1 Pro against seven models a builder would realistically weigh it against today, on five criteria. Every cell carries the score and the evidence behind it, so you can disagree with a weight and re-rank in your head. The rows are ordered by final score, highest first.

How to read this. Agentic Coding (30%) carries the most weight because long-horizon terminal and repository work is where models of this class earn their keep in 2026, and it uses the Vals Terminal-Bench 4.0 leaderboard because every model there ran in the same harness. Independent Intelligence (20%) is the Artificial Analysis Index v5, the broadest third-party measure available. Cost per Task (20%) uses the measured cost of a real evaluation task rather than the price list, because that is what an invoice reflects. Openness (20%) rewards weights you can download and a license you can live with, and Speed (10%) is first-party output tokens per second. On this blend Kimi K3.1 Pro edges out DeepSeek's far cheaper but far weaker Flash model, and every closed model lands below both. Shift weight from openness to raw capability and Opus 5.5 takes the top spot; shift it to cost and GPT-6.1 Sol and DeepSeek lead. The scorecard is a lens, and the rest of the guide is the evidence behind each cell.

1. What Kimi K3.1 Pro Actually Is

Kimi K3.1 Pro is the first model in Moonshot AI's new K3.1 series, released on October 23, 2026 alongside a faster sibling called K3.1 Pro Highspeed. Moonshot describes it as "our most capable 3T-class open-weight model to date," with a 1-million-token context window and gains across coding, 3D creation and financial research, and it promises the full weights "by Nov 4" - Moonshot AI. Highspeed is the same model served for roughly 2-3x faster output at twice the per-token price.

The most important technical fact is easy to miss: K3.1 Pro is not a new architecture. Moonshot calls it "a post-trained version of Kimi K3, with substantially larger post-training compute," trained with large-scale joint reinforcement learning across hundreds of downstream domains. That means the base underneath is the Kimi K3 design published in July: a 2.8-trillion-parameter Mixture-of-Experts model that activates 104 billion parameters per token, routes each token to 16 of 896 experts, and was trained with 4-bit MXFP4 quantization built in from the fine-tuning stage onward - Hugging Face.

Everything new in K3.1 Pro came from what Moonshot taught the same network after pre-training, which is why its gains are concentrated in agentic, tool-using work rather than raw knowledge.

Where you can use it today

The model shipped everywhere Moonshot sells at once: Kimi.ai and the mobile apps, the Kimi Work desktop app, the Kimi Code command-line agent, and the Kimi API under the model names kimi-k3.1-pro and kimi-k3.1-pro-highspeed. For enterprises, Kimi Enterprise administrators can switch it on for their organization, with access off by default at launch, and Zero Data Retention is available to API customers.

Third-party routers list it too: OpenRouter carries it as moonshotai/kimi-k3.1-pro, though at launch every endpoint behind that listing is Moonshot's own - OpenRouter.

The reception was unusually loud for a Chinese model. The launch post collected 1,096 points and 679 comments on Hacker News - Hacker News.

Simon Willison summed up why: "This is the first time a (soon-to-be) open weight model has scored this highly against the frontier" - Simon Willison. That sentence was written against the launch-day score of 55, and section 3 explains why it needs a footnote now.

The clearest short explainer of the launch is Fireship's breakdown, which became the most-watched video about the model within three days. It covers the headline claim (within a point of Opus on Terminal-Bench) and then tests whether the model is actually good, which is the right order of questions.

Five facts define the model before any benchmark enters the picture:

• Same body, new training: K3 architecture, far more reinforcement learning
• Two speeds: Pro at $2/$10, Highspeed at $4/$20 per million tokens
• One million tokens: the context window on every K3-series model
• Always reasoning: thinking cannot be switched off, only dialed between low, high and max
• Weights pending: promised by November 4, unpublished as of October 30

Read together, those facts describe a model built for long, tool-heavy tasks that is priced aggressively but spends a lot of tokens thinking. The "always reasoning" point matters more than it looks: every request pays for hidden reasoning tokens at the output rate, so the sticker price understates the bill on short questions and is closer to fair on long agent runs. In practice that means K3.1 Pro is a poor choice for quick classification or one-line answers, where a non-reasoning model at a tenth of the price does the job, and a much better fit for multi-step work where the thinking is the product.

The "weights pending" point matters for procurement, because a model you cannot yet download is, for compliance purposes, a hosted API from a Chinese provider. If you are evaluating it today, treat it as an API product with an open-weight option arriving soon, and plan your tests so the same prompts can later run against a self-hosted copy.

2. Moonshot's Benchmark Sheet, Read Carefully

Every lab publishes the benchmarks it looks good on, and Moonshot is no exception. Its launch chart compares K3.1 Pro with Claude Opus 5.5, GPT-6 Astra, Claude Fable 5.1, DeepSeek V4.1 Flash 1017 and GLM-5.3 across fourteen evaluations in coding, agentic knowledge work, reasoning and vision. The headline is Terminal-Bench 4.0, a test of coding agents working in real terminal environments, where Moonshot reports 65.7% for K3.1 Pro, ahead of GPT-6 Astra at 58.2% and narrowly behind Opus 5.5 at 66.4% - Moonshot AI.

The fine print matters as much as the bars. Moonshot ran K3.1 Pro at maximum reasoning effort with the Claude Code harness for most coding tests, and took many rival scores from those labs' own reports or public leaderboards rather than rerunning them. Its footnote also warns that "Claude Models may include fallbacks and GPT Models may include cyberguards," which means some rival runs were partly answered by a backup model or blocked by safety filters. None of this is dishonest, but it means the chart compares numbers produced under different conditions, which is exactly the situation independent evaluators exist to fix.

The chart above is worth reading by pattern rather than by bar. K3.1 Pro leads on SWE-Marathon (51.7 vs Opus 5.5 at 46.3), a test of very long software tasks, on Humanity's Last Exam with tools (70.0 vs 67.7), on OfficeQA Pro v2 (64.4 vs 62.2), which asks agents to analyze real financial PDFs, and on Agents' Last Exam (43.2 vs 42.6). It trails clearly on Terminal-Bench-Science (38.1 vs GPT-6 Astra at 68.1 and Opus at 63.3), on Moonshot's own Kimi Code Bench 3.0 Long-horizon (61.2 vs Astra at 66.5) and on BenchCAD 3D reconstruction (92.7 vs Opus at 96.2).

What the pattern tells you

The interesting signal is not any single win but where the wins cluster. K3.1 Pro is strongest on long software engineering, document-heavy knowledge work and tool-assisted question answering, and weakest on agentic science, where a model has to run unfamiliar experiments in a terminal and reason about results it has never seen. That shape is exactly what you would predict from how it was made: Moonshot says it scaled reinforcement learning across "hundreds of downstream domains," and reinforcement learning rewards the behaviors its environments can check. Software tasks with test suites and finance questions with exact answers are easy to check at scale, while open-ended scientific investigation is not.

Moonshot also made a specific claim about factual accuracy that matters for finance and research use. On its internal Kimi Hallu Bench Hard, a deliberately adversarial set of prompts, the claim-level hallucination rate fell from 23.4% for K3 to 8.3% for K3.1 Pro, and Moonshot is careful to note that these stress-test rates "do not represent overall error rates in daily use" - Moonshot AI. The same chart puts GPT-6 Astra lower still and Opus 5.5 higher.

Treat an internal benchmark the way you would treat a company's own customer survey: useful for direction, weak as proof. The independent numbers in the next section partly confirm the direction (Artificial Analysis measured the hallucination rate on its own knowledge test falling from 53% to 44%), which is a better reason to believe the trend than Moonshot's chart alone.

Why this matters: the benchmarks you choose to read decide which model looks best, and Moonshot's selection flatters the work K3.1 Pro was trained hardest on. How to apply this: map your own workload onto the pattern. If your agents mostly write and fix code, process financial documents or answer questions with search and tools, the vendor sheet is roughly representative. If they do open-ended technical investigation, the science scores are the ones to weight, and there K3.1 Pro sits well behind the closed frontier. For a deeper look at why vendor-reported coding scores so often overstate real performance, see our analysis of why AI coding benchmarks mislead.

3. The Score That Moved: Why 55 Became 46

The number most coverage repeated came from Artificial Analysis, an independent evaluator that runs every model through the same battery of tests. At launch it scored K3.1 Pro at 55, fourth overall behind Claude Opus 5.5 (58), Claude Sonnet 5.5 (56) and Muse Wonder Full (56), and 11 points above the original Kimi K3 at 44 - Artificial Analysis. It also noted that once the weights are released, K3.1 Pro would cut the gap between the best open-weight model and the overall leader from 12 points to 3.

Those launch numbers were not marketing. Artificial Analysis measured large, specific gains over K3 on its own tests: Terminal-Bench 4.0 jumped from 13% to 67%, the highest score of any model it had tested, AutomationBench rose from 58% to 73%, Humanity's Last Exam from 47% to 52%, and on its GDPval-AA knowledge-work test the model reached 1,846 Elo, third overall. Its knowledge-reliability score improved from 20 to 30, driven by the hallucination rate falling from 53% to 44%.

The chart shows how lopsided the improvement was. The terminal-coding and automation tests moved by tens of points, while scientific coding, physics reasoning and factual recall moved by two to five. Post-training taught K3 how to act, not new facts about the world, which is what you would expect from a model whose pre-training never changed.

What changed on October 27

Four days after launch, Artificial Analysis shipped Intelligence Index v5, a major overhaul of how it scores models. About 60% of the index now runs on private test sets or held-out answers, the four categories (knowledge work, coding, science, general) each carry 25%, and the mix of tests changed substantially - Artificial Analysis. Two benchmarks were added: Cognition's private FrontierCode 2.0 at 15%, graded on whether a maintainer would merge the change, and Terminal-Bench-Science at 15%. Three were upgraded, and three were removed: GDPval-AA, SciCode and AA-LCR.

Under v5, K3.1 Pro scores 46. It is still the top open-weight model, but now 12 points behind Claude Opus 5.5 at 58, while the best models with weights actually released today (DeepSeek V4.1 Flash 1017 and GLM-5.3) sit at 32. The new tests landed exactly on K3.1 Pro's weak side: it scores 37% on HLE-Diamond and 34% on Terminal-Bench-Science, against 68% and 63% for the top closed models.

The diagram makes the mechanism plain. One of the tests that dropped out, GDPval-AA, was one where K3.1 Pro ranked third in the world. One of the tests that came in, Terminal-Bench-Science, is one where most open-weight models score under 10% and K3.1 Pro scores 34%. Meanwhile Terminal-Bench 4.0, where K3.1 Pro still holds the top score at 67.2%, stayed but carries just 10% of the weight - Artificial Analysis.

One more model sits above all of these on the live leaderboard: Google's Gemini 4 Carbon at 59, announced on October 28. It is restricted to a subset of cybersecurity defenders through Google's Fairwind Program with no general availability date, so it is not a model you can choose today - Khaleej Times.

A third opinion: Vals

When two versions of one evaluator disagree, a different evaluator is the tiebreaker. Vals AI ranks K3.1 Pro 9th of 30 on its Vals Index at 62.52%, a little above DeepSeek V4.1 Flash 1017 at 61.26%, and 3rd of 58 on its own run of Terminal-Bench 4.0 at 63.64%, within two points of Opus 5.5 - Vals AI. Its domain indexes show the same shape as Artificial Analysis: strong on coding (84.89% on Vibe Code Bench, 81.89% on IOI) and middling on legal research and tax work, where it ranks 43rd of 88 and 42nd of 79. That agreement matters because Vals uses different tasks, different harnesses and a different weighting from Artificial Analysis, so a pattern that survives both is unlikely to be an artifact of one test suite.

Put the three independent readings side by side (Artificial Analysis at launch, Artificial Analysis v5 and Vals) and they agree on a coherent picture:

• Terminal coding: genuinely frontier, top three everywhere it is measured
• Breadth of intelligence: strong, but a tier below the closed flagships
• Agentic science: clearly behind, roughly half the frontier score
• Specialist domains: legal and tax work are relative weak spots
• Trajectory: a large jump over K3 in under four months

So which number is "true", 55 or 46? Both, for different questions. The v4.3 score answered "how good is this model on a broad mix including tests it may have seen variants of," and the v5 score answers "how good is it on mostly private tasks with a heavier science component." The structural lesson is that the open-closed gap is not one number: on public, checkable software work it is close to zero, and on private, open-ended reasoning it is still large. Why this matters: if you picked K3.1 Pro on the "three points behind Opus" claim, you were buying a gap that does not exist on every workload. How to apply this: decide which of these two readings resembles your tasks, then run a twenty-task pilot of your own before switching anything in production. Our guide to agent evals and benchmarks explains how to build that pilot so it measures what you care about.

4. Price: Sticker Rate vs Cost per Finished Task

The headline price is simple and verifiable on Moonshot's own pricing page. Kimi K3.1 Pro costs $2 per million input tokens, $10 per million output tokens and $0.20 for cached input, which is 33% less than Kimi K3's $3/$15/$0.30 - Kimi API Platform. Highspeed doubles the input and output rates to $4/$20 while keeping the same $0.20 cache-hit price.

The K3 series also bills cache writes separately, by how long the cache lives. A five-minute cache costs the same as normal input, and a one-hour cache costs double. Moonshot's quickstart explains when to pay the premium: the default five-minute window is "enough for rapid back-and-forth," while workloads with gaps longer than five minutes should select the one-hour tier "to avoid repeated writes" - Kimi API Platform.

Those rival prices come from each lab's own page: Opus 5.5 at $4/$20 with a $5 five-minute cache write - Claude, and GPT-6.1 Sol at $2/$10 with $0.10 cached input - OpenAI. The table shows something the launch coverage glossed over: K3.1 Pro is not cheaper than GPT-6.1 Sol per token. It matches Sol on input and output and charges twice as much for cached input. It is cheaper than Opus 5.5 by exactly half, and Simon Willison's launch note made the same comparison.

Why the per-task cost tells a different story

A per-token price only becomes a bill once you multiply it by the number of tokens a model actually spends, and K3.1 Pro spends a lot. On the launch-day index it used 55,000 output tokens per task, 14% more than K3 - Artificial Analysis. On the harder v5 index it generated 110 million output tokens to complete the full evaluation, against a median of 71 million for comparable models, and its measured cost came to $3.68 per task - Artificial Analysis.

This chart is the most useful single picture in the article. At an identical list price, GPT-6.1 Sol completes a task for $1.27 and scores 55 on the index, while K3.1 Pro spends $3.68 and scores 46. Against Opus 5.5 the story reverses: K3.1 Pro costs roughly a third as much per task for a score 12 points lower. The independent Vals Terminal-Bench run shows the same ordering on coding alone, with K3.1 Pro at $4.57 per test against $1.72 for GPT-6.1 Sol and $13.20 for Opus 5.5 - Vals AI.

A worked example

Arithmetic makes the trade-off concrete. Imagine a typical agent step that reads 200,000 tokens of context, 85% of it already cached, and writes 20,000 tokens including reasoning. On K3.1 Pro that is 30,000 fresh tokens at $2 ($0.060), 170,000 cached tokens at $0.20 ($0.034) and 20,000 output tokens at $10 ($0.200), or about $0.29 per step. The same token counts on Opus 5.5 cost about $0.55, and on GPT-6.1 Sol about $0.28.

That is the per-token view, and it flatters K3.1 Pro because it assumes every model spends the same tokens. They do not. If K3.1 Pro needs 55% more output tokens than Sol to finish the same step (the gap between its index usage and the median), its cost rises to about $0.40 while Sol stays at $0.28. If it needs one retry where Opus succeeds first time, the comparison with Opus narrows too. The real unit of cost is the solved task, which combines price per token, tokens per attempt and attempts per success. We work through this framing in detail in our comparison of GPT-6.1 Sol and Claude Opus 5.5 cost per agent task.

When Highspeed is worth double

Speed is K3.1 Pro's sharpest practical weakness. Artificial Analysis measures Kimi's standard endpoint at 32.1 output tokens per second, one of the slowest frontier endpoints it tracks, and the Highspeed endpoint at 73.9 tokens per second - Artificial Analysis. A task that writes 55,000 tokens takes about 29 minutes of pure generation on the standard endpoint and about 12 minutes on Highspeed.

That difference is invisible in a nightly batch job and painful in an interactive session, so the question is never "is Highspeed better" (it is the same model) but "what is a saved minute worth here." Because Highspeed doubles the input and output rates but keeps the cache-hit price flat, its premium is smallest on input-heavy, heavily cached calls and largest on output-heavy reasoning. Paying double for Highspeed makes sense in a few specific situations:

• Interactive coding sessions: a developer is waiting on every turn
• Voice or chat products: latency is visible to your customer
• Parallel agent fleets: wall-clock time gates the whole job
• Short, frequent calls: the cache-hit price is unchanged, so input-heavy calls barely cost more

For overnight batch jobs, document processing queues and background research agents, the standard endpoint is the rational choice, because nobody is watching the clock and the token bill halves. The general rule is to buy speed only where a human or a downstream deadline is waiting, which is the same logic we apply in our model routing guide. Note too that the cache-hit price is identical on both tiers, so a workload that is mostly cached input pays only a small premium for Highspeed.

API access tiers and consumer plans

The API has a deliberately small entry door. K3.1 Pro unlocks after a minimum top-up of $1, and your cumulative top-up sets your rate limits: the $1 tier allows one concurrent request, 3 requests per minute and 1.5 million tokens per day, while the $10 tier jumps to 15 concurrent requests and unlimited daily tokens, and the $3,000 tier allows 100 concurrent requests and 5 million tokens per minute - Kimi API Platform. Anyone testing an agent fleet should top up at least $10 before drawing conclusions, because the lowest tier will throttle a multi-step agent into apparent failure.

Kimi's consumer subscriptions are a different product with different economics. In China Moonshot now sells Go, Plus, Pro, Max and Ultra plans from ¥49 to ¥1,399 per month, where Go excludes Kimi Code and Plus and above include it with a rolling five-hour usage limit - Kimi. Early users were not impressed with those limits. One developer reported hitting the five-hour quota on a $19 Kimi Code plan after consuming tokens worth just $1.37 at API rates - Hacker News. Another said in the launch thread that a $99 plan ran out within 47 minutes of a single session - Hacker News. How to apply this: if your team plans to use K3.1 Pro heavily for coding, budget it through the API, where you pay for what you use, rather than through a subscription whose limits are opaque. For broader context on where these prices sit in the market, our cheapest LLM APIs price table tracks the low end and the October ranking of LLMs for agents tracks cost per solved task.

5. Open Weights: What "By November 4" Really Means

The open-weights promise is the reason K3.1 Pro matters strategically, and it is also the part of the story with the least verified substance today. Moonshot's statement is short: "Full model weights will be released by Nov 4, 2026" - Moonshot AI. As of October 30, Moonshot's Hugging Face organization lists Kimi K3 as its newest model, with no K3.1 repository published - Hugging Face.

The distinction is not academic. Artificial Analysis classifies K3.1 Pro as proprietary until the weights appear, which is why its v5 write-up calls it the top open-weight model "(weights not yet released)." Several aggregators already label it open-weight, Vals among them - Vals AI. For a buyer, the honest status is: a hosted Chinese API today, with a credible but unfulfilled promise of downloadable weights next week.

Why the promise is credible

Moonshot has a track record of doing exactly this on schedule. Kimi K3 was announced on July 16 with a promised weights date, and the weights appeared on Hugging Face on July 27, weighing 1.56 TB - Simon Willison. That repository logged more than 860,000 downloads in the past month alone. A lab that has hit a published date once, at this scale, has a reputational reason to hit it again, and its Hugging Face page lists the earlier K2 models released the same way - Hugging Face.

The license is the more important unknown. Moonshot has not published a K3.1 license, but the K3 license is the obvious template, and its terms are specific. Anyone may use, modify and redistribute the weights for free, with three conditions - Hugging Face:

• Attribution: keep the copyright and permission notice in copies
• Large model-as-a-service: a provider earning over $20 million in 12 months needs a separate agreement before commercial use
• Large products: over 100 million monthly users or $20 million monthly revenue must display "Kimi K3" prominently
• Exemptions: internal use, and use through Moonshot or certified partners, are exempt from both

For almost every company reading this, those conditions never bite. A business embedding the model in its own product, or running it internally, pays nothing and owes nothing beyond the notice. The clause is aimed squarely at inference providers that would resell Moonshot's model in competition with Moonshot's own API, which is why the license defines "Model as a Service" so carefully and excludes products where the model is "solely embedded within specific features." Simon Willison noted that Moonshot avoids calling this "open source" and uses "open weight" instead, which is the accurate term. If K3.1 ships under the same text, the practical openness is high for end users and deliberately limited for large hosts.

The cybersecurity decision

The most debated part of the launch was not a benchmark but a safety choice. Moonshot found that cyber-offense capability rose steadily as post-training scaled, traced it to cyber-related content in its training mix, and removed that data from both mid-training and reinforcement learning for the open-weight release. On its internal exploit benchmark, the checkpoint without these controls solved 90.5% of tasks and the released K3.1 Pro solved 81.0%, up from 33.3% for K3 - Moonshot AI.

The chart contains a detail that undercuts the framing. On Moonshot's own test, DeepSeek V4.1 Flash, which is already downloadable under an MIT license, scored 85.7%, above the released K3.1 Pro. Moonshot's stated principle is "not to release open weights that would extend the absolute frontier of cyber capability," and by its own numbers K3.1 Pro does not even extend the open frontier. Reasoning from first principles, the marginal risk of a release is what it adds beyond what is already available, and here that is close to nothing on this axis. The data removal may therefore cost real usefulness (several of the most-discussed comments in the launch thread came from people worried about exactly this) while buying little safety.

Moonshot's counterargument is about trajectory rather than this release: it says it intends "to progressively raise the cyber capability available in open weights," letting defensive capability "diffuse gradually." Whether you find that persuasive depends on whether you believe gradual diffusion helps defenders more than attackers, which is an open question. Why this matters: if your use case is security work, the open-weight K3.1 Pro will be deliberately weaker at it than the API model you can test today, so benchmark the downloaded weights before committing. How to apply this: when the repository appears, run your security evaluation set against both the hosted API and a self-hosted copy, and treat any gap as permanent.

6. Running It Yourself: Hardware, Hosting and Break-Even

Open weights are only useful if you can run them, and a 2.8-trillion-parameter model is not something you run on a workstation. Because K3.1 Pro is post-trained K3, the K3 deployment numbers are the best available guide. The model was trained with MXFP4, a 4-bit format, built in from fine-tuning onward, so the downloadable checkpoint is already compact for its size, and the vLLM recipe lists about 1,680 GB of GPU memory for the MXFP4 weights and 3,360 GB in FP8 - vLLM Recipes.

The same recipe recommends at least 8x GB300 GPUs for the NVIDIA path, or 8x MI355X or MI350X on AMD, with multi-node deployment "for real production traffic." In plain terms, the minimum is one full rack-class server with eight of the newest data-center GPUs, and serious traffic needs several. Older H100 or H200 servers with 80 to 141 GB per GPU cannot hold the model in eight cards, so they would need two nodes and fast networking between them.

That hardware floor is the first filter on the whole open-weights story. A model that needs a rack of the newest GPUs is "open" in the sense that matters to inference providers, large enterprises and research labs, and much less so for a startup or an individual developer, who will reach it through someone else's servers either way.

What that costs

GPU rental prices give a usable anchor. The median on-demand price for an NVIDIA B300 was $9.50 per GPU-hour in early October, according to Uvik's GPU price index - Uvik. Eight of them cost about $76 per hour, or roughly $55,500 per month if left running around the clock, before storage, networking or engineering time.

Now compare that with the API. At $10 per million output tokens, $76 buys 7.6 million output tokens. To beat the API on output cost alone, a self-hosted node must produce more than 7.6 million output tokens every hour, which is about 2,100 tokens per second sustained across all concurrent users, every hour of every day. That is achievable on well-tuned hardware with heavy batching, but only with a steady, high-volume workload. A team running a few agents during business hours will pay far more per token self-hosting than through the API.

# Pattern from the published Kimi K3 recipe (8 GPUs, tensor parallel).
# Swap in the K3.1 repository name once Moonshot publishes it.
vllm serve moonshotai/Kimi-K3 \
  --tensor-parallel-size 8 \
  --gpu-memory-utilization 0.95

The command above is the shape of a single-node deployment from the published recipe, and the K3 model card lists vLLM, SGLang and TokenSpeed as the recommended inference engines. Expect day-one rough edges: the vLLM recipe for K3 carries pages of hardware-specific flags for AMD, NVLink and FP8 caching, and a new checkpoint usually takes a few weeks to reach the same maturity.

When self-hosting is the right call

The break-even math says self-hosting is rarely about cost for most teams. A node that sits idle at night or between bursts of agent activity still bills every hour, and the API only charges for tokens you actually use, so utilization rather than list price decides the winner. Only organizations with steady, round-the-clock traffic, or with an existing GPU fleet whose cost is already sunk, reach the throughput where owning the hardware pays.

The real reasons to run the weights yourself are structural rather than financial. They come from what a hosted API cannot give you at any price: control over where data goes, the ability to change the model itself, and capacity nobody else can throttle. They are worth naming precisely, because each one points to a different deployment choice:

• Data control: prompts and documents never leave infrastructure you control
• Regulatory fit: no dependency on a Chinese API provider for sensitive workloads
• Customization: fine-tuning on proprietary data, with full control of the result
• Predictable capacity: no shared rate limits or surprise throttling
• Very high volume: sustained throughput where the per-token math flips

If none of those apply, the efficient path is to wait for inference providers to host the open weights after November 4. Hosting companies have already done the expensive work of buying GPUs, tuning inference engines and keeping them busy around the clock, which is precisely the utilization problem that makes a private node expensive. Renting a slice of their capacity per token lets you benefit from open weights (price competition, portability, the option to self-host later) without carrying an idle rack, and if one host disappoints you can move to another without touching your prompts.

The K3 precedent shows what to expect: OpenRouter now lists about 20 providers serving Kimi K3, including Amazon Bedrock, Together, Fireworks and DeepInfra, with output prices from $7.50 to $22.50 per million against Moonshot's own $15 - OpenRouter. That also solves the compliance question for many buyers, because a US or EU host running open weights on its own hardware is a different data-processing arrangement from calling Moonshot directly.

Our guide to the true cost of LLM inference explains why hosted prices for open models keep falling, and our Muse Spark Open guide walks through the same self-hosting decision for Meta's open model.

7. Kimi K3.1 Pro vs the Field

Comparisons only mean something when every model runs the same test under the same conditions. The cleanest current source is the Vals Terminal-Bench 4.0 leaderboard, updated October 29, where every model ran in the same mini-SWE-agent harness and Vals recorded both accuracy and cost per test - Vals AI.

Two numbers in this table deserve attention. K3.1 Pro sits 1.5 points behind Opus 5.5 on accuracy at about a third of the cost per test, which is the strongest case anyone can make for it. And Claude Sonnet 5.5 costs more per test than Opus despite a lower list price, because at maximum effort it spends far more tokens. The second point is a reminder that the price list ranks models by what they charge per token, while your invoice ranks them by what they spend per task.

Against Claude Opus 5.5 and Sonnet 5.5

Claude Opus 5.5 remains the strongest generally available model on the broad Artificial Analysis index at 58, leads FrontierCode 2.0 at 46.4%, and tops Vals' Terminal-Bench run. It costs twice K3.1 Pro per token and about three times per measured task. The choice between them is a classic quality-cost trade: Opus is the safer pick for open-ended work where a wrong answer is expensive, and K3.1 Pro is the value pick for well-specified coding and document work where you can verify the output. Claude Sonnet 5.5 shares K3.1 Pro's $2/$10 list price and nearly matches Opus on coding, but its max-effort token appetite makes it surprisingly expensive per task, so at lower effort settings it is the more interesting rival. Our analysis of Gemini 4 Argon vs Opus 5.5 cost per task shows how effort settings swing these numbers.

Against GPT-6.1 Sol and GPT-6 Astra

GPT-6.1 Sol is K3.1 Pro's most uncomfortable comparison. It has the same $2/$10 list price, half the cache-hit price, a higher Artificial Analysis score (55 vs 46) and roughly a third of the cost per task. Where K3.1 Pro beats it is terminal coding accuracy (63.6% vs 55.1% on Vals) and openness. If you do not need the weights and your work is broad rather than coding-centric, Sol is the better buy today. GPT-6 Astra is OpenAI's most capable model at $10/$50 and leads agentic science, where it scores 68.1 on Terminal-Bench-Science against K3.1 Pro's 38.1 in Moonshot's own chart. For research-heavy agents Astra is in a different class, and for most coding work it is not worth five times the price. We break down the OpenAI lineup in our GPT-6 Astra vs Sol vs Luna guide.

Against Gemini 4 Argon and Gemini 4 Carbon

Gemini 4 Argon costs $2/$10 today but only "through November 30, 2026," after which Google's own pricing page lists $4 input and $20 output - Google AI for Developers. It scores 50 on the Artificial Analysis index but trails K3.1 Pro on Terminal-Bench and costs more than twice as much per measured task even at the promotional rate. Gemini 4 Carbon outscores everything on the live index at 59 and posts 65.2% on Artificial Analysis' Terminal-Bench run, but it is not available to buy. Our Gemini 4 Argon guide covers the December price change in detail.

Against the other open-weight models

DeepSeek V4.1 Flash 1017 is the price floor of the frontier-adjacent market. It is MIT-licensed with weights on Hugging Face now - Hugging Face, costs $0.15/$0.60 off-peak and $0.30/$1.20 at peak, and adds $0.75-per-1,000 Search and Fetch APIs - DeepSeek API Docs. It scores 32 on the Artificial Analysis index and half of K3.1 Pro's Terminal-Bench score, so it is a router's workhorse rather than a replacement. GLM-5.3 from Z.ai is the other open model with released weights at the top of the open tier (also 32), under a custom license - Hugging Face. Mistral Large 4 scores 26 on the same index. Once its weights land, K3.1 Pro will sit 14 points above the next-best open-weight model on that index. For the wider open landscape, see our top open-source LLMs of 2026 and our earlier Kimi K3 guide, which covers the base model in depth.

Why this matters: no model wins every column, so the choice is about which column your workload lives in. How to apply this: use K3.1 Pro where terminal coding quality per dollar is the constraint, Sol where broad quality per dollar is, Opus where the cost of a wrong answer dominates, and DeepSeek Flash for high-volume routine steps.

8. Trust, Compliance and Geopolitics

Model choice is no longer only a technical decision, and Moonshot carries more political weight than most labs. In February 2026, Anthropic published evidence that three Chinese labs had run industrial-scale "distillation" campaigns against Claude, training their own models on Claude's outputs. For Moonshot specifically it described over 3.4 million exchanges through "hundreds of fraudulent accounts," targeting agentic reasoning, coding and computer-use development, and said it attributed the campaign through request metadata "which matched the public profiles of senior Moonshot staff" - Anthropic.

The dispute widened in September.

After a later Anthropic report, China's internet regulator opened an investigation into DeepSeek and Moonshot, focused not on distillation but on the reverse flow: Chinese users' data reaching an American company. One example in the reporting alleges that Kimi passed a user's request and police camera footage to Claude without telling the user, though neither company has commented and the probe has reached no conclusion - The Next Web.

Bloomberg reporting carried by The Edge says Moonshot closed its final private round at about $50 billion and is heading for a Hong Kong IPO in the first quarter of 2027, with the probe an open question for that timeline - The Edge Malaysia.

The DeepSeek precedent

The US government has already shown what a policy response looks like. On October 20, the Department of Homeland Security ordered federal civilian agencies to remove DeepSeek products, including "third-party products and services built using DeepSeek technology," from their systems - TechCrunch. The order does not mention Moonshot or Kimi, and it applies only to federal civilian agencies, not companies. But its reach into third-party products built on a Chinese model is the important precedent, because it means a vendor's model choice can become its customers' compliance problem. A software company selling to US agencies that quietly routes requests through a Chinese model could find its own product excluded, even though the order never names it.

For a company deciding whether to use K3.1 Pro, the practical risks sort into a few distinct questions:

• Data flow: where your prompts are processed when you call Moonshot's API
• Customer contracts: whether your buyers forbid Chinese-hosted AI in their data path
• Regulatory drift: whether a DeepSeek-style order could later extend to Moonshot
• Provenance: whether the distillation allegations matter to your brand or buyers
• Vendor stability: an active regulatory probe in China during an IPO process

Each of those has a different answer depending on how you deploy, which is the key insight, and it is why a blanket "Chinese model: yes or no" policy is the wrong instrument. The data-flow and contract questions are about where inference physically runs, the regulatory and provenance questions are about whose model you use, and the stability question is about which company you depend on for updates and support. Calling Moonshot's API puts your data under a Chinese provider's processing, mitigated by its Zero Data Retention option.

Running the open weights on your own or a Western host's hardware removes the data-flow question entirely, because the model is just a file and no request leaves your infrastructure. The provenance and regulatory questions do not disappear with self-hosting, but they shrink from "who processes our data" to "whose model file do we run," which most legal teams treat very differently.

OpenRouter also notes the model is not currently available through its EU in-region routing, which matters for European buyers with residency requirements - OpenRouter.

One more trust signal is worth knowing. During the launch, Simon Willison pointed to shared Moonshot "creators campaign" documents suggesting some enthusiastic social posts may have been paid promotion - Hacker News. That does not change the independent benchmarks, but it is a good reason to weight Artificial Analysis and Vals over viral demos.

How to apply this: for regulated or government-adjacent customers, wait for the weights and deploy on infrastructure you or a trusted host control. For everyone else, use the API with Zero Data Retention for non-sensitive workloads, and document the decision. Our piece on sovereign AI and nationally owned models covers the broader logic of model provenance in procurement.

9. Where It Wins and Where It Fails

Benchmarks and prices narrow the field, but practical fit comes from knowing where a model shines and where it breaks.

The pattern across Moonshot's chart, Artificial Analysis, Vals and early hands-on testing is consistent enough to turn into guidance. K3.1 Pro is a builder's model: excellent at producing working artifacts from clear specifications, weaker at open-ended investigation and slower than almost anything else at the frontier.

Its standout strength beyond code is 3D and visual creation. Moonshot reports 92.7% on BenchCAD with tools, close to Opus 5.5's 96.2%, and says the model can write and run scripts for Blender and CAD tools, work across Unity, Unreal and Godot, and build parametric models from a text brief or sketch.

It launched a consumer feature called 3D Make on the back of this, which lets users generate, edit and export 3D models from Kimi.ai.

The interface above shows how Moonshot is packaging the model's spatial ability for non-developers, with ready templates like the pagoda and jet engine. For builders, the same capability is available through the API: K3.1 Pro can generate the Blender or CAD scripts directly, which turns "make me a 3D model of this product" into a scriptable, repeatable pipeline rather than a one-off chat.

Bijan Bowen's 45-minute test session is the most thorough public hands-on look so far. It runs the model through a browser-based operating system, C++ games, a robot arm simulation, Blender and Godot builds and a CAD engine test (the CAD segment starts at 23:53), and includes a section on an issue he hit mid-test at 19:01.

Where it wins

The strengths are not scattered, and they are not where the marketing put them. Moonshot's launch emphasized 3D and finance demos, but the independent numbers point first to software engineering, with the visual and financial wins as extensions of the same skill. They cluster around work that produces something concrete at the end, which is the same shape the benchmarks showed in section 2, and the same shape the reinforcement learning behind the model would predict. That makes the list below less a feature inventory than a description of one underlying capability applied to different domains.

Taken together, the evidence from Moonshot, Artificial Analysis, Vals and hands-on testing points to a clear set of workloads where K3.1 Pro is the best value available today:

• Terminal and repository coding: top-three Terminal-Bench everywhere it is measured
• Long software builds: leads SWE-Marathon in Moonshot's comparison
• Financial document analysis: leads OfficeQA Pro v2 at 64.4
• 3D, CAD and game assets: near-frontier BenchCAD, scriptable tools
• Teams needing an exit: open weights mean no lock-in to one API

The common thread is verifiability. Each of these tasks produces an artifact you can check: code that passes tests, numbers that reconcile with a document, a 3D file that renders. When output can be verified cheaply, a slightly less capable model at a third of the price per task is a rational choice, because the occasional failure is caught and retried rather than shipped. When output is hard to verify (a strategic recommendation, a legal judgment, an unfamiliar scientific conclusion), the cheaper model's failures slip through, and the savings disappear into the cost of mistakes.

Where it fails

The weak spots are equally consistent, and several are operational rather than intellectual. Speed is the most visible: at about 32 tokens per second on the standard endpoint, long agent runs take a long time. Verbosity compounds it, since a model that spends 55,000 output tokens per task at that speed holds a task open for half an hour.

Agentic science is the main capability gap, at roughly half the frontier score on Terminal-Bench-Science, and Vals places it in the bottom half on legal research and tax work.

There are also API constraints you only discover by integrating. Moonshot's quickstart states that sampling parameters such as temperature (fixed at 1.0) and top_p (fixed at 0.95) cannot be changed, that vision input does not accept public image URLs, and that its built-in web search tool "is being updated and is not recommended for production workflows in the near term" - Kimi API Platform. Hacker News testers also reported personality quirks: one noted that the model is "much more blunt and argumentative than USA models," and another found its reasoning traces sometimes identifying itself as ChatGPT - Hacker News. None of these are dealbreakers, but each will surprise a team that swaps it into an existing pipeline without testing. How to apply this: route verifiable build tasks to K3.1 Pro, keep investigative and science-heavy steps on a closed flagship, and bring your own search tool rather than relying on Moonshot's for now.

10. How to Use It: API, Coding Agents and Routing

Getting started takes minutes because Moonshot speaks the two dialects every tool already understands. The Kimi API offers an OpenAI-compatible Chat Completions endpoint at https://api.moonshot.ai/v1, a Responses API and an Anthropic-compatible Messages API, so the OpenAI and Anthropic SDKs work with a changed base URL and key. The model always reasons, and you control how much with the top-level reasoning_effort field, which accepts low, high or max, defaulting to max - Kimi API Platform.

The default matters for cost. Because max is the default and reasoning tokens bill at the output rate, a team that never sets the field pays maximum-effort prices on every request, including trivial ones. Setting effort deliberately per task type is the single cheapest optimization available.

from openai import OpenAI

client = OpenAI(api_key="YOUR_MOONSHOT_API_KEY", base_url="https://api.moonshot.ai/v1")

response = client.chat.completions.create(
    model="kimi-k3.1-pro",            # or "kimi-k3.1-pro-highspeed"
    reasoning_effort="high",          # low | high | max (default: max)
    messages= [{"role": "user", "content": "Refactor this function and add tests."}],
)
print(response.choices [0].message.content)

Two integration details trip people up. First, for multi-turn conversations and tool calls, Moonshot requires you to send back the complete assistant message, including its reasoning content and tool calls, not just the visible text, because the model was trained to see its own previous thinking. Second, max_completion_tokens defaults to 131,072 and can be raised to the full 1,048,576, so long agent turns will not be cut off unexpectedly, but runaway generations can also run long.

Inside coding agents

Moonshot documents setups for using its models inside Claude Code and Codex, as well as its own Kimi Code command-line agent. For Claude Code, you point the ANTHROPIC_BASE_URL at https://api.moonshot.ai/anthropic, set your Kimi key as the auth token, and choose the model in the env block of your Claude Code settings file - Kimi API Platform. Moonshot's guide also warns that stale ANTHROPIC_* values in that settings file silently override terminal exports, a common cause of requests going to the wrong endpoint.

This is also how most of Moonshot's own benchmark numbers were produced (with the Claude Code harness), which is a useful hint. A model evaluated inside a particular agent harness tends to perform best inside that harness, so if you want results resembling the published Terminal-Bench scores, run it the same way. Our comparison of Claude Code, Codex and Cursor covers how harness choice affects coding agent results.

Routing: the way most teams should use it

Few production systems should run on one model. The economics in section 4 point to a routing strategy, where each step goes to the cheapest model that can handle it reliably. K3.1 Pro fits naturally as the high-quality coding and build tier beneath a closed flagship and above a cheap high-volume model.

The diagram encodes the logic of this whole guide. Verifiability decides whether a cheaper model is safe at all, task type decides whether K3.1 Pro's specific strengths apply, and latency decides whether Highspeed earns its doubled price. The dashed path is the option the closed models do not offer: once the weights are public, the same tier can move onto your own infrastructure without changing your prompts.

Building and tuning a stack like this is real engineering work: evaluation sets, fallbacks, cost monitoring and periodic re-testing as prices and models change. Teams that would rather not run that machinery themselves can use platforms that build and operate a whole company's work through AI, such as O-mega, and judge them by the same yardstick this guide applies to models: cost per solved task on your own work. For teams doing it themselves, our LLM cost efficiency guide covers caching, trimming and routing in depth.

Why this matters: the difference between a model that saves money and one that costs more is usually configuration, not the model. How to apply this: set reasoning_effort per step type, use the one-hour cache for agents that pause between turns, send back full assistant messages, and route only verifiable work to K3.1 Pro until your own pilot proves it on the rest.

11. The Future Outlook

The near-term calendar is unusually concrete. Moonshot's weights deadline is November 4. Google's Gemini 4 Argon promotional pricing ends on November 30, after which a direct rival at the same $2/$10 list price doubles to $4/$20, which will make K3.1 Pro look relatively cheaper without Moonshot doing anything. And Moonshot's Hong Kong listing, if it proceeds, puts a public-market spotlight on the company's economics in early 2027.

The structural trend is more interesting than the dates. Moonshot shipped Kimi K3 in July and a post-trained K3.1 Pro in October that gained 11 points on the same independent index, entirely through post-training. That says the binding constraint for open-weight labs is no longer pre-training compute but reinforcement learning infrastructure: environments, rollout scheduling, sandboxes and verification at scale, which is exactly what Moonshot's launch post emphasized. A lab that can re-train an existing base model into a much stronger one in three months can keep pace with the closed frontier on any task that can be automatically checked.

The flip side is visible in the v5 index. On tasks that resist automatic checking, such as open-ended scientific investigation, the gap between the best open model and the best closed model is still around 12 points, and it is not obviously closing. The likely shape of the next year is therefore a market split by verifiability: open-weight models at or near parity on code, documents and structured knowledge work, and closed models retaining a lead on judgment-heavy, open-ended tasks. Price pressure will follow the same line, which is why the per-task cost gap between K3.1 Pro and Opus 5.5 is already roughly threefold.

For AI agents specifically, this matters more than for chatbots. An agent's work is mostly a long chain of checkable steps (run the tests, read the file, call the tool, compare the result), interrupted by occasional judgment calls. That structure is ideal for routing: cheap verifiable steps to open models, rare judgment steps to closed flagships. The arrival of a near-frontier open model with downloadable weights makes that architecture cheaper and more portable, and it gives every agent builder a credible fallback if a closed provider changes its price or terms. We explored how agent progress increasingly comes from the system around the model in are AI models smarter or just searching more, and K3.1 Pro is a clean example: the same base model, given better training environments, became a different product.

What to watch next is simple. First, whether the weights land by November 4 and under what license. Second, which inference providers host them and at what price, since that will set the real market rate for K3.1-class capability. Third, whether independent evaluators find the downloaded weights match the API model, given the deliberate cyber-data removal. And fourth, how quickly the next closed releases move the frontier, which a Hacker News commenter predicted only half-jokingly within twenty minutes of launch.

Conclusion: A Decision Framework

Kimi K3.1 Pro is the strongest open-weight model announced to date, a genuine frontier-class coding model, and a strong value at $2/$10, but it is neither "three points behind Opus" on every task nor the cheapest way to buy broad intelligence. The right decision depends on which of a few situations you are in.

Choose K3.1 Pro (standard) if your agents do verifiable coding, document analysis or 3D work in the background, and you want near-Opus coding accuracy at roughly a third of the cost per task. Choose Highspeed only for interactive or latency-sensitive steps where a person is waiting. Choose GPT-6.1 Sol instead if your work is broad rather than coding-centric and you do not need open weights, because it is cheaper per task and scores higher on the independent index. Stay on Claude Opus 5.5 for open-ended, high-stakes or science-heavy work where a wrong answer costs more than the tokens. Wait for the weights if you serve regulated or government-adjacent customers, then self-host or use a trusted third-party host.

Whatever you choose, run your own pilot on twenty real tasks, measure cost per solved task rather than price per token, and re-test after November 4. The model that wins your workload is the only benchmark that matters.

This guide reflects Kimi K3.1 Pro and the AI model market as of October 30, 2026. The open weights were not yet published at the time of writing, and pricing, benchmarks and availability change frequently, so verify current details before making purchasing or architecture decisions.

What this article rests on

Every model figure above is read from its record, re-read from OpenRouter's model feed every 6 hours, so the figures on this page are current even where the prose around them is older. Prices are OpenRouter's listed price per million tokens: for a lab's closed models that is the lab's own list price, and for an open-weight model it is the price of the host OpenRouter routes to by default, which can differ from the lab's own API and from other hosts.

• Kimi K3.1 Pro (MoonshotAI): $2 in and $10 out per million tokens, cached input $0.20, a 1M token window, listed 23 October 2026.
• Claude Opus 5.5 (Anthropic): $4 in and $20 out per million tokens, cached input $0.20, a 1M token window, listed 22 September 2026.
• GPT-6.1 Sol (OpenAI): $2 in and $10 out per million tokens, cached input $0.10, a 1.05M token window, listed 29 September 2026.
• Claude Sonnet 5.5 (Anthropic): $2 in and $10 out per million tokens, cached input $0.10, a 1M token window, listed 28 September 2026.
• GPT-6 Astra (OpenAI): $10 in and $50 out per million tokens, cached input $1, a 1.05M token window, listed 4 September 2026.
• Gemini 4 Argon (Google): $2 in and $10 out per million tokens, cached input $0.10, a 1M token window, listed 13 October 2026.

In this topic: AI models

• Gemini 4 Argon vs Opus 5.5: Real Cost per Agent Task (2026)
• Muse Spark Open: Benchmarks, License, How to Run (2026)
• Gemini 4 Argon: Benchmarks, Real Cost and Access (2026)
• Meta Muse Wonder: Benchmarks, Pricing and Access (2026)
• GPT-6 Sol vs Astra vs Luna: Which Model to Use (2026)
• GPT-6.1 Sol vs Claude Opus 5.5: Real Cost per Task (2026)
• Best LLM for AI Agents (October 2026 Ranking)
• Sakana Fugu Ultra v2 Beats Frontier LLMs (2026)

Which AI model should your agents run on? Every guide on it