An Open-Weights 2.8T MoE Model: License Terms and Deployment Thresholds Explained

    A 2.8-trillion-parameter Mixture-of-Experts multimodal agent model has released its full weights, and it is now described as the largest open-weight model published to date. This article breaks down what is inside the checkpoint: the MoE architecture with 896 routed experts plus 2 shared experts, 104B activated parameters per token, sparse attention on 24 of 93 layers, MXFP4 weights and MXFP8 activations produced through quantization-aware training, and a 1M-token context window. It explains how to read the vendor's self-reported benchmark numbers, why open weights do not equal open source, what license clauses enterprises should check before commercial use, and what it actually takes to serve 1.56TB of weights locally. You will learn how memory capacity is driven by total parameters while compute is driven by activation size, how to size GPUs for an 8-card deployment, and which inference engine, multimodal pipeline, agent runtime, and operational capabilities are required beyond the model files.

    An Open-Weights 2.8T MoE Model: License Terms and Deployment Thresholds Explained

    2.8T parameters. A 1.56TB weight file. Eight GPUs at minimum for local deployment. On November 4, a model vendor released the complete weights of a trillion-parameter multimodal agent model as promised, and the community is already calling it the strongest downloadable open model available. For developers and enterprises, this article covers the three things that matter: what the checkpoint actually contains, how to read the license, and whether ordinary hardware can run it.

    1. What Happened: API First, Weights Later

    From API to weights. On October 24, the model went live through a cloud API and a web interface, and the vendor committed to publishing the full weights before November 4. The weights appeared on schedule on a major model hosting community, in a public repository with no application required.

    Release details. The hosting repository was created on November 2. It remained closed on the morning of November 4 and opened that evening. The model directory contains 112 files, of which 96 are general tensor shards totaling roughly 1.56TB. Many shards of moderate individual size make the download well suited to parallel transfer and shard-level verification.

    Why it matters. This is the largest open-weight model released to date, far larger than the vendor’s previous releases and larger than any previously public open model. Once the weights are public, three questions need real answers: what structure is inside, how the license should be interpreted, and whether it can run locally — and at what cost.

    2. How 2.8T Is Composed: Anatomy of the Model

    2.1 Positioning: An Agent Model Continued from a Natively Multimodal Base

    According to the official model card, this is a natively multimodal agent model that supports image input and was trained by continuing from the previous generation. “Natively multimodal” means visual input participated in training alongside text from an early stage, rather than being bolted on later as a visual adapter. “Agent model” means it can plan steps autonomously, invoke tools, and read back execution results — not just answer single-turn questions.

    2.2 The MoE Skeleton: 896 Routed Experts Plus 2 Shared Experts

    The model uses a Mixture of Experts (MoE) architecture. Each expert can be understood as a small feed-forward network, and a router selects a few experts to compute for each token. The key parameters:

    Dimension Value Notes
    Total parameters ~2.8T Actual weight footprint
    Activated parameters per token 104B Main driver of compute cost
    Routed experts 896 16 selected per token
    Shared experts 2 Always active
    Layers 93 24 of them use sparse attention
    Context length 1M tokens Long documents and long sessions
    Vision encoder Vendor’s own encoder Image understanding

    Three details are worth attention:

    • An activation ratio of about 3.7%. Out of 2.8T total parameters, each token activates only 104B, with 18 experts participating at each step. Per-step compute is therefore roughly comparable to a model in the tens-of-billions range of dense parameters, while memory capacity requirements are set by all 2.8T parameters. “Enough compute, not enough memory” is the signature deployment characteristic of this class of model.
    • Shared experts carry common knowledge. Widely applicable domain knowledge and general capabilities sit in the always-active shared experts, while routed experts specialize by domain or position. Compared with a purely routed design, this reduces redundant learning of general knowledge across different experts, which is why adding shared experts back has become a common practice in recent years.
    • Experts are substantial in size. Taking 104B activated parameters as a rough estimate, a single expert holds on the order of billions of parameters. Finer-grained experts make routing more flexible, but they also increase the communication needed to dispatch tokens.

    2.3 The Only Structural Change: Sparse Attention

    Compared with the previous generation, the architecture changed in exactly one place: full attention in 24 of the 93 layers was replaced with sparse attention (DSA). In standard attention, every token must be compared pairwise with all preceding tokens, and the cost grows quadratically with context length. At a 1M-token context, full attention consumes both compute and repeated reads of a very large key-value cache (KV Cache). Sparse attention first performs a lightweight selection of the historical portion most relevant to the current token, computes only over that portion, and substantially reduces compute and bandwidth cost at long context lengths.

    The change reflects a broader trend: the focus of long-context optimization has shifted from simply enlarging the window to making attention affordable to compute and cheap enough to read once the window is large enough. The cost is greater implementation complexity — operators and inference engines need dedicated adaptation.

    2.4 Quantization: MXFP4 Weights, MXFP8 Activations

    Weights use MXFP4 (4-bit micro-scaled floating point) and activations use MXFP8 (8-bit micro-scaled floating point). This is a hardware-friendly low-bit numeric format: data is stored in 4 or 8 bits, and a group of values (a group is typically 32 elements in MX formats) shares an 8-bit scale factor, which preserves numerical precision as far as possible at very low bit widths.

    More importantly, the vendor explicitly states that this is the product of quantization-aware training (QAT). The conventional approach — train in full precision, quantize at inference time — tends to introduce accuracy loss. QAT instead simulates quantization error during training so the model adapts to low-bit representations in advance, which typically reduces performance degradation noticeably.

    Users need to be clear about three points:

    • There is only this one version. The vendor released only the MXFP4 build, with no BF16 or FP8 weights.
    • It cannot truly be “dequantized.” A BF16 or FP8 copy upsampled from 4-bit weights will not be more accurate than the original 4-bit weights; it will only occupy more memory.
    • Runtime support is required. For local deployment, the inference engine and accelerator cards must natively support MX formats. Where they do not, an offline conversion is the only option — and conversion itself consumes memory and time.

    3. How to Read the Benchmarks: Interpreting Vendor-Reported Numbers

    One point first: all figures below come from a vendor-published comparison table and have not been independently reproduced.

    Coding and agent tasks land near the top tier. A terminal-based interactive coding benchmark 4.0 score of 65.7% is slightly below a contemporaneous flagship closed model’s 66.4% and above another closed model’s 58.2%. On a long-horizon software engineering benchmark, the model scored 51.7% against 46.3% for the comparison model.

    Scientific knowledge and parts of reasoning lag clearly. On a scientific-computing coding benchmark, the model scored 38.1% versus 63.3% for the comparison model, a gap of more than 25 percentage points. On the Diamond subset of a broad academic knowledge and reasoning benchmark, it scored 39.4% versus 60.9%. This matches the architectural profile of sparse activation with multi-domain experts: tasks with deterministic feedback that can be reinforced through training, such as code and tool use, perform better, while breadth of knowledge coverage is comparatively weak.

    The overall picture. The vendor reports leading on 16 of 37 benchmarks. Item by item the record is mixed: leads on coding and agent tasks, deficits on science and some reasoning tasks. A third-party evaluation organization’s composite intelligence index places the model fourth globally.

    3.1 Why Vendor-Reported and Independent Results Often Diverge

    • Scaffolding differences. Prompts, number of samples (for example best-of-n sampling), tool-calling frameworks, and scoring scripts all affect scores materially.
    • Training-set overlap. Public benchmarks may have appeared in the training corpus, inflating scores.
    • Version mismatch. When the API version and the weight version differ, results cannot be compared directly.
    • Missing dimensions. Benchmark scores do not include latency, cost, stability, or data security — which are often the deciding factors for enterprise deployment.

    3.2 The Recommendation: Replace “Leaderboard Score” with “Private Task Success Rate”

    Build your own evaluation set on your own codebases and business Q&A data, fix the sampling parameters and scoring scripts, and re-test candidate models uniformly. Also examine long-context recall, the validity rate of structured output (valid JSON), success and hallucination rates for multi-step tool calls, and record per-task latency and cost per token. Only when these dimensions are included is model selection complete.

    4. “Open Weights” Does Not Mean “Open Source”

    This is the point most worth isolating from the whole event. The repository ships under a custom license, the Kimi K3.1 Pro License, and the license field on the hosting page is marked “other” rather than MIT, Apache 2.0, or another standard open source license. The license is word-for-word identical to the previous generation’s, with only the name changed.

    4.1 Where the Two Kinds of License Differ

    The standard definition of open source — for example the Open Source Initiative’s Open Source Definition — emphasizes that a license must not restrict fields of use, must not discriminate against particular groups, and that its conditions must be clear and unambiguous. Open weights means the parameter files are public; how they may be used is determined entirely by the license text. The two are not equivalent.

    In this specific case, the main body of the license does use MIT-style terms, permitting free use, copying, modification, distribution, fine-tuning, and commercial use. Such licenses usually differ from standard MIT in their additional conditions. In practice, three categories are common:

    1. Scale thresholds. When a product exceeds a certain monthly active user count, or offers related services, separate authorization or a specific form of attribution is required. Such clauses do not affect the vast majority of individual developers and small teams, but they directly affect commercial products serving users at large scale.
    2. Attribution requirements. Clear naming or labeling requirements for derivative models and distributed artifacts.
    3. Use and redistribution restrictions. Prohibited uses, the requirement to include the license text upon redistribution, and terms governing copyright ownership of model outputs.

    A caution: the information made public during this weight release did not list the full text of the additional clauses, and the categories above reflect common industry practice only. Specific applicability is governed by the official license text. Also, “downloadable” and “commercially usable” are two different things — a publicly downloadable repository should never be read as blanket permission for arbitrary commercial use.

    4.2 An Enterprise Compliance Checklist

    • Read the terms before committing. Have legal and technical leads review the license text clause by clause, focusing on user-scale thresholds, attribution requirements, and prohibited uses.
    • Treat the model as a dependency that requires approval. Similar to a third-party component inventory, set up a registration process for models that records source, version, license type, and permitted scope of use.
    • Agree on derivative model rights in advance. If you plan to distribute fine-tuned models, first confirm whether derivative models must carry the same license and how they must be labeled.
    • Do not mistake “open” for “public domain.” Open weights do not mean the absence of rights constraints.

    5. Local Deployment Thresholds: What “8 GPUs at Minimum” Means

    1.56TB of weights across 8 accelerators means each card must hold roughly 195GB of weights. That number largely defines what “8 GPUs at minimum” actually implies: it is not a compute requirement but a memory capacity requirement.

    5.1 Understand the Rules First

    Memory capacity is set by total parameters. No matter how sparse the experts are, the weights of all 896 experts must be resident in memory, or at least quickly reachable from storage.

    Compute is set by activated parameters. Each token activates only 104B parameters, so per-step compute is roughly equivalent to a model in the tens-of-billions dense range.

    Decoding is memory-bandwidth bound. During autoregressive generation, the activated weights must be read from memory for every token produced. The throughput ceiling is approximately aggregate memory bandwidth divided by the bytes read per token.

    Communication determines distributed efficiency. Intra-node multi-GPU setups can use high-bandwidth interconnects; cross-node setups must rely on network interfaces, where bandwidth is lower by more than an order of magnitude.

    5.2 A Rough Sizing Table

    Per-GPU memory Minimum GPUs to hold 1.56TB Notes
    80GB 20 Requires multi-node deployment, or offloading part of the weights to host memory or storage
    141GB 12 Does not fit on a single node; at least two nodes are required
    192GB 9 8 cards on one node total about 1.54TB, still short; two nodes with 16 cards, or offloading part of the weights, is needed

    Note: converted from 1.56TB, the figures above are theoretical minimums and exclude KV Cache, framework runtime, and communication buffers.

    So “8 GPUs at minimum” means eight high-end accelerators on a single node with roughly 200GB of memory per card — a very high bar. Substitute common 80GB-class accelerators and you need at least 20 cards across multiple nodes, with networking and operational complexity rising sharply.

    5.3 A Simple Estimation Tool

    1. import math
    2. def estimate_deployment(total_params, active_params, bytes_per_param,
    3. gpu_vram_gb, gpu_bw_tbs, num_gpus):
    4. """Estimate trillion-parameter MoE deployment needs along two axes: memory and bandwidth.
    5. Results are order-of-magnitude references only; KV Cache and load balancing overheads are excluded.
    6. """
    7. total_bytes = total_params * bytes_per_param # Total weight bytes
    8. per_token_bytes = active_params * bytes_per_param # Weight bytes read per token
    9. usable = gpu_vram_gb * (1024 ** 3)
    10. min_gpus = math.ceil(total_bytes / usable) # Theoretical minimum GPU count
    11. real_gpus = math.ceil(min_gpus / 0.85) # Reserve ~15% for KV Cache and runtime
    12. agg_bw = real_gpus * gpu_bw_tbs * (1000 ** 4) # Aggregate memory bandwidth
    13. upper_bps = agg_bw / per_token_bytes # Single-request throughput ceiling
    14. kv_bytes_per_1k = 0.5 * 1024 # Example: ~0.5MB KV Cache per 1K tokens
    15. print(f"Total weights: {total_bytes / 1024**4:.2f} TiB, "
    16. f"read per token: {per_token_bytes / 1024**3:.1f} GiB")
    17. print(f"Minimum GPUs: {min_gpus} -> with headroom: {real_gpus}")
    18. print(f"Single-request throughput ceiling: {upper_bps:.0f} token/s")
    19. print(f"1M context KV Cache floor: "
    20. f"{kv_bytes_per_1k * 1000 / 1024**3:.1f} GiB")
    21. print(f"256 concurrency (32K context each) KV Cache: "
    22. f"{kv_bytes_per_1k * 32 * 256 / 1024**3:.0f} GiB")
    23. if __name__ == "__main__":
    24. estimate_deployment(
    25. total_params=2.8e12, # Total parameters
    26. active_params=104e9, # Activated parameters per token
    27. bytes_per_param=0.5625, # ~4.5 bit, consistent with the actual 1.56TB size
    28. gpu_vram_gb=192, # Memory per GPU
    29. gpu_bw_tbs=8, # Memory bandwidth per GPU, illustrative value
    30. num_gpus=8,
    31. )

    With 192GB per card and 8TB/s per-card bandwidth as inputs, the program reports roughly 1.44TiB of weights and about 55GiB read per token; a theoretical minimum of 9 cards, around 11 once headroom is reserved, meaning 8 cards on one node is not enough; and a single-request throughput ceiling of about 1,300 token/s. All of these are ideal values. Expert-parallel communication, uneven expert load, sampling overhead, and batch scheduling all pull actual throughput down, so real numbers must come from measurement.

    5.4 Choosing a Distributed Inference Strategy

    • Tensor parallelism (TP). Splits each layer’s weights across cards and requires frequent synchronization. Suits high-bandwidth intra-node interconnects; cross-node communication becomes the bottleneck.
    • Expert parallelism (EP). Distributes the 896 experts across cards, with each token routed to the card holding its expert. The advantage is that memory is apportioned roughly linearly with card count; the cost is all-to-all communication plus a “weakest link” effect from uneven expert load, where hot experts slow down the whole system.
    • Pipeline parallelism (PP). Splits by layer, with each card responsible for a different layer segment. Low communication volume and suitable for cross-node setups, but pipeline bubbles reduce utilization.
    • KV Cache compression. KV Cache grows quickly at long context. Options include paged management, KV quantization, sliding windows, or sparse attention.

    Illustrative code can only answer “roughly how many cards.” Before production, small-scale load testing must determine the actual card count, parallel configuration, and supportable concurrency.

    5.5 Beyond the Threshold: Four Capabilities Other Than Compute

    • An inference engine that supports MX formats. It must correctly load MXFP4 weights and MXFP8 activations, otherwise you are limited to a degraded conversion path.
    • A native multimodal processing pipeline. This requires the matching vision encoder plus engineering support for image preprocessing, multiple images and mixed image-text input, and token accounting policy.
    • An execution environment for agents. Code execution sandboxes, filesystems, tool-calling protocols, and failure retries are engineering components that affect final results more than the weights do.
    • Operations and cost. Instances with hundreds of gigabytes of memory tend to be expensive and short on supply, so elastic scheduling, queuing, and usage metering are needed.

    6. Practical Recommendations

    6.1 License: Review Before Use

    Put “can we use this commercially” on the first page of technical selection, rather than patching it in before launch. Pay particular attention to user-scale thresholds and attribution requirements; when distributing externally, make sure the license text ships with the model.

    6.2 Quality: Evaluate First

    Re-test coding, agent, and long-document capability on a private task set, and check whether the weaknesses in scientific knowledge and reasoning affect your business. If factual Q&A requirements are high, consider combining the model with a specialized one and routing tasks at a router layer.

    6.3 Deployment: Three Paths, Chosen by Scenario

    • Cloud API. No hardware threshold, good elasticity. Suitable for fast validation and spiky traffic.
    • Dedicated cloud instances. The platform handles scheduling and operations, which suits scenarios with strict data isolation and stability requirements. General capabilities such as cloud GPU instances, container services, object storage, log services, and monitoring and alerting can be combined; check each platform’s latest documentation for specific configurations and pricing.
    • Self-hosted on-premises. Suitable when data must not leave your premises and usage is long-term and high-volume, but it requires an upfront investment in high-memory accelerators and high-bandwidth interconnect, plus ongoing operations and model upgrade costs.

    6.4 Operations: Run the Model as a Service

    • Monitor first-token latency, per-token generation speed, concurrency, and memory utilization.
    • Record the model version, quantization format, and sampling parameters for every request so results are traceable and reproducible.
    • Set up canary release and rollback mechanisms.
    • Define timeout and degradation strategies for long-context tasks.

    7. Summary

    The significance of this weight release is not the number “2.8T” but the industry question it puts on the table: what does open weights actually open?

    • Architecturally, MoE trades a small activation for low inference cost, sparse attention makes long context affordable to compute, and QAT quantization makes trillion-parameter models runnable.
    • Licensing-wise, open weights are not open source. An MIT-style core plus additional clauses needs clause-by-clause review.
    • Deployment-wise, memory capacity is set by total parameters and compute demand by activated parameters. The essence of “8 GPUs at minimum” is a high-memory threshold.

    For developers, the rational sequence is: read the license first, run a private evaluation second, then choose a hosting approach based on the scenario. For the industry, the continuing release of trillion-parameter models is pushing inference frameworks, low-bit formats, and high-speed interconnects to evolve together. “Can you download it” is no longer the central question — “can you use it compliantly and run it economically” is the next threshold.