72 Hours, Four Open-Source Models: Only NVIDIA Nemotron Fits in 24GB

Over the past 72 hours, the open-source large model space has seen a dense wave of releases. Meta, NVIDIA, Reflection, and DeepSeek have each dropped a heavyweight model, with parameter counts climbing from 74B all the way to 816B. But here's the awkward fact: of these four models, only NVIDIA's Nemotron 3.5 Bolt can actually run within 24GB of VRAM.

The Four Models at a Glance: Parameters and Hardware Requirements

According to the original Reddit post, the official specs for the four models are as follows:

Meta Muse Spark Open (released Thursday): 816B total parameters, 42B active, 1M context. The official tagline is "bring agentic AI to your desktop"—but "desktop" here means two M5 Ultra Mac Studios, each with 512GB of memory. Apple says this configuration "ships in late October" and has not yet announced pricing. The alternative is four 256GB units, totaling roughly $38,000. The license is a custom agreement: attribution "Built with Muse Spark Open" is mandatory, and separate signing is required once annual revenue exceeds $20 million. On the Artificial Analysis index, Meta's own model card gives it a score of 39, trailing GLM 5.3 (45) and Kimi K3 (44).

NVIDIA Nemotron 3.5 Bolt (released the same day): 74B total parameters, 9B active. The key selling point is quantization-aware training taken directly to 2bit, bringing the overall size to 22GB, plus a 1.7GB vision projector. It's designed specifically to fit within 24GB of VRAM. Unsloth released the GGUF the same day, with support for llama.cpp, Ollama, and LM Studio.

Reflection Beam (released Friday): 501B total parameters, 23B active, Apache 2.0 license with no additional terms. The smallest official checkpoint is in NVFP4 format at 294GB.

DeepSeek^Ad V4.1 Flash 1017 (released Saturday afternoon): MIT license. The official table shows a DeepSWE score of 77.0, versus 74.0 for Opus 5 (vendor-reported figures; treat with caution). The repository size is 510GB.

Mixture-of-Experts (MoE) and Total vs. Active Parameters

The recurring phrases in this article—"816B total parameters, 42B active" and "74B total parameters, 9B active"—are typical descriptions of a Mixture-of-Experts (MoE) architecture. MoE splits the feed-forward layers into many "expert" subnetworks, and each token is routed to only a few of them for computation. So "total parameters" is the scale of all the model's weights, while "active parameters" is the portion actually used in a single forward pass. This explains why an 816B model can still be deployed—VRAM must hold all the weights, but compute cost is calculated based on active parameters. And precisely because all weights must reside in memory, MoE models demand far more VRAM capacity than compute power. This is the fundamental reason Meta Muse Spark Open needs 512GB-class memory, while Nemotron 3.5 Bolt can be compressed to 22GB with 2bit quantization. When reading parameter tables, "active parameters" should be understood as a metric for inference cost, and "total parameters" as a metric for VRAM usage.

Quantization-Aware Training and 2bit Weights

The key to Nemotron 3.5 Bolt running within 24GB of VRAM isn't fewer parameters—it's "quantization-aware training (QAT) taken directly to 2bit." The conventional approach is to first train a full-precision model and then quantize it afterward (PTQ), which often incurs significant accuracy loss at low bit widths. QAT, by contrast, simulates quantization error during the training phase, letting the weights actively adapt to low-precision representations, so usable quality is preserved even under extreme compression like 2bit. 2bit means each weight occupies on average only about a quarter of a byte, bringing the size of 74B parameters down to the 22GB range. For comparison, Reflection Beam's smallest official checkpoint, in NVFP4 (4bit floating point) format, is still 294GB. This also shows that low-bit formats and quantization methods are the primary variable determining whether a model can "run locally"—no less important than the parameter count itself.

GGUF and the Local Inference Ecosystem

The article mentions that Unsloth released the GGUF the same day, with support for llama.cpp, Ollama, and LM Studio. This refers to the de facto standard format and toolchain for local inference. GGUF is a single-file model container format that packages weights, tokenizer, and metadata together, supports multiple quantization levels (such as Q4_K_M, Q2_K), and is loaded directly by llama.cpp; Ollama and LM Studio are one-click runtime environments built on top of llama.cpp. Whether a model is "available on day one" depends heavily on whether the community produces a GGUF conversion in time. The existence of the GGUF ecosystem allows the same weights to run at different quantization levels on pure CPU, Apple Silicon unified memory, and consumer GPUs—which is also the main channel through which 24GB users can still keep up with new models.

