Skip to main content
Last verified: 2026-10-14
Kimi K3 is Moonshot AI’s frontier model: 2.8 trillion total parameters, 104 billion active per token through Stable LatentMoE routing (16 active + 2 shared experts across 896 total), native visual input via MoonViT-V2, and a 1-million-token context window. Moonshot launched K3 on July 17, 2026 for long-horizon coding, knowledge work, and reasoning, and released the downloadable weights on July 27-28, 2026 on HuggingFace (1.1M+ downloads). The weights, model card, and license are public. You can self-host K3 today on a sufficiently large cluster and connect it to Tokios.
Kimi K3 weights are available on HuggingFace. The repository has 1.1M+ downloads. You can self-host K3 with vLLM on a cluster with 64+ accelerators and connect it to Tokios.

What is available?

Source: Kimi K3 launch post and Kimi K3 API guide.

Kimi K3 at a glance

Moonshot published the technical report, checkpoint files, and model card alongside the weight release. Read the model card for the full specification and license terms.

Can you run Kimi K3 locally?

Yes — if you have a large enough cluster. The weights are available on HuggingFace, but K3’s ~1.4 TB weight floor at 4-bit precision rules out every consumer and prosumer setup. Moonshot’s own recommendation is a supernode with 64 or more accelerators. Eight DGX Sparks pool 1 TB of unified memory and still fall 376 GB short. See the DGX Spark memory math for the full calculation. vLLM is the officially supported serving backend. You can also use Docker Model Runner or Transformers with trust_remote_code.
K3 requires 64+ accelerators. See what to run instead of Kimi K3 for the best coding and general model for your exact hardware, from Strix Halo to a 4-Spark cluster.

Kimi K3 hardware requirements

No consumer or prosumer setup holds K3. At exactly 4 bits per parameter, 2.8T parameters need about 1.4 TB for the weights alone — before microscaling metadata, runtime buffers, activations, and context state. For scale: eight DGX Sparks pool 1 TB of unified memory and are still at least 376 GB short of the raw weight floor, NVIDIA currently documents Spark clusters only to four nodes, and Moonshot recommends serving K3 on a supernode with 64 or more accelerators. See the DGX Spark memory math for the full calculation, cluster table, and network constraints.

Serving K3 locally

The officially supported serving path is vLLM. Docker Model Runner and HuggingFace Transformers (with trust_remote_code) also work.
K3 needs KDA-aware kernels and cache semantics. A runtime that merely loads the weights is not automatically K3-compatible. Use vLLM with KDA support or one of the other verified backends.

Why the architecture matters for self-hosting

K3 is not simply a larger K2 checkpoint. Five changes matter to anyone planning to serve it:
  • Kimi Delta Attention (KDA) — a hybrid linear-attention design that makes million-token prompts cheaper to prefill. It needs matching kernels and cache semantics: Moonshot says conventional prefix caching does not map cleanly to KDA and that its vLLM prefill-cache contribution ships with the weights. A runtime that merely loads the weights is not automatically K3-compatible.
  • Attention Residuals (AttnRes) — layers selectively retrieve useful representations from earlier depth instead of adding every layer’s output with fixed weight. Moonshot’s AttnRes paper reports more stable information flow in deeper models.
  • Stable LatentMoE — 16 active + 2 shared experts route per token across 896 total. Sparse activation cuts per-token compute, but it does not shrink the stored checkpoint: every expert must stay resident across the serving cluster, which makes fast interconnects a first-order requirement.
  • MoonViT-V2 — a 401M-parameter vision encoder that processes text, image, and video input natively.
  • Native MXFP4 — quantization-aware training ran from the supervised fine-tuning stage onward, targeting MXFP4 weights and MXFP8 activations. This is the intended serving format, not a community quant — so the 4-bit figure above is a floor, not a compromise.

K3 API behavior to preserve

If you test K3 through Moonshot’s API, or validate a self-hosted runtime, these protocol details matter:
  • K3 always reasons. Use the top-level reasoning_effort: "max"; do not send K2.x’s thinking parameter.
  • Streaming responses separate reasoning into reasoning_content and the final answer into content.
  • For multi-turn conversations and tool loops, replay the complete assistant message, including preserved reasoning and tool-call fields. Returning only content can destabilize later turns.
  • max_completion_tokens defaults to 131,072 and can be set as high as 1,048,576.
  • The launch API fixes sampling values. Moonshot recommends that you omit temperature, top_p, n, and penalty parameters rather than override them.
  • Public image URLs are not accepted. Send base64 data or an ms://<file-id> reference.
See the official K3 API guide for the current request schema.

