Kimi K3.1 Pro Is Here: What Changed, How to Access It, and What’s Still Coming

Kimi K3.1 Pro has launched, and the most useful way to understand it is as a substantial upgrade to the work Moonshot already started with K3: coding across a real project, handling large collections of information, and producing files that people can inspect and use.

Moonshot announced availability on October 23, 2026 across Kimi.ai, its mobile apps, Kimi Work, Kimi Code, and the API. A second option, K3.1 Pro Highspeed, promises faster responses. The downloadable model weights are a separate milestone: Moonshot says those will arrive by November 4, 2026. Source: official launch announcement.

There is already independent evidence worth examining. Artificial Analysis lists an Intelligence Index score of 55 for K3.1 Pro. But a strong aggregate score does not tell you how well it will fix your application, whether its CAD output is usable, or how much a long coding session will cost. Those questions require a closer look at the product, the evaluation conditions, and the billing rules.

Evidence note: This is a research-based launch analysis, checked October 23, 2026. Kingy.ai has not run a hands-on K3.1 Pro benchmark or paid inference test for this article. We distinguish Moonshot’s reported results, independent evaluator measurements, documented product behavior, and our own analysis. Official artwork and product imagery are credited to Moonshot.

Kimi K3.1 Pro at a glance

Sources: Moonshot’s announcement, Kimi Code model configuration, and Artificial Analysis’s model page. Prices and access rules are a launch-day snapshot, not a permanent offer.

What changed from Kimi K3?

Moonshot describes K3.1 Pro as a post-trained K3 model, with substantially more post-training compute. It says its reinforcement-learning work spans hundreds of domains. The company uses “3T-class” to describe the model. That rounded description should not be turned into a claim that it has exactly three trillion parameters.

The practical question is whether the additional training improves the decisions a model makes while doing a job. A coding assistant has to choose which files to inspect, distinguish the cause of a failure from its symptoms, make a change, run an appropriate check, and decide whether the result is sufficient. Better performance at those decisions can matter more than a longer answer or a more polished opening explanation.

The million-token context is familiar territory for this family. K3 already offered that capacity, so presenting it as an entirely new K3.1 feature would overstate the upgrade. The more interesting proposition is improved work within that window. The K3 documentation provides the predecessor’s technical context; our earlier Kimi K3 guide covers the previous launch and its dated evidence.

For an existing K3 user, a useful upgrade test is a task that previously stalled: a regression involving several files, a spreadsheet with linked assumptions, or a research answer requiring evidence from multiple documents. Record whether the new model finishes correctly, how many interventions you make, and how much it consumes. Those observations answer the switching question more directly than the version number.

What the benchmarks establish, and what they leave open

Moonshot reports 65.7% on Terminal-Bench 4.0, compared with 58.2% for GPT-6 Astra and 66.4% for Claude Opus 5.5 in its launch comparison. On its internal Kimi Code Bench 3.0 Long-horizon evaluation, it reports 61.2%, versus 55.95% for K3. These are vendor-reported results. Source: launch results and evaluation footnotes.

The footnotes matter. Moonshot says it evaluated K3.1 Pro on Terminal-Bench using the Claude Code harness, with maximum reasoning effort unless otherwise specified. Its comparison also incorporates results from other companies’ reports and public leaderboards. That is useful launch evidence, but it does not constitute a single controlled experiment in which every model ran under identical conditions.

A harness is the software around the model: the tools it can call, how it receives feedback, how the task is presented, and the rules for continuing or stopping. Changing that environment can change the result. A score achieved through Claude Code should not automatically be advertised as the score a user will obtain through every Kimi Code configuration.

The reported gap between K3.1 Pro and Opus 5.5 is 0.7 percentage points. Without an analysis of variation across runs and the full evaluation conditions, it would be premature to turn that difference into a dependable ranking for everyday coding. For readers choosing a tool, the stronger conclusion is that K3.1 Pro deserves testing on demanding development work.

The independent Artificial Analysis result

Artificial Analysis reports an Intelligence Index score of 55, measured output speed of approximately 73.5 tokens per second, and a weighted cost of US$2.11 per Intelligence Index task. Its page also records 150 million output tokens across the index evaluation. These are evaluator results, not Kingy.ai measurements. Source: Artificial Analysis.

Read those numbers separately. The index measures performance across a collection of tasks. Output speed describes generation throughput under the evaluator’s setup. Cost per index task is a benchmark-specific calculation. None is a quote for the price or duration of your next coding job.

