Kimi K2 Thinking Challenges GPT 5 With Open Weights, Strong Agent Scores and Lower Prices

Moonshot pushes open AI into the leading group

Moonshot AI's Kimi K2 Thinking is challenging leading proprietary artificial intelligence systems with a combination of strong reasoning scores, extended tool use and comparatively low prices. As of November 7, 2025, the newly released model reports 60.2 percent on BrowseComp, a test of web browsing agents, compared with 54.9 percent for GPT 5 and 24.1 percent for Claude Sonnet 4.5. On Humanity's Last Exam, it reports 44.9 percent with tools enabled.

Moonshot says K2 Thinking outperforms leading closed systems across several demanding evaluations involving reasoning, browsing and software engineering. Its coding results include 71.3 percent on SWE Bench Verified and 83.1 percent on LiveCodeBench v6. The release places an open weights model among the strongest systems in several areas, while some tasks still favor the best proprietary models.

K2 Thinking is available through Kimi.com and Moonshot's platform, with downloadable weights for organisations that want to run it themselves. Its Modified MIT License allows commercial use and requires light attribution for very large deployments. Open weights means the model's learned parameters are available for others to download and operate, giving developers a different level of control from accessing a closed model only through a provider.

The system combines one trillion total parameters with about 32 billion active for each token it generates. It supports a context window of 256,000 tokens and, according to Moonshot, can sustain 200 to 300 sequential tool calls. Those features target work that requires a model to search, read, calculate, write and check results over many steps, rather than simply produce a single answer.

How a trillion parameters become manageable

K2 Thinking uses a Mixture of Experts transformer architecture. Parameters are the numerical values a model learns during training. In a Mixture of Experts system, a router directs each token to a small selection of specialised modules, called experts, instead of activating the entire network.

Moonshot describes K2 Thinking as having 61 layers, 384 experts and eight experts selected for each token. Its specifications also include 64 attention heads, a hidden dimension of 7,168 and a vocabulary of 160,000. The attention mechanism is multi head latent attention, and the model uses SwiGLU activation. These are technical choices governing how the network handles information and transforms it while generating a response.

About 32 billion parameters activate for each token, roughly 3.2 percent of the stated trillion parameter total. This selective computation allows a large pool of learned capacity without requiring every parameter to perform calculations at every step. Moonshot presents the architecture as a way to maintain breadth and reasoning ability while keeping computation manageable on current accelerators.

The 256,000 token context window determines how much material the model can work with at once. Tokens are the pieces of text a model processes, including words, parts of words and punctuation. A large window can hold lengthy research material or substantial code projects while the system follows a plan across repeated actions. The routing system focuses computation on selected experts for the material being processed, supporting throughput and accuracy.

Compact weights help lower running costs

Moonshot trained K2 Thinking with quantization aware methods so that it can run natively in INT4 for weight storage and inference. Quantization stores numerical values in a more compact form than higher precision formats. Training with that compact representation in mind helps the model retain quality when it is deployed using it.

Moonshot reports approximately twice the generation speed with minimal quality loss compared with higher precision operation. All the reported benchmark scores were obtained under INT4. Lower memory needs and faster generation are part of the company's explanation for the model's competitive operating costs.

Community testers report running the model on high end desktop systems. Moonshot recommends engines including vLLM, SGLang and KTransformers. These engines handle the practical work of loading the model and generating responses, making the inference software another part of a deployment's speed and memory requirements.

K2 Thinking also supports APIs compatible with OpenAI and Anthropic. An API is the interface through which software sends requests to a model and receives responses. Compatibility makes integration simpler for developers already using those request patterns. Community reports describe generation speeds ranging from tens to hundreds of tokens per second on high end desktop machines, depending on settings.

Where the benchmark gains are strongest

Humanity's Last Exam tests demanding reasoning across difficult questions. K2 Thinking reports 23.9 percent in a setting using text alone, 44.9 percent with tools enabled and 51.0 percent in a heavy setting. The different settings matter because extra computation and access to tools change what the model can do while answering.

