Open-Weight AI Models You Can Run Yourself: October 2026 Edition

Open-weight AI models are easy to download and much harder to fit in memory. Meta's Muse Spark Open, released on 15 October 2026, shows the gap clearly: 816B parameters, a 1M-token context window, and, per Engadget, about 1 TB of RAM to run it locally.

Below: what "open-weight" means, this month's releases side by side, a Python memory estimator, license checks, and hardware sizing.

Open-weight vs open source: what you actually get

An open-weight model gives you the trained parameters (the "weights"). You can run it on your own hardware and, if the license allows, fine-tune it.

That is narrower than open source AI. The Open Source Initiative's Open Source AI Definition 1.0 also asks for detailed information about the training data and the complete code used to train and run the system. OSI's explainer on open weights says they "differ significantly from Open Source AI" because that code and data detail is missing.

In short: you can download and run the model. The license decides everything else.

October 2026 open-weight models at a glance

Model	Released	Total parameters	Active per token	Context	License
Muse Spark Open (Meta)	15 Oct 2026	816B (MoE)	42B	1M tokens	Muse Model License (custom)
DeepSeek V4.1 Flash 1017	17 Oct 2026	552B backbone (MoE) + 196B Engram memory	8B prefill, 16B decode	Up to 1M tokens	MIT
Granite Switch 4.1 8B (IBM)	14 Oct 2026	8B base model	Not listed	128K (base model)	Apache 2.0
Qwen3.8-27B (for comparison)	August 2026	27B (dense)	All 27B	262,144 native, up to 1M	Apache 2.0

All four have downloadable weights on Hugging Face; Muse Spark Open's require an access request.

Muse Spark Open: a desktop model, if your desktop has 1 TB

Muse Spark Open is a mixture-of-experts (MoE) model, which routes each token through a few "expert" sub-networks. Its model card lists 256 experts, 8 active per token.

Meta's launch post says the model was optimized for two Apple M5 Ultra Mac Studios running MLX. Each machine's GPU can use up to 512 GB of unified memory, so the pair adds up to a terabyte.

On GPUs, the model card says you need at least 700GB of VRAM for the NVFP4 version and 2TB for BF16. Downloading requires an access request with your full legal name, date of birth and organization. For another reference, see Muse Spark Open on Toolbit. (I work on Toolbit.)

DeepSeek V4.1 Flash 1017: huge total, small active

DeepSeek released V4.1 Flash 1017 on 17 October, with weights on Hugging Face and ModelScope. Its model card calls it a minor update to V4.1 Flash and puts it under the MIT license.

The V4.1 Flash model card lists 552B backbone parameters, with 8B active per token during prefill (reading your prompt) and 16B during decode (generating output). DeepSeek says its design cuts the global KV cache to 890 bytes per token, under 1 GB for 1M tokens.

Smaller options: Granite Switch 4.1 and Qwen3.8-27B

IBM's Granite Switch 4.1 8B lists a release date of 14 October. It's built on the Granite 4.1 8B base model (8B parameters, 128K context), uses Apache 2.0, and also comes in a 30B version. IBM also publishes GGUF files at several quantization levels.

For mid-size, Qwen3.8-27B (August) is a 27B dense model with 262,144 tokens of native context, extensible to 1M, under Apache 2.0.

How much memory do open-weight AI models need?

Hugging Face's guide to optimizing LLMs gives a simple rule: a model with X billion parameters needs roughly 2 × X GB of VRAM in bfloat16, or 4 × X GB in float32. Generalized:

weights (GB) ≈ parameters (billions) × bits per weight ÷ 8

That's the floor. Two things sit on top of it:

• KV cache. Stored keys and values for every token in context. The guide counts them as 2 × sequence length × heads × head dimension × layers, so the cache grows linearly with context. Grouped-query attention (GQA) uses fewer key-value heads, which shrinks it.
• Runtime overhead. Activations, buffers and framework memory.

Quantization lowers the bits per weight. The guide says 8-bit or 4-bit weights work without a significant loss in performance, but warns that quantization trades memory against accuracy and sometimes speed. Real formats add a little: NVIDIA's NVFP4 stores one FP8 scale per 16 values, which works out to about 4.5 bits per weight.

The guide's own test shows the gap: it expects about 31 GB for OctoCoder in bfloat16, so 4-bit should be about 7.75 GB, yet it measured "just a bit over 9GB."

A quick Python memory estimator

def weights_gb(params_billion, bits_per_weight):
    """Weights only, in GB (1 GB = 1e9 bytes)."""
    return params_billion * bits_per_weight / 8


def kv_cache_gb(tokens, layers, kv_heads, head_dim, bytes_per_value=2):
    """Keys + values for every token, layer and KV head (2 bytes = BF16)."""
    return 2 * tokens * layers * kv_heads * head_dim * bytes_per_value / 1e9


MARGIN = 1.2  # +20% for cache, activations and runtime (an assumption)