Artificial Analysis’s listed index version, v4.3.2, combines ten evaluations spanning work tasks, coding, science, knowledge, and long-context reasoning. Its methodology explains the composition. A blended score can hide an uneven profile: a model may be excellent at one type of work and ordinary at another. Use the aggregate to decide what to investigate, then use a task-specific result to decide what to adopt.

Why coding and 3D creation are the most interesting launch angles

The coding pitch extends beyond generating a component or completing a function. Moonshot’s launch materials describe projects involving game engines, interactive web scenes, and scripts for Blender and CAD tools. It also introduces a 3D Make interface for creating and editing models. These are vendor demonstrations; we have not reproduced them. Source: coding and 3D sections of the announcement.

There are several different kinds of success here. An attractive render demonstrates visual presentation. An editable scene demonstrates that the object and its materials can be changed. A dimensionally correct CAD model demonstrates something more specific again. A printable object also needs suitable geometry, scale, and tolerances. One appealing screenshot cannot establish all four.

For a designer, the useful deliverable is often the project file. Can you change the chair’s width without rebuilding everything? Are repeated parts generated from parameters? Can a colleague understand the object hierarchy? Are textures and external assets identified? Those are the questions that determine whether an AI-generated scene saves time after the first impression.

The same distinction applies to games. A short demonstration can look complete while leaving collision behavior, input handling, save data, performance, or error recovery untested. A worthwhile evaluation would require the project to open in the stated engine, run without missing dependencies, and survive a small set of repeatable play scenarios.

For ordinary application development, we would start with a smaller test: provide an existing repository and a clear bug report, require a focused patch, and check it against a regression case the model has not seen. Compare the accepted change and review effort with the current tool. A longer autonomous run is useful only if its final state is easier to trust and maintain.

Pro versus Highspeed: faster output has a quota trade-off

Kimi Code’s documentation says Pro Highspeed has the same model capabilities as Pro, with approximately 2–3× faster output and about twice the quota usage. Under its new plans, regular Pro starts at Plus; the full million-token context requires Pro or above. Highspeed starts at Pro. Legacy-plan names have their own eligibility mapping, so existing subscribers should check their specific plan. Source: Kimi Code model table.

The speed claim applies to model output. If most of a job’s time is spent running tests, installing dependencies, rendering a scene, or waiting for an external service, faster token generation will improve only part of the total duration.

Consider a hypothetical ten-minute task with four minutes spent generating model output and six minutes executing tools. Doubling generation speed reduces the first portion to two minutes, making the whole task eight minutes. That is a 20% reduction in elapsed time. This is an illustration of the trade-off, not a Kimi measurement.

Highspeed may therefore suit interactive sessions where waiting for the model interrupts your work. Regular Pro may be the more economical starting point for long jobs dominated by tools. Compare elapsed time and completed tasks per allowance before deciding which should be your default.

Do not translate the coding plan’s quota multiplier into an API price multiplier. Membership allowances and API billing are different products, and we have not independently verified a complete Highspeed API price schedule for this article.

How to access Kimi K3.1 Pro

Choose the access route that matches the work you intend to do. A consumer chat account, a coding subscription, and a developer API balance do not necessarily carry the same allowances.

Kimi.ai, mobile, and Kimi Work

The launch announcement directs users to Kimi.ai and updated mobile apps. For desktop work, it specifies Kimi Work 3.1.0 or later on Windows and Apple silicon Macs. It also says enterprise administrators must enable K3.1 Pro for their organization because access is off by default at launch. Source: availability section.

Check the model selector and the allowance attached to your account. An announcement that a model is available in a product does not establish unlimited access on every plan. We have not tested the consumer free tier or account-specific rollout behavior.

Kimi Code

In the official CLI, use /model to select the model and begin a fresh session. Moonshot recommends avoiding a mid-session switch from another model because the earlier reasoning history and cache can affect the new session. The coding endpoint uses k3.1-pro and k3.1-pro-highspeed. Its documentation warns that a mistyped model identifier can fall back to K2.8 Preview without thinking. Source: model selection and routing.

That warning is relevant to reviews as well as configuration. A reviewer should record the endpoint, exact model identifier, effort setting, and displayed model confirmation before drawing conclusions about K3.1 Pro.

The developer API

The general API uses different identifiers: kimi-k3.1-pro and kimi-k3.1-pro-highspeed. The official quickstart documents an OpenAI-compatible client using https://api.moonshot.ai/v1.

