Kimi K3: benchmarks, pricing, hardware requirements, and self-hosting

Kimi K3 is Moonshot AI's flagship 2.8-trillion-parameter multimodal reasoning model. It has a 1-million-token context window and is designed for long-running coding, knowledge work, visual reasoning, and agentic tasks.

Kimi K3 is available through Kimi's applications and API today. The full model weights are not publicly available yet. Moonshot says it will release them by 27 July 2026. It also says its Kimi Delta Attention implementation for vLLM will arrive with the model release, while a fuller technical report is still forthcoming. Until the weights arrive, developers can use the Kimi API but cannot self-host Kimi K3 from public weights.

Northflank will publish a deployment guide and stack template after the weights and compatible inference software are released and tested.

Current status, verified 17 July 2026: Kimi K3 is available through Kimi.com, Kimi Work, Kimi Code, and the Kimi API. Public self-hosting is expected after the model weights are released by 27 July 2026. Moonshot recommends production deployment on supernode configurations with 64 or more accelerators, but has not published a minimum viable GPU configuration.

The architecture and availability details above come from Moonshot AI's Kimi K3 release. Current token prices come from the Kimi API platform.

Kimi K3 is a large multimodal Mixture-of-Experts model created by Moonshot AI. It uses 2.8 trillion total parameters, activates 16 of 896 experts during inference, and can process up to 1 million tokens of context. Moonshot built it for complex work that may require sustained reasoning, tool use, code execution, and visual understanding.

Kimi K3 succeeds the Kimi K2 family. The main changes are a much larger sparse expert architecture, a context window almost four times larger than Kimi K2.6, and new attention and residual mechanisms intended to make the increased scale computationally practical.

The model currently runs with maximum reasoning effort by default. Moonshot says low- and high-effort settings will follow in later updates. This matters for latency and cost because reasoning models may generate substantial internal reasoning tokens before returning a final answer.

Kimi K3 is not downloadable yet. Moonshot describes Kimi K3 as an open model and says the full weights will be released by 27 July 2026. As of 17 July, there is no public Kimi K3 model repository or published licence.

The most precise description today is an API model with a planned open-weight release. Calling it fully open source before the weights, licence, inference code, and technical report are published would be premature.

Open weights and open source are also different terms. Open weights means developers can download and run the trained model parameters. A fully open-source release may additionally include training code, data details, recipes, and a licence covering modification and commercial use. Moonshot has promised the Kimi K3 weights, but the complete scope of the release is not yet known.

No. Kimi K3 cannot be self-hosted from public weights as of 17 July 2026 because Moonshot has not released the weight files or its vLLM implementation yet. The only currently available options are Kimi's hosted products and API.

Moonshot says the full weights will be available by 27 July 2026. Self-hosting should become technically possible after the following artifacts are public:

• The complete model weights
• The Kimi K3 licence
• Model configuration and tokenizer files
• A compatible vLLM release or patch containing Kimi Delta Attention
• Moonshot's deployment guidance

The release date alone does not guarantee that every GPU configuration will work immediately. Kimi K3 introduces new architecture, extreme expert sparsity, and a model size that requires distributed inference. Production deployments will need validation against the exact software versions and hardware topology recommended by Moonshot.

Kimi K3 is not deployable from public weights on Northflank yet because the required files have not been released. Northflank can run custom GPU-accelerated containers and vLLM services, so the platform can support a Kimi K3 deployment once the model and compatible inference implementation are available.

Northflank plans to release a Kimi K3 stack template after 27 July. The template will be based on the verified model repository, inference image, distributed serving configuration, storage requirements, and supported GPU topology. It will expose an OpenAI-compatible API and include the infrastructure required to operate the model.

Given Moonshot's recommendation of 64 or more accelerators, Kimi K3 will require a large distributed GPU deployment. This is different from deploying a smaller model on one GPU or a single eight-GPU node. The practical deployment path is likely to involve reserved capacity on Northflank Cloud or a dedicated Northflank BYOC cluster in AWS, Google Cloud, Azure, or another supported environment.