The Meaning of "Running Locally" Is Being Rewritten

Plot the four models against the 24GB VRAM line and the conclusion is rather stark: between the consumer-grade GPUs in most developers' hands and this wave of "open-source" releases lies a massive gulf.

Meta's Muse Spark Open needs two maxed-out Mac Studios to run, at a total price of nearly $40,000. Reflection Beam's smallest checkpoint is 294GB, likewise beyond what a single GPU can handle. DeepSeek V4.1 Flash's 510GB repository is even more so. "Running locally," in the face of these models, has quietly come to mean "running on a computer more expensive than a car."

NVIDIA is the only company this week that designed a model specifically for 24GB GPUs. It's a bit ironic—a vendor that keeps selling 24GB GPUs to the market is, in turn, the only lab that seriously caters to 24GB users. Whether it's a pang of conscience or a sales funnel is up for debate.

Licenses Are More Interesting Than Parameters

What really separated the field this week wasn't parameter counts—it was licenses.

DeepSeek's MIT and Reflection's Apache 2.0 are genuine open source with no additional conditions. Meta, by contrast, with the loudest marketing, used a custom license with attribution requirements and revenue-sharing clauses. For commercial users, the impact of this difference far outweighs a few billion extra parameters.

Per the Reddit poster's note, Mistral's Large 4 weights (codename "Le Chonk," 1T total parameters) will also land before the end of the month. At this rate, the 24GB VRAM line will only grow lonelier.

The Real Divide Among Open-Source Licenses

MIT and Apache 2.0 are both OSI-recognized standard open-source licenses: the former is extremely permissive, requiring only that copyright and license notices be retained; the latter additionally includes explicit patent grant clauses and requires marking modified files. Both allow commercial use, modification, redistribution, and closed-source integration. The "custom agreement" Meta uses in this article is not an open-source license at all, but a conditional weights license: mandatory attribution "Built with Muse Spark Open," with separate signing triggered once annual revenue exceeds $20 million. Such terms are common in "open weights" models like the Llama series, and their legal nature is closer to a commercial license with a scale threshold than to a grant of full freedom. To judge whether a model is "truly open source," look at whether it satisfies the open-source definition's freedoms to use, modify, and redistribute—not merely whether the weights can be downloaded. For commercial deployment, terms like revenue thresholds, attribution obligations, and revocability often determine total cost and compliance risk more directly than benchmark scores.

Practical Impact for Developers

If you have a 24GB GPU, the only new model available to you this week is essentially Nemotron 3.5 Bolt. Fortunately, its ecosystem moved quickly: the GGUF was available the same day, with full coverage across llama.cpp, Ollama, and LM Studio, so the barrier to entry is low.

If you're evaluating commercial deployment, license terms need to be reviewed ahead of benchmark scores. MIT and Apache 2.0 mean you can freely integrate, modify, and distribute; custom licenses may bring additional costs at scale.

As for those models weighing hundreds of GB, running them on consumer hardware remains unrealistic in the near term. Cloud inference or enterprise-grade clusters will remain their primary home.

One-line Summary

Four open-source large models released in a dense 72-hour window, only one fits in 24GB of VRAM, and licenses matter more than parameters.

Paragraph Summary

Over the past 72 hours, Meta, NVIDIA, Reflection, and DeepSeek have each released a large model, with parameter counts ranging from 74B to 816B. But measured against the 24GB VRAM consumer baseline, only NVIDIA Nemotron 3.5 Bolt (74B total parameters, 9B active, 2bit quantization-aware training, 22GB size) can run locally, and the GGUF plus llama.cpp, Ollama, and LM Studio ecosystem followed on the same day. Meta Muse Spark Open requires two 512GB Mac Studios at roughly $38,000 total, and its license includes attribution and revenue-sharing terms; Reflection Beam (Apache 2.0) has a smallest checkpoint of 294GB, and DeepSeek V4.1 Flash (MIT) has a 510GB repository. The article argues that the real divide this week is licenses, not parameter counts, and that the definition of "running locally" is being pushed toward expensive hardware.