2.8T-Parameter Open-Weight Model Released: 1.56TB Checkpoint Requires at Least 8 GPUs for Local Deployment

    This article examines the public release of a 2.8T-parameter open-weight multimodal agent model with a roughly 1.56TB MXFP4 checkpoint. It breaks down the model’s sparse MoE architecture, long-context attention design, low-bit precision, vendor-reported benchmarks, custom license restrictions, hardware requirements, and practical deployment options, including hosted APIs, private cloud deployment, and self-managed infrastructure.

    From Release Promise to Actual Availability

    On October 24, an AI vendor released a multimodal agent model with API and web access. At the same time, the vendor promised to release the full model weights by November 4.

    The weight repository was created in an open-source community on November 2. On the morning of November 4, it was still closed. Later that evening, the repository was officially opened to the public without requiring an application.

    The actual release on November 4 included the following details:

    • Release size: The repository contains 112 files, including 96 sharded weight files. Together, they amount to approximately 1.56TB. No previously released open-weight model had come close to this size.
    • Access channel: The weights are available through public open-source communities.
    • Version availability: Only this single precision version is provided. There is no BF16 or FP8 version for users to choose from.

    This jump in size is not simply a result of having more parameters. It also changes deployment methods, hardware requirements, and licensing considerations. The sections below examine the weight composition, benchmark results, license terms, and deployment feasibility.

    What Is Inside the Checkpoint: Architecture Breakdown

    According to the model card, this model was continued from a previous-generation base model and natively supports multimodal inputs and agentic tasks.

    Core parameters:

    Dimension Parameter
    Total parameters / activated parameters per token 2.8T / 104B
    Architecture Mixture-of-Experts, MoE
    Routed experts / shared experts 896 / 2
    Routed experts selected per token 16
    Number of layers 93
    Context length 1 million tokens
    Vision encoder Proprietary second-generation vision encoder
    Weight / activation precision MXFP4 / MXFP8

    1. Sparse Experts: Decoupling Compute from Memory

    The model contains 896 routed experts and 2 shared experts. For each token, 16 routed experts are activated, while the 2 shared experts are always used. This results in an activation ratio of roughly 1.8%.

    This creates two important characteristics:

    • Compute is based on activated parameters: The computation per token is close to that of a dense model with 104B parameters, so the per-token compute cost remains manageable.
    • Memory is based on total parameters: The weights for all 2.8T parameters must either remain resident in GPU memory or be loaded from memory or storage on demand. Sparsity does not eliminate the capacity pressure.

    2. Sparse Attention: Reducing Long-Context Compute

    Compared with the previous generation, the architecture has only one change: 24 full-attention layers have been replaced with sparse attention, referred to by the vendor as DSA.

    Standard attention computation grows quadratically with sequence length. At a context length of 1 million tokens, this becomes a substantial overhead. Sparse attention computes only selected key positions, which can reduce compute and cache overhead for long contexts.

    However, there are trade-offs. Which positions are retained and whether distant information is missed still need to be validated through real-world testing.

    3. A Single Low-Precision Version: Smaller Size, Some Trade-offs

    The weights use MXFP4, meaning 4-bit floating point with a shared scaling factor for every group of 32 elements. Activations use MXFP8.

    This is the result of quantization-aware training, where the model is trained to tolerate quantization errors rather than being compressed only after training. This usually causes less accuracy loss.

    The trade-offs are twofold:

    • There is no higher-precision version, so users cannot choose between different precision levels.
    • The hardware must natively support these block-based low-precision formats. Without native support, the model can only run after dequantization, which can worsen both memory usage and speed. In that case, the benefits of low precision are largely lost.

    4. Understanding the 2.8T, 1.56TB, and 8-GPU Figures

    These three numbers can be compared directly.

    If we estimate 4 bits per parameter plus a small amount for scaling factors, 2.8T parameters require roughly 1.5TB of storage, which matches the actual checkpoint size of about 1.56TB.

    During inference, GPU memory demand consists of at least three parts:

    1. Weights: Approximately 1.56TB in decimal terms, or about 1.45TiB, and the full set must be resident in memory.
    2. KV cache: Used to store key-value vectors for historical tokens. Its size grows with context length and the number of concurrent requests.
    3. Activations and communication buffers: Larger batch sizes and higher parallelism increase this overhead.

    From this, we can infer that “8 GPUs as the minimum” is physically plausible only if each GPU has around 192GB of memory.

    If each GPU has the more common 80GB of memory, the weights alone would require roughly 19 to 20 GPUs. If using accelerator cards with 141GB each, around 12 GPUs would be needed. Once cache and buffers are included, the 8-GPU figure is closer to a conditional minimum than a universally repeatable configuration.

    Note: If the hardware does not natively support low-precision formats and requires dequantization, memory requirements may increase substantially, and more devices may be needed. If users only care about the final output quality, hosted APIs usually remove the need to solve these problems directly. Whether it is worth investing in hardware depends on the evaluations discussed below.

    Benchmarks: Vendor-Reported Results with Mixed Outcomes

    The vendor published a set of comparison results. All figures are vendor-reported and are compared against a closed-source flagship model, referred to here as the comparison model.

    Evaluation area This model Comparison model Result
    Terminal automation benchmark, version 4 65.7% 66.4% Slightly lower
    Repository-level long-horizon code repair 51.7% 46.3% Ahead
    Science benchmarks 38.1% 63.3% Significantly behind
    High-difficulty academic QA 39.4% 60.9% Significantly behind

    The vendor claims that the model outperformed the comparison model on 16 out of 37 benchmarks. Another third-party evaluation organization assigned it a composite intelligence score of 55, ranking it fourth globally.

    Overall, the model performs relatively well on coding and agentic tasks, but is noticeably weaker on some science and reasoning tasks.

    For technical selection, these results should be treated with caution:

    • Vendor-reported results are only for reference: Evaluation scripts, sampling counts, tool use, and multi-turn attempts can all materially affect scores. Ideally, results should be reproduced under identical conditions.
    • Long-horizon behavior matters more than single-point accuracy: For agentic applications, the ability to avoid drift across multiple tool calls and to know when to stop is often more important than whether a single answer is correct.
    • Validate with real business tasks: A repository-level repair score does not guarantee good performance on an enterprise’s own codebase or private frameworks. Internal task sets should be used for small-scale comparison testing.

    Open Weights Do Not Equal Open Source: Two License Restrictions

    The release uses a custom license. Community platforms categorize it as “other,” rather than as a standard open-source license. The license text is identical to the previous generation’s, apart from the name.

    The main body is an MIT-style permissive grant: users may use, copy, modify, distribute, fine-tune, and commercialize the model for free.

    However, two additional restrictions apply. Both target large-scale, outward-facing commercial use:

    1. If the model is provided as a “model-as-a-service” to external users and the provider’s trailing 12-month revenue exceeds USD 20 million, a separate agreement must be signed with the rights holder before commercial use.
    2. If a commercial product’s monthly active users exceed a certain scale, in the million-user range, separate authorization is also required.

    This means individual developers, small and medium-sized teams, and most internal enterprise use cases are generally unaffected. Before offering services at scale, however, compliance confirmation is required.

    Enterprises can self-check using the following steps:

    • Clarify the use case: internal use only, distribution as part of a product, or providing model services externally.
    • Compare against the revenue and monthly active user thresholds to assess whether additional authorization is triggered.
    • If fine-tuned models will be distributed, clearly define the permitted use of derivative models in the relevant agreements.
    • If external model services are planned, discuss authorization with the rights holder in advance rather than waiting until after product launch.
    • Assign someone to track license updates, because custom license terms may change across versions.

    From Pilot to Production: Key Engineering Considerations

    After confirming licensing and hardware requirements, private deployment still faces several engineering challenges:

    • Distributed partitioning: The deployment may combine tensor parallelism, pipeline parallelism, and expert parallelism. Communication overhead from expert parallelism needs particular testing in multi-node deployments.
    • Long-context management: Mechanisms such as paged cache management and prefix-cache reuse can reduce repeated computation and cache usage in multi-turn agentic tasks.
    • Scheduling and stability: Latency-sensitive interactive requests should be scheduled separately from throughput-oriented batch workloads. The compatibility matrix between the inference engine and underlying accelerators should be validated in advance. Larger models take longer to load and recover more slowly after failures.
    • Input and output safety: Multimodal inputs may include images, documents, and other content. Outputs should pass through content-safety filtering before reaching users, and invocation audit logs should be retained.
    • Continuous monitoring: Key metrics include GPU memory usage, cache hit rate, queueing time, cost per token, and error rates. Alert thresholds should be configured.

    Three Deployment Paths: How to Choose

    • Hosted API: No hardware investment is required. Users pay based on usage, and the service provider handles version updates. This is suitable for scenarios with fluctuating demand or rapid validation. The trade-off is that data leaves the organization, and users need to consider rate limits and service stability.
    • Private cloud deployment: Weights can be stored in object storage and loaded by inference services running on a container platform, with load balancing to distribute traffic. Logging and monitoring can be used to observe runtime behavior. This option offers elasticity and avoids direct hardware operations, making it suitable for enterprises with sensitive data and fluctuating demand.
    • Self-managed data center: This offers the highest level of control, but requires significant upfront investment. If utilization is low, unit costs can be high. Power, cooling, and data-center operations must also be considered.

    For decision-making, two rough cost lines can be compared: the amortized hardware cost plus operations staffing for a self-managed deployment, and the cumulative pay-per-token charges of a hosted API. When request volume is stable and consistently high, self-managed or private deployment is often more economical.

    Conclusion

    The real value of this open-weight release is not the “largest model” headline. It is that a 2.8T-parameter, million-token-context multimodal agent model has been made available for public deployment and fine-tuning.

    At the same time, it introduces three practical thresholds:

    • The 1.56TB checkpoint size determines the minimum GPU memory and device count.
    • License terms tied to million-level monthly active users and USD 20 million in annual revenue define the compliance boundary for commercialization.
    • Vendor-reported benchmark results, with clear strengths and weaknesses, highlight the need to validate performance with real business tasks.

    For technical teams, a reasonable order is: first confirm whether the license applies, then validate effectiveness using business data, then estimate costs and choose a deployment model, and finally move toward production in stages.