Northflank already supports GPU-accelerated containers and vLLM deployments on cloud infrastructure. Exact Kimi K3 support will depend on the artifacts released by Moonshot.

Moonshot recommends deploying Kimi K3 on a supernode configuration with 64 or more accelerators. It has not published a minimum GPU count, a list of validated GPU models, the required interconnect, or a minimum amount of aggregate GPU memory.

The 64-accelerator figure should be treated as a production recommendation rather than a confirmed minimum. It reflects the communication demands of distributing 896 experts and routing each token through 16 selected experts. Fast communication between devices is likely to be essential for useful throughput.

The exact model download size and runtime memory requirement are unknown until the weights are released. A simple lower-bound calculation helps explain the scale:

2.8 trillion parameters x 4 bits per parameter = 11.2 trillion bits
11.2 trillion bits / 8 = 1.4 trillion bytes

That is approximately 1.4 TB of raw weight data, or about 1.27 TiB, before accounting for quantisation metadata, scales, model configuration, runtime buffers, activations, routing state, and the cache used for long contexts. It is an estimate derived from the parameter count and MXFP4 format, not a published deployment requirement.

The complete runtime will need materially more memory than the raw four-bit payload. A 1-million-token context can also create substantial memory pressure, depending on the attention implementation, request concurrency, cache configuration, and number of tokens actually processed.

No single H100, H200, or B200 can hold the full Kimi K3 model. A distributed cluster is required. Moonshot has not yet published its validated production matrix, so claims about an exact number of H100, H200, B200, or other accelerators would be speculative.

The final deployment requirement will depend on:

• The size of the released weight files
• The accelerator's supported low-precision formats
• Aggregate high-bandwidth memory
• Interconnect bandwidth and topology
• Tensor parallel and expert parallel support
• The requested context length
• Concurrent request volume
• vLLM's Kimi Delta Attention implementation

Running the full Kimi K3 model on a normal workstation or consumer GPU is not realistic. The raw four-bit weights alone are estimated at roughly 1.4 TB, and the model is designed around distributed expert-parallel inference. No verified local or CPU-offload configuration exists as of 17 July 2026.

Future community quantisations may reduce storage or make experimental CPU-offloaded runs possible. Such configurations would not provide production-level latency or throughput, and none can be validated before the weights are released.

Kimi K3 combines a very large sparse Mixture-of-Experts architecture with new mechanisms for processing long sequences and moving information through the model.

Kimi K3 contains 896 experts and activates 16 of them for a given computation. This allows the model to contain 2.8 trillion total parameters without using every parameter for every token. Sparse activation reduces the compute required per token compared with a dense 2.8-trillion-parameter model.

The total parameter count therefore does not describe the amount of computation performed for each token. Moonshot has not published a single active-parameter figure comparable to the 32 billion active parameters specified for Kimi K2.6.

Kimi Delta Attention, or KDA, is Moonshot's attention architecture for improving efficiency across long sequences. K3 uses KDA as part of its foundation for supporting a 1-million-token context window. Moonshot says it has contributed a KDA implementation with prefill caching to vLLM and will release it with the model.

Prefill caching matters for long prompts because repeated system instructions, code, or documents can otherwise require expensive reprocessing. The actual performance of KDA and its cache implementation outside Moonshot's infrastructure cannot be evaluated until the code and weights are available.

Attention Residuals, or AttnRes, changes how information is carried across model depth. Moonshot describes it as selectively retrieving representations from earlier layers instead of accumulating them uniformly. The stated goal is to improve information flow as the model becomes deeper and larger.

Stable LatentMoE is the framework Moonshot uses to manage K3's high level of expert sparsity. The model routes computation to 16 of 896 experts. Moonshot also describes a quantile-balancing method intended to distribute expert load without heuristic balancing updates.

