Open-Weight Trillion-Parameter Models: License Boundaries and Compute Requirements
This article examines a 1.56TB open-weight multimodal agentic model with 2.8T total parameters and 104B activated parameters per token. It breaks down the model’s architecture, quantization format, license restrictions, memory and bandwidth requirements for local inference, and provides a practical deployment checklist for teams evaluating large open-weight models.
Introduction: The Real Work Begins After the Weights Land
On October 24, 2025, a leading LLM team released a flagship agentic model that was initially available only as an online service. The team also committed to releasing the full weights by November 4, 2025. On November 4, the weights appeared on major model-hosting platforms and could be downloaded publicly without an application. The package contained 112 files across 96 shards and totaled about 1.56 TB, making it the largest publicly downloadable open-weight model at the time.
The initial discussion focused heavily on benchmark scores. The questions that matter more for engineering decisions appear only after the weights are released:
- What is actually inside the weights?
- Can the license be used, and how?
- How much compute is required locally?
- How should vendor-reported evaluation results be interpreted?
This article neutralizes these specifications, numbers, and license terms and does not point to any specific product.
1. What Is Inside the Weights: Architecture and Specifications
According to the official model card, the model is a native multimodal agentic model, continued from the previous generation. Its core specifications are:
- Total parameters: 2.8T, with only 104B activated per token; this is a sparse mixture-of-experts (MoE) architecture.
- 896 routed experts; each token selects 16, with an additional 2 always-on shared experts.
- 93 layers and a 1 million-token context window.
- A ViT-style visual encoder provides image understanding capabilities.
The activation ratio is about 3.7%, meaning per-token compute is far smaller than the parameter count. This is the fundamental reason a trillion-parameter model can still be practical for inference.
Compared with the previous generation, only one structural change was made: 24 full-attention layers were replaced with sparse attention (DSA) to reduce long-context compute overhead.
The weights themselves are the product of quantization-aware training (QAT): weights are stored as 4-bit microscaling FP4, and activations are computed in 8-bit microscaling FP8. The official release includes only this version; no BF16 or original FP8 weights are provided.
A useful way to understand this generation is:
- Parameter count is “capacity,” determining how much knowledge the model can retain.
- Activated parameters are “compute,” determining the cost of processing each token.
- The quantization format is “size and accuracy,” determining how much can be deployed and how much output quality is lost.
The combination of these three factors determines what use cases the model is suited for.
2. How to Read the Official Results: Vendor-Reported and Third-Party References
The following are vendor-reported comparison data, benchmarked against another overseas flagship closed-source model and an internationally mainstream reasoning model.
| Benchmark | This model | Overseas flagship closed-source Model A | International reasoning Model B | Interpretation |
|---|---|---|---|---|
| Coding task, terminal interaction | 65.7% | 66.4% | 58.2% | Roughly on par with A and ahead of B |
| Software engineering task, long-horizon | 51.7% | 46.3% | Not listed | Ahead of A |
| Science task | 38.1% | 63.3% | Not listed | Clearly behind A |
| High-difficulty knowledge reasoning | 39.4% | 60.9% | Not listed | Clearly behind A |
The vendor claims that the model outperforms Model A on 16 out of 37 benchmarks. A line-by-line comparison shows the following pattern:
- The results are mixed, not a broad lead.
- Strengths are concentrated in coding and agentic tasks.
- Scientific reasoning and some high-difficulty reasoning remain weak areas.
Another third-party independent evaluation platform assigned the model an intelligence index score of 55, placing it fourth globally.
Three points should be noted when reading such tables:
- Scope: Vendor-reported and third-party retests often differ in prompts, sampling frequency, and scoring scripts, so scores should not be compared directly across sources.
- Scenario: Terminal interaction and long-horizon software engineering tasks naturally favor models that are strong at tool invocation.
- Source: Cross-model comparisons have limited reference value. Businesses should validate models using private evaluation sets built from their own real tasks.
3. License Terms: Broad in the Main, with Two High Bars
The weights are released under a custom license. On the hosting platform, this is labeled license: other, meaning it is not a standard open-source license certified by an open-source governance organization, such as MIT or Apache. A more accurate description is “open weights” rather than “open source” in the strict sense.
“Open weights” also has no universal definition. By common industry interpretation, releasing model weights without training data and complete training code is only partial openness.
The main license uses MIT-style grants: the model can be used, copied, modified, distributed, fine-tuned, and used commercially free of charge. On top of these MIT-style terms, the license adds two obligations that apply to large-scale external business. The thresholds below are hypothetical examples; the official license text remains authoritative:
- Agreement obligation: If the model is commercialized through model-as-a-service (MaaS) and cumulative revenue exceeds $20 million over any continuous 12-month period, a separate agreement with the model provider is required before commercial use.
- Attribution obligation: Commercial products with more than 100 million monthly active users or more than $20 million in monthly revenue must display the model name prominently in the product interface.
Given the wording of the MIT-style terms and the same clauses in the previous generation, these two obligations are effectively whitelist-style obligations:
- Under the default license, an entity whose revenue reaches the signing threshold is instead not permitted to commercialize directly under MIT terms.
- The attribution obligation is not conditional on revenue; a free product with 100 million monthly active users is also subject to it, making its scope broader.
Implications for enterprises:
- Internal tools, team-level agents, and products below the revenue or user thresholds carry relatively low license risk.
- Once thresholds are reached, legal review should be completed before launch, including an assessment of revenue measurement scope and agreement timelines.
- Attribution is an ongoing requirement, and product redesigns must preserve the placement for attribution.
- Downstream redistribution, secondary fine-tuning, and integration as a component in commercial products are also subject to the two obligations.
- If license terms need to be more predictable, models under standard open-source licenses should be considered first.
4. Can It Run Locally: Memory, Bandwidth, and Concurrency
1. Capacity: Can 8 Cards Hold It?
Splitting 1.56 TB evenly across 8 cards gives about 195 GB per card. With runtime overhead, an 8-card setup is only barely feasible capacity-wise and leaves almost no headroom.
Converted to mainstream accelerator configurations:
- 141 GB per card: 8 cards total about 1.13 TB, clearly insufficient.
- 192 GB per card: 8 cards total about 1.54 TB, less than the weights themselves, so offloading is required.
- 288 GB per card: 8 cards total about 2.3 TB, leaving room for headroom.
If you have one of the first two configurations, there are three possible routes:
- Add more cards.
- Offload some weights to CPU memory or local high-speed storage, at the cost of higher latency.
- Further compress the weights if quality remains acceptable.
2. Compute: Why Decode Is Limited by Memory Bandwidth
Only about 104B parameters actually participate in computation per token. At roughly 0.5 bytes per parameter in FP4, generating one token requires reading about 52 GB of weights.
In single-request autoregressive decoding, accelerator compute is heavily underutilized, and speed is primarily constrained by memory bandwidth. The following is an idealized estimate:
# Theoretical upper bound for single-stream decoding speed: for estimation only; actual performance varies by framework, parallelism, and batch sizeWEIGHT_READ_GB = 52.0 # 104B activated parameters × 0.5 bytes per parameterBW_PER_CARD_TBPS = 3.35 # per-card memory bandwidth; replace with the actual accelerator specificationN_CARDS = 8upper_bound = N_CARDS * BW_PER_CARD_TBPS * 1000 / WEIGHT_READ_GBprint(f"Theoretical upper bound for single-stream speed: {upper_bound:.0f} tokens/s")# Output: Theoretical upper bound for single-stream speed: 515 tokens/s# Long-context KV cache (assumed: 8 heads each for K and V, head dimension 128, 1 byte per element)kv_per_token = 2 * 93 * 8 * 128 # 2 × layers × heads × head dimensionprint(f"KV cache per million tokens: {kv_per_token * 1_000_000 / 1024**3:.0f} GiB")# Output: KV cache per million tokens: 177 GiB
The engineering implications are:
- Sparse activation makes decoding more bandwidth-dependent than compute-dependent, so the key to improving throughput is higher batch concurrency, allowing one weight read to serve multiple requests.
- Sparse attention (DSA) directly reduces long-context cache overhead. The estimate above assumes a conventional KV structure for full attention; actual deployment should refer to the KV structure details published by the vendor.
- A 1M-token context is an upper limit, not an economically optimal operating range. Long context and concurrent throughput must be traded off.
3. Low Precision Only: The Tradeoff of Publishing a Single Weight Format
Publishing only the QAT FP4 version has clear benefits:
- Its size is about 28% of the same-scale BF16 weights, which are about 5.6 TB, bringing a trillion-parameter model into the “locally deployable” range.
- Quantization error is incorporated during training, so accuracy is usually better than with post-training quantization.
- It eliminates the need to perform in-house quantization.
However, the costs should also be recognized:
- Limited fine-tuning space: Low-bit weights are difficult to support full-parameter fine-tuning directly, and usually rely on low-rank adaptation and accept some accuracy loss.
- Higher hardware requirements: Low-precision weights require corresponding low-precision compute support and matching operators; many accelerators and inference runtimes that only support BF16/FP16 cannot load them directly.
- Accuracy ceiling: The upper limit is constrained by the native format.
- Retrospective comparison: For backward-compatible comparisons, only the low-precision version can be used as the baseline.
4. Memory and Card Count Reference
The table below provides an illustrative estimate. It does not include activations, communication buffers, framework overhead, or framework-reserved memory. Actual deployment should be based on load testing.
| Memory per card | Can 8 cards hold 1.56 TB of weights? | Headroom for long context and concurrency | Suitable scenarios |
|---|---|---|---|
| 141 GB | No | Requires more cards or offloading | Not suitable |
| 192 GB | About 20 GB short; offloading required | Very limited | Short context, single concurrency |
| 288 GB | Yes, with about 740 GB remaining | Relatively sufficient | Long context, medium concurrency |
5. Deployment Path and Pre-Launch Checklist
Deployment Path
- Selection: Determine requirements based on the business scenario, such as coding agents, long-document understanding, multimodality, or scientific reasoning.
- Download: Obtain from official channels, then verify file hashes and shard integrity.
- Hardware: Check machine configuration against both memory capacity and memory bandwidth.
- License: Complete legal review and compliance archiving in advance.
If enterprises use public cloud, they can rely on mature cloud platforms and their AI infrastructure services. Model-weight distribution and storage, containerized scheduling for distributed inference, and service-quality monitoring all have standard service categories and do not require building a private data center.
Pre-Launch Checklist
- Estimate memory capacity (weights + KV cache + runtime overhead) using peak concurrency rather than average concurrency.
- Confirm that accelerators support the low-precision weight format and its matching operators.
- Confirm the KV cache structure and long-context capability, and set a context limit and truncation policy.
- Build a private evaluation set, with emphasis on relatively strong areas such as coding and agents, as well as weaknesses such as scientific reasoning.
- Compare the revenue definition against the license terms, and assess the agreement timeline and where attribution should be implemented.
- Prepare version-upgrade and retirement plans (the official release has only a single precision version, so there is no fallback to an original version).
Conclusion
The significance of this weight release is not simply the scale of the numbers. It lays both capability boundaries and usage boundaries out for everyone to see.
- Capability boundary: The model is competitive with top closed-source models in some coding and agentic tasks, while clearly trailing in scientific reasoning.
- Usage boundary: The custom license preserves MIT-like freedom, while adding signing and attribution thresholds for large-scale commercial use.
For developers, the real cost is not only hardware. Memory, bandwidth, long-context caching, fine-tuning space under low precision, and license terms together determine the scale, scenario, and mode in which this model can enter production.
