Kimi K2 is an open source MoE large language model series launched by Moonshot AI. It has a total parameter of 1T and an activation parameter of 32B. It is specially designed for agent scenarios such as tool calling, code generation and autonomous task solving. It provides two variants, Base and Instruct, supports 128K context, reaches the open source SOTA level on Agent benchmarks such as SWE-bench and Tau2-bench, and the API is compatible with the OpenAI/Anthropic interface.

KimiK2

Core parameters and statistics

Kimi K2 is a large language model series open sourced by Moonshot AI in July 2025. It adopts a mixed expert (MoE) architecture with a total parameter volume of 1 trillion (1T) and only 32B parameters are activated per token. It achieves the cutting-edge level of knowledge, reasoning and programming on the non-thinking model route, and on this basis, it is deeply optimized for agent tasks - not only "answering questions", but also "executing actions".

Parameter items	Kimi K2-Instruct / K2-Base	Kimi K2-0905 (enhanced version)	Kimi K2.6 (universal flagship)
Architecture	MoE (Mixed Expertise)	MoE	MoE
Total parameters	1T	1T	Undisclosed
Activation parameters	32B	32B	Undisclosed
Number of experts	384 (choose 8 per token)	384	Undisclosed
Attention Mechanism	MLA (Multiple Latent Attention)	MLA	MLA
Context window	128K tokens	256K tokens	256K tokens
Vocabulary size	160K	160K	Undisclosed
Training data	15.5T tokens	—	—
Optimizer	MuonClip (self-developed stabilization optimizer)	MuonClip	—
Visual input	Not supported	Not supported	Supported (picture + video)
Thought chain reasoning	Not supported (non-thinking model)	Not supported	Supported (thinking/non-thinking dual mode)
Open Source License	Modified MIT	Modified MIT	Not Open Source (API only)
Inference engine	vLLM / SGLang / KTransformers / TensorRT-LLM	Same as above	API service

Parameter Interpretation: Only 8 of the 384 experts are activated per token (+1 shared expert). This high sparsity design (activation rate is about 2.3%) is the core reason why Kimi K2 achieves deployable reasoning with 1T total parameters. Compared with DeepSeek-V3 (671B total parameters/37B activations), which is also on the MoE route, K2 has 49% larger total parameters, but 13% smaller activation parameters, which means that it has a lower amount of inference calculations under the same hardware conditions.

128K→256K context transition: The initial version supports 128K tokens, and the 0905 enhanced version and subsequent K2.6 are expanded to 256K. For code repository-level context, long document analysis, and multiple rounds of Agent conversations, the 256K window can cover more complete context and reduce planning breaks caused by truncation. However, please note: after doubling the context, the KV cache overhead increases simultaneously, and the video memory capacity needs to be evaluated in self-deployment scenarios.

Positioning differences of non-thinking models: The initial version of K2 is positioned as a "reflex-grade" (reflection-level) non-thinking model - it does not perform explicit chain-of-thought, but relies on pre-training and reinforcement learning to internalize capabilities into intuitive responses. This makes the reasoning latency of K2 lower than that of contemporary thinking models (such as DeepSeek-R1), but the thinking model still has advantages in complex reasoning tasks that require multi-step logic expansion. The subsequent K2.6 version has added support for thinking chain reasoning, making up for this gap.

User and market recognition of Kimi K2

The market influence of Kimi K2 is particularly prominent in the open source community and developer ecosystem. C-end users mainly come into contact with K2 series models through the free chat portal of kimi.com.

Open Source Community Popularity: GitHub repository MoonshotAI/Kimi-K2 has received more than 11,000 Stars and 880+ Forks, and 10 active maintainers continue to contribute. This is one of the model warehouses with the highest community attention among the open source projects of Chinese AI companies. The community has spawned a large number of ecological projects around K2 (such as kimi-writer, kimiflare, Kimi-K2.7 Swarm Workstation, etc.).

