JetBrains Mellum2.1 on a Mac: 8.1 GB at Q4, 16 GB Is the Real Floor

JetBrains shipped Mellum2.1 on October 8, 2026, the next version of its 12B mixture-of-experts coding model, and this time it brought an official GGUF. That matters because the model is built to do agent work, meaning it explores a repository, edits files and checks its own changes, and all of that can now run through llama.cpp instead of a rented GPU. The smallest build is 7.0 GB, which makes an 8 GB Mac look possible. The honest answer is that 8 GB is the wrong target for this model, and a 16 GB Mac is the real entry point.

This is not a new model family. The architecture is unchanged from Mellum2, which JetBrains open-sourced in June 2026, and Mellum2.1 is a version update with almost all of the work spent on post-training. We did not benchmark it ourselves, so every speed and score figure below is either JetBrains' own claim or a file size straight from the GGUF repository.

What is Mellum2.1?

Mellum2.1 Thinking is a 12B mixture-of-experts model that activates 2.5B parameters per token, with 64 experts and 8 activated per token (model card). It carries a 131,072-token context, a 1,024-token sliding window on 3 of every 4 layers, grouped-query attention (32 query heads, 4 key-value heads) and a vocabulary of 98,304. It ships under Apache 2.0, so commercial use is fine.

The distinguishing feature is the thinking format. The model emits its chain of thought inside think blocks before the final answer, and the model card lists that as the reason it handles "working in a repository, running commands, and calling tools" (model card). That has a direct cost for anyone counting tokens: a reasoning turn produces far more output tokens than a non-thinking 12B, so the same prompt takes longer and burns more context. Budget for it rather than expecting chat-model latency.

The timing is worth getting right, because the release dates do not line up with a single day:

• Base weights repository created 2026-09-20.
• Official GGUF repository created 2026-10-07 (GGUF card).
• Public announcement 2026-10-08 (JetBrains blog).

So the weights existed quietly for over two weeks before the blog post, and the GGUF landed the day before the announcement.

Does Mellum2.1 run on your Mac?

Yes, on a big enough one. Memory is the whole game here, because the model runs on unified memory shared with macOS. The GGUF repository publishes five quantizations, and the file size is the floor you build on:

File sizes from the official GGUF card. We did not run the model on Apple Silicon, so these are the publisher's file sizes, not our measurements.

The file size is not the resident memory. llama.cpp allocates the KV cache on top of the weights, and its size scales with the context you request. At the full 131,072-token window the KV cache is measured in gigabytes by itself, so the smallest builds only stay comfortable when you keep the context modest. If you push for the full window on a 16 GB machine, expect to hit swap. The general weight-versus-overhead arithmetic is the same one we apply everywhere in how much VRAM an LLM needs.

That is why 8 GB is the wrong target. The only build that even approaches an 8 GB budget is MXFP4_MOE at 7.0 GB, and once macOS takes its share and the KV cache is added, there is nothing left for the editor, the shell and the tools this model is meant to drive. A 16 GB Mac is the practical floor, and 24 GB is where the higher-quality builds open up.

Which quantization should you pick?

Q4_K_M is the recommended build and the sane default on a 16 GB Mac. The GGUF card publishes quality numbers for each build, measured as KL divergence from the BF16 logits and top-token agreement against them (GGUF card):

Lower KLD and higher agreement mean closer to the unquantized model. Two things stand out. Q8_0 is close to lossless at 0.008, and it costs 12.9 GB to get there. MXFP4_MOE is the smallest at 7.0 GB but it is also the furthest from BF16 at 0.115 KLD and 85.6% agreement, which is the tradeoff you accept for the reduced footprint. MXFP4 quantizes the MoE experts, which is where most of this model's weight lives, so the savings are real rather than cosmetic; support for the MXFP4 type exists in current llama.cpp. If you have the memory, Q6_K at 10.9 GB is the better balance of size and fidelity than the 4-bit builds.

How does Mellum2.1 score?

Every benchmark below is self-reported by JetBrains and marked unverified on the model card. There is no independent reproduction of these numbers, so treat them as vendor claims and nothing more (model card).

The interesting column is Mellum2.1 against its own predecessor. SWE-bench Verified jumps from 2.0 to 47.0, which is the reinforcement-learning story made concrete: the same architecture, retrained on real sandboxed software environments, goes from barely usable on agentic coding to competitive with a 9B rival. LiveCodeBench moves from 69.4 to 82.0. On the math and knowledge benchmarks the gains are smaller and Qwen3.5 9B still leads several of them, so this is not a model that wins everywhere.

