Ultra-Large Multimodal Agent Model Open Weights: Deployment Requirements and License Essentials

    This article reviews the released full weights of an ultra-large native multimodal agent model, covering its sparse MoE architecture, 1M-token context, MXFP4/MXFP8 quantization, vendor-reported benchmark results, custom license terms, and local and cloud deployment considerations. It explains why the roughly 2.8T-parameter model needs at least 1.6TB of GPU memory for weights and runtime buffers, why the published benchmark data cannot be directly reproduced, and which commercial license thresholds require separate agreements. Readers get a deployment checklist and a set of license questions to verify before launch.

    1. Model Overview

    An AI research team recently released the full weights of its latest-generation native multimodal agent model. The model has about 2.8T total parameters, and the download size is about 1.56TB. The official release includes only one quantization-aware training version: weights are stored in MXFP4, and activation computation uses MXFP8. No BF16 or FP8 versions are provided.

    The data in this article mainly comes from vendor-published materials, and most of it has not been independently reproduced by third parties. When reading and selecting the model, treat these numbers as information to be verified.

    2. Architecture: Sparse Experts and Long Context

    2.1 Mixture-of-Experts Structure

    The model uses a fine-grained mixture-of-experts (MoE) structure with 896 expert networks. Each token is routed to 16 experts, and 2 shared experts always participate in computation during every inference. The vendor states that activated parameters are about 104B.

    The gap between total parameters and activated parameters indicates that per-inference compute is far below the total weight scale. However, VRAM must hold the weights of all experts, so lower compute does not mean lower hardware requirements.

    The vendor has not disclosed the number of parameters per expert, the size of the shared experts, or whether the vision encoder is counted in the 2.8T. Because these definitions are missing, readers cannot independently verify the source of the 104B figure.

    2.2 Multimodal and Long Context

    The model has 93 layers, supports a 1 million-token context window, and integrates a dedicated vision encoder for native image understanding. Processing a million-level context creates significant compute and VRAM pressure. To address this, the model replaces 24 traditional full-attention layers with sparse attention (DSA).

    With sparse attention, each query computes attention only with a selected subset of historical tokens. This reduces compute and KV cache usage, making very long contexts easier to deploy. Actual effectiveness still needs to be tested with your own long-document tasks.

    2.3 Quantization Precision

    MXFP4 is a micro-scaling 4-bit floating-point format, and MXFP8 is an 8-bit floating-point format. Quantization-aware training (QAT) means simulating low-precision computation during training. Compared with quantizing directly after training, this approach usually preserves more accuracy while compressing size.

    If you plan to run precision comparisons, distillation, or secondary fine-tuning, confirm in advance whether the training framework and inference engine support these formats, and reserve testing time.

    3. Performance: Interpreting Vendor-Reported Data

    The vendor reports high scores in coding and agent benchmarks. Terminal-Bench 4.0 scored 65.7%, and SWE Marathon scored 51.7%. The vendor says these results are close to or exceed a selected closed-source flagship model.

    In science and deep-reasoning benchmarks, the same material shows the model clearly behind. Terminal-Bench-Science scored 38.1%, and HLE-Diamond scored 39.4%. The comparison scores are about 63.3% and 60.9%, respectively.

    The vendor states that across the 37 benchmarks it published, the model exceeds the compared closed-source model on 16. A third-party intelligence index ranks it fourth. However, the material does not provide the leaderboard name, evaluation date, test prompts, or sampling parameters, so these results cannot be directly reproduced.

    For model selection, a simple conclusion is useful: the model is better suited to code generation, tool calling, and multi-step agent tasks, and it is not suitable as the primary model for rigorous scientific reasoning. The most reliable approach is a small-scale evaluation using real tasks from your own business.

    4. License: A Non-Standard Custom Agreement

    The model is labeled as a custom license on hosted platforms. It is not equivalent to standard open-source licenses such as MIT or Apache.

    4.1 Basic Grant

    The basic terms allow users to use, copy, modify, distribute, and fine-tune the model for free, including for commercial purposes. For small and medium businesses and independent developers, this scope is already sufficiently permissive.

    4.2 Two Commercial Restrictions

    On top of the basic grant, the agreement adds two restrictions for large-scale external business:

    • If an enterprise provides model-as-a-service (MaaS) external calls and cumulative revenue over the past 12 months exceeds $20 million, it must sign a separate agreement with the model provider before commercial use.
    • If a commercial product built on the model exceeds 1 million monthly active users, a separate agreement is also required.

    These restrictions show that open weights are not equivalent to unrestricted open source. The provider uses them to prevent large cloud service providers from competing directly at zero cost.

    4.3 Definitions to Confirm

    The original license text determines the final obligations. The following questions need to be checked item by item:

    • Whether revenue is calculated on a consolidated group basis, and whether subsidiaries and affiliates are included.
    • How the 12-month statistical window is defined: rolling calculation or calendar year.
    • Which statistical period and account definition apply to monthly active users.
    • Once a trigger condition occurs, how long the company has to sign, and what happens if it does not sign.

    Have legal staff review the original license at the project-planning stage, not just before launch.

    5. Local Deployment: Estimate VRAM First, Then Choose a Plan

    5.1 Minimum VRAM

    At roughly 4 bits per parameter, the weights of a 2.8T-parameter model occupy about 1.4TB. Adding quantization scaling parameters and unquantized portions brings the download size to 1.56TB, which is broadly consistent with the official data.

    This leads to a clear conclusion: 8 GPUs with 80GB each total 640GB and cannot hold the full weights. Even 16 GPUs with 80GB each, totaling 1,280GB, are still insufficient. At 80GB per GPU, the weights alone require about 20 GPUs. Adding KV cache, activation buffers, and communication overhead means actual planning should start above 1.6TB.

    This estimate assumes 0.5 bytes per parameter and excludes KV cache, activation buffers, framework overhead, and fragmentation. Actual requirements will be higher.

    5.2 Feasible Hardware Paths

    • Multi-node, multi-GPU: at least three 8-GPU servers, or 24 80GB GPUs or equivalent high-memory accelerators, interconnected by a high-bandwidth network.
    • High-memory single cards: choose accelerators with larger memory to reduce the number of nodes, but confirm whether per-card memory and total capacity meet the minimum above.
    • Memory or disk offload: some weights can be placed in CPU memory or on local NVMe, but inference latency will rise significantly. This is suitable only for offline batch processing or functional validation.

    5.3 Minimum Checklist

    • VRAM: plan for more than 1.6TB for full weights plus KV cache and activation buffers.
    • Host memory: must be able to fully handle sharded data during loading and leave headroom.
    • Disk: download, checksum, and decompression require about 1.56TB or more; reserving 2TB is recommended.
    • Network: cross-node expert communication is sensitive to latency and bandwidth; prefer high-speed networks such as InfiniBand or RoCE.

    5.4 Inference Frameworks and Startup Example

    Whether the official release supports a given inference framework, which version is required, and whether MXFP4 is supported should be based on the model card and framework release notes. When choosing, prioritize inference engines that support MoE, tensor parallelism, expert parallelism, and pipeline parallelism, such as newer versions of vLLM or SGLang.

    Below is a structural example. Parameters need to be adjusted according to the model card and the version you use:

    1. vllm serve <local-model-path> \
    2. --tensor-parallel-size 8 \
    3. --pipeline-parallel-size 3 \
    4. --max-model-len 131072 \
    5. --gpu-memory-utilization 0.90

    First set max-model-len to a smaller value to complete startup, then increase it gradually. Opening the full 1 million context directly usually exhausts VRAM at startup or on the first request.

    5.5 Common Troubleshooting

    • Out of memory during loading: confirm whether total VRAM exceeds the weight lower bound, and reduce max-model-len or concurrency.
    • Weight loading failure: check file checksums, confirm the download is complete, and verify that the disk has enough space for decompression.
    • Long-text requests crash midway: check the KV cache configuration and lower the maximum context or concurrency limit.
    • Throughput lower than expected: check whether expert load is balanced, observe cross-node communication time, and adjust the parallelism strategy if necessary.
    • Abnormal output quality: confirm that the inference engine correctly recognizes MXFP4 and MXFP8, and compare the same batch of samples with the official reference implementation.

    5.6 Cloud Deployment Tradeoffs

    Building a multi-node GPU cluster in-house carries high procurement, data center, and operations costs. For teams with unstable compute demand, consider GPU instances from mainstream cloud providers or a self-managed hosting platform, renting multi-GPU environments on demand.

    Cloud deployment requires attention to three things. First, where weight files are stored and how fast they can be pulled; object storage can be used to manage weight versions. Second, logs and monitoring for the inference service should cover VRAM usage, queue length, and time to first token. Third, cost estimates should include storage, network egress, and idle instance costs.

    6. Conclusion

    The model performs strongly on coding and agent tasks, and its sparse attention and quantization training approach are worth learning from. However, it has high hardware requirements, and the license terms explicitly restrict large-scale commercial use.

    For individuals or small teams without multi-node GPU resources, local operation is not realistic. They can first validate the model by renting on demand in the cloud. For scenarios with high scientific reasoning requirements, evaluate the model with your own data first. Before official launch, be sure to read the original license and confirm the definitions of the two commercial restrictions.