Verdict: You can use Kimi K3 for free today at kimi.com — but "running it locally" is not a laptop project. The model weighs 2.8 trillion parameters across 896 mixture-of-experts and ships as a 1.56 TB checkpoint that requires a minimum of 8× H100 80 GB GPUs just to load experimentally, and Moonshot AI recommends 64 or more accelerators for production serving. For the vast majority of people, the free browser path or the $3/$15 API is the realistic way to use K3; self-hosting is a data-center project that costs $550,000+ in hardware alone.
TL;DR — Last verified: 2026-08-04
- Kimi K3 is Moonshot AI's 2.8T-parameter MoE model, released July 16, 2026; open weights dropped July 27, 2026.
- Free to use at kimi.com (sign in, switch from K2.6 to K3 in the dropdown).
- Local self-hosting needs 8× H100 80 GB minimum (experimental); 64+ accelerators for production.
- The checkpoint is 1.56 TB in native MXFP4 format; even 1-bit quantized GGUF is 594 GB needing 610 GB of RAM.
- API pricing: $3.00/M input tokens (cache miss), $0.30/M cache-hit, $15.00/M output.
- License: custom Kimi K3 License — commercial use is allowed but Model-as-a-Service above $20M revenue requires a separate Moonshot agreement.
- Pricing and hardware specs change often — last checked August 2026.
What Is Kimi K3?
Kimi K3 is Moonshot AI's flagship large language model — a 2.8-trillion-parameter mixture-of-experts (MoE) model released July 16, 2026. Each token activates 16 of its 896 experts, making the active parameter count approximately 104 billion per token. It features a 1,048,576-token (1M) context window, native visual understanding, and Moonshot's Kimi Delta Attention (KDA) architecture with Attention Residuals. The model shipped with "thinking mode" always on, meaning it reasons through problems by default rather than requiring a separate reasoning variant.
Moonshot positions K3 as "the world's first open 3T-class model." The open weights were published on Hugging Face on July 27, 2026, under the custom Kimi K3 License. On benchmark performance, K3 landed among the top frontier models — Moonshot reports 93.5% on GPQA Diamond, 88.3% on Terminal-Bench 2.1, and 91.2% on BrowseComp, positioning it competitively against Claude Fable 5 and GPT-5.6. It climbed to #1 on the Frontend Code Arena leaderboard within hours of release.
For context on the broader open-weight movement and how Chinese labs like Moonshot are using this strategy, see our analysis of why open-weight AI is reshaping the global landscape.
Can You Actually Run Kimi K3 on Your Own Computer?
No — not the full 2.8T model on any consumer hardware. The arithmetic makes this clear: the native MXFP4 checkpoint is 1,560.94 GB across 96 weight shards on Hugging Face. Even the most aggressive community quantization (Unsloth's 1-bit IQ1_S GGUF) comes in at 594 GB and requires at least 610 GB of combined RAM and VRAM to run. A single RTX 4090 with 24 GB of VRAM cannot hold even 1/50th of the model.
Here is a breakdown of the hardware tiers:
| Configuration | Hardware | Total VRAM/RAM | Cost (est.) | Feasibility |
|---|---|---|---|---|
| Consumer GPU | 1× RTX 4090 (24 GB) | 24 GB | ~$1,600 | Cannot load 1/50th of the model |
| Mac Studio (maxed) | M4 Ultra, 512 GB unified memory | 512 GB | ~$5,500 | Cannot fit even Q4 quant (~350 GB) with usable context |
| Minimum experimental | 8× H100 80 GB (single node) | 640 GB | $200K–$240K | Loads weights; very limited context and concurrency |
| Practical Hopper setup | 4× 8-GPU H100 nodes (32 GPUs) | 2,560 GB | $550K–$700K | SGLang-documented minimum for serving |
| Moonshot recommended | 64+ accelerators (supernode) | 5,120+ GB | $1.6M+ | Production-grade serving with KV cache headroom |
The key insight is that K3 was quantization-aware-trained at 4-bit (MXFP4 weights with MXFP8 activations). This means there is no "free halving" from the usual 16-bit-to-4-bit compression step — the released format is already the compressed format. Sub-4-bit community quants (like 2-bit builds) exist but trade quality for the reduction; an 8-bit build would be bigger than what shipped, not smaller.
Why Unsloth's 594 GB number is misleading
You will see "594 GB" repeated across launch coverage. That figure refers to Unsloth's 1-bit quantized GGUF, not the native model. The arithmetic confirms this: 594 GB at 4-bit implies about 1.2 trillion parameters, and K3 has 2.8 trillion. The 594 GB number measures a heavily compressed derivative, not the official weights. Budget 1.56 TB for weights alone, and 1.8–2 TB once you add KV cache and compute buffers.
How to Use Kimi K3 for Free (The Browser Path)
The genuinely free path is kimi.com. Here is the exact setup that works today:
- Go to kimi.com and sign in with a free account — a Google login or phone number gets you straight in, no credit card required.
- Open the model dropdown. By default, it shows the older K2.6 model, not K3. This is the step most people miss — they stay on K2.6 and wonder why the output feels weaker.
- Switch to K3. Skip "K3 Swarm" — it is a multi-agent mode that spins up several workers at once and burns through free tokens far too quickly for a free account to sustain.
- Start prompting. Use K3 for real build work — coding, analysis, drafting. For quick, simple questions, K2.6 is faster and lighter, so switch back for small tasks and save K3 for the heavy lifting.
Settings that stretch your free tokens
Moonshot does not publish a fixed free-tier token quota, and it can change — so do not trust third-party posts claiming "X messages per day." Check the usage indicator inside the app. Three settings make the biggest difference:
- Keep context window on standard. The extra-long 1M-token window is a premium feature that eats tokens fast on the free tier. Use standard for most work.
- Lower thinking effort. K3's always-on reasoning means a higher effort setting burns more tokens per response. Standard or medium effort stretches your free access much further; reserve high effort for the genuinely hard problems.
- Work off-peak. During busy hours, free tokens can get throttled or paused. Coming back when servers are quiet gives you significantly more room.
Where free access actually stops
The free tier covers general chat, file uploads, and web search. However, the full 1M-token context window is a paid feature — Moonshot's subscription tiers (Moderato at ~$19/month for 256K context, Allegretto at ~$39/month for the full 1M context) gate the longer windows. If your goal is casual use, coding help, or testing the model, the free tier is genuinely enough. If you need to paste an entire repository or a very long document into a single prompt, you will hit a paywall.
How Much Does the Kimi K3 API Cost?
If you need programmatic access rather than a chat window, Moonshot's API is pay-per-token — there is no permanent free API tier. The pricing is flat across the full 1M-token context window (no long-context surcharges):
| Token type | Price per million tokens |
|---|---|
| Input (cache miss) | $3.00 |
| Input (cache hit) | $0.30 |
| Output | $15.00 |
The 90% cache-hit discount is the real story for agent workloads: if you send the same system prompt, documentation, or repository context repeatedly, most input tokens hit the cache at $0.30/M instead of $3.00/M. For a coding agent that resends large context every turn, that cache lane is where most of the savings live. The API is OpenAI-compatible at https://api.moonshot.ai/v1 with model ID kimi-k3, and it is also available through OpenRouter.
For comparison with other cost-routing strategies — including when a $0.28 model beats a $25 one for the same task — see our DeepSeek V4 Flash vs Claude Opus cost-routing guide.
What Does It Actually Take to Self-Host Kimi K3?
Self-hosting K3 is a serious infrastructure project, not a docker pull on a laptop. Here is what the deployment landscape looks like as of August 2026.
The confirmed deployment facts
The following facts were verified against the Hugging Face model card, Moonshot's announcement, vLLM's day-0 support post, and SGLang's cookbook:
| Deployment input | Confirmed value | Source |
|---|---|---|
| Total parameters | 2.8 trillion | Hugging Face model card |
| Active parameters per token | ~104 billion | Moonshot platform docs |
| Checkpoint size (MXFP4) | 1,560.94 GB (96 shards) | Hugging Face repository |
| Minimum experimental GPUs | 8× H100 80 GB (640 GB total) | OpenModelMap hardware analysis |
| SGLang-documented minimum | 32× H100 (4× 8-GPU nodes) | SGLang Kimi K3 cookbook |
| Moonshot recommendation | 64+ accelerators (supernode) | Kimi K3 blog announcement |
| Serving engines | vLLM, SGLang, TokenSpeed | Model card deployment section |
Which serving tool should you use?
- vLLM — production-grade serving with tensor+expert parallelism support. vLLM published day-0 support for K3 with optimized KDA prefill cache handling. The vLLM recipe treats 8× GB300-class GPUs as the baseline single-node config.
- SGLang — high-performance inference. The SGLang cookbook documents a 4× 8-GPU H100 (32-GPU) Hopper configuration as the minimum practical entry point, and also publishes topology-aware examples for B300 1×8, GB300 2×4, B200 2×8, H200 2×8, and MI350X/MI355X 1×8.
- TokenSpeed — optimized specifically for MoE models with large expert counts.
- llama.cpp — can run the Unsloth 1-bit GGUF quant (594 GB) with at least 610 GB of combined RAM and VRAM. This is the "cheapest" local path but still requires server-class hardware.
- Ollama — best used as a client pointed at a vLLM/SGLang endpoint, not as the serving engine for a 2.8T model. Ollama is built for smaller single-machine models.
A practical pattern: prototype locally, serve on the cluster
A realistic workflow for teams building on K3: use a smaller open model in Ollama or llama.cpp locally to develop and test your workflow, then swap the endpoint to a full Kimi K3 deployment (hosted or your own cluster) for production. Keep the same OpenAI-compatible client code throughout — the endpoint changes, the application does not. For more on this "plug a model into an agent framework" approach, see our guide to wiring large open models into an autonomous agent system.
What Does It Cost to Self-Host vs Use the API?
The honest comparison is not "free weights vs paid API" — it is total cost of ownership.
| Approach | Upfront cost | Ongoing cost | Best for |
|---|---|---|---|
| Free browser tier (kimi.com) | $0 | $0 (rate-limited) | Testing, light use, prototyping |
| API (pay-per-token) | $0 | Hours of dev time to integrate; then usage-based | Most teams, startups, variable workloads |
| Cloud GPU rental (8× H100) | $0 | ~$20–26/hour | Burst workloads, evaluation runs, short jobs |
| Owned 32× H100 cluster | $550K–$700K | Power, cooling, networking, ops staff | Teams with predictable high-volume inference needs |
| Owned 64+ accelerator supernode | $1.6M+ | Same plus data-center facility costs | Model-as-a-Service providers, large enterprises |
For most workloads, the API is dramatically cheaper until your inference volume is high enough and predictable enough that owning hardware wins on unit economics. A team running 24/7 inference may break even on owned hardware at a certain volume, but the calculus also has to account for setup time, maintenance, and the fact that a newer model will likely replace K3 within months — your hardware investment needs to outlast any single model.
For teams whose primary concern is keeping data inside their own perimeter rather than per-token cost, self-hosting has value beyond price. Our analysis of sovereign AI and enterprise data control covers that decision in depth.
What License Is Kimi K3 Released Under?
Kimi K3 is released under a custom Kimi K3 License — and it is not the same "Modified MIT" that the K2 series used. The license contains two commercial conditions:
- MaaS gate: If you operate a Model-as-a-Service business with more than $20 million in aggregate revenue over any trailing 12-month period, you must sign a separate commercial agreement with Moonshot before using K3 commercially.
- Display requirement: If your commercial product or service has more than 100 million monthly active users or more than $20 million in monthly revenue, you must prominently display "Kimi K3" on the user interface.
Internal use — where you do not make the model, its outputs, or its underlying capabilities available to third parties — is exempt from both conditions regardless of company revenue. The license grants broad rights to use, copy, modify, merge, distribute, sublicense, sell, fine-tune, and create derivative works. It does not restrict outputs or distillation. By standard open-source definitions (OSI), the MaaS gate and display requirement mean this is technically "open weights" rather than "open source" — but the practical reality is that most individuals, startups, and enterprises can use K3 freely for commercial purposes.
For a deeper look at how free AI setups can work for development work — including running AI coding agents at $0/month by routing to free-tier providers — see our complete guide to running Claude Code for free.
What This Means for You
- If you are a developer or small business owner: Use K3 free at kimi.com for testing and light work. Switch from K2.6 to K3 in the dropdown, keep context on standard, and use K2.6 for quick questions to save tokens. When you need API access, the $3/$15 per-million-token rate with 90% cache-hit discount is competitive for agent workloads.
- If you are an indie or hobbyist: Do not spend a week downloading a 594 GB quantized GGUF that still needs 610 GB of RAM. The free browser path gives you the same frontier-grade model with zero setup.
- If you are an infrastructure team evaluating self-hosting: Download the official MXFP4 weights from
huggingface.co/moonshotai/Kimi-K3, pin a commit hash, use vLLM or SGLang with the published recipes, and start with the smallest topology your engine documents (8× H100 experimental, 32× H100 practical). Run a TCO calculation — cloud GPU rental at ~$20/hour for 8× H100 is the cheapest way to evaluate before committing to owned hardware. - If you are a Model-as-a-Service business: Read the Kimi K3 License before deployment. The $20M revenue threshold triggers a separate-agreement requirement that does not exist under the K2 license. Contact
license@moonshot.aibefore commercial deployment if you are near the threshold.
FAQ
Q: Is Kimi K3 completely free to use?
A: General chat at kimi.com is free with no credit card required, but the full 1M-token context window is a paid feature (Moderato ~$19/month, Allegretto ~$39/month). The API is pay-per-token ($3/M input, $15/M output) with no permanent free tier.
Q: Can I run Kimi K3 on my laptop or desktop?
A: No. The full 2.8T model requires a minimum of 8× H100 80 GB GPUs (640 GB VRAM) just to load experimentally. Even the most aggressive 1-bit GGUF quantization is 594 GB and needs 610 GB of combined RAM and VRAM. Consumer GPUs like the RTX 4090 (24 GB) cannot hold even a fraction of the model.
Q: How big is the Kimi K3 download?
A: The native MXFP4 checkpoint on Hugging Face is 1,560.94 GB (~1.56 TB) across 96 shards. Unsloth's 1-bit IQ1_S GGUF quantization brings this down to 594 GB, but that still requires 610 GB of total memory to run.
Q: What is the cheapest way to use Kimi K3?
A: The free browser tier at kimi.com costs nothing and gives you access to the same frontier-class model. For programmatic access, the API with cache-hit input at $0.30/M tokens is the cheapest serious path — far cheaper than the $550K+ hardware investment for self-hosting.
Q: Should I use K3 or K3 Swarm on the free plan?
A: Use plain K3. K3 Swarm is a multi-agent mode that spins up several workers at once, burning through tokens dramatically faster. A free account is unlikely to sustain a full Swarm build session.
Q: What is the Kimi K3 License and can I use the model commercially?
A: Yes, commercial use is broadly permitted under the custom Kimi K3 License. The main restriction affects Model-as-a-Service businesses above $20 million in trailing-12-month revenue, who must sign a separate agreement with Moonshot. Products above 100 million monthly active users or $20 million monthly revenue must display "Kimi K3" in the interface. Internal use is exempt from both conditions regardless of company size.
Discussion
0 comments