Connect K3 with Tokios

Tokios sits after a local runtime. It doesn’t download the model or replace vLLM. Serve K3 on a supported cluster and connect it to Tokios:
1

Verify the official artifacts

Confirm the repository is moonshotai/Kimi-K3. Read the model card, license, checkpoint manifest, supported accelerator list, and recommended parallelism settings.
2

Serve K3 on the supported cluster

Run vllm serve "moonshotai/Kimi-K3" or follow the Docker Model Runner / Transformers instructions. Confirm the local server can complete a streaming request, preserve reasoning_content, and execute a multi-turn tool loop on its own /v1 API.
3

Pair the Tokios connector

Install the connector on a node that can reach the serving endpoint. In the dashboard, open Setup, select Start pairing, and use the one-time TKS-XXXX-XXXX claim code.
Windows
macOS
Linux
Then approve the device on the Setup or Connectors tab.
4

Register a deployment

Point the connector at the cluster’s OpenAI-compatible /v1 base URL. Register the upstream model id under a public deployment name such as kimi-k3-tunnel.
5

Create an API key

In the Keys tab, click Create key. Copy the sk-tok-… key now — it’s shown only once.
6

Test before sharing the endpoint

Test streaming, long turns, vision, structured output, and tool calls through https://api.tokios.com. Use a dedicated sk-tok-… API key and keep the initial context short while you validate memory use.

Call it from anywhere

Once that path is verified, clients call your deployment name rather than the upstream model id:

Launch caveats

  • K3 benchmark results are Moonshot-reported. Independent reproduction requires the evaluation setup.
  • Moonshot warns that losing preserved reasoning history, or switching another model’s existing session to K3, can make output unstable.
  • K3 is trained for long, difficult tasks and can act too proactively when instructions are ambiguous. Put explicit boundaries in your system prompt or AGENTS.md.
  • A 1M-token limit is a maximum, not a target. Long contexts increase prefill time, cache storage, and inference cost.
  • The Kimi K3 License is custom — read the model card for terms before deploying in production.

FAQ

At its native MXFP4 precision (4 bits per parameter), K3’s 2.8T parameters need about 1.4 TB for weights alone — before block scales, runtime buffers, activations, and KV cache. That is roughly 11 DGX Sparks at their 128 GB each, just for the raw weight floor. In practice you need 14-16 Sparks minimum for a hypothetical distributed serving stack, and NVIDIA only documents Spark clusters up to 4 nodes.
Not practically. Eight DGX Sparks give you 1 TB of unified memory — 376 GB short of the weight floor. NVIDIA’s documented Spark topology tops out at 4 nodes (512 GB), and Moonshot targets K3 at supernodes with 64 or more accelerators. For Spark-scale models today, see DGX Spark model compatibility.
The weights are available on HuggingFace under a custom “Kimi K3 License” — not MIT or Apache. Read the model card for the full license terms before deploying. Kimi K2.6 and K2.7-Code are also open-weight — see the Kimi model family.
Serve the checkpoint on a supported cluster with 64+ accelerators. The officially supported path is vllm serve "moonshotai/Kimi-K3". Docker Model Runner and Transformers with trust_remote_code also work. Tokios can front that local endpoint with scoped API keys — see Connect K3 with Tokios above. You can also call Moonshot’s hosted API using the model id kimi-k3.
1,048,576 tokens (1M). The max_completion_tokens parameter defaults to 131,072 and can be set as high as the full context window. Long contexts increase prefill time, cache storage, and inference cost — 1M is a maximum, not a target.
K3 is a Mixture-of-Experts model with 93 layers (69 KDA + 24 Gated MLA), hidden dim 7168, 96 attention heads, and 4 key innovations: Stable LatentMoE (16 active + 2 shared experts per token across 896 total, 104B active), Kimi Delta Attention (hybrid linear attention for efficient million-token prefill), Attention Residuals (depth-wise information routing), MoonViT-V2 (401M-param vision encoder for text + image + video), and native MXFP4 (quantization-aware training from SFT onward). These are not drop-in compatible with standard transformer serving — KDA in particular needs matching kernels and cache semantics.

Kimi K3 on DGX Spark

The full memory math, cluster constraints, and launch-evidence table.

Kimi models

Compare K3 with the downloadable K2.6 and K2.7-Code, and self-host Kimi today.

What to run instead of K3

The best coding and general model for your hardware, from Strix Halo to a 4-Spark cluster.

Model serving and scaling

Understand tensor, pipeline, and expert parallelism before you plan a frontier-scale cluster.

Quickstart

Pair a connector and register a local model that is available today.