Trillion-Parameter Open-Weight Model Released: A Guide to Its License and Local Deployment

    A newly released trillion-parameter MoE model has opened its full weights for download. This article breaks down what developers actually need to know: the model's architecture and capability profile, how to read its vendor-reported benchmarks, what its custom license allows for commercial use, and what it takes to run it locally. It closes with an actionable decision checklist spanning licensing, hardware sizing, context length, performance testing, and deployment strategy.

    In early November, a team delivered on an earlier promise and opened the full weights of a trillion-parameter MoE model on a major model hosting platform: 2.8T total parameters, only about 104B activated per inference, roughly 1.56TB of weight files split across 96 shards. The team calls it “one of the strongest open models you can currently download,” and local deployment starts at eight accelerators.

    For developers, three questions really matter:

    • What does its capability profile look like?
    • Does the custom license allow commercial use?
    • What do you need to prepare for local deployment?

    Using this release as a case study, this article takes each question in turn and ends with an actionable decision checklist.

    1. The release timeline: how the weights went public

    • Late October: The model first went live via API and a web interface. The team also promised to release the full weights before early November.
    • Early November: The repository on the hosting platform was created ahead of time. It stayed closed on the morning of launch day and opened officially in the evening, downloadable without any application process.
    • Weight scale: 112 files, 96 weight shards, roughly 1.56TB in total.
    • Release cadence: Creating the repository early, uploading shards over time, and opening everything at a chosen moment is a standard way to handle upload and distribution of trillion-parameter-class models.

    This is also one of the largest open-weight models by parameter count released to date. Below, we focus on the questions that come up once the weights are out: what is inside, how the license counts, and how to run it locally.

    2. Inside the model: 2.8T total parameters, ~104B activated per token

    1. MoE: separating “capacity” from “compute”

    The model is a natively multimodal agent model, trained further on top of the previous generation. Its core structure is a mixture of experts (MoE):

    • Expert configuration: 896 routed experts, with each token selecting 16; plus 2 shared experts that always participate in computation.
    • Activated scale: about 104B parameters activated per token, only about 3.7% of the total.
    • Layers: 93 layers in total.

    The point of MoE is to decouple two metrics:

    • Total parameters determine the model’s knowledge capacity, and how much VRAM the weights occupy.
    • Activated parameters determine the compute per token, and how much inference compute is required.

    With a total-to-activated ratio of roughly 27:1, the design strongly emphasizes “high VRAM barrier, controllable per-token compute.”

    2. Sparse attention: saving compute for long context

    Compared with the previous generation, only one structural change was made: 24 full-attention layers were switched to sparse attention (DSA). In standard self-attention, every token must compute relations with all previous tokens, and the cost grows quadratically with sequence length. Sparse attention lets each token attend only to a small number of carefully selected historical tokens, sharply reducing attention compute and memory reads on long sequences. Paired with a 1-million-token context window, this reflects a design aimed at long documents and long-chain agent tasks.

    3. Vision encoder: native multimodality

    The model ships with its own vision encoder (MoonViT-V2) and can understand images directly. This means it is not limited to code and text; it can also handle tasks such as reading UI screenshots, charts, and documents.

    Dimension Specification Engineering implication
    Total parameters 2.8T (MoE) Sets the lower bound on VRAM demand
    Activated parameters ~104B per token (16 routed + 2 shared experts) Determines per-token compute
    Layers 93 layers, 24 of them sparse attention More compute-efficient on long context
    Context 1 million tokens Heavy KV cache management pressure
    Multimodality MoonViT-V2 vision encoder Requires extra planning for image preprocessing and VRAM overhead

    3. Reading the benchmarks: how to interpret vendor-reported numbers

    The official comparison data are all vendor self-tests. The main results:

    • Terminal-environment coding: 65.7%, slightly below model A’s 66.4% and above model B’s 58.2%.
    • Long-horizon software engineering: 51.7%, above model A’s 46.3%.
    • High-difficulty science subjects: 38.1%, versus model A’s 63.3%.
    • High-difficulty cross-disciplinary knowledge QA: 39.4%, versus model A’s 60.9%.
    • Overall: the team says it beat model A on 16 of 37 benchmarks.
    • Third-party reference: an independent evaluator gave it a composite intelligence index of about 55, ranking among the global top tier.

    The capability profile is clearly uneven:

    1. Coding and agent tasks are in the first tier; on long-horizon software engineering it even overtakes model A.
    2. Science and some reasoning lag noticeably, trailing model A by more than 20 percentage points on the two high-difficulty knowledge tests.
    3. Treat comparison data with caution. Official results are usually the best performance the vendor measured under selected settings, and may enable strategies such as test-time scaling and multi-sample voting. It is safer to treat them as an “upper-bound reference” rather than “default behavior.”

    It is worth validating with an evaluation set close to your own business, for example:

    • Test coding ability with problems from your internal code repositories;
    • Test agent ability with multi-step tool-calling tasks;
    • Test domain depth with field-specific knowledge QA.

    4. The license: “open weights,” not “open source”

    This is the point that most deserves separate scrutiny in this release. The repository uses a custom license (the Kimi K3.1 Pro License), and the platform’s license tag is “other,” not a standard open-source license like MIT or Apache. Its text is word-for-word identical to the previous generation, with only the name changed, and two “Added Terms” are prepended before the original license.

    1. Main terms: permissive MIT-like grants

    • Allowed by default: use, copy, modify, distribute, distribute derivative works (including fine-tuning), and commercial use.
    • Accompanying obligations: retain the copyright and license notices in distributed artifacts; the license travels with the software and applies equally to derivative models or synthetic data; provided “as is,” with no warranty.
    • Additional terms: the two new terms take precedence over the above.

    2. Additional restrictions: binding only on “large-scale external business”

    • Term 1: organizations that offer the model as a service to third parties and whose relevant trailing-12-month total revenue exceeds $20 million must arrange a separate agreement with the model team before commercial use.
    • Term 2: organizations whose commercial products or services built on this model exceed 100 million monthly active users must first complete a separate arrangement.

    Note: the original text is truncated here. The full wording of Term 2, the attribution and calculation basis of “total revenue / MAU” in both terms, and the consequence of “no agreement reached within 90 days of first contact” should all defer to the original license text.

    3. Common scenarios at a glance

    Usage scenario Touches the additional restrictions? Explanation
    Personal study, research, internal PoC No Not restricted
    SMBs using a fine-tuned model in their own products No (below revenue or MAU thresholds) Just follow the attribution and distribution obligations
    Selling the model as a service externally Depends on whether trailing-12-month revenue exceeds $20M Large service providers need a separate arrangement
    Large-scale commercial product embedding the model Depends on whether MAU exceeds the threshold Must be calculated against the original wording
    Redistributing the weights or a fine-tuned version Governed by the distribution terms Retain notices and attach the same license

    4. Recommendations for enterprise adoption

    • Account for “open weights,” not “open source”: open weights are not the same as open source, and the boundaries of use are set by the license text, not the label.
    • Move license review earlier into the selection stage: have legal assess the license and estimate early whether revenue and user scale approach the thresholds; if they get close, engage the rights holder as early as possible to avoid being forced into action after launch.
    • Keep records: save the download page, a snapshot of the license text, and the version identifier as evidence for future audits.

    5. Local deployment: where the “8-card minimum” comes from

    1. VRAM estimation

    VRAM demand = weights + KV cache + framework and activation overhead. Start with the simplest model:

    1. def estimate_vram_gb(params_b: float, bytes_per_param: float = 0.5) -> dict:
    2. """
    3. Roughly estimate the resident VRAM requirement (in GB, 1 GB = 1e9 bytes)
    4. params_b: number of parameters (billions)
    5. bytes_per_param: bytes per parameter, ~0.5 for 4-bit quantization
    6. """
    7. weight = params_b * 1e9 * bytes_per_param / 1e9
    8. result = {"weight_only": weight}
    9. for card_mem in (141, 180, 192): # in GB, corresponding to common high-memory accelerators
    10. import math
    11. result[f"{card_mem}GB cards needed (weights only)"] = math.ceil(weight / card_mem)
    12. return result
    13. print(estimate_vram_gb(2800))
    14. # {'weight_only': 1400.0,
    15. # '141GB cards needed (weights only)': 10,
    16. # '180GB cards needed (weights only)': 8,
    17. # '192GB cards needed (weights only)': 8}

    The resident VRAM for the weights alone is roughly 1.4TB:

    • 141GB-class cards: at least 10 required.
    • 180–192GB-class cards: 8 cards can hold the weights, but each card is left with only tens of GB for KV cache, activations, and framework overhead.

    So the implicit premise behind “8-card minimum” is that each card has first-tier high-memory capacity among current accelerators, not just any 8 accelerators.

    2. Why 1.56TB does not equal the VRAM requirement

    1.56TB is the on-disk file size. Part of it is non-expert parameters such as embeddings, and the resident VRAM at inference time is not exactly the same as the file size; the exact figure depends on actual loading. What really decides whether it “can run” is runtime VRAM allocation, which should be based on measured data from the official inference components.

    3. Long context is the second barrier

    Deploying the full 1-million-token context is not realistic. KV cache grows linearly with context length and concurrency, and can easily reach hundreds of GB without compression. Viable strategies include:

    • Using KV cache quantization to lower per-token footprint;
    • Capping maximum context length and concurrency;
    • Smoothing VRAM peaks through chunked prefill.

    4. Networking and storage

    MoE inference often combines tensor parallelism with expert parallelism: each card holds only a portion of the expert weights, and tokens are routed via All-to-All communication to the cards where the corresponding experts reside.

    • Interconnect: use high-bandwidth inter-card links within a node, and keep single-machine scale as small as possible.
    • Bandwidth: cross-node network bandwidth is usually the main bottleneck for scaling efficiency.
    • Storage: loading 1.56TB of weights is time-consuming each time, so it is best kept on fast local storage, or served by an inference framework that supports streaming loads.
    Deployment option Barrier Advantages Costs
    8-card local self-build High: high-memory accelerators, high-speed interconnect, high-speed storage Data stays inside the network, low marginal call cost, deep customization Large hardware investment, complex ops and scaling
    Cloud GPU instances Medium: choose card count and specs on demand No procurement, elastic scaling, no ops Long-term high-frequency use may cost more than self-build
    Managed API Low: no infrastructure needed Out of the box, elastic Data must leave the domain; bound by service terms and rate quotas

    For most teams, if call volume is not enough to keep GPUs highly utilized, a cloud API is usually the more cost-effective starting point; consider self-building or renting instances only when demand is stable, data is sensitive, and you have the operational capability.

    6. Quantized weights: what 4-bit weights and 8-bit activations mean

    The weights are stored in MXFP4 format and computed in MXFP8 format, and are the product of quantization-aware training (QAT):

    • 4-bit weights: 2.8T parameters need only about 1.4TB of VRAM. Stored in 16-bit float, they would require about 5.6TB, which single-machine multi-card setups basically cannot accommodate.
    • 8-bit activations: activation values participate in computation as 8-bit floats, balancing precision and throughput.
    • Quantization-aware training: simulating quantization error during training usually yields much smaller precision loss than post-training quantization.
    • Only this one format is released: there is no 16-bit or 8-bit float version. To get higher precision, you have to dequantize it yourself. But dequantization cannot recover already-lost information, and VRAM usage also increases several-fold.

    So when choosing this kind of model, default to judging performance by the quantized version, and factor quantization precision, inference backend, and hardware support into your selection evaluation.

    7. Decision checklist

    • License: confirm whether your business’s revenue/MAU touches the additional restrictions; keep a snapshot of the license.
    • Hardware: size by “weights ~1.4TB + KV cache for context and concurrency,” and avoid estimating from parameter count alone.
    • Context: do not chase the full 1-million-token window by default; configure context length and KV quantization as needed.
    • Performance: test first-token latency, throughput, and long-context behavior with real requests, and do not apply vendor numbers directly.
    • Effect: validate with a self-built evaluation set, focusing on real gains in areas where it excels, such as coding and tool-calling.
    • Architecture: design rate limiting, timeouts, and failure fallbacks for image inputs and long-chain agent tasks.

    Bottom line

    This weight release puts three questions on the table:

    • Capability boundary: coding and agents are first-tier; science and some reasoning still lag.
    • License boundary: open weights are not open source, and large-scale external business may trigger the additional terms.
    • Hardware boundary: the 8-card minimum is only the entry ticket; long context and concurrency are the real cost centers.

    Validate business fit on a cloud API first, then decide between self-hosting and the cloud based on call volume, data-compliance requirements, and your team’s operational capability. That is the more prudent path for landing a trillion-parameter-class open-weight model like this one.