Kimi K3 Hardware Requirements: What It Takes to Self-Host a 2.8T-Parameter Model

Kimi K3 — Moonshot AI's 2.8-trillion-parameter mixture-of-experts model, released July 16, 2026 — is the largest open-weight model ever announced, and its hardware requirements match: the published checkpoint is approximately 1.56TB (MXFP4 weights are supported), and Moonshot's own production guidance calls for 64 or more accelerators. That is supernode-class infrastructure, not a server closet. The 1M-token context window and native vision compound the footprint, because long-context serving demands large KV-cache memory on top of the weights. The practical tiers: production serving requires a multi-node enterprise cluster; expert-offload configurations (hot experts in accelerator memory, the rest in system RAM) bring evaluation and batch work within reach of large single nodes at reduced throughput. Weights have been public since July 27, 2026 — the hosted API, which routes through Moonshot's infrastructure, is not an option for regulated data and no longer needs to be.

What exactly is Kimi K3?

The specification sheet, from Moonshot AI's launch materials and first-day independent testing:

Attribute	Kimi K3
Architecture	Mixture-of-experts, 2.8 trillion total parameters
Context window	1,000,000 tokens
Modalities	Text + native vision
Checkpoint size	~1.4TB (native 4-bit, as distributed)
Release	July 16, 2026 (API); open weights July 27, 2026 (moonshotai/Kimi-K3, Kimi K3 License)
Serving guidance	64+ accelerators for production serving (Moonshot)
Launch benchmarks	Beat Claude Opus 4.8 and GPT-5.5 on coding and agentic evals; third on independent intelligence indexes
Notable behavior	Best open model at admitting uncertainty rather than hallucinating (independent first-day testing)

Independent reviewers verified multi-hour autonomous runs in the first 24 hours — 3+ hours and 122 tasks completed from a single paragraph-long prompt — plus sub-agent orchestration (25 parallel verification agents in one observed audit) and vision-in-the-loop UI work where the model screenshots and critiques its own output. This is the capability class you are sizing hardware for.

How much hardware does production K3 serving require?

Three factors drive the bill of materials:

1. Weights: ~1.4TB even in the native 4-bit release, sharded across accelerators with fast interconnect. Weight memory alone rules out single-chassis serving. (Dequantized to BF16, 2.8T parameters would occupy ~5.6TB — the 4-bit release is the production format, not a compromise tier.)
2. KV cache: the 1M-token context is the expensive part. Long-context requests consume tens to hundreds of gigabytes of KV cache each, scaling with concurrent sessions. A cluster that merely loads K3 is not a cluster that serves K3 to a working team.
3. Interconnect: MoE expert routing plus tensor parallelism across 64+ accelerators demands NVLink/InfiniBand-class fabric; commodity networking becomes the bottleneck long before compute does.

This is why Moonshot's 64+ accelerator guidance should be read as honest, not conservative. In our sizing work, production K3 with meaningful long-context concurrency is a multi-million-dollar cluster — the same class of build as a national-lab inference node. We say this plainly because the alternative — pretending K3 fits in a closet — produces failed deployments.

What do the deployment tiers look like?

Offload and reduced-footprint configurations are the lever that moves K3 from "supercomputer only" toward "large enterprise cluster":

Tier	Weight footprint	Realistic pattern	Best for
Native 4-bit, fully in accelerator memory	~1.4TB + KV cache	64+ accelerators, multi-node	Maximum quality, high concurrency, production agents
Expert-offload (hot experts in HBM, rest in system RAM)	~1.4TB split across HBM + RAM	Large single nodes or small clusters	Evaluation, batch analysis, lower-concurrency internal tools
Further-compressed community variants	below native 4-bit	Research settings	Experimentation only — quality must be re-evaluated per workload

Two caveats we enforce in every engagement. First, compression below the native release is workload-specific: a further-quantized variant that holds up on summarization may degrade on long-horizon agentic runs — exactly K3's headline strength — so we evaluate against a harness built from your actual tasks before committing to a tier. Second, KV cache does not quantize away: if your use case is genuinely 1M-token contexts at scale, memory for cache can rival memory for weights regardless of precision.

Should your organization self-host K3 at all?

For most, the honest answer in July 2026 is: not as your first deployment. GLM-5.2 — 744B parameters with only 40B active, MIT-licensed — delivers within a few points of Claude Opus 4.8 on key agentic benchmarks and serves well on a single rack; our GLM-5.2 GPU requirements guide covers that sizing. The economics of the whole category are in our on-premise deployment cost breakdown; the ~2M-tokens/day break-even applies to K3-class builds too, just with a bigger numerator.

Where K3 earns its footprint: organizations with heavy long-horizon agentic workloads — overnight code-migration runs, large document-set analysis across million-token contexts, multi-agent verification swarms — and the volume to keep a cluster busy. A precision manufacturer running K3 batch analysis over decades of CAD notes, tolerances, and failure reports is the archetype: enormous private corpus, air-gap requirements, work that runs overnight at zero marginal cost.

For organizations that want K3-class capability without owning a supernode, we operate a managed sovereign facility tier: dedicated in-country hardware, your data residency and access controls, our physical operations.

The day-one window

The strategic fact about K3 was timing. From July 16 to July 27 the only way to use it was Moonshot's API — routed through Moonshot's own infrastructure — and even the reviewers most enthusiastic about the model advised against putting sensitive data through it. Since July 27 the weights have been static files you can download, checksum, air-gap, and own, with no US or Chinese provider anywhere in the chain. The organizations that benefited on day one were the ones whose racks were already ready. As of September 2026 the question has moved on: GLM-5.3 matches K3 on Terminal-Bench 2.1 (88.2 vs 88.3) from a single 8-GPU node, and GLM-5.3-Flash puts a frontier-class MIT-licensed model on two GPUs — so K3 is now the choice for organizations that specifically need its depth and can feed its cluster. See the GLM-5.3 GPU requirements guide.