Moonshot AI has released the model weights for Kimi K3, bringing one of the largest and most technically ambitious open-weight AI models to the public.
Kimi K3 is a 2.8-trillion-parameter Mixture-of-Experts model with native visual understanding, advanced reasoning capabilities, and a context window of up to one million tokens. It is designed primarily for long-running coding tasks, research, knowledge work, and agentic workflows rather than ordinary chatbot conversations.
There is, however, an important reality behind that headline: open weights do not necessarily mean accessible hardware.
Although anyone can access the model weights, Kimi K3 is not something most people will download and run on a gaming computer. Early deployment reports put the checkpoint above 1.4 TB, while practical deployment requires multiple data-centre GPUs connected through high-speed networking.
So what exactly has Moonshot released, why is the model receiving so much attention, and what would it take to run it?
What is Kimi K3?
Kimi K3 is Moonshot AI's latest flagship model and the successor to the Kimi K2 family.
Moonshot describes it as its most capable model so far, built for work that may require hundreds or thousands of steps instead of a single prompt and response. That includes exploring large software repositories, operating terminal tools, conducting extended research, creating interactive reports, and completing engineering projects with limited human supervision.
Its headline specifications include:
| Feature | Kimi K3 specification |
|---|---|
| Total parameters | 2.8 trillion |
| Architecture | Sparse Mixture of Experts |
| Experts | 896 experts |
| Active experts | 16 experts per token |
| Context window | Up to 1 million tokens |
| Input types | Text and images |
| Weight format | Native MXFP4 |
| Activation format | MXFP8 |
| Main use cases | Coding, research, AI agents, and knowledge work |
| Open weights | Publicly available |
The 2.8-trillion figure represents the model's total parameter count. Kimi K3 does not activate every parameter for every token. Instead, its routing system selects 16 of the model's 896 experts for each token being processed.
This sparse architecture reduces the computation required during inference, although all experts must still remain available in memory. That is why the model remains extremely demanding to deploy even though only a fraction of its experts are active at one time.
What makes the architecture different?
Kimi K3 is not simply a larger Kimi K2. Moonshot introduced several architectural changes intended to make a model of this scale more efficient.
Kimi Delta Attention
The first major component is Kimi Delta Attention, or KDA.
Traditional full-attention models retain key and value information for every previous token. This KV cache becomes increasingly expensive as the context grows.
KDA uses a recurrent state for most layers, reducing the memory needed to preserve information from a long sequence. Periodic full-attention layers are still used to maintain accurate global recall.
This hybrid design is a major reason Kimi K3 can support a one-million-token context window without relying entirely on a conventional, continuously expanding KV cache.
Attention Residuals
Kimi K3 also uses Attention Residuals, or AttnRes.
In a standard Transformer, information is repeatedly added to the same residual stream as it passes through the model. AttnRes allows later layers to selectively retrieve representations produced at different depths.
In simpler terms, the model does not have to depend only on one continuously accumulated stream of information. It can choose which earlier representations are useful for the current computation. Moonshot says this improves information flow through very deep models.
Stable LatentMoE
Kimi K3's 896 experts are organised using Moonshot's Stable LatentMoE framework.
The model activates 16 experts for each token and uses routing and balancing techniques to prevent certain experts from becoming overloaded while others remain underused.
That is particularly important at K3's scale. Poor expert balancing would create communication bottlenecks and leave expensive accelerators waiting for work.
Quantisation-aware training
Kimi K3 uses MXFP4 weights and MXFP8 activations. Importantly, Moonshot applied quantisation-aware training during post-training rather than converting the finished model into a low-precision format afterwards.
This lets the released model use four-bit weights while attempting to preserve more of the original model's quality. It also makes the model better suited to modern accelerator hardware designed for FP4 computation.
How much hardware does Kimi K3 need?
This is where the practical challenge begins.
Early infrastructure reports say the native MXFP4 weights occupy more than 1.4 TB of storage. That is only the weight data; it does not include the memory needed for caches, runtime processes, image processing, batching, and operating-system overhead.
Launch-era deployment guidance cited configurations built around:
- 8 NVIDIA B300 GPUs
- 8 AMD MI355X GPUs
- 16 NVIDIA B200 GPUs
The smallest configuration that can load a model is not necessarily the one that can serve it efficiently. High-throughput commercial deployments may spread work across much larger clusters using expert and data parallelism.
Can it run on an RTX 5090?
No—the complete model cannot practically run on a single RTX 5090, RTX 4090, Mac Studio, or ordinary AI workstation.
Even several consumer GPUs would provide only a small fraction of the memory needed to hold the checkpoint. Consumer systems would also lack the interconnect bandwidth required to move expert data efficiently between devices.
Downloading the weights is possible for anyone, but serving the complete model is currently realistic mainly for:
- AI laboratories
- Universities with large GPU clusters
- Cloud-computing providers
- Enterprises operating dedicated AI infrastructure
- Inference platforms specialising in distributed models
Researchers may eventually produce smaller distillations, aggressive quantisations, or partial variants. Those would be separate versions and would not provide the same experience as running the complete Kimi K3 model.
The GPUs are only one part
A serious deployment also needs:
- More than 1.4 TB of fast storage for the original weights
- Extra storage for downloads, caches, and converted checkpoints
- NVLink or RDMA networking between accelerators
- A distributed inference runtime
- Large amounts of host memory
- Sufficient power and cooling
- Production monitoring and failure recovery
- Engineers familiar with tensor, expert, and data parallelism
The first runtime releases for a model this new can also depend on specialised containers and pre-release software components. Production teams should expect the deployment stack to evolve.
What can Kimi K3 do?
Kimi K3 is positioned less as a conventional assistant and more as an engine for long-running autonomous work.
Long-horizon coding
The model is built to inspect large repositories, modify multiple files, execute terminal commands, run tests, and continue working through engineering problems with limited supervision.
Moonshot has demonstrated Kimi K3 working on extended GPU-kernel optimisation tasks. The company also presented MiniTriton, a system K3 reportedly built from scratch, including a programming interface, intermediate representation, compiler optimisation passes, and a PTX code-generation pipeline.
These are company demonstrations, not guarantees that every user will reproduce the same result. Still, they illustrate the extended technical workflows for which the model has been trained.
Visual coding and design
Kimi K3 has native visual understanding, allowing it to examine screenshots and use visual output as feedback.
That can be useful in frontend development, game development, CAD workflows, and interface testing. Instead of generating code once, the model can inspect the result, identify visual problems, and continue refining its work.
Research and knowledge work
Moonshot has shown K3 performing literature reviews, analysing scientific data, and generating interactive research websites.
Company case studies include an interactive report spanning decades of the AI-chip industry and an analysis of gravitational-wave events using multiple sub-agents. The model is also integrated into Kimi Work, where it can produce dashboards, reports, presentations, spreadsheets, and persistent interactive widgets.
Video and motion graphics
Because K3 can work with visual information, Moonshot has also demonstrated it creating motion-graphics explainers and editing video.
One example involved selecting and arranging footage from many source clips, synchronising cuts, processing audio, and revising the output. As with the other demonstrations, this is best treated as a showcase of intended capability rather than an independent benchmark.
Open weights do not mean easy local AI
The release matters because developers can inspect, modify, and host the model without being limited to Moonshot's official API.
Open weights can support:
- Private and air-gapped deployments
- Independent safety and performance evaluations
- Custom fine-tuning
- Domain-specific adaptation
- Research into model architecture and routing
- Competition between inference providers
- Integration without permanent dependence on one API
But Kimi K3's size creates an unusual situation: the model is openly available, while only organisations with substantial infrastructure can run the complete version.
For most independent developers and smaller companies, hosted inference will remain the practical route.
What does the API cost?
Developers who do not want to manage a GPU cluster can use hosted inference. Launch pricing listed for the official Kimi K3 API was:
| Usage | Price per one million tokens |
|---|---|
| Cached input | $0.30 |
| Uncached input | $3.00 |
| Output | $15.00 |
Moonshot has reported a cache-hit rate above 90% for some coding workloads, although real results depend on how prompts, repositories, and conversation histories are reused.
For most teams, an API or managed inference platform will be substantially easier than acquiring, connecting, and operating the hardware needed for self-hosting.
Important limitations
Moonshot lists several limitations that developers should consider.
First, K3 is sensitive to its previous reasoning history. If an agent framework fails to return all required history—or switches to K3 in the middle of an existing session—output quality can become unstable.
Second, the model may be too proactive. Because it was trained for difficult, long-running work, it may make unexpected decisions when instructions are ambiguous. Applications requiring strict boundaries should use detailed system prompts, permission controls, and explicit agent policies.
Finally, Moonshot acknowledges that K3's overall user experience still trails the strongest proprietary models, even though it performs competitively on many technical and agentic evaluations.
There are practical deployment limitations too. Tool calling should be tested against real application traffic, and production applications should implement retries, structured-output constraints, and fallback behaviour.
Should you try Kimi K3?
Kimi K3 is worth testing when your work involves:
- Large codebases
- Long-running AI agents
- Terminal and tool use
- Research across many documents
- Visual software-development workflows
- Complex reports and dashboards
- Experiments with open-weight frontier models
It is less compelling when you only need quick chat, light content writing, or a model that runs locally on consumer hardware. In those situations, a smaller open model will be cheaper, simpler, and faster.
Developers can access K3 through Moonshot's hosted products or API. Organisations with large GPU infrastructure can download the weights and deploy them with a compatible distributed inference runtime.
Final thoughts
Kimi K3 is an important release, but not because it suddenly allows everyone to run frontier AI on a laptop.
Its real significance is that a 2.8-trillion-parameter, multimodal, long-context model is available as open weights. Researchers can examine it, infrastructure companies can compete to serve it, and enterprises with enough resources can deploy it under their own control.
At the same time, K3 demonstrates the growing gap between open access and accessible hardware.
The model can be downloaded openly, but practical self-hosting begins at data-centre scale. For ordinary developers, hosted access remains the sensible option.
Kimi K3 is therefore not a local-AI release. It is open AI infrastructure at data-centre scale—and that alone makes it one of the most notable model releases of 2026.