Developer API adoption: Kimi API platform has served millions of professional developers, and its partners include Vercel, Cursor, Windsurf, TRAE, GenSpark, Xiaohongshu, Huawei, Coze, CodeBuddy and other leading companies and development tools. Especially in the field of AI programming, many well-known IDE plug-ins (such as Kilo Code, Cursor) integrate the K2 series as the underlying model. Tencent CodeBuddy integrates the K2 Thinking model to assist developers in solving complex programming tasks; Genspark uses K2 0905 version to drive autonomous Agents on its Agent platform.

Industry customer verification: Public cases show that K2 has been used in professional fields such as financial research (AlphaEngine FinGPT Agent), materials science (XtalPi chemical literature understanding), AI for Science (DP Technology RxnBench Top 2), etc. These scenarios have extremely high requirements on the accuracy of tool calls and the reliability of long contexts. The implementation of K2 in these vertical scenarios shows that its agent capabilities have reached production-level levels.

Benchmark Performance: Surpassing all open source models in the same period with 65.8% pass@1 on SWE-bench Verified (Agentic Coding); ranking first in open source in the three sub-fields of Tau2-bench (tool usage), among which the telecom sub-item leads the second place by more than 40%. In the Math & STEM evaluation, AIME 2024/2025, MATH-500, GPQA-Diamond and other benchmarks have reached or approached the level of the closed-source flagship model (see GitHub README evaluation table). It should be noted that these results were achieved under non-thinking model conditions - it is expected that there is room for further improvement after joining the thinking chain (K2.6 and beyond).

Cost advantage: Open source + API dual-track pricing covers all scenarios

The cost structure of Kimi K2 is different from a pure closed-source model or a pure open-source model. It provides both "open source self-hosting zero license fee" and "pay-per-volume API extremely low unit price", covering different budgets and compliance needs from individual developers to large enterprises.

C-side: Free to use on kimi.com: Ordinary users can choose K2 series models for dialogue on kimi.com for free, with no limit on the number of times. This is the core strategy of Dark Side of the Moon to attract C-end users - to build brand awareness through free experience, and then guide developers and enterprises to use paid APIs. The free version currently does not support high-end functions such as MCP tool calling and visual input.

API Pricing (Developer Level): The API price of Kimi K2.6 is in the low-to-medium range among mainstream large models, and the marginal cost of repeated input is further reduced through the context caching mechanism.

model	input (cache hit)	input (cache miss)	output	context window
Kimi K2.6	$0.16 / million tokens	$0.95 / million tokens	$4.00 / million tokens	256K
Kimi K2.7 Code	$0.19 / million tokens	$0.95 / million tokens	$4.00 / million tokens	256K
Kimi K2.7 Code HighSpeed	$0.38 / million tokens	$1.90 / million tokens	$8.00 / million tokens	256K
Comparison: DeepSeek-V4-Flash	~$0.14 / million tokens	~$0.14 / million tokens	~$0.28 / million tokens	1M
Comparison: GPT-4o	~$2.50 / million tokens	~$2.50 / million tokens	~$10.00 / million tokens	128K

Enterprise/Private Deployment: K2 Base and Instruct weights are open source under the Modified MIT license. Enterprises can freely download, self-host and fine-tune them without paying any license fees. The hidden costs of self-deployment include: GPU server (recommended starting from 4×A100-80G, more for high concurrency), operation and maintenance manpower, network bandwidth and inference engine tuning. For industries with data sovereignty requirements or high compliance auditing needs (finance, medical care, government affairs), self-hosting is the only feasible path; for small and medium-sized teams, directly calling APIs is far more economical than self-building.

Implicit cost considerations: The initial version of K2 does not support visual input and thought chain reasoning. If the business scenario requires multi-modal or complex reasoning, you must upgrade to K2.6 or above. K2.6 is not open source and can only be called through APIs, which poses a "capability ceiling" for teams that expect end-to-end self-hosting - a trade-off needs to be made between self-hosting (free license + limited capabilities) and API (pay-as-you-go + complete capabilities).

Key features of Kimi K2

