Can a 24GB Mac Run Sage-A1.5? Q3 Yes, Q4 No

Sage-A1.5 is a 35B mixture-of-experts agent model published by InternScience and attributed on its card to Shanghai AI Laboratory, built on Qwen3.6-35B-A3B and Agents-A1. Its official Q4_K_M file is 21.7 GB, which is 20.2 GiB of weights, against the 16,800 MB a 24GB Mac can wire to its GPU. So that machine gets a no at Q4 and a yes at 3-bit, where the smallest builds sit at 16.1 GB and leave about 700 MB behind. The weights are the wall here, and the context cache is not.

TL;DR: 24GB Mac: only a 3-bit file, text only, around 34,000 tokens of context. 32GB Mac: Q4_K_M loads but leaves about 700 MB. 48GB is the first comfortable size for the official Q4_K_M, and 64GB for Q8_0. No Ollama library tag exists, and the published benchmark scores are BF16 only.

What is Sage-A1.5?

The model card describes a 35B MoE agentic model aimed at long-horizon scientific work, with three features that matter for tooling. Agentic Orchestration fans independent sub-questions out to parallel subagents with isolated contexts. Verification Mode is an opt-in self-review inside the model's own chain of thought. Tool use is native.

The specs that decide whether it runs on your Mac:

• Base: Qwen3.6-35B-A3B plus Agents-A1
• Parameters: 35B in total, with 3B activated per token (Qwen3.6-35B-A3B card)
• Layers: 40, split into 30 linear-attention and 10 full-attention layers
• Experts: 256, with 8 routed per token
• Context: 262,144 tokens, extendable to 512K with YaRN
• Input: text and images, through a Qwen3-VL vision tower
• Licence: Apache-2.0
• Weights published: 15 October 2026

That 3B active figure is good news for speed. It is not good news for memory, because MoE models still hold all 35B of weights in RAM. Decode reads the active experts per token, but the file has to be resident in full.

Mixture-of-experts is a layout where each layer holds many small expert networks and routes every token through a few of them. Sage-A1.5 keeps 256 experts and activates 8 per token, which is why its speed behaves like a 3B model while its memory behaves like a 35B one.

Can a 24GB Mac run Sage-A1.5?

No at Q4_K_M. Yes at 3-bit, and only from third-party quantizers. The official repositories ship Q4_K_M, Q6_K and Q8_0, so nothing in the official ladder is small enough for a 24GB Mac.

The budget column applies ModelFit's sizing rule, the one behind every pick in the homepage wizard. Unified memory is the single pool that Apple Silicon shares between its CPU and its GPU, and macOS caps how much of that pool the GPU may wire. The engine allows 70% of unified memory at 32GB and below, ramping to 85% at 128GB and above, and the full ladder is in the RAM guide for local LLMs. That is 11,200 MB on 16GB, 16,800 MB on 24GB and 22,400 MB on 32GB.

Two sizes come out of that family, 16.1 GB and 17.5 GB, and only the 16.1 GB pair fits a 24GB Mac. If you want the wider field of models that suit that budget, our Mac mini M4 24GB picks cover it.

Why the official Q4_K_M file misses a 24GB Mac

The official Q4_K_M repository lists the file at 21.7 GB and its memory footprint at about 20.2 GiB, plus 0.84 GiB for the vision projector. Its own note says a single 24 GB GPU comfortably serves the model at moderate context lengths.

That note is about a discrete GPU, and it does not transfer to a Mac. A 24GB card gives you 24 GB of VRAM that the model can occupy. A 24GB Mac gives you a single unified pool that macOS also uses for the OS, the window server and every app you have open, and it caps the share the GPU may wire. By ModelFit's rule that is 16,800 MB, so a 21.7 GB file is roughly 4.9 GB over before you load anything else.

The same logic explains the Q8_0 repository. It lists 37.8 GB and a footprint of about 35.2 GiB, and its note recommends a 48 GB GPU. On a Mac that maps to 34,800 MB at 48GB, which is why 48GB is the practical floor for the file and 96GB is where it stops being tight.

One caveat on the Q6_K repository: its card repeats the Q4_K_M sizes for the Q6_K file. The file itself is larger, and the file table on mradermacher's quant puts Q6_K at 29.3 GB and Q5_K_M at 25.4 GB. Size the tier off that number, not off the official card.

