🚀 B200 starting at $3.75/hr. The best price you'll find. DC in US West → (Access it from button on top after login).

Get Your B200 →
Start Building
Guide

Moonshot Kimi K3 GPU Requirements: Confirmed VRAM & Deployment Guide

Kimi K3 shipped less than a day ago, and hardware figures are still settling. Here's what's actually confirmed about VRAM and deployment, sourced directly from Moonshot's own repository.

Author photo
packet.ai Team
July 28, 2026

Kimi K3's official Hugging Face repository confirms a 1.56TB footprint for the native weights. Since the model shipped within the last day, figures are still settling across the ecosystem, and an official active-parameter count hasn't been published yet, so any specific number you've seen there is a community estimate rather than a confirmed spec.

Key takeaways

  • Kimi K3's official repo size is 1.56TB, confirmed directly from Moonshot's Hugging Face page. Since the model just shipped, use this as your reference point rather than pre-release estimates that predate the actual weights.
  • K3 has 2.8T total parameters across 896 experts, with 16 active per token. Moonshot has not published an official active-parameter count.
  • This is cluster-scale hardware regardless of quantization. There is no realistic single-GPU or single-node path to running K3 natively.
  • Kimi Delta Attention (KDA) is the architectural headline, a linear-attention mechanism built to make K3's 1M-token context computationally practical rather than just theoretically possible.
  • K3 shipped its open weights July 27, 2026. This guide reflects what's confirmed as of the day after release, and figures may firm up as the model settles.

Moonshot released Kimi K3's open weights on July 27, 2026. Given how recent that is, hardware figures for the model are still settling across the ecosystem. Here's what's confirmed as of today, sourced directly from Moonshot's own repository.

Kimi K3 in One Paragraph: What Shipped Yesterday

Kimi K3 is Moonshot AI's successor to the Kimi K2 family, a 2.8-trillion-parameter sparse mixture-of-experts model with native vision support and a 1-million-token context window. It's positioned as a direct open-weight challenger to closed frontier models, with Moonshot's own launch materials showing K3 leading or tied for first on 8 of 33 public benchmark rows, including strong results on agentic coding tasks. The model routes through 896 total experts, activating 16 per token, and ships under Moonshot's own "Kimi K3 License," described as MIT-like with commercial gates.

Kimi K3 VRAM Requirements: The Confirmed Number

Because K3 shipped so recently, it's worth confirming exactly which figure you're working from. A 594GB estimate for K3's weights has circulated in some early coverage, calculated by unpacking Moonshot's native MXFP4 training format into BF16. That was a reasonable way to estimate the footprint before the weights were public, but the confirmed number now comes directly from the released repository.

⚠ Watch out

Moonshot's own Hugging Face repository for Kimi K3, confirmed directly at time of writing, lists the total repo size at 1.56TB. This is the current, confirmed figure for the native weight files, worth using as your reference point given how quickly information about a same-week release can shift.

1.56TB of native weights puts K3 firmly outside any single-node conversation. Even an 8-GPU H100 node (640GB combined) covers roughly 41% of that footprint, and that's before KV cache for anything approaching the 1M-token context window is added on top.

The Missing Active-Parameter Number

K3 activates 16 of 896 experts per token, a genuinely extreme sparsity ratio, under 2% of experts fire on any given forward pass. What Moonshot has not published is a specific active-parameter count in billions, unlike some other MoE releases that state this figure directly in their model card.

⚡ Note

Any specific active-parameter figure you see for K3 right now, commonly cited as roughly 50B, comes from community estimates on Hugging Face discussion threads, not from Moonshot's own documentation. Treat it as a reasonable approximation, not a confirmed spec, until Moonshot publishes an official number.

Regardless of the exact active count, the underlying principle holds the same way it does for every MoE model: active parameters describe compute per token, not memory footprint. All 2.8T total parameters, spread across all 896 experts, have to be addressable in memory, since the router can select any expert on any forward pass. A low active-parameter count makes K3 fast to generate tokens once loaded. It has no bearing on whether the model fits on your hardware in the first place.

Kimi Delta Attention: What Actually Changed From K2

The architecture story matters as much as the parameter count here. K3 introduces Kimi Delta Attention (KDA), a linear-attention mechanism using short convolutions, normalized keys, and gated state updates in place of a standard quadratic attention matrix. Paired with Attention Residuals, KDA is what makes K3's 1M-token context window computationally viable rather than a theoretical maximum nobody can actually use.

Moonshot credits this combination, along with routing changes like Quantile Balancing, for roughly 2.5x better scaling efficiency compared to Kimi K2. That efficiency claim is about compute and training stability, not about reducing the hardware needed to hold the model in memory, which remains governed by the 2.8T total parameter count regardless of how efficiently K3 processes each token once loaded.