Moonshot says Kimi K3 used quantisation-aware training from supervised fine-tuning onward. The published architecture uses MXFP4 weights and MXFP8 activations. Low-precision weights reduce the memory and bandwidth required to serve a model of this size, although hardware and inference-engine support will determine which accelerators can run it efficiently.

Kimi K3 supports a context window of 1 million tokens. Moonshot's integration documentation uses the exact value 1,048,576 tokens. The context window is the total amount of information the model can consider during a request, including instructions, conversation history, documents, code, tool results, and generated content as defined by the serving API.

A large advertised context window does not mean every request should use the full capacity. Long prompts increase prefill time, cache usage, and cost. Retrieval, summarisation, and context management may still be more efficient for production applications.

Moonshot reports a BrowseComp score of 90.4 when K3 was evaluated with its full 1-million-token context and no context-management strategy. That result comes from Moonshot's own evaluation and should not be treated as an independent measure of long-context accuracy.

Kimi K3 is a natively multimodal model with visual understanding. Text and image inputs are supported through the general Kimi API according to independent API testing. Moonshot also demonstrates K3 working with video inside its own products.

Input support may differ between Kimi.com, Kimi Work, Kimi Code, and individual API endpoints. Developers should verify the accepted request format for the endpoint they plan to use. Native video understanding at the model level does not guarantee that every API route accepts raw video files.

Kimi K3 costs $3 per million cache-miss input tokens and $15 per million output tokens through Moonshot's API. Input tokens served from cache cost $0.30 per million, a 90% reduction from the normal input price.

The basic calculation is:

cost = (cache-hit input tokens x $0.30 / 1M)
     + (cache-miss input tokens x $3.00 / 1M)
     + (output tokens x $15.00 / 1M)

Example token costs:

These examples cover token charges only. They do not include any separate charges for search, tools, storage, network traffic, or third-party services.

Kimi K3 is more expensive than Kimi K2.6 through the official API. Artificial Analysis lists K2.6 at $0.95 per million input tokens and $4 per million output tokens, compared with K3 at $3 and $15. K3's higher price comes with a larger context window and substantially stronger results in current independent evaluations.

The Kimi API uses an OpenAI-compatible Chat Completions interface. The model identifier is kimi-k3, the base URL is https://api.moonshot.ai/v1, and K3 currently accepts max as its only reasoning-effort setting.

Install the OpenAI Python SDK:

pip install --upgrade openai

Set a Kimi API key in the environment and send a request:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["MOONSHOT_API_KEY"],
    base_url="https://api.moonshot.ai/v1",
)

response = client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {
            "role": "user",
            "content": "Review this architecture and identify its scaling bottlenecks.",
        }
    ],
    reasoning_effort="max",
)

print(response.choices[0].message.content)

K3 always reasons. For multi-turn conversations and tool calls, Moonshot instructs developers to pass the complete assistant message returned by the API back into the next request, including any reasoning_content. Removing parts of the returned message can make subsequent responses unstable.

See the official Kimi API overview, Kimi K3 quickstart, and reasoning-effort documentation for the current request format.

Early independent evaluations place Kimi K3 among the strongest models available in July 2026, especially for coding and multi-step agent tasks. They do not establish K3 as the best model for every workload. Moonshot itself says K3's overall performance and user experience still trail its strongest proprietary competitors.

The following results were current on 17 July 2026:

Sources: Artificial Analysis Kimi K3 evaluation, Vals Kimi K3 results, and Arena WebDev leaderboard.

Benchmark results depend on the agent harness, reasoning settings, tools, context management, sampling configuration, and scoring method. Moonshot's release table uses different harnesses for some models, including Kimi Code, Claude Code, and Codex. That makes several comparisons useful as directional evidence rather than controlled head-to-head tests.

The strongest launch-day evidence comes from combining several sources:

• Moonshot's evaluations explain the model's intended capabilities and recommended settings.
• Artificial Analysis provides a consistent composite evaluation and hosted API performance measurements.
• Vals tests production-oriented coding, terminal, finance, and professional tasks.
• Arena records human preferences, although K3's early scores remain preliminary.