On speed, JetBrains claims Mellum2.1 serves almost twice as many tokens as Qwen3.5 9B under heavy load on a single H200, and that multi-token prediction makes a single request about 1.6 times faster (JetBrains blog). Those are data-center numbers on an H200 and they say nothing about a Mac. ModelFit ran no benchmark on this model and publishes no Apple Silicon decode-throughput figure for it.

How do you run Mellum2.1 on a Mac?

The GGUF cards document two paths. Both need a recent llama.cpp build, since the MXFP4_MOE quantization is not in older releases.

With llama.cpp, the repository gives an exact command that pulls the Q4_K_M build and serves it with the full context (GGUF card):

llama-server -hf JetBrains/Mellum2.1-12B-A2.5B-Thinking-GGUF:Q4_K_M   --ctx-size 131072   --temp 0.6 --top-p 0.95 --top-k 20

Two cautions on that line. The suffix :Q4_K_M selects the quantization, so change it to :MXFP4_MOE or :Q6_K to pull a different build. And --ctx-size 131072 requests the full window, which is the maximum; on a 16 GB Mac lower that value or the KV cache will push you into swap. A smaller --ctx-size is the single most effective knob for running this on a modest machine.

The server then exposes an OpenAI-compatible API on http://localhost:8080/v1, which is what you point an agent harness at.

With Ollama, there is no official library tag. We checked ollama.com/library/mellum2.1 and the older mellum2 and both return a 404, so you cannot ollama pull it by name yet. The GGUF card instead documents pulling straight from Hugging Face:

ollama run hf.co/JetBrains/Mellum2.1-12B-A2.5B-Thinking-GGUF:Q4_K_M

LM Studio is named on the GGUF card as a compatible runtime, but there is no library entry for it either, so the path is to download the GGUF file and load it as a local model rather than search for it inside the app. Confirm the import works before you plan around it.

Since this is a coding model, it slots into the same local-agent setups we covered for Qwen3.6 and Gemma 4 and for the Ornith 9B coder on a 16 GB Mac. If you are deciding between this and a dense 12B, the Qwen 3.6 on Mac guide and the Qwen3.8 27B local walkthrough cover the alternatives at similar memory tiers.

FAQ

Can a 12B model really run in 8 GB?

Not this one comfortably. The smallest build, MXFP4_MOE, is 7.0 GB on disk, and once macOS and the KV cache are counted there is no usable room left on an 8 GB Mac. A 16 GB Mac running Q4_K_M at 8.1 GB is the realistic entry point.

Does Mellum2.1 have an official Ollama tag?

No. As of October 9, 2026, ollama.com/library/mellum2.1 returns a 404, and so does the older mellum2. You can still run it through Ollama by pulling the GGUF directly from Hugging Face with ollama run hf.co/JetBrains/Mellum2.1-12B-A2.5B-Thinking-GGUF:Q4_K_M.

Is Mellum2.1 a new model or an update?

It is an update. The architecture is unchanged from Mellum2, which was open-sourced in June 2026, and Mellum2.1 is the same 12B mixture-of-experts design with 2.5B active parameters. Almost all of the work went into post-training with reinforcement learning in real sandboxed environments.

Are the Mellum2.1 benchmark scores verified?

No. The model card marks every result as unverified, and they are self-reported by JetBrains. SWE-bench Verified 47.0 and LiveCodeBench v6 82.0 are the headline claims, but no independent leaderboard has reproduced them yet.

Why does the model take longer to answer than a normal 12B?

Because it thinks first. Mellum2.1 writes its chain of thought inside think blocks before the final answer, so a single turn emits many more tokens than a non-thinking model of the same size. That changes both latency and how much context you burn per request.

Sources

• JetBrains blog, "Mellum2.1 Gets to Work: A Fast Open Model for Coding Agents", October 8, 2026, for the announcement date, the post-training story and the H200 speed claims, read October 9, 2026
• JetBrains/Mellum2.1-12B-A2.5B-Thinking model card, for the architecture, context length, license and the self-reported benchmark table, read October 9, 2026
• JetBrains/Mellum2.1-12B-A2.5B-Thinking-GGUF card, for the quantization table, file sizes, KLD figures, run commands and the Ollama import line, read October 9, 2026
• Hugging Face API metadata for both repositories, for the repository creation dates (2026-09-20 and 2026-10-07), read October 9, 2026
• ollama.com/library/mellum2.1 and ollama.com/library/mellum2 returning HTTP 404, checked October 9, 2026, for the absence of an official Ollama tag
• llama.cpp source, for the MXFP4 quantization type used by the MXFP4_MOE build

Every number in this article is either a vendor figure we opened ourselves or a file size from the publisher's repository, labelled as such. ModelFit runs no benchmarks of its own, so no Apple Silicon throughput figure is claimed here. How we work: about ModelFit.