Which 3-bit builds actually fit a 24GB Mac?

One quantizer currently publishes a ladder small enough to matter. The na0x2c6 repository uses an importance matrix and mixes quant types per tensor group, which buys back size without giving up much.

KLD is the divergence of the quantized next-token distribution from BF16, so lower is closer to the original. Read the last two rows against each other: the 17.5 GB IQ3_S-exps-down4 lands at 0.0370 mean KLD on English, slightly better than the official Q4_K_M at 0.0378, while being 4.2 GB smaller. The quantizer's own summary says the down4 files sit within about 0.98 to 1.19 times the official Q4_K_M's mean KLD, and that IQ3_S-exps-down4 is the only file below 18 GB whose 99.9th-percentile KLD is also below the official file's.

On a 24GB Mac that 17.5 GB file is still over budget, so the real choice is IQ3_S-exps at 16.1 GB. Its mean KLD of 0.0451 is a visible step down, and it has a much heavier tail than the down4 mix. If quality matters more than the file fitting, the honest options are the 17.5 GB mix on a 32GB Mac or Q4_K_M on a 48GB Mac.

Does the 24GB Mac have room for context?

More than you would expect, because Sage-A1.5 barely uses full attention. Its published config.json sets full_attention_interval to 4, and its layer_types array lists three linear-attention layers followed by one full-attention layer across 40 layers. That gives 30 linear-attention layers and 10 full-attention layers.

Only the 10 full-attention layers carry a cache that scales. Full attention is the layer type whose cache grows with every token you add, while linear attention is the variant that keeps a constant recurrent state instead. KV cache is the per-token memory a model keeps for the keys and values it has already attended to. Each of those layers has 2 key-value heads at a head dimension of 256, so at f16 each stores 2 (key and value) x 2 x 256 x 2 = 2,048 bytes per token. Across 10 layers that is 20,480 bytes, or 20 KiB, per token.

This is ModelFit's arithmetic from the published config, not a measurement, and it assumes an f16 cache with no quantized-KV tricks. Quantizing the cache to q8_0 or q4_0 shrinks it further.

Two consequences follow. The full 262,144-token context is never the reason a quant fails to load on this model, because a 5.4 GB cache is small by current standards. And on a 24GB Mac, for example, the 700 MB left after the 16.1 GB file holds roughly 34,000 tokens, so a short-context agent session works and a long document does not.

The vision projector is the other squeeze. It is 0.9 GB on top of the weights, so on a 24GB Mac it does not fit alongside the 16.1 GB file and a usable cache. Treat image input as a 32GB feature here, and start with --jinja and no --mmproj on 24GB.

Do the model card's benchmark scores survive quantization?

No. This is the part people get wrong when they compare a 16.1 GB download against a frontier API model.

The published results are BF16. The Q6_K card states it plainly: all benchmark results above are evaluated on the original full-precision (BF16) Sage-A1.5 weights, and the quantization trades accuracy for footprint. At 16.1 GB you are running 3-bit weights with a mean KLD of 0.0451, which is not the model that scored these numbers.

Read that as a shape, not a scoreboard. Sage-A1.5 leads the large closed model on the science and instruction set (GAIA, FrontierScience-Olympiad, CMT, PinchBench, IFBench) and trails it on the software-engineering and general-agent set (SWE-bench Pro, HLE w/ tools, MLE-Lite, AA-LCR). BrowseComp is the split case: 81.7 without Agentic Orchestration and 82.8 with it, against 90.4 for GPT-5.6-sol.

Three caveats belong with those numbers. They are the lab's own measurements, generated with its open-source evaluation framework. Competitor figures come from the competitors' own technical reports where they publish one. And the SWE-bench runs use the mini-SWE-agent harness at temperature 1.0 with a 200K-token context window, in an offline environment.

We publish no speed numbers for Sage-A1.5. There is no Apple Silicon tokens-per-second measurement for this model anywhere, official or community, and ModelFit runs no benchmarks of its own. If you want a throughput figure, measure it on your own machine.

How do you run it on a Mac?

