Moonshot opens Kimi for agents and changes the question about downloadable models

On November 6, 2025, Moonshot AI released the weights for Kimi K2 Thinking, a version focused on reasoning and tool use. The official model card describes a mixture-of-experts model with one trillion total parameters, 32 billion activated per token, a 256,000-token context window, and INT4-quantized weights. It also claims stable tool use across sequences of up to 200 or 300 calls.

This is a notable combination, but it cannot be reduced to “a GPT-5 rival.” Moonshot’s own table changes winners according to the test, tool access, and allowed compute. Downloadable weights, inference efficiency, and autonomy are also separate properties. The durable skill is auditing each one before choosing infrastructure or delegating a task.

Total and active parameters answer different questions

Kimi K2 uses a mixture-of-experts architecture. A router selects some specialized blocks to process each token. Activating 32 billion parameters does not turn it into a model of that size: the system retains one trillion total parameters and must be able to access whichever experts the router chooses.

Active parameters approximate part of the arithmetic performed per token. Total parameters affect storage and memory; expert distribution adds communication between devices; input length increases attention work and temporary memory. Hardware, inference software, batch size, and quantization also change speed and cost. No single figure determines them.

The card identifies Kimi K2 Thinking as a native INT4 model. Four bits for each of one trillion parameters produces an arithmetic floor of roughly 500 decimal gigabytes for weights alone, before metadata, quantization scales, cache, activations, and engine overhead. This is an order-of-magnitude estimate, not a requirement for a specific setup. “Open” does not mean “fits on a laptop.”

Moonshot attributes a twofold low-latency speedup and memory reduction without loss to quantization-aware training. That is the developer’s claim. Translating it to a deployment requires matching output, hardware, engine, batch, sequence length, precision, and quality criterion. Quantization may preserve an average benchmark while changing individual cases.

Open weights do not mean a reproducible system

Moonshot releases code and weights under a modified MIT license. This permits inspection and operation of an artifact a closed service does not provide, subject to the license conditions and third-party notices. An organization can pin a version, calculate its footprint, run it inside its network, and modify the surrounding layer.

That does not automatically mean “open source” in every sense or make the model reproducible from scratch. Weights are the result of training. Repeating it would require data, filtering, ordering, full code, hyperparameters, and compute. The license answers which uses the owner grants; documentation answers what can be studied; reproducibility asks whether another party can reconstruct the result. They are three axes.

The Kimi K2 family technical report, published before this version, documents the mixture-of-experts base: 1.04 trillion total parameters, roughly 32 billion active, 384 experts with eight selected per token plus a shared expert, and pretraining on 15.5 trillion tokens. K2 Thinking builds on that base, while its November model card is the specific source for quantization, context, and evaluations of the reasoning variant.

The table does not name a universal winner

On Humanity’s Last Exam without tools, Moonshot reported 23.9 for Kimi K2 Thinking and 26.3 for GPT-5 High. With tools, the table changed to 44.9 and 41.7. Under the setting called “heavy,” it reported 51.0 and 42.0. The benchmark name stayed the same, but the evaluated system now included different resources and tools.

BrowseComp, an agentic search evaluation, showed 60.2 for Kimi and 54.9 for GPT-5 with tools. GPQA without tools reversed the order again: 84.5 for Kimi and 85.7 for GPT-5. These provider-reported results can justify a practical trial; they do not establish superiority in conversation, coding, safety, cost, or every agent task.

A comparable table needs the exact version, date, question set, tools, instructions, token limit, call limit, sampling, attempts, judge, and error treatment. “Heavy” is not a universal unit either; it must be translated into compute budget and cost. A comparison with unequal resources can remain useful at the product level, but it does not isolate model quality.

The business question is not which system wins more cells. It is the cost of achieving an accepted outcome in the chosen task. An agent that solves more cases with many more calls may be preferable for critical research and worse for high-volume support. Value depends on tolerated error, time, and supervision.

Two hundred calls are not two hundred correct decisions

Moonshot claims Kimi K2 Thinking maintains goal-directed behavior across 200 or 300 consecutive tool invocations. This describes a capability observed by the provider, not a requirement to consume that many calls or a guarantee across every tool. A long sequence can indicate planning, useless repetition, or recovery from failure.

Compound reliability illustrates the challenge. In a hypothetical example, if 200 mandatory steps were independent and each succeeded 99% of the time, the chance that all succeeded would be about 13.4%. These assumptions deliberately simplify the system: some failures can be corrected, while others propagate. The calculation still shows why a longer horizon needs verification, retries, and checkpoints rather than only a larger window.

A call budget should come with verifiable state. After each tool, the agent must check the result against an external condition rather than trust its own summary. It should distinguish success, recoverable error, denied permission, and incomplete data. Cost and time limits stop loops; human approval protects irreversible operations; logs reconstruct the path.

Test an agent without optimizing for the showcase

Select real tasks with defined beginnings and endings: find clauses in a closed document set, repair a bug under tests, or gather sources supporting a table. Prepare unseen variants and a reference answer. Run the same version multiple times and record full-task success, partial errors, calls, tokens, time, cost, human intervention, and unwanted changes.

Test the environment too, not only the model. Search may return a dead page, an API may return malformed data, or a terminal may deny permission. A useful agent recognizes the exception, preserves state, and chooses a safe recovery. The evaluation should reject an answer that looks finished but fails the external test.

For local deployment, pin the artifact hash, review the license and notices, restrict network egress, isolate execution, separate secrets, and log calls. Measuring files before buying hardware prevents active parameters from being mistaken for total memory. Testing on the intended engine and batch prevents a laboratory figure from becoming a budget.

Kimi K2 Thinking brought reasoning and tool capabilities into an enormous downloadable artifact. That expands who can study and operate the model, but it also shifts work to the user: infrastructure, security, evaluation, and maintenance. The decisive test is not whether it chains hundreds of calls. It is whether it reaches a verifiable result on a known budget, preserves boundaries, and leaves a trail another person can audit.

That test remains useful when the model name changes.