There is not enough evidence to say Kimi K3 is universally better than the leading Claude or GPT models. Current results show K3 competing closely with frontier proprietary models and leading some coding evaluations, while trailing on others.

Moonshot states that K3 still trails Claude Fable 5 and GPT-5.6 Sol overall. Independent results are mixed:

• Vals ranked K3 second overall, between Claude Fable 5 and GPT-5.6 Sol, on 17 July.
• Artificial Analysis gave K3 an Intelligence Index score of 57 and ranked it fourth in its displayed comparison.
• Arena placed K3 first on its preliminary WebDev leaderboard.
• Vals placed GPT-5.6 Sol ahead of K3 on Terminal-Bench 2.1 and SWE-bench Verified.

K3's main strategic difference is its planned open-weight release. Claude and GPT frontier models are accessed through hosted APIs. If Moonshot releases K3 under terms that permit private and commercial deployment, organisations will be able to operate a frontier-class model within infrastructure they control. The cost and complexity of a 64-accelerator deployment will limit when that advantage is economically useful.

Kimi K3 is considerably larger than Kimi K2.6 and introduces a new inference architecture. K2.6 can already be downloaded and self-hosted, while K3 remains API-only until its weights are released.

Kimi K2.6 specifications are taken from the official Kimi K2.6 model card. Benchmark scores and API prices are from Artificial Analysis and were current on 17 July 2026.

Kimi K3 is designed for workloads that benefit from strong reasoning, large context, visual input, and sustained tool use. Likely applications include:

• Navigating and modifying large software repositories
• Long-running coding agents that compile, test, inspect logs, and revise their work
• Research across large collections of documents
• Analysis of reports, spreadsheets, presentations, and visual material
• Frontend, game, CAD, and other work combining code with visual feedback
• Multi-step professional workflows using external tools
• Agent systems that need to retain extensive task history

K3 is unlikely to be economical for simple classification, short chat, extraction, or high-volume low-latency tasks. Smaller models can handle those workloads with much lower inference costs.

Moonshot identifies three important limitations in its release notes.

First, K3 expects its previous reasoning history to be preserved during multi-turn agent sessions. If an agent framework discards that information or switches models during a session, output quality may become unstable. Moonshot recommends using a verified harness such as Kimi Code.

Second, Moonshot says K3 can be excessively proactive. The model may make decisions when instructions are ambiguous or when it encounters minor problems. Applications should use explicit system instructions, permission boundaries, tool policies, and human approval for consequential actions.

Third, Moonshot acknowledges that K3's overall user experience still trails the strongest proprietary systems. Independent testing also suggests the model can be verbose. Artificial Analysis recorded 130 million output tokens across its Intelligence Index evaluation, roughly twice the median for comparable reasoning models in the same price tier.

Self-hosted performance remains unknown. No external team can verify throughput, latency, reliability, context scaling, or hardware efficiency until the model artifacts are public.

A production Kimi K3 deployment is expected to require the following components:

1. A distributed cluster with supported accelerators and high-bandwidth interconnects
2. Persistent storage large enough for the model and temporary download files
3. A compatible vLLM image containing Kimi Delta Attention support
4. Tensor-parallel and expert-parallel configuration across the cluster
5. An OpenAI-compatible inference endpoint
6. Authentication, rate limiting, network policies, and secrets management
7. Metrics for GPU memory, accelerator utilisation, request latency, throughput, and failures
8. Autoscaling or capacity controls appropriate for a large stateful model server

The exact commands should not be guessed before Moonshot publishes its deployment guide. Northflank will test the released artifacts and publish a reproducible stack template with the verified configuration.

Kimi K3 was created by Moonshot AI, the Beijing-based company behind the Kimi family of models and applications. Moonshot describes K3 as its most capable model to date.