BrowseComp examines whether a model can plan a search, browse pages, follow links, combine findings and verify an answer. K2 Thinking's 60.2 percent score is 5.3 percentage points above GPT 5's reported 54.9 percent and 36.1 percentage points above Claude Sonnet 4.5's 24.1 percent. That makes browsing one of the clearest numerical advantages highlighted in the release.

Other reported results include 56.3 percent on Seal 0, 87.0 on Frames and 47.4 on FinSearchComp T3. Seal 0 and Frames involve information gathering, planning and consistency during tool use. Together with BrowseComp, they show why Moonshot is presenting K2 Thinking as a system for extended research and action, rather than only conversation.

Mathematics results include 94.5 percent on AIME25 without tools and 99.1 percent when the model can run Python. The difference is 4.6 percentage points. K2 Thinking also reports 89.4 percent on HMMT25 without tools and approximately 85 to 86 percent on GPQA Diamond, which tests scientific knowledge. Across many of these categories, the model meets or surpasses GPT 5.

Why hundreds of tool calls matter

Moonshot's central claim about agent behavior is that K2 Thinking can maintain planning and structured tool use across 200 to 300 sequential calls. A tool call is an action outside ordinary text generation, such as searching the web or executing code. A long task may require many such actions before the system has enough information to finish.

K2 Thinking uses interleaved thinking: it reasons, calls a tool, examines the result and updates its plan. The large context window helps keep relevant information available throughout that process. Its transparent reasoning traces also let users inspect intermediate steps, providing a way to examine how a task progressed.

Moonshot's demonstrations include a doctoral level mathematics problem that required reading papers, extracting formulas, running Python and verifying results. The system moved through more than twenty reasoning and tool steps before producing a final solution. The example shows how a difficult answer can depend on a sequence of searches and calculations.

Another demonstration involved identifying actor Jimmy Gary Jr. and confirming a particular film role. The model repeatedly searched and checked information across many web pages. That task illustrates a different use for extended tool chains: resolving a specific factual question by gathering and comparing information rather than relying on an immediate response.

Coding results and projects developers are testing

SWE Bench Verified evaluates whether a model can read an issue in a software repository, produce a patch and pass tests. K2 Thinking reports 71.3 percent with tools. This measures a different kind of work from answering a coding question, because the system must navigate existing software and make a change that works within it.

LiveCodeBench v6 gives K2 Thinking a reported score of 83.1 percent, while SWE Multilingual is reported at 61.1 percent. The multilingual result adds another dimension to the model's coding performance. Its large context window can support code navigation, while INT4 operation is intended to reduce delays during extended development sessions.

Community demonstrations show functional projects generated from a single prompt, including games and full web applications, followed by fixes through repeated tool calls. Reported examples include a working Space Invaders style game produced in one pass, website layouts, front end components and a desktop style interface with files and menus.

An experienced developer forum tester, whose name was not given, described steady behavior on hardware accessible to consumers across long tool chains and large prompts. The tester said:

In my tests, it handled up to 300 sequential tool calls without losing coherence, a big improvement over prior models.

The same tester reported that the native INT4 path improved speed while keeping quality stable. The account also cited the 256,000 token context window's usefulness for large code projects, multilingual coding strength and practical gains in front end tasks. These experiences add detail about how developers are using the model alongside its reported benchmark results.

Access, licensing and the price comparison

Moonshot makes K2 Thinking available for chat on Kimi.com and through the Kimi Open Platform API. Teams that want to host it themselves can obtain the weights from the Kimi model repository. Information for connecting applications is available through the Kimi platform documentation.

The Modified MIT License permits commercial use, with a light attribution requirement for very large deployments. Downloadable weights give organisations control over where the system runs, how it handles data and how it fits their compliance requirements. Developers can also experiment with agent behavior without relying exclusively on a proprietary provider's deployment.

Moonshot lists prices of about $0.15 per million tokens for cache hits, $0.60 per million tokens for cache misses and $2.50 per million output tokens. A cache hit means previously processed input can be reused; a cache miss requires input to be processed without that reuse. Output tokens are the text the model generates.

