Can You Run Kimi K3 Locally? (July 2026): No — Here's the Arithmetic and What to Run Instead

Bottom Line

• Can you run Kimi K3 locally? No. 2.8T total parameters, 104B active, ~1.4TB of weights on disk.
• Quantization will not save you. K3 ships natively MXFP4 weights / MXFP8 activations, quantization-aware trained from the SFT stage. Even a hypothetical 2-bit build exceeds 700GB.
• No official GGUF or Ollama build exists as of July 28, 2026. Ignore anyone claiming otherwise.
• Minimum realistic hardware: terabyte-class memory, roughly 8x H100. Not 24GB. Not 128GB.
• Run instead at 24GB: Laguna XS 2.1 at Q4_K_M — 20.27GB, 256K context, agentic coding.
• Run instead at 64GB/128GB: Laguna S 2.1 — 39.7GB at UD-Q2_K_XL, 57.6GB at UD-IQ4_XS, 73.1GB at UD-Q4_K_M.
• The 2026 pattern: frontier open-weight releases moved away from desks. “Open weights” no longer means “you can run it.”

What Kimi K3 Actually Is

Moonshot AI announced Kimi K3 on July 16, 2026 and published the weights on Hugging Face on July 26-27. The specs:

• 2.8 trillion total parameters, 104B active per token
• Mixture-of-Experts: 896 experts, 16 active plus 2 shared
• 1,048,576 token context (1M)
• Native vision through MoonViT-V2, a 401M-parameter encoder
• Weights: moonshotai/Kimi-K3

Self-reported benchmarks: GPQA Diamond 93.5, DeepSWE 67.5, Terminal-Bench 2.1 88.3, BrowseComp 91.2. There is no published SWE-Bench Verified score for K3 — if you see one quoted, someone invented it. DeepSWE 67.5 is the only agentic-coding number Moonshot released.

The license is a custom “Kimi K3 License,” not MIT. Internal and research use is free. A Model-as-a-Service business above $20M annual revenue needs a separate agreement with Moonshot. Kimi K2 shipped under Modified MIT, so K3 tightened the terms.

The Arithmetic: Why It Cannot Fit

Simon Willison measured the Hugging Face repo at 1.56TB. Call the weights ~1.4TB.

Normally that number is a starting point, not a verdict. A 1T-parameter BF16 model compresses hard: pull it to 4-bit and you cut roughly 4x. That is the move everyone reaches for.

K3 already made that move for you. The released weights are MXFP4 with MXFP8 activations, and Moonshot quantization-aware trained the model from the SFT stage onward. The 4-bit discount is baked in. You are not looking at a BF16 checkpoint waiting to be squeezed — you are looking at the squeezed version.

Push further and the math still fails. A hypothetical 2-bit build of K3 lands above 700GB. That is 5.5x a 128GB Mac Studio, and 2-bit would wreck the tool-calling reliability that makes an agentic model worth running.

What the tiers actually mean

Even the hypothetical 700GB 2-bit build leaves every row short. Serving K3 means terabyte-class memory, roughly 8x H100 at minimum. That is datacenter territory, not a desk.

Kimi K3 Is Not Alone — The 2026 Frontier Left Your Desk

This is the part worth internalizing. Three of 2026’s biggest open-weight releases are all unrunnable locally:

• Kimi K3 (July 26-27, 2026) — 2.8T/104B, ~1.4TB, natively MXFP4
• GLM-5.2 — ~750B total, MIT licensed, needs ~256GB RAM minimum at 2-bit; Unsloth’s 4-bit builds run 372-475GB
• Kimi K2.7-Code (June 12, 2026) — 1T total / 32B active, still ~340GB at 2-bit

GLM-5.2 is genuinely MIT. It is still out of reach. Openness of license and reachability of hardware became separate axes in 2026.

Meanwhile the small-MoE coding models got dramatically better. Poolside’s Laguna line puts 33B and 118B MoE models with 256K and 1M context onto single consumer machines. That is where local capability actually improved this year.

What to Run Instead

24GB GPU (RTX 4090, RTX 3090) — Laguna XS 2.1

Poolside released Laguna XS 2.1 on July 2, 2026: 33B total parameters, 3B active per token (MoE), 256K context, under the OpenMDW-1.1 license. The Q4_K_M build is 20.27GB and is the default tag at ollama.com/library/laguna-xs-2.1. It fits a 24GB card with room for context.

ollama pull laguna-xs-2.1
openclaw config set agents.defaults.models.agent ollama/laguna-xs-2.1
openclaw run --agent "Fix the failing tests and open a PR"

SWE-bench Verified sits at roughly 70.9% (chart-sourced from Poolside’s blog, so treat it as approximate). The firmly verified anchor is its predecessor, Laguna XS.2, at 68.2%. Either number puts a 20GB download in serious agentic-coding territory.

64GB and 128GB — Laguna S 2.1

Poolside’s larger sibling landed July 21, 2026: 118B total, 8B active, 1M context, also OpenMDW-1.1. Terminal-Bench 2.1 scores 70.2. Unsloth’s GGUF builds:

• UD-Q2_K_XL — 39.7GB
• UD-IQ4_XS — 57.6GB
• UD-Q4_K_M — 73.1GB

At 64GB you run it at 2-3 bit, or push to UD-IQ4_XS at 57.6GB with tight context. At 128GB you run UD-Q4_K_M comfortably with long context headroom.

Compare that Terminal-Bench 2.1 of 70.2 against K3’s 88.3. K3 wins. K3 also needs 8x H100. Laguna S 2.1 needs one Mac.

Runnable vs Not Runnable (July 2026)

Common Mistakes

1. Waiting for a GGUF that fixes the size. No official GGUF or Ollama build is confirmed as of July 28, 2026, and one would not help. The MXFP4 weights already spent the 4-bit budget.
2. Quoting a SWE-Bench Verified score for K3. Moonshot never published one. DeepSWE 67.5 and Terminal-Bench 2.1 88.3 are the real agentic numbers.
3. Assuming “open weights” means MIT. K3 uses a custom license with a $20M MaaS revenue threshold. K2 was Modified MIT. Read the terms before you build a product on it.
4. Buying a 128GB machine to run K3. 128GB is 11x short of the released weights and 5.5x short of a hypothetical 2-bit build. Buy 128GB for Laguna S 2.1 at Q4 instead — that is a real reason.
5. Skipping Laguna XS 2.1 because 33B sounds small. 3B active per token means it generates at small-model speed, and ~70.9% SWE-bench Verified beats every dense 32B coder you can fit in 24GB.

See Also

• Best Local LLMs for 64GB RAM — the tier that runs Laguna S 2.1 at 2-3 bit
• Best Local LLMs for 128GB RAM — where Laguna S 2.1 Q4 fits comfortably
• Best Local LLMs for 32GB RAM — Laguna XS 2.1 Q4 with real context headroom
• Best Local LLM by RAM (hub) — pick your tier first, then the model
• OpenClaw Best Local Models — which of these hold up in long agent loops