Kimi K2's capability set revolves around the two main lines of "tool invocation" and "autonomous task execution". It is different from the traditional chat model. Its core product logic is to "let the model directly operate tools and complete closed-loop tasks."

• Tool Calling/Function Calling: K2’s core differentiation capability. The model can independently decide when to call external tools, what parameters to pass in, and how to parse the returned results. Supports OpenAI/Anthropic compatible tool schema definition, developers only need to pass the tools parameter in the request to enable it. Typical applications: weather query, database query, external API call, code execution. In the Tau2-bench evaluation, K2 is significantly ahead of other open source models in the three fields of retail/airline/telecom, demonstrating its ability to control complex tool combination scenarios.

• Agentic Coding: K2 became the open source model champion with 65.8% pass@1 (single build, calculated without testing) on ​​SWE-bench Verified. This means that K2 can understand GitHub Issues, locate relevant code files, generate fix patches, run tests, and iteratively make corrections—all without human intervention. It also reaches 47.3% pass@1 on SWE-bench Multilingual, surpassing most closed-source models. For developers, this means K2 can serve as the underlying engine for PR review assistants, bug fix automation, and code refactoring.

• Autonomous task planning and execution: K2 can accept a high-level task description (such as "Analyze the impact of remote work on salary in 2020-2025"), and then autonomously break it down into a multi-step plan: load data → clean → statistical analysis → visualize → generate report. K2’s official demo shows autonomously completing a complete data science workflow in 16 IPython calls, including executing Python code, catching errors, correcting strategies, and generating interactive HTML reports.

• Long context understanding (128K→256K): Based on the MLA (multi-head latent attention) mechanism, K2 maintains low KV cache overhead in long context scenarios. Initial version 128K, 0905 enhanced version and subsequent versions 256K context windows to handle complete code repositories, hundreds of pages of documentation, or dozens of rounds of Agent conversation history. In the long-context Retrieval task, K2's mid- and late-stage information recall rate is better than that of models of the same scale, which is especially critical for its Agent scenario - Agents often need to review early instructions later in the conversation.

• API ecological tool set: Kimi API platform has built-in rich official tools, including: Web Search (Internet search), Code-Runner (Python code execution), Excel (Excel/CSV file analysis), Memory (conversation memory persistence), Fetch (URL content extraction), Rethink (idea reorganization), etc. These tools are deeply integrated with K2 models and can be used out of the box without the need for developers to develop their own.

Model and version evolution

Since Kimi K2 was first open sourced in July 2025, it has iterated into 4 major version nodes with a clear path: initial open source → Agentic Coding enhancement → Multi-modal general flagship → Programming specialized branch.

Mainline version

Version	Release Date	Core Changes	Features	Open Source Status
K2-Base/K2-Instruct	2025-07 (~2025-07-22)	Initial Open Source Release	128K context, non-thinking, tool calls	Open Source (Modified MIT)
K2-0905	2025-09-05	Agentic Coding enhancement	The context is expanded to 256K, and the success rate of programming tasks is improved	Open source (Modified MIT)
K2.6	2026-04	General capability upgrade	Support visual + text input, 256K context, thinking chain reasoning, add thinking/non-thinking dual mode	API only
K2.7 Code / K2.7 Code HighSpeed	2026-05	Programming specialization branch	Programming task optimization, HighSpeed version ~180 tokens/s, 256K context, thinking chain reasoning	API only

Interpretation of version context

V1 stage (K2-Base/Instruct): The Dark Side of the Moon chose to fully open source the 1T parameter MoE model under the Modified MIT license. This was one of the open source models with the largest number of parameters at the time. The Base version is for researchers and teams that need in-depth fine-tuning, while the Instruct version is for plug-and-play general dialogue and Agent scenarios. The initial version was positioned as a "non-thinking model" and was intentionally differentiated from the mainstream chain reasoning route at the time.

V2 stage (K2-0905): Enhanced version about 1.5 months later, focusing on improving Agentic Coding capabilities and doubling the context to 256K. This release reflects Dark of the Moon’s tilt towards the developer scene – the leading performance on SWE-bench proves the effectiveness of its technical approach.

