2.8T Open-Weight Model: Licensing Rules and 8-GPU Deployment Requirements Explained
A massive open-weight MoE model with 2.8T total parameters (about 1.56TB of weights) is now available for download, with an 8-GPU minimum for local deployment. This article breaks down its sparse architecture, MXFP4 quantization, storage and loading requirements, memory math for the 8-GPU baseline, licensing restrictions, benchmark results, and a practical rollout plan. Key takeaway: open weights are not open source, and deployment cost, communication bottlenecks, and compliance boundaries all need to be evaluated together.
A massive open-weight model with 2.8T total parameters has recently become available for download. The weights total roughly 1.56TB, and the official minimum for local deployment is 8 GPUs. The technical significance of this release goes beyond “more parameters”: it puts the architecture of an ultra-large sparse model, its quantization format, its deployment requirements, and its licensing boundaries in front of developers all at once.
One conclusion should be stated up front: open weights do not mean open source. The model ships downloadable, modifiable, fine-tunable, and commercially usable weights, but with custom license restrictions. It also provides only a quantization-aware trained weight version, with no additional high-precision variant. Evaluating a model like this means looking beyond parameter count at architecture, memory, communication, long-context costs, and compliance conditions.
1. Architecture: 2.8T Total Parameters, but Only 104B Active per Token
The model uses a sparse MoE architecture: 2.8T total parameters, with only 104B activated per token during inference. It includes 896 experts, selecting 16 per token plus 2 shared experts, spans 93 layers, supports a 1M-token context length, and includes a vision encoder, making it a natively multimodal agent-oriented model. Compared with the previous generation, one key change is that full attention is replaced with sparse attention in 24 layers to reduce compute overhead in long-context scenarios.
These numbers need to be read separately. Total parameters determine weight storage size; active parameters determine per-token compute; expert count and routing strategy determine communication and load-balancing complexity. With 896 experts and 16 selected per token, expert parallelism and All-to-All communication become critical bottlenecks during inference. If interconnect bandwidth between GPUs is insufficient, throughput can be dragged down by communication even when compute is adequate. The shared experts carry general capabilities, reducing quality loss caused by routing variance.
The weights are in MXFP4 format with MXFP8 activations, the product of quantization-aware training. The benefit is a significant reduction in weight storage and bandwidth pressure; the cost is that the inference stack must support these low-precision formats natively. Otherwise, conversion is required, which can add storage overhead, precision loss, or engineering complexity. For local deployment, the first step is not buying GPUs — it’s confirming that your inference framework, operator libraries, and parallelism strategy fully support the quantization format.
2. Handling the Weights: 1.56TB Is a Sharding Exercise, Not a Single File
The public weights total about 1.56TB, distributed across 112 files and 96 weight shards. Downloading, verifying, storing, and loading them is an engineering problem in itself. The 1.56TB is raw weights only; deployment also requires additional space for download caches, hash verification, format conversion, logs, and temporary files. Fine-tuning requires reserving space for optimizer states and training data caches. Plan for at least double the available storage, and place the weights on high-throughput local disks or high-performance shared storage to avoid random-read amplification on network storage.
Perform integrity checks before loading: record hashes per shard, verify file counts and sizes, and confirm all shards are present. Load in a streaming fashion by layer or expert shard to avoid memory spikes from pulling in all files at once. For multi-node deployments, weight distribution should support resumable transfers and parallel fetching, or the 1.56TB cold start becomes an operational bottleneck.
3. What “8-GPU Minimum” Actually Means: Raw Weights Are Only the Floor
Dividing 1.56TB across 8 GPUs gives roughly 195–200GB of weights per card — before accounting for activations, KV cache, communication buffers, framework overhead, and the extra memory demanded by long contexts. Here’s a rough calculation:
weights_tb = 1.56cards = 8per_card_weight_gb = weights_tb * 1024 / cards # ~200GB, weights onlyreserve_ratio = 0.25required_per_card_gb = per_card_weight_gb / (1 - reserve_ratio)
The takeaway: if per-GPU available memory is below the raw weight share, loading fails entirely; even if it just barely covers the weights, runtime headroom is still mandatory. The 1M-token context significantly increases KV cache pressure, and long contexts, high concurrency, and multimodal inputs all push memory and bandwidth requirements further up. So “8 GPUs minimum” should be read as the lowest configuration, suitable for short-context, low-concurrency validation. Production environments should scale up GPU counts based on context length, concurrency, expert-parallel communication, and SLA targets, or adopt tiered offloading, expert sharding, and high-speed cross-node interconnects.
4. Licensing: Commercial Use Allowed, With Trigger Conditions
The model uses a custom license, not a standard permissive open-source license. The core grant covers free use, copying, modification, distribution, fine-tuning, and commercial use, but with two restrictions aimed mainly at large-scale external services. First, companies offering the model as a service with trailing 12-month revenue exceeding $20 million must sign a separate agreement with the publisher before commercial use. Second, when a commercial product’s monthly active users reach the license threshold, the license terms also apply. The specific threshold for the second condition must be taken from the license text itself — companies should not rely on secondhand information.
Compliance evaluation can be abstracted as:
if service_is_model_as_a_service and revenue_12m > 20_000_000:require_custom_agreement()if commercial_product_mau > license_threshold:require_custom_agreement()
This means internal use, research validation, small-scale commercial use, and large-scale external services each face different compliance paths. Legal, business, and architecture teams should jointly confirm: whether the model is offered as a service, how revenue is calculated, how MAU is defined, and whether redistribution is involved. Open weights lower the barrier to access, but they do not eliminate licensing risk.
5. Capability Assessment: Strong at Coding and Agentic Tasks, Not Across the Board
According to the vendor’s self-reported 37 benchmarks, the model leads a closed-source comparison model on 16 of them — an overall mixed result. It performs strongly on terminal coding, long-horizon software engineering tasks, and agentic workloads, but is relatively weaker on scientific terminal tasks and high-difficulty reasoning. A third-party comprehensive evaluation gives it 55 points, ranking fourth globally. Treat these numbers with technical caution: vendor-reported results depend on prompts, tool calling, and evaluation configurations, and cannot be taken directly as production performance. Developers should build small offline evaluation sets around their own tasks, focusing on tool-calling success rates, long-context retrieval, code-edit correctness, multimodal understanding, and refusal rates.
6. Rollout Recommendation: Validate First, Then Scale
A four-step approach is recommended. First, validate capabilities through the online API or small-scale inference to confirm business value. Second, account for storage, download, verification, and cold-start costs. Third, establish a short-context baseline on an 8-GPU setup, monitoring memory, throughput, latency, and expert-parallel communication. Fourth, gradually increase context length and concurrency, evaluating KV cache and All-to-All bottlenecks. Production environments should also establish weight version management, license compliance records, input/output safety filtering, and monitoring with alerting. Only by weighing model architecture, deployment cost, and licensing boundaries together can open weights translate into controllable technical capability.