Moonshot formally announced Kimi K3 on 17 July 2026. The hosted model is available now through Kimi.com, Kimi Work, Kimi Code, and the Kimi API. The full model weights are scheduled for release by 27 July 2026.

Moonshot says the full Kimi K3 model weights will be released by 27 July 2026. It also plans to release more technical details and vLLM support for Kimi Delta Attention. No public model repository was available when this article was last updated on 17 July.

There is no official Kimi K3 download as of 17 July 2026. Moonshot says the full weights will be released by 27 July. Developers should use the official repository linked by Moonshot when it appears rather than downloading unverified files uploaded under similar names.

No official Kimi K3 repository was available on Moonshot AI's Hugging Face account when this article was last verified on 17 July 2026. Moonshot has not confirmed where it will publish the weights. This section will be updated when the official repository is released.

Kimi K3 has a planned open-weight release. Its weights and licence are not public yet, so it should not be described as a fully downloadable open-source model today. The exact usage and commercial terms will become clear when Moonshot publishes the licence.

Yes. Kimi K3 is a reasoning model and currently uses maximum reasoning effort by default. Moonshot says additional effort settings will be released later.

Yes. Kimi K3 is a sparse Mixture-of-Experts model with 896 experts. It activates 16 experts during inference. Moonshot has not published a single active-parameter count.

Kimi K3 has 2.8 trillion total parameters. Since it uses a sparse Mixture-of-Experts architecture, all 2.8 trillion parameters are not used for every token.

Kimi K3 supports up to 1 million tokens of context. Actual usable input and output limits depend on the product or API endpoint and its request configuration.

Yes. Kimi K3 has native visual understanding and supports image input. Moonshot also demonstrates video understanding in Kimi products, although accepted media formats may differ between API endpoints.

Not through a public stable release as of 17 July 2026. Moonshot says it has contributed a Kimi Delta Attention implementation with prefill caching to the vLLM community and will release it alongside the model weights.

No verified Ollama deployment is available because the Kimi K3 weights have not been released. Its estimated 1.4 TB raw weight payload and distributed expert architecture also make K3 very different from the smaller quantised models commonly run through Ollama on a workstation.

Moonshot recommends a supernode configuration with 64 or more accelerators. It has not published a minimum GPU count or validated hardware matrix. Any more specific requirement should wait for the official deployment guide and external testing.

No current data suggests that the full Kimi K3 model can run on one GPU. Its raw MXFP4 weights are estimated at about 1.4 TB before runtime overhead, far beyond the memory capacity of one current accelerator.

The full model is not practical for consumer hardware. It requires distributed inference and an amount of memory measured in terabytes. No verified local configuration exists because the weights have not been released.

The official Kimi API charges $3 per million cache-miss input tokens, $0.30 per million cache-hit input tokens, and $15 per million output tokens. Prices were verified on 17 July 2026 and may change.

There is no public Kimi K3 fine-tuning guidance yet. Fine-tuning will depend on the released weights, licence, training code, memory requirements, and support in distributed training frameworks.

Kimi K3 should be deployable in a cloud environment that can provide the required accelerator capacity, memory, and high-speed interconnects after the weights and inference code are released. Exact supported configurations are not yet known. Northflank plans to support K3 through Northflank Cloud and BYOC where suitable capacity is available.

Northflank plans to publish a Kimi K3 stack template after Moonshot releases the weights and compatible vLLM implementation. The template will be released once the configuration has been tested against real hardware rather than inferred from launch materials.

• Moonshot AI: Kimi K3 release and technical overview
• Kimi API platform: model availability and pricing
• Kimi API documentation: OpenAI-compatible API overview
• Artificial Analysis: Kimi K3 intelligence, speed, latency, and price
• Vals: independent Kimi K3 evaluation
• Arena: WebDev leaderboard
• Moonshot AI: Kimi K2.6 model card
• Northflank: configuring GPU workloads

This article was last verified on 17 July 2026. Deployment requirements will be updated when Moonshot releases the Kimi K3 weights, licence, technical report, and vLLM implementation.