V3 stage (K2.6): This is the key version of the K2 series' transition from "pure text non-thinking model" to "multi-modal thinking model". With the addition of visual input, thinking chain reasoning and thinking/non-thinking dual modes, the ability coverage is greatly expanded. But it is also the first version that is not open source, marking the differentiation of Dark Side of the Moon's open source strategy - basic model capabilities continue to be open source, and cutting-edge capabilities are commercialized in the form of APIs.

V4 stage (K2.7 Code): A deeply specialized branch for programming scenarios, providing a high-throughput version (180 tokens/s) that directly targets the underlying model requirements of IDE plug-ins such as Cursor and Windsurf. The Code family complements the universal K2.6: one anchors code quality, the other covers breadth of applications.

Technical advantages: Technology stack from MuonClip to large-scale Agentic RL

The technical advantage of Kimi K2 is not a single innovation, but a full-link systematic engineering breakthrough from pre-training optimizer to post-training reinforcement learning.

MuonClip Optimizer: Solve the instability problem of Muon training: The Muon optimizer is significantly better than the widely used AdamW in token efficiency, but it is prone to attention logit explosion in large-scale training, causing training interruption. The Kimi K2 team proposed the qk-clip technology: directly rescaling the query/key projection weight after Muon is updated to control the attention logit scale from the source. By introducing an adaptive factor (dynamic threshold based on maximum logit), MuonClip achieves zero training spikes in pre-training on 15.5T tokens. The engineering implication behind this is that the cost and risk of large-scale MoE training are significantly reduced, allowing Dark Side of the Moon to train 1T parameter models at a budget far lower than that of its peers.

High sparsity MoE design: 384 experts + 8 selected per token (+1 shared expert), activation rate is only ~2.3%. High sparsity means that the amount of calculation increases sub-linearly as the total number of parameters increases, and only 32B activation parameters are loaded into the video memory during inference. This allows a single card A100-80G to run inference, lowering the hardware threshold for self-deployment.

Large-scale Agentic data synthesis pipeline: K2’s Agent capabilities come from two key innovations. First, an automated data synthesis pipeline inspired by ACEBench - systematically evolves thousands of tools (including real MCP tools and synthesis tools) in hundreds of fields, generates hundreds of Agents carrying diverse tools, and allows them to interact with user Agents in multiple rounds in a simulated environment. LLM Judge scores and filters interaction results based on rubrics to produce high-quality training data. Second, a general reinforcement learning system - distinguishes between verifiable rewards (mathematics, competition programming) and non-verifiable rewards (writing, research), and adopts a "self-criticism" mechanism for the latter: the model acts as its own critic and provides scalable feedback based on rubrics. At the same time, the on-policy rollout of verifiable rewards continuously updates critic, forming a positive feedback loop.

API Compatibility Design: The API is compatible with the interface formats of both OpenAI and Anthropic. This reduces migration costs for developers - existing OpenAI SDK-based applications can switch to K2 by simply modifying the base_url and API key. The temperature of the Anthropic compatible interface is mapped through real_temperature = request_temperature × 0.6 to ensure compatibility with existing applications.

Multiple inference engine support: The recommended running engines include vLLM, SGLang, KTransformers and TensorRT-LLM, covering different performance requirements from academic research to production deployment. vLLM and SGLang focus on throughput optimization, KTransformers is suitable for single-card experiments, and TensorRT-LLM is used for extreme inference optimization.

How to use

Kimi K2 provides three usage paths, covering the complete access level from ordinary users to developers.

How to use	Entrance	Suitable for the crowd	Core restrictions
Web Chat	kimi.com	Ordinary users, product experiencers	Visual input and MCP tools (initial version) are not supported; login required
API call	platform.kimi.ai	Developer, enterprise integration	Need to register an account and create an API Key; billing based on volume
Self-hosted deployment	GitHub + Hugging Face	Research team, high-compliance enterprise	GPU server required; inference engine needs to be built by yourself

