Kimi (Moonshot AI)

Kimi is the family of language models built by Moonshot AI, available through an API compatible with the OpenAI interface and published in part as open weights.

Moonshot AI's official GitHub repository describes Kimi K2 as a mixture-of-experts model with 1 trillion total parameters and 32 billion active per token. The original version has a 128K-token context and was trained with the MuonClip optimizer on 15.5 trillion tokens, according to the repository itself.

On Hugging Face, the moonshotai organization publishes the weights as separate variants. The Base variant is for teams that want to fine-tune the model. The Instruct variant handles chat and agent tasks without long reasoning. The Thinking variant is described as an agent that reasons and calls tools across 200 to 300 sequential steps.

For production use through the API, the Kimi platform keeps a quickstart guide per model, a Chat Completions reference and tool-calling documentation. The model list changes often, and the platform documentation is the reference for which one is current.

Kimi is for technical teams that need a language model for agents, programming and long-context tasks, through an API or with open weights to host themselves.

Application developers get an API compatible with the OpenAI SDK. The official guides call for Python 3.9 or later, the OpenAI SDK and an API key from the platform. The account region matters: the English and Chinese documentation use different API addresses, so the key has to be used at the address of the platform where it was created.

Teams building agents use tool calling, with tools declared in JSON Schema, and the official tools hosted by the platform, such as web search.

Research and machine learning teams find the Base variant for fine-tuning and the Instruct variant for direct use on Hugging Face. Anyone hosting the weights takes on running inference for a model with 1 trillion total parameters. Anyone who prefers not to run infrastructure uses the API.

Before starting, decide which model in the platform's current list fits the task, because the documentation pages cover different generations.

The main features of Kimi are the Kimi K2 mixture-of-experts model family, tool calling through the API and the official tools hosted by the platform.

• Model variants: Base, Instruct and Thinking, published on Hugging Face by the moonshotai organization, plus a dedicated documentation page for a code-oriented variant.
• Long context: the repository states 128K tokens for the original version, and the Hugging Face page of a later Instruct revision cites 256K tokens.
• Tool calling: tools are declared in JSON Schema, and the choice parameter accepts auto, none, required or the name of a specific function.
• Official tools: the documentation describes hosted tools, such as web search, reached through their own declare-and-execute flow.
• Reasoning content: the Chat Completions reference tells you to send back the complete assistant message, including reasoning_content and tool_calls, unchanged.
• Compatibility: the API follows the OpenAI SDK format, so existing integration code can be reused.

The Thinking page describes chained tool use across 200 to 300 sequential steps, according to Hugging Face.

Kimi is worth it for teams that want open weights of a long-context model or an API compatible with the OpenAI SDK for agents, and less so for teams that need a stable model list.

Pros:

• Weights published on Hugging Face in the Base and Instruct variants, which allows fine-tuning and self-hosting.
• A 128K-token context in the original version, extended to 256K in a later revision, according to the official pages.
• An API compatible with the OpenAI SDK, with tool calling and official tools such as web search.
• A Thinking variant described as chaining 200 to 300 tool calls in sequence.

Cons:

• The documentation lists models from different generations side by side, and you need to check which one is current before integrating.
• The global and Chinese platforms use different API addresses, and a key only works in the region where it was created.
• In the tool loop, the assistant response must be sent back complete, with reasoning_content and tool_calls, and integration code has to respect that.
• The model has 1 trillion total parameters, so hosting the weights means running that inference yourself.

The alternatives to Kimi are other labs that offer language models through an API, some with open weights and others only as a hosted service.

• DeepSeek: a Chinese lab that publishes open weights of language models, like Kimi, and also offers an API.
• Alibaba Qwen: the Qwen family, with several open-weight models in different sizes, plus API access.
• OpenAI: offers models through an API and through ChatGPT, with its main models having no published weights.
• Anthropic: offers the Claude models through an API and an app, without open weights.
• Google: offers the Gemini models through an API, and the Gemma family has open weights.

The central difference from Kimi is access to the weights. With Kimi, the Base and Instruct variants can be downloaded from Hugging Face and hosted yourself. Among the closed labs, access happens only through the provider's service. Among those that publish weights, compare each license's documentation before using it in a product.