for label, params in [("8B", 8), ("27B", 27), ("816B", 816)]:
    for bits in (16, 8, 4):
        w = weights_gb(params, bits)
        print(f"{label:>5} @ {bits:>2}-bit: ~{w:,.1f} GB weights, ~{w * MARGIN:,.1f} GB with margin")

# Muse Spark Open model card: 62 layers, 16 KV heads, head dim 64
print(f"Full 1M-token BF16 cache: ~{kv_cache_gb(1_000_000, 62, 16, 64):,.0f} GB")

A 27B model needs about 13.5 GB of weights at 4-bit, and 816B at BF16 lands near 1,958 GB with the margin, close to the 2TB on Meta's model card.

The last line uses Muse Spark Open's card values. If every layer caches every token, a full 1M-token context adds roughly 254 GB on top of about 408 GB of 4-bit weights.

For MoE models, always use total parameters, not active ones.

What to check in a license before commercial use

Not legal advice, but check these first:

1. Is it a standard license? DeepSeek's MIT license lets you use, modify and sell copies as long as you keep the copyright and license notice. Apache 2.0 (Qwen3.8-27B, Granite Switch) includes an explicit patent license. Custom licenses need a closer read.
2. Are there attribution rules? The Muse Model License requires products using the model to prominently display "Built with Muse Spark Open."
3. Is there a scale or revenue trigger? If you offer model access to third parties via API and your company's gross revenue tops $20 million in any 12-month period, Meta's license requires notifying Meta and signing a separate agreement. Internal use, and powering features of your own product that isn't a model-as-a-service, are exempt.
4. What does the usage policy ban? Muse's license includes a usage policy with a list of prohibited uses, and says the model isn't intended for anyone under 18.
5. Do obligations follow your fine-tunes? Muse's definition of "Derivatives" covers models fine-tuned or distilled using the model or its outputs.

Meta itself calls the commercial terms limited. Have a lawyer read the full text before you ship.

Which size fits your hardware?

Weights-only math, so leave room for context:

• Laptop with 16 to 32 GB of RAM or unified memory: 8B-class models such as Granite Switch 4.1 8B, at 4-bit (about 4 GB) or 8-bit (about 8 GB). llama.cpp treats Apple silicon as "a first-class citizen" and also supports x86 CPUs.
• Single-GPU workstation with 24 to 48 GB of VRAM: 27B dense models like Qwen3.8-27B, at 4-bit (about 13.5 GB) or 8-bit (about 27 GB). BF16 needs about 54 GB, more than a single 48 GB card holds.
• Server or multi-machine setup: Muse Spark Open and DeepSeek V4.1 Flash 1017. Even DeepSeek's 552B backbone alone is about 276 GB at 4-bit.

For models bigger than your VRAM, llama.cpp offers CPU+GPU hybrid inference to partially accelerate them.

FAQ

Do MoE models need less memory because only some parameters are active?

No. Active parameters cut compute per token, but every expert must still be loaded. Muse Spark Open activates 42B of its 816B parameters, yet Meta pairs two Mac Studios so they "can hold an entire model." The MoE win is speed: Meta notes each token reads only a small part of the model from memory.

Is an open-weight model free to use commercially?

It depends on the license, not the word "open." MIT and Apache 2.0 models like DeepSeek V4.1 Flash 1017 and Qwen3.8-27B grant broad rights, including distributing copies, under their notice terms. Muse Spark Open allows a lot too, with attribution, a usage policy and the revenue clause above.

The takeaway

Before you download anything, multiply total parameters by bits per weight, divide by 8, and add headroom for the context length you actually need. If that fits your RAM or VRAM, read the license next, before the model ends up in a product.

Sources

• Meta launches an open-weight AI model that runs on Macs (TechCrunch)
• Meta built a huge open-weight AI model for Macs, but you'll need 1TB of RAM to run it (Engadget)
• Introducing Muse Spark Open (Meta AI Research)
• Muse-Spark-Open-816B-A42B model card and Muse Model License (Hugging Face)
• DeepSeek-V4.1-Flash-1017 release note (DeepSeek API Docs)
• DeepSeek-V4.1-Flash-1017 model card (Hugging Face)
• DeepSeek-V4.1-Flash model card (Hugging Face)
• Granite Switch 4.1 8B model card (Hugging Face)
• granite-switch-4.1-8b GGUF (Hugging Face)
• Qwen3.8-27B model card (Hugging Face)
• The Open Source AI Definition 1.0 (Open Source Initiative)
• Open Weights (Open Source Initiative)
• Optimizing LLMs for Speed and Memory (Hugging Face Transformers docs)
• Introducing NVFP4 for Efficient and Accurate Low-Precision Inference (NVIDIA Developer Blog)
• llama.cpp README (GitHub)
• DeepSeek-V4.1-Flash-1017 LICENSE (MIT)
• Apache License, Version 2.0 (Apache Software Foundation)

This article was written with AI assistance and reviewed by the author.