API quick access example (Python, compatible with OpenAI SDK):

from openai import OpenAI

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

response = client.chat.completions.create(
    model="kimi-k2.6",
    messages=[
        {"role": "system", "content": "You are Kimi, the AI assistant created by Dark Side of the Moon."},
        {"role": "user", "content": "Write a quick sort algorithm in Python."}
    ],
    temperature=0.6,
    max_tokens=2048,
    stream=False
)
print(response.choices[0].message.content)

API example with tool calls:

tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Get the current weather information of the specified city",
        "parameters": {
            "type": "object",
            "required": ["city"],
            "properties": {
                "city": {"type": "string", "description": "city name"}
            }
        }
    }
}]

response = client.chat.completions.create(
    model="kimi-k2.6",
    messages=[{"role": "user", "content": "How is the weather in Beijing today?"}],
    tools=tools,
    tool_choice="auto",
    temperature=0.6
)

Self-hosted deployment (vLLM example):

# Install vLLM (must support Kimi K2 version)
pip install vllm

# Start the inference service (taking K2-Instruct as an example)
python -m vllm.entrypoints.openai.api_server \
    --model moonshotai/Kimi-K2-Instruct \
    --tensor-parallel-size 4 \
    --max-model-len 131072 \
    --gpu-memory-utilization 0.9

# After the service is started, it can be called through the OpenAI compatible interface

Typical usage process: Visit kimi.com or platform.kimi.ai → Register/Login → Create API Key (API mode) → Select model (K2.6/K2.7 Code) → Input message and tool definition (optional) → Get generated results → Parse tool_calls (if required) → Manually review key output.

Product Pricing

The pricing strategy of the Kimi K2 series adopts a three-tier structure of "open source free + API pay-as-you-go + enterprise customization", which complements the open source strategy.

C-side: free on kimi.com: All Kimi series models (including K2/K2.6/K2.7 Code) can be used for free on kimi.com with no upper limit. The purpose of this pricing strategy is to maximize the user base and cultivate paid conversions for the API service. It is worth noting that the free version has limited functions (such as not supporting tool calls, limited high-frequency requests, and no SLA guarantee).

API pay-as-you-go: API prices are differentiated by model version and cache hit status.

Model	Input (cache hit) / million tokens	Input (cache miss) / million tokens	Output / million tokens	High-throughput version output
Kimi K2.6	$0.16	$0.95	$4.00	—
Kimi K2.7 Code	$0.19	$0.95	$4.00	—
Kimi K2.7 Code HighSpeed	$0.38	$1.90	$8.00	—
Kimi K3 (Flagship)	$0.30	$3.00	$15.00	—

Enterprise customized solution: The platform provides "enterprise solutions and customization" services, including flexible rate limits, multi-project deployment support, SLA guarantee, data compliance and privacy protection, and exclusive technical support. Enterprise prices need to be obtained by contacting the business team, and standard pricing has not been disclosed. For enterprises with self-hosting needs, K2 Base/Instruct open source weights are available for free, but the costs of GPU infrastructure, operation and maintenance manpower, and inference engine tuning need to be evaluated by yourself.

Free quota and billing details: After API registration, there is a free trial quota by default (the specific value is subject to the platform.kimi.ai page). Contextual caching takes effect automatically - cache hit prices are automatically applied when the same prefix is ​​entered repeatedly. The file upload and content extraction interfaces are currently free. The actual billing is based on the real-time page. It is recommended to calculate the estimated API usage through Token before deployment.

Application scenarios

The core capabilities of Kimi K2 determine that it is most suitable for task scenarios that require active manipulation of tools rather than just text generation. The following types of scenarios have the highest input-output ratio.

• Agent Programming and Code Warehouse Maintenance: K2’s SOTA performance on SWE-bench means that it is capable of engineering tasks such as GitHub Issue repair, code review, test generation and refactoring. The actual use effect depends on the modularity of the code warehouse and the clarity of the issue description - in a highly coupled old code base, K2's problem location accuracy will decrease. Acceptance concerns: It is recommended to start verification from single file repair tasks in small and medium-sized warehouses (<50K lines), and gradually expand to multi-file reconstruction.