llama.cpp is the path, and the official cards ship instructions for it, plus Ollama and LM Studio. For the 16.1 GB 3-bit file, download it from the third-party repository and point the same flags at it.

brew install llama.cpp
llama-server \
  -m Sage-A1.5-IQ3_S-exps.gguf \
  -ngl 99 -fa on -c 32768 \
  --port 8000 --jinja --reasoning-format deepthink

--jinja enables the model's built-in chat template with function-calling support, and --reasoning-format deepthink keeps the model's self-review in reasoning_content, separate from the final answer in content. Both flags come from the official Q4_K_M card, which also shows the multimodal and 131,072-token text-only variants with -c.

Two gaps worth knowing before you install:

• No Ollama library tag. The registry returns 404 for sage-a1.5, so there is no ollama run line to give. You can still build a local one with ollama create from a downloaded GGUF, and that needs a recent Ollama version for the qwen35moe architecture.
• An MLX build exists but is not the 24GB answer. mlx-community/Sage-A1.5-OptiQ-4bit ships a mixed-precision MLX checkpoint. Its language tower is 20.6 GB, on top of 0.9 GB of bf16 vision weights and 0.5 GB for the MTP head, so 22 GB on disk. That is over a 24GB Mac's budget. Its card also notes the per-layer bit allocation was copied from the Qwen3.6-35B-A3B recipe rather than measured on Sage-A1.5.

The MTP head is worth a note. The GGUF files carry a built-in multi-token prediction layer, so self-speculative decoding is possible, but the official card defers the flags to your llama.cpp version.

FAQ

Can a 24GB Mac run Sage-A1.5?

Yes, at 3-bit and text only. The 16.1 GB IQ3_S-exps or Q3_K-exps files fit inside the 16,800 MB budget with about 700 MB for the KV cache, which is roughly 34,000 tokens. The official Q4_K_M at 21.7 GB does not fit, and no official quant does.

Can a 32GB Mac run the official Q4_K_M?

It loads, but barely. The file is 21.7 GB against a 22,400 MB budget, so about 700 MB remains, again roughly 34,000 tokens of context. That leaves no room for the 0.9 GB vision projector. A 48GB Mac, at 34,800 MB, is the size where Q4_K_M becomes comfortable.

Is there an Ollama tag for Sage-A1.5?

Not today. The Ollama library returns 404 for sage-a1.5, so ModelFit publishes no ollama run command for it. You can create a local tag from a downloaded GGUF, and Ollama needs a recent version to handle the qwen35moe architecture.

Do the benchmark scores apply to a 3-bit quant?

No. Every figure on the model card is BF16, and the card says so. A 16.1 GB file is 3-bit weights with a mean KLD of 0.0451 against BF16 on English text, so expect a real quality gap on long reasoning chains even though the headline numbers look unchanged.

Which quant should I pick?

On 24GB, IQ3_S-exps at 16.1 GB, because it has a lower tail than Q3_K-exps at the same size. On 32GB, IQ3_S-exps-down4 at 17.5 GB, which the quantizer measures within the official Q4_K_M's mean KLD while being 4.2 GB smaller. On 48GB and up, the official Q4_K_M at 21.7 GB, or the imatrix Q4_K_M at the same size with lower measured divergence.

Sources

• InternScience/Sage-A1.5 model card (benchmark tables, architecture, licence)
• Sage-A1.5 on the Hugging Face API (parameter count, creation date)
• Sage-A1.5 config.json (layer types, attention heads, context length)
• InternScience/Sage-A1.5-Q4_K_M-GGUF (file size, memory footprint, llama.cpp and Ollama instructions)
• InternScience/Sage-A1.5-Q8_0-GGUF (file size and footprint)
• InternScience/Sage-A1.5-Q6_K-GGUF (BF16 evaluation note)
• na0x2c6/Sage-A1.5-GGUF (3-bit and mixed quant sizes, KL divergence table)
• mradermacher/Sage-A1.5-GGUF (Q6_K and Q5_K_M sizes)
• mlx-community/Sage-A1.5-OptiQ-4bit (MLX checkpoint size and composition)
• Qwen/Qwen3.6-35B-A3B model card (35B total, 3B activated)
• Sage-A1.5 technical report, arXiv 2610.28578
• Ollama library: sage-a1.5 (404, no official tag)