Moonshot’s recharge documentation says an account needs at least a US$1 top-up to start using the service. Rate limits depend on cumulative recharge and include requests, tokens, and concurrency. A successful account setup therefore does not guarantee that a very large prompt or a burst of parallel jobs will fit your tier.

Use the configuration guide for the product you are connecting. Copying a Kimi Code identifier into the general API, or combining a coding-plan key with the wrong endpoint, is an avoidable source of confusion.

Reasoning is always on, and it affects both speed and cost

K3.1 Pro supports low, high, and max reasoning effort, with max as the default. Thinking cannot be disabled. For Chat Completions, effort is a top-level reasoning_effort field. Source: reasoning-effort documentation.

Maximum effort is a sensible setting to investigate on a difficult task, but it should not be selected automatically for everything. A simple extraction, a small formatting change, and a complicated debugging investigation have different requirements. Compare settings on a few representative tasks and check whether additional reasoning improves the accepted result enough to justify the extra wait and consumption.

The thinking-model documentation explains that reasoning adds latency and token usage. It also requires the complete assistant message, including returned reasoning and tool-call fields, to be preserved in multi-turn API conversations. An integration that keeps only the final visible answer can discard information the model expects on the next turn.

Developers should inspect the returned usage accounting, not estimate the bill from the length of the final answer. A short response can follow a much longer reasoning process. Equally, a highly verbose answer may be less useful than a concise one that reaches the correct result and produces a clean artifact.

Pricing: understand the whole request before estimating the bill

At our check, Artificial Analysis lists standard K3.1 Pro at US$2 per million input tokens and US$10 per million output tokens, with a 90% cache discount. The corresponding cached-input rate is US$0.20 per million tokens. Source: independent pricing listing. Confirm the applicable rates on the provider’s pricing page before funding a workload.

For a deliberately simplified calculation, 100,000 uncached input tokens at US$2 per million cost US$0.20. Another 20,000 billable output tokens at US$10 per million cost US$0.20. Those two components total US$0.40. This is arithmetic using the listed rates, not an observed invoice; it excludes any separately billed cache writes, tools, taxes, and further agent turns.

Moonshot’s billing guide says K3-series cache writes are billed separately according to retention duration. A cache hit is billed at the cached-input rate. The caching documentation describes automatic prefix caching, with five-minute and one-hour retention options.

The practical benefit depends on reuse. If a conversation repeatedly sends the same large repository instructions or document collection, cached prefixes may reduce input charges. If the prefix changes frequently, or the cache expires between requests, the saving can be smaller. The cache discount alone is not a complete task-cost estimate.

For an agent, include every turn. Reading files, receiving test output, revising a patch, and trying again can create many requests before the task finishes. The figure that matters to a team is total cost per accepted task, including the human time needed to verify and repair the result.

Moonshot explicitly distinguishes the pay-as-you-go API from Kimi memberships and Kimi Code in its product comparison. A monthly subscription price and a per-token API rate should never be treated as interchangeable budgets.

What a million-token context window does for real work

A large window gives an application room to provide more material in a request: source files, meeting notes, document extracts, conversation history, or tool output. It can reduce the need to discard useful context early. It does not establish that the model will find every relevant detail or resolve every contradiction correctly.

Suppose a research task includes several versions of a report. One contains a preliminary number, another corrects it, and a third quotes the preliminary number after the correction was published. Successful reasoning requires attention to dates and provenance, not just enough capacity to hold all three files.

A good long-context test therefore asks for exact supporting passages, includes conflicting evidence, and checks whether the model can identify what remains unknown. For a codebase, require references to the files and functions that support the proposed change. For a spreadsheet, verify the formulas and input assumptions independently.

Keep context capacity, output limits, account rate limits, and product plan entitlements separate. They answer different questions: what fits in the model’s window, what one response can produce, what the service will accept over time, and what the account is allowed to access.

Financial research and factual accuracy need careful interpretation

Moonshot highlights financial modeling and research, and reports an OfficeQA Pro v2 result of 64.4. These workflows are relevant because a useful answer may need to retrieve evidence, reconcile documents, calculate a result, and leave an auditable trail. The launch results remain the vendor’s evidence. Source: finance results.