• In-depth research and analysis report generation: Combining Web Search, Code-Runner and long context capabilities, K2 can serve as a research assistant to complete a complete workflow from data collection, statistical analysis to report writing. The official demo demonstrates the ability to complete payroll data analysis and generate interactive HTML reports in 16 IPython calls. Acceptance concerns: The higher the authoritative requirements for the data source, the more necessary it is to set up manual review points in the key conclusion link; K2's statistical analysis can be automated, but it is not recommended to leave causal inference and business recommendations completely to the model.

• Automated Workflow and Agent System: K2 is an ideal underlying model for building autonomous Agent systems. Developers can build multi-Agent collaboration systems on the Kimi API. Each Agent carries a different tool set and completes complex business logic through task orchestration. Tencent CodeBuddy and Genspark Agent platforms are typical cases of this scenario. Acceptance concerns: In the Agent scenario, attention needs to be paid to the growth of Token consumption - multiple rounds of tool calls will significantly increase the amount of output tokens. It is recommended to set a single task max_steps and Token budget upper limit.

• Customer Service and Conversational Intelligence: K2’s command-following capabilities and long context window make it suitable for building intelligent customer service systems. Can handle multi-turn conversations lasting dozens of rounds, maintaining an accurate understanding of user intent and context. With the Memory tool, conversation history persistence and user portrait accumulation can be achieved. Acceptance concerns: It is necessary to build high-quality few-shot examples and system prompt words for the business field; for sensitive business operations (refunds, account cancellation, etc.), manual confirmation points must be set.

• Legal and Contract Review: K2's long context capability allows it to process tens to hundreds of pages of contract documents at one time, extract key terms, mark risk points, and compare version differences. Acceptance focus: The special terminology and logical structure of legal texts require high-precision understanding. It is recommended to use contract samples in the target field for system evaluation before official launch. The final legal opinion should still be confirmed by a practicing attorney.

Applicable people

Kimi K2's audience spans individual developers, research teams, and large enterprises, but the value points and prerequisites of different roles vary significantly.

• AI Application Developers: This is K2’s core audience. Whether building agent applications, programming assistants, or automated workflows, K2's tool calling capabilities and open source license provide a flexible integration foundation. Prerequisites: Familiar with OpenAI/Anthropic API format, understanding tool schema definition and Agent architecture. For developers who require self-hosting, experience with GPU cluster deployment is also required. Not applicable scenarios: Multi-modal applications that require high visual understanding (recommend K2.6 API or switch multi-modal models); real-time conversations that require extreme latency (recommend dedicated small models or high-speed version API).

• AI Research Team: K2-Base's open source weights provide researchers with a 1T parameter-aware research platform that can be used for fine-tuning, alignment research, model compression, and Agent behavior analysis. The implementation of the MuonClip optimizer also provides a reference for training stability research. Prerequisites: Sufficient GPU computing power (8×A100-80G or above recommended) and MoE model training/fine-tuning experience. Not applicable scenario: Individual researchers with tight budget (model weight exceeds 600GB, high storage and loading costs).

• Enterprise AI Team: K2's open source licensing and API dual-track system provides enterprises with flexible choices - choose self-hosting if compliance requirements are high, and choose API if speed requirements are high. Small and medium-sized businesses can quickly prove concepts through the API, and large enterprises can build private deployments based on open source weight. Prerequisites: The total cost of ownership (TCO) of self-hosting vs. API needs to be evaluated, including GPU purchase/rental fees, operation and maintenance manpower, and model update frequency. Not applicable to scenarios: Scenarios that have a strong need for multi-modality (picture/video input) and are unwilling to use the API (the initial version of K2 does not support vision); scenarios that require a very long context of more than 1M tokens (DeepSeek or other models that support 1M context are recommended).