Deployment Reality

Given the 1.56TB confirmed footprint, realistic self-hosting starts at cluster scale, not single-node.

Single 8-GPU node (640GB, e.g. 8x H100): Not enough for native weights alone. Aggressive quantization plus reduced context length is the only path here, with real quality and capability tradeoffs.

Multi-node cluster (1.5TB+ combined): The realistic tier for native weights at reasonable context lengths. This is squarely a multi-node InfiniBand cluster decision, not a single-server one.

Full 1M-token context at scale: Needs headroom well beyond the weights-only figure for KV cache. Budget significantly above 1.56TB if you're targeting the full context window in production.

Given how new this release is, treat any specific "X GPUs get you Y tokens/second" claim you see right now with caution. Real-world serving benchmarks for K3 are still being established, and the confirmed facts today are the weight size, the architecture, and the sparsity ratio, not yet a settled picture of production throughput per GPU tier.

Decision Framework: Four Questions

1. Have you checked the license terms for your specific use case? The Kimi K3 License carries commercial gates rather than a standard permissive license. Confirm your deployment qualifies before building around it.

2. Do you actually need the full 1M-token context? KV cache at that scale adds substantially on top of the weights-only figure. Shorter context needs meaningfully less headroom.

3. Is self-hosting worth it this early, or is the API the better call for now? K3's API is live today. Self-hosting a model this size and this new carries real infrastructure risk before serving patterns are well established.

4. Are you planning around a single node or accepting this is a cluster decision? 1.56TB doesn't fit an 8-GPU node at any realistic quantization with meaningful context. Plan hardware around the cluster tier from the outset.

Common Mistakes When Sizing Kimi K3

Sizing hardware from a pre-release estimate rather than the live repo. A 594GB figure circulated before K3's weights were public. Now that they're released, the confirmed number is 1.56TB, worth double-checking before finalizing any hardware plan.

Treating a community active-parameter estimate as an official spec. Moonshot hasn't published this number. Any specific figure you see is a third-party approximation.

Assuming K3's sparsity reduces the memory requirement. Sixteen active experts out of 896 affects speed, not the fact that all 896 experts' weights need to be addressable in memory.

Committing to hardware based on day-one throughput claims. Serving benchmarks for a model this fresh are still being established. Wait for corroborated, multi-source performance data before sizing a production deployment around a specific tok/s figure.

Running Kimi K3 on packet.ai

Given K3's confirmed 1.56TB footprint, a self-hosted deployment is a cluster conversation from the start. packet.ai's GPU Clusters are InfiniBand-connected multi-node fabric built for exactly this scale of model, rather than trying to force a 2.8T-parameter checkpoint onto single-node hardware it was never going to fit on.

If you'd rather evaluate K3 without standing up infrastructure yourself, packet.ai's Token Factory, a managed, OpenAI-compatible inference API, is worth joining the waitlist for. Given how fresh K3 is, using a hosted API to test its actual behavior on your workload before committing to self-hosted infrastructure is a reasonable way to de-risk the decision.

For sizing other current models before deciding on infrastructure, packet.ai's general VRAM requirements guide covers the same kind of sizing math across the broader model landscape.

Frequently asked questions

Moonshot's official Hugging Face repository lists Kimi K3's total size at 1.56TB, confirmed directly from the live repo. Given how recently the model shipped, this is the figure worth working from over any pre-release estimate.
Kimi K3 activates 16 of 896 total experts per token. Moonshot has not published an official active-parameter count in billions. Figures circulating online, commonly around 50B, are community estimates rather than confirmed specifications.
No, not realistically. At a confirmed 1.56TB, K3 doesn't fit even an 8-GPU H100 node (640GB combined) at native precision. This is a multi-node cluster decision, not a single-server one, regardless of quantization strategy.
Kimi Delta Attention (KDA) is a linear-attention mechanism Moonshot built for Kimi K3, using short convolutions, normalized keys, and gated state updates instead of a standard quadratic attention matrix. It's what makes K3's 1-million-token context window computationally practical rather than just a theoretical maximum.
Kimi K3 ships under Moonshot's own "Kimi K3 License," described as MIT-like but with commercial gates rather than a standard open-source license like Apache 2.0 or MIT itself. Review the specific license terms on Moonshot's Hugging Face repository before commercial deployment.

Last reviewed: July 28, 2026, one day after Kimi K3's open weight release. Figures reflect Moonshot's official Hugging Face repository at time of writing. Given how recent this release is, some details, particularly serving benchmarks and community quantization support, are likely to evolve; check current sources before finalizing a production deployment.

Waste less compute.

Same models. Same API. Fraction of the cost. Start free — no credit card required.

Start Building →

More from the blog