We found a specific inconsistency during research. The public launch blog reports a claim-level hallucination rate of 8.3% for K3.1 Pro on its internal hard evaluation, down from 23.4% for K3. The API quickstart instead displays 6.85% and 23.35%, alongside some unfinished benchmark placeholders elsewhere on the page. We cannot establish from those pages whether the discrepancy reflects different evaluation versions or an editing error. Launch blog; API quickstart.

Neither figure should be described as the model’s error rate in normal use. Moonshot says the evaluation deliberately stresses difficult factual cases. A claim-level error rate also differs from the percentage of answers containing at least one error.

For a business workflow, ask for document names, dates, page references, calculations, and the assumptions behind the answer. Then check them. A polished report with inaccessible citations or hard-coded spreadsheet totals creates review work, even when its narrative sounds convincing.

Open weights are promised; deployment details still need confirmation

The November 4 commitment matters because downloadable weights would let organizations investigate deployment on infrastructure they control. At publication, our verified evidence is Moonshot’s promise. We have not verified a downloadable K3.1 Pro checkpoint, its final license, the complete file set, or a supported self-hosting configuration.

Do not copy K3’s download size, quantization instructions, or hardware requirements into a K3.1 Pro buying recommendation. Even a model derived from the same predecessor can require updated serving code, different packaging, or different configuration. Our K3 weights and hardware article concerns that earlier release.

Before buying hardware for K3.1 Pro, wait for the actual model card and deployment instructions. Check the license, total storage, supported numerical formats, accelerator memory requirements, inference-engine support, and the context length used in any performance example. A server that can load a model may still be unsuitable for the concurrency or response time you need.

Open weights and an open-source license are also different claims. The final license will determine what users can do with the files and under what conditions. We are not assigning K3.1 Pro a license based on its predecessor.

Privacy and enterprise access deserve their own check

Moonshot’s Zero Data Retention documentation describes ZDR as an enterprise option available on request. It also lists exceptions: batch jobs, directly uploaded images and videos, operational data, and third-party services are not all covered by the same promise.

That is narrower than assuming every Kimi interaction automatically has zero retention. If an organization needs that arrangement, confirm that it is enabled for the relevant account and workflow. Also check which data passes through connectors and tools outside the model provider.

For an initial evaluation, use public material or a repository you are authorized to process. Decide which actions the agent may take and where it may write before asking it to complete a large job. Those decisions remain part of deploying an agent, regardless of its benchmark score.

Who should try it now?

Developers who already use K3 have a clear comparison to make: repeat a difficult, well-defined task with K3.1 Pro and inspect the resulting patch. Designers working with scripted 3D assets can investigate whether it produces editable projects that hold up after the first revision. Research teams can test source-grounded answers against a small document collection with known correct answers.

Teams evaluating a coding subscription should compare regular Pro and Highspeed on completed work per allowance. API users should compare total request costs at more than one effort setting. Anyone planning a self-hosted deployment should wait for the actual weight release and its documentation before committing to a hardware configuration.

A useful first trial is deliberately narrow. Choose one task with a clear acceptance condition, save the original inputs, record the model and effort setting, and keep the output files. Note the elapsed time, any retries, and every correction you make. If the result passes, expand to a second task with a different failure mode.

K3.1 Pro has enough published evidence to warrant that trial. A dependable adoption decision still comes from the work it completes in your environment, at a cost and review burden you can measure.

Sources and reporting scope

Primary references are Moonshot’s K3.1 Pro launch announcement, API quickstart, Kimi Code model documentation, and the linked billing, reasoning, cache, rate-limit, and privacy documentation. Independent measurements come from Artificial Analysis, with its methodology linked above.

We inspected public source pages and retained launch-day copies. We did not log into a Kimi account to verify individual entitlements, run the example projects, buy API access, or test a local checkpoint. Benchmark figures retain their source attribution; our cost and timing examples are explicitly hypothetical. This article’s evidence date is October 23, 2026.

The Kingy Brief

Get The Kingy Brief.

AI changes, original tests and one practical thing to try. Fridays at 09:00 Vancouver time.

Free · Double opt-in · Unsubscribe anytime

Privacy policy

Sign up for The Kingy Brief on Beehiiv.

Signup help and newsletter schedule

Signup form provided by Beehiiv. After submitting, check your inbox for "Confirm your subscription to The Kingy Brief" and open its confirmation link. Check Spam or Promotions if you cannot find it.

Fridays at 09:00 Vancouver time: source-checked AI changes, original tests and one practical thing to try. We skip a week when there is not enough verified material. Free. Unsubscribe anytime.

Sign up free