• Self-media operations and content creators: The free entrance of kimi.com allows ordinary users to experience K2's text generation capabilities at zero cost, which is suitable for light tasks such as article drafting, content summarization, and brainstorming. Not applicable to scenarios: Scenarios that require visual generation (such as graphics and text layout, poster design); scenarios that require in-depth long-form creative writing (the output of K2 non-thinking mode may not be as creative and narrative logic as the dedicated writing model).

Summary and Outlook

Kimi K2 is Dark Side of the Moon's precise position in the "open source Agent model" segment - it is not the model with the largest parameters or the longest context, but it is the first product to bring the open source model to the closed source flagship level in terms of tool calls and Agent tasks. The technology combination of 1T MoE + MuonClip optimizer + large-scale Agentic RL is a clear differentiator in the open source model landscape of 2025.

Core Competencies: Agentic capabilities (SWE-bench 65.8%, Tau2-bench open source first) is K2’s most difficult moat to copy, which comes from Dark Side of the Moon’s long-term investment in Agentic data synthesis and general RL systems. The open source strategy (Modified MIT) reduces enterprise trial and error costs, and API compatibility with OpenAI/Anthropic lowers the migration threshold. The model also has obvious advantages in inference efficiency - 32B activation parameters mean that it can be run on a single card, and the inference cost is lower than dense models of the same capability level.

Current limitations: The initial version does not support visual input and thought chain reasoning (K2.6 has made up for it through API); the open source version stays at K2-0905, and subsequent K2.6/K2.7 Code only provides API calls, and self-hosted users cannot obtain multi-modal and thought chain capabilities. It is inferior to competing products such as DeepSeek in ultra-long context (1M+) scenarios. In some complex reasoning tasks, token waste and incomplete tool calls occasionally occur (officially acknowledged in Limitations).

Follow-up evolution observation: (1) Whether Dark Side of the Moon will continue to open source the weight of subsequent versions - this will determine K2's long-term ecological status in the open source community; (2) The further integration of the K2 series in the direction of "thinking model" - the initial version clearly does not follow the CoT route, but K2.6 begins to add thinking chain support, this strategic change is worth tracking; (3) Agent ecological construction - whether community projects around K2 (Swarm, MCP tool integration, etc.) can form a similar LangChain Or the ecological agglomeration effect of AutoGPT.

Procurement/Adoption Risk Assessment: The most economical entry path for small and medium-sized teams is to start with the Kimi API and do proficiency verification with K2.6, which does not require initial GPU investment. For large and medium-sized enterprises, it is recommended to first use the API to do PoC to verify the performance of K2 in the target scenario (focusing on testing tool calling accuracy, long context recall rate and task completion rate), and then evaluate whether it is worth building a self-hosted environment. Self-hosting needs to focus on verifying: (1) the terms of the license regarding commercial use and secondary distribution (specific restrictions of Modified MIT); (2) the purchase/lease cost of the GPU cluster and the capabilities of the operation and maintenance team; (3) the predictability of model updates and community support. In strong compliance industries (finance, medical, government affairs), K2 open source weights provide data sovereignty protection, but companies still need to complete internal security audits and adversarial testing before formal production.

Related tools: , langchain

Version Info

• Kimi K2.6 ：The universal flagship version of the K2 series supports visual and text input, thought chain reasoning, and 256K contexts. The API is priced at $0.95/million token input and $4.00/million token output. （2026-04）
• Kimi K2.7 Code ：A specialized programming version that supports 256K context and thought chain reasoning, has a higher success rate in programming tasks, and provides a high-speed version (~180 tokens/s). API pricing is $0.95/million token input and $4.00/million token output. （2026-05）
• Kimi K2-0905 ：Enhanced copyright protection, improved Agentic Coding capabilities, expanded context to 256K, and Hugging Face is available for download. （2025-09-05）
• Kimi K2-Instruct ：Initial instruction fine-tuning version, 128K context, non-thinking mode, optimized for general chat and agent scenarios. （2025-07）
• Kimi K2-Base ：Basic pre-training model, 1T total parameters/32B activation, suitable for researchers to fine-tune and customize. （2025-07）