The cited GPT 5 prices are about $1.25 per million input tokens and $10 per million output tokens. On those figures, K2 Thinking's output rate is one quarter of GPT 5's, while its input rate for cache misses is 48 percent of the cited GPT 5 input rate. Moonshot links its lower running costs to native INT4 support and selective computation through Mixture of Experts.

Kimi.com's standard chat mode uses a restricted tool set for a lighter experience. Results in that mode may differ from the agent benchmarks while the Agent mode rollout is being completed. No completion date was given.

China's labs accelerate the competition

Kimi joins DeepSeek, Qwen and MiniMax among Chinese AI developers releasing increasingly competitive models. MiniMax's earlier model established a strong benchmark pace for open models and a lower cost baseline. K2 Thinking extends that competition into lengthy reasoning tasks and agent tooling.

Nathan Lambert, an AI researcher who follows open models and agent systems, described the release's position relative to leading closed systems:

The release is seen as the closest open models have come to the closed frontier in performance.

Lambert also pointed to the speed of releases from Chinese laboratories and the wider open model community:

Open models release faster. Chinese labs release their models much more quickly than Western labs.

The release discussion points to tighter feedback loops, frequent releases and test time scaling as parts of that progress. Test time scaling means giving a model more computation while it works on an answer, rather than relying only on what it learned during training. Some tasks continue to favor the strongest closed systems.

K2 Thinking's combination of scores, access and pricing puts pressure on proprietary vendors to compete through reliability, safety tools, enterprise support and integrated products as well as benchmark performance. For businesses, the attraction is control over deployment and data. For developers, it is access to advanced agent behavior at lower stated token prices.

Reliability and hosting remain practical concerns

Some users report occasional recall dips in very long contexts. A model may accept a large amount of text yet struggle to retrieve particular details consistently from it. Organisations working with extensive documents or code repositories will need to examine that behavior alongside the advertised window size.

Benchmark comparisons also depend on allowed tool budgets and limits on thinking tokens. A system given more searches, calculations or time to reason operates under different conditions from one given fewer. Fixed settings and reproducible evaluations will be important for enterprises comparing versions and choosing a deployment.

Hundreds of tool calls create practical hosting demands. Providers must manage more state, network requests and larger logs as a task develops. The speed of text generation is one part of that workload; maintaining an extended sequence of actions creates additional operating requirements.

Reasoning traces give teams intermediate steps to inspect, while requiring decisions about how much to log and when to mask sensitive content. Enterprises will also examine safety tools and stability across model versions. Open weights allow rapid community experimentation, bringing variants with different balances of speed, memory use and quality.

Testing across languages, subject areas and hardware will help developers identify the model's strongest uses. As of November 7, K2 Thinking combines competitive reported scores with extended tool use and lower stated prices, while production testing remains a central task for organisations considering it.

The Bottom Line

• Moonshot AI's Kimi K2 Thinking is available through Kimi.com, an API and downloadable weights under a Modified MIT License allowing commercial use.
• The model has one trillion total parameters, about 32 billion active per token and a context window of 256,000 tokens.
• Moonshot reports native INT4 operation, approximately twice the generation speed of higher precision operation and minimal quality loss.
• BrowseComp scores are 60.2 percent for K2 Thinking, 54.9 percent for GPT 5 and 24.1 percent for Claude Sonnet 4.5.
• K2 Thinking reports 44.9 percent on Humanity's Last Exam with tools, 71.3 percent on SWE Bench Verified and 83.1 percent on LiveCodeBench v6.
• The system is designed for 200 to 300 sequential tool calls, with reasoning traces that users can inspect.
• Listed prices are about $0.15 per million cached input tokens, $0.60 for input without a cache hit and $2.50 for output.
• Chinese developers including Kimi, DeepSeek, Qwen and MiniMax are competing through frequent releases, stronger scores and lower costs.
• Long context recall, reproducible performance, safety tools and the demands of extended tool chains remain priorities for deployment testing.