2.8T-Parameter Open-Weight Model: What 1.56TB of Weights and the 8-GPU Deployment Floor Actually Mean

    A Chinese AI team has released the full weights of its 2.8-trillion-parameter flagship model — roughly 1.56TB in total, making it one of the largest open-weight releases to date. This article unpacks what that release actually delivers: what is packed into the weights (a sparse MoE with 104B active parameters, native multimodality, and a 1M-token context), how to read the vendor-reported and third-party benchmark results, why a custom license with revenue and user-scale thresholds is not the same as a standard open-source license, and how the 8-GPU deployment floor is derived from memory and bandwidth constraints. It closes with three practical deployment paths — hosted API, rented cloud GPUs, and a self-built cluster — to help individual developers and enterprises decide how to adopt models at this scale.

    1. Introduction: From “a promise to open up” to “reusing the weights”

    Since 2024, most flagship models at the trillion-parameter scale have been offered only through APIs. Over the past two years, that pattern has begun to loosen. On November 4, 2025, a Chinese AI team released the complete weights of its flagship model, as it had previously promised. According to public reports, the weights total roughly 1.56TB, making them among the largest openly released weights to date, and many view them as a new ceiling for open-model capability.

    The release also raised questions:

    • Deploying 1.56TB of weights locally requires at least 8 accelerators to start.
    • The repository carries the team’s custom license, which hosting platforms classify as an “other” license rather than a standard open-source license like MIT or Apache 2.0.

    So what does “open weights” actually mean, does the “open source” label hold up, and can everyday developers and enterprises afford to use it? All of this needs to be unpacked. The sections below approach it from four angles: what is inside the weights, how to read the scores, how to interpret the license, and how high the deployment bar really is.

    2. Reusing the weights: open source vs. open weights

    Under the definition the open-source community has long used, something that is “open source” should at minimum meet these conditions:

    • Freely usable for any purpose;
    • Source code available;
    • Modification and derivative works allowed;
    • No discriminatory field-of-use restrictions;
    • The license must not restrict use based on distribution method or the type of software it is attached to.

    For a model, “open weights” means the trained parameters can be downloaded, loaded, and used for inference, and some also allow fine-tuning. “Open source” goes further, requiring the training code, the training data (or a reproducible data-construction pipeline), and the recipe needed to reproduce the experiments.

    The two have different capability boundaries:

    • Open weights let users “run it and modify it,” for example domain fine-tuning or quantization/distillation.
    • Open source lets users “inspect it and reproduce it,” meaning they can review the training process and independently reproduce the results.

    Many “other”-category custom licenses have permissive commercial terms but add conditions tied to revenue, user scale, and so on, so they cannot be recognized as standard open-source licenses. Equating “open weights” directly with “open source” both overstates the freedom involved and can plant risk during enterprise compliance reviews.

    3. Inside the model: the “total” and the “active” in 2.8T parameters

    3.1 Scale and architecture

    According to the model card, the model is positioned as a natively multimodal agent model, continued from training on the previous generation:

    • 2.8T total parameters, with only 104B activated per token;
    • A mixture-of-experts (MoE) architecture: 896 experts in total, each token routed to 16 of them, plus 2 shared experts that are always active;
    • 93 Transformer layers, with a 1-million-token context window;
    • A proprietary vision encoder that can directly understand image inputs.

    Compute sparsity: 104B÷2.8T≈3.7%. In other words, for each token generated, the model “lights up” less than 4% of its total parameters.

    3.2 What changed from the previous generation: a single structural change

    Compared with the previous generation, the new model made only one structural change: it replaced full attention with sparse attention (DSA) in 24 of the layers. This is an optimization specifically for long context.

    Full attention’s compute and memory cost grows quadratically with sequence length. Once the context gets long, attention becomes the main bottleneck. Sparse attention lets each query attend to a carefully selected subset of KV entries, substantially reducing compute in long-document and long-conversation scenarios. Some research also suggests that such sparse patterns carry a risk of “attention collapse,” where attention over-concentrates on a few tokens and quality may fall short of full attention. So a 1-million-token context still needs to be validated against specific tasks rather than taken at face value from the headline number.

    3.3 Precision: MXFP4 weights + MXFP8 activations

    Weights are quantized to 4-bit floating point (MXFP4) and activations to 8-bit floating point (MXFP8), a product of quantization-aware training (QAT) — that is, simulating the numerical error introduced by quantization during training so the model “adapts” to lower precision in advance.

    Low precision has two direct consequences:

    • At the same parameter scale, the weight size is about half that of BF16, which is what makes the 1.56TB figure possible. Stored in BF16, the weights alone would be about 5.6TB.
    • Everyday inference requires almost no extra quantization; you can deploy as soon as you have the weights.

    But the team offers only this one version, with no BF16 or FP8 variant. On one hand, scenarios that demand higher precision (such as numerically sensitive scientific computing and evaluations) can only attempt dequantization themselves, and dequantization cannot recover information already lost. On the other hand, low-bit formats place higher demands on operator support in inference engines and on hardware instructions in accelerators, so you should confirm your software and hardware stack fully supports them before deployment.

    4. How to read the scores: vendor-reported, third-party index, and community reproduction

    4.1 The vendor’s self-reported benchmark results

    The model team published results on 37 benchmarks, 16 of which exceed same-generation leading closed models. The distribution of strengths and weaknesses is clear:

    • Leading or on par on coding and agent tasks: 65.7% on a terminal-task benchmark, slightly below the competitor’s 66.4%; 51.7% on a long-horizon engineering benchmark, above the competitor’s 46.3%.
    • Clearly behind on science and some reasoning tasks: 38.1% on a science terminal-task benchmark versus the competitor’s 63.3%; 39.4% on a multi-discipline graduate-level Q&A benchmark versus 60.9%.

    A third-party intelligence index scored it 55, placing it among the global leaders. Overall the results are a mixed win-loss, not a clean sweep.

    4.2 Three principles for reading the table

    First, distinguish self-reported from reproduced. Vendor-reported numbers are usually carefully tuned, and settings such as prompts, sampling temperature, and number of execution turns may not match those of competitors. The advantage of open weights is that results can be re-tested by third parties, so selection should rely on independent evaluations.

    Second, look at “active parameters,” not just “total parameters.” A MoE model’s actual compute consumption is closer to its active-parameter size. For example, a certain 700B-class open model activates 37B, and a certain 200B-class model activates about 21B; looking only at total parameters easily leads to misjudging cost and speed.

    Third, look at task distribution, not the aggregate score. A composite intelligence index masks capability gaps. If the business is mainly code generation and automated workflows, this model is worth shortlisting; if it involves scientific reasoning or knowledge-intensive Q&A, you need to carefully assess whether its weakness in those dimensions affects delivery quality.

    5. The license: open weights ≠ open source

    5.1 License structure

    The repository carries the team’s custom license, labeled “other” on the hosting platform rather than a standard open-source license like MIT or Apache 2.0. Comparing it line by line against the previous generation’s license text, you find the content is word-for-word identical — only the name changed. Its structure can be summarized as “a standard permissive license + two scale thresholds”:

    • Core grant: Free use, copying, modification, distribution, fine-tuning, and commercial use are allowed, consistent with a MIT-style permissive license.
    • Restriction 1 (external service): Enterprises offering “model-as-a-service” externally whose cumulative revenue over the past 12 months exceeds USD 20 million must sign a separate agreement with the model team before commercial use.
    • Restriction 2 (user scale): Once a commercial product’s monthly active users reach a certain scale, a separate arrangement is likewise required. The original text is truncated on this point, so before commercial use, refer to the full license text in the repository.

    5.2 Impact on different users

    A snippet of illustrative code makes the decision logic more concrete:

    1. LICENSE_REVENUE_LIMIT = 20_000_000 # Model-as-a-service, 12-month cumulative revenue cap (USD)
    2. def need_separate_agreement(product) -> bool:
    3. """Determine whether the license's separate-agreement condition is triggered."""
    4. if product.kind == "model_as_a_service":
    5. return product.revenue_last_12m > LICENSE_REVENUE_LIMIT
    6. if product.kind == "commercial_product":
    7. return product.monthly_active_users > product.LICENSE_MAU_LIMIT
    8. return False
    • Individual developers and most SMBs: Everyday fine-tuning, internal tools, and small-scale commercial products are largely unaffected.
    • Large cloud providers and model-as-a-service providers: Once external revenue crosses the threshold, legal review is required.
    • Super-apps with large MAU: These need to evaluate the licensing path in advance.
    • Buyers: If an upstream supplier is itself bound by the terms, an enterprise as a downstream user needs to confirm the licensing chain is complete.

    This “permissive license + scale threshold” approach is not unique. In recent years, several large-parameter model families have adopted similar thinking: encouraging broad adoption and secondary development while preserving room to negotiate over large-scale commercialization.

    For compliance, three recommendations:

    1. Rely on the full license text in the repository, not second-hand interpretations.
    2. Sort out your product form, revenue definition, and MAU counting method to determine which side you fall on.
    3. Keep compliance records. If the license changes with version upgrades, there should be a documented basis for past usage.

    6. The deployment floor: how “8 GPUs to start” is calculated

    6.1 The memory bill: weights alone consume most of the VRAM

    The publicly reported “8 GPUs to start” typically corresponds to accelerators with 192GB per card and about 1.5TB across 8 cards. We estimate weight bytes with “parameter count in bits × bits per parameter ÷ 8”:

    • BF16: 2.8T×16÷8≈5.6TB
    • FP8: 2.8T×8÷8=2.8TB
    • MXFP4: 2.8T×4÷8≈1.4TB

    Adding quantization scaling factors and metadata, the actual ~1.56TB matches the theoretical MXFP4 value closely. Working backward, each card in an 8-card setup carries about 195GB of weights.

    But memory is not just weights. Taking a 1-million-token context as an example, you can roughly estimate with the formula below:

    1. KV memory per token ≈ 2 (K and V) × num_layers × num_kv_heads × head_dim × bytes_per_element
    2. Total KV memory ≈ KV memory per token × context length

    Plugging in 93 layers, even with grouped-query attention and KV stored in FP8, each token per layer needs only a few KB, but the KV cache for a 1-million-token context still reaches tens of GB. An 8-card setup has very little headroom after loading the weights. The good news is that sparse attention itself also reduces the KV pressure from long context.

    You also need to reserve memory for:

    • The inference engine’s own overhead;
    • Activations;
    • Extra space for optimizations such as CUDA graph capture;
    • Memory fragmentation.

    So “8 GPUs to start” is better understood as a theoretical lower bound for “it fits,” not the recommended value for production deployment.

    6.2 The bandwidth bill: decode speed is bound by memory bandwidth

    When a MoE model decodes token by token, arithmetic intensity is very low, so speed depends mainly on memory bandwidth. A rough estimate: single-card bandwidth at 3TB/s, 8 cards at 24TB/s combined; with INT8 activations and weights dequantized from MXFP4 for compute, reading all the weights once takes about 1.56TB÷24TB/s≈65 microseconds, which works out to roughly 15,000 tokens/s.

    Translating that into real-world throughput, this is roughly the shared output ceiling for around a hundred concurrent users on an 8-card cluster. And this is a theoretical value that ignores communication overhead; the real number will be noticeably lower.

    MoE also has an unavoidable cost: token routing. When experts are split across different cards, each token’s request must first be routed between cards (typically via all-to-all communication), then computed by the corresponding expert, then gathered back. The lower the inter-card bandwidth and the more cross-node it spans, the larger this overhead share. This is exactly why the team sets the bar at 8-GPU-class high-bandwidth-interconnect machines rather than a bunch of ordinary accelerators stitched together.

    6.3 An engineering checklist

    • Hardware support: Confirm whether the accelerators natively support MXFP4/MXFP8 and have the corresponding data-type conversion instructions.
    • Inference framework: Choose an inference engine with mature support for this quantization format and MoE routing; mainstream frameworks usually read the quantization config in the weights and handle dequantization automatically.
    • Parallelism strategy: An 8-card single machine can combine tensor parallelism and expert parallelism, so each card holds only some of the experts and results are merged with all-reduce. Beyond a single machine, you need pipeline parallelism and must weigh the extra communication overhead.
    • Weight distribution: Transferring and verifying 1.56TB is itself an engineering problem. Store the weights centrally in shared or object storage with verification enabled, and distribute via shared-storage mounts or container-image-layer caching across nodes, so each node does not re-download.
    • Context strategy: Do not default to the full 1 million tokens. First run load tests at the lengths your business actually needs to locate the memory and latency inflection points.
    • Private fine-tuning: The merged expert weights are huge, and conventional full-parameter fine-tuning is extremely costly; in practice, parameter-efficient methods such as low-rank adaptation (LoRA) are more commonly used.

    7. How individuals and enterprises should choose: three viable paths

    • Path A: Hosted API or managed inference. Suited to individual developers, startups, and businesses with high, spiky demand. No accelerators to own; pay per token, and the provider handles model upgrades. But watch three things: data compliance (whether sensitive data can leave your environment); licensing (businesses sensitive to revenue or user scale should confirm in advance); and data and request retention policies.
    • Path B: Rent cloud accelerators on demand and self-deploy. Suited to teams with some operations capability that need private deployment or a customized inference stack. Request GPU resources on demand, run the inference service in containers, keep weights in shared or object storage, and track memory, latency, and throughput with logging and monitoring. The trade-off is that instance size, inter-card interconnect, and quantization-format support all need to be confirmed item by item.
    • Path C: Build a local cluster. Suited to large organizations with hard requirements for data isolation and long-term stable usage. The focus is cluster scale and license compliance: the memory floor determines the starting configuration, and inter-card interconnect determines the ceiling; at the same time, you must confirm whether your revenue or user scale triggers the additional terms.

    If you tally the total cost, taking an 8-card machine as an example and roughly estimating at current mainstream accelerator rental prices, the GPUs alone can cost roughly a dozen to several dozen yuan per hour; even estimating 300 hours per machine per month, the base monthly cost falls in the range of thousands to over ten thousand yuan. Adding storage, network, and labor, the cost of building your own over the long term rises further. By comparison, teams with medium- and low-frequency usage usually find pay-as-you-go cloud paths more economical.

    Domestic cloud providers are also accelerating support for ultra-large-scale open-weight models. Baidu AI Cloud, for instance, can offer enterprises multiple deployment options for hosting such models by leveraging general cloud capabilities such as GPU cloud servers, container services, object storage, and logging and monitoring, together with inference-acceleration techniques like low-bit computing and PD (prefill/decode) separation. The specific instance specs available and the model support scope should be based on what the platform actually offers.

    8. Conclusion: the capability ceiling has risen, and so has the bar to use it

    This weight release shows at least three things:

    • On capability: 2.8T total parameters, 104B active, native multimodality, and a 1-million-token context push the open-model capability ceiling to a new position, with coding and agent tasks as its strengths.
    • On engineering: MXFP4 quantization compresses the size to 1.56TB, but the 8-GPU floor and memory-bandwidth constraints keep it far from an ordinary workstation. On-demand cloud usage remains the more realistic choice for most teams.
    • On compliance: “Open weights” does not equal “open source.” The scale thresholds under a custom license need to be assessed in advance; only after completing a license review and independent re-testing can you confidently move into production.

    For developers, the more rational approach is not to chase parameter scale, but to clarify your business’s capability gaps and cost budget, and then choose between open-weight models and cloud services accordingly.