JetBrains Mellum 2 as a Local Cursor and Cline Backend in 2026: The 8GB Coding Model That Fits a 12GB Card

By AICoderScope Team · 11 min read
mellumjetbrainslocal-llmollamacursorclinebyoksetup-guideai

TL;DR: JetBrains open-sourced Mellum 2 in June 2026 — a 12B Mixture-of-Experts coding model with 2.5B active parameters, 131K context, and a clean Apache 2.0 license. The Q4_K_M quant is about 8.1GB, so it runs on a 12GB card, not the 24GB that Qwen3-Coder-class backends demand. It’s the fastest local backend we’ve wired into Cline this year — and the wrong choice as your only model.

Mellum 2 (local, 12GB card)Qwen3-Coder-30B-A3B (local, 24GB card)Cloud frontier (Cursor’s default models)
Best forFast chat, edits, and sub-agent work on hardware you already ownThe strongest all-round local coding agentPeak quality per prompt, zero setup
Price / Cost$0/token, ~8.1GB download, Apache 2.0$0/token, ~19GB download, Apache 2.0From $20/mo (Cursor Pro) plus usage beyond limits
The catchTrails bigger models on long agentic tasks — it’s a specialist, not a generalistWon’t fit on anything under 24GB of VRAMYour code transits someone else’s cloud

Honest take: If you have 24GB of VRAM, Qwen3-Coder-30B is still the better primary local agent. Mellum 2 wins two specific fights: it’s the best coding model that fits a 12GB card today, and it’s fast enough at 2.5B active parameters to be the “quick model” in a two-model local stack. If that describes your hardware or your workflow, get it; if not, skip it.

What JetBrains actually shipped

Mellum 2 landed in early June 2026, announced on the JetBrains AI blog and covered the same week by MarkTechPost. This is not the cloud AI Assistant subscription we reviewed in May — that’s a separate product with its own credit-burnout problems. Mellum 2 is the open-weight model itself: weights you download, run, and never pay for again.

The spec sheet, cross-checked against the Hugging Face model cards and the technical report:

  • Architecture: Mixture-of-Experts, 12B total parameters, 2.5B activated per token (8 of 64 experts per forward pass)
  • Attention: sliding-window attention on three quarters of the layers, full attention on the rest — a latency play for long inputs
  • Context: 131,072 tokens
  • License: Apache 2.0 — commercial use, fine-tuning, and redistribution all permitted, no custom-license fine print
  • Variants: Base (fill-in-the-middle code completion), Instruct (chat and agent work), and Thinking (RLVR-trained reasoning)
  • Official GGUF quants: Q4_K_M, Q8_0, MXFP4_MOE, and a BF16 reference, straight from JetBrains’ own Hugging Face org

The pedigree matters here. The original Mellum was JetBrains’ in-IDE completion model, trained on the edit patterns, refactor histories, and test-generation flows the company sees across its IDE telemetry — there’s a published paper on that production completion system. Mellum 2 extends the family from pure completion into chat, tool use, and agentic workflows while keeping the design goal that made the first one interesting: be fast and cheap enough to run constantly, not occasionally.

That goal shows up in the numbers JetBrains leads with: more than 2× faster inference than similarly sized open models, per the vendor’s own claim. The mechanism is no mystery — at 2.5B active parameters, each token costs roughly what a small dense model costs to decode, while the 12B of total weights give it more breadth than any actual 2.5B model has.

The benchmark split you need to read twice

JetBrains reports 69.9% on LiveCodeBench v6 for Mellum 2, with the Thinking variant reaching 75.1 — strong results for the active-parameter budget. The Thinking variant also posts 58.4% on AIME math problems.

Here’s the split, and credit to TechJack Solutions’ analysis for framing it cleanly: that 58.4% AIME score trails Qwen3.5-4B, a dense model a third its total size, which posts 68.3%. A 12B MoE losing a math benchmark to a 4B dense model is not a scandal — it’s exactly what the architecture trades away. Sparse experts buy you throughput on the distribution you trained for (code, edits, tool calls) and give it back on depth-of-reasoning tasks outside it.

Two practical conclusions follow, and they’re the honest core of this review:

First: don’t make Mellum 2 the primary agent for long, hard, multi-step tasks. On SWE-bench-style agentic work, the community consensus matches the architecture story — it’s better cast as the fast helper (routing, summarization, quick edits, sub-agent calls) than as the model that owns a two-hour refactor. All benchmark figures here are JetBrains’ self-reported numbers from the technical report; no independent verification suite had published Mellum 2 results as of today, so treat them as vendor numbers with an unusually candid architecture paper behind them.

Second: the comparison with Qwen3-Coder-30B-A3B — the default local coding pick for most of 2026 — is really a hardware question. Qwen3-Coder-30B has 3.3B active parameters and a ~19GB Q4 quant: a 24GB-card model. Mellum 2’s Q4_K_M is 8.1GB: a 12GB-card model. They’re not fighting for the same slot. (Their vendor benchmark numbers also come from different LiveCodeBench versions and harnesses, so we won’t pretend a head-to-head score table exists. It doesn’t.)

Local setup: three commands with Ollama

Ollama v0.32.5 (the current stable, released July 27) runs the official GGUFs directly from Hugging Face — no Modelfile required:

$ ollama run hf.co/JetBrains/Mellum2-12B-A2.5B-Instruct-GGUF-Q4_K_M
pulling manifest
pulling ... 100% ▕████████████████▏ 8.1 GB
verifying sha256 digest
success
>>> /bye

JetBrains also publishes models under its own Ollama namespace if you’d rather pull the Q8_0 Thinking build. Pick your variant deliberately:

  • Instruct, Q4_K_M (8.1GB) — the default for Cline and Cursor chat. Tool calling, edits, conversational work.
  • Thinking, Q4_K_M — when you want the RLVR reasoning pass; slower per answer, better on gnarly bugs.
  • Q8_0 (~13GB) — effectively lossless, but you’ve now spent the VRAM savings that made this model interesting on a 12GB card. Only worth it on 16GB+.
  • Base — fill-in-the-middle completion. Only relevant if your editor can use a raw FIM endpoint (Continue.dev can; see below).

The rest of the runtime menu works too — the GGUFs load in llama.cpp and LM Studio as well, and if you go the LM Studio route, our connection-error fix guide covers the port and CORS traps that bite Cline and Continue users.

Wiring it into your tools

Cline: Settings → API Provider → Ollama, base URL http://localhost:11434, model hf.co/JetBrains/Mellum2-12B-A2.5B-Instruct-GGUF-Q4_K_M (the full tag, as ollama ls shows it). Cline’s OpenAI-compatible provider pointed at http://localhost:11434/v1 also works. Use the Instruct variant — Cline’s whole loop is tool calls, and if you see the model narrating tool calls instead of making them, that’s the failure mode we documented in the Cline tool-use loop fix.

Cursor: local models go through the OpenAI base-URL override, and the caveats haven’t changed — Chat and Cmd+K work, Tab completion stays on Cursor’s cloud models regardless of what you configure. The full walkthrough is in our Cursor + Ollama setup guide; everything there applies with the model name swapped.

Continue.dev: the sleeper fit. Continue supports separate chat and autocomplete models, and Mellum 2 is one of the few 2026 releases that ships a dedicated FIM-capable Base variant from a vendor whose entire lineage is production in-IDE completion. Instruct for chat, Base for autocomplete, both under 131K context, both on one mid-range card — that’s a complete local Copilot replacement in under 20GB of downloads.

Claude Code: Ollama’s Anthropic-compatible endpoint runs it as a backend — the one-command setup we documented in July works unchanged. But given the agentic-depth caveat above, we’d keep Claude Code pointed at a stronger model and use Mellum 2 elsewhere in the stack.

The trap: Ollama’s context default on a 12GB card

Ollama scales its default context window by total VRAM, and the bands are unforgiving: cards below the 24GiB band can land on the 4K default — which silently truncates Cline’s system prompt and produces the confused, tool-less behavior that looks like a broken model. It isn’t. Pin the context explicitly:

OLLAMA_CONTEXT_LENGTH=16384 ollama serve

On a 12GB card with 8.1GB of weights loaded, you have roughly 4GB for the KV cache; 16K is a sane starting pin, and Mellum 2’s sliding-window attention is specifically designed to keep long-input latency down once you raise it. Watch for system-RAM spill on your first long Cline session — generation slowing over time is cache spill, not model fatigue. The full mechanics are in our Ollama context length fix, and if the connection itself won’t come up, start with the connection-refused checklist.

The hardware math is the actual story

Every local backend we’ve covered this year — Laguna XS 2.1 at 20GB, Ornith-1.0 at 21.2GB, Qwen3-Coder-30B at 19GB — assumed you own a 24GB card. An RTX 3060 with 12GB, the most common “I have a gaming PC” configuration in the r/LocalLLaMA hardware threads, has been shut out of the serious-coding-model tier all year.

Mellum 2 is the first 2026 release from a major vendor that changes that: 8.1GB of weights plus headroom for a 16K cache fits in 12GB with room to breathe. On a 24GB RTX 4090, the calculus inverts — you could run Mellum 2 with a huge context pin, but you could also run Qwen3-Coder-30B, and for a primary agent you probably should. The interesting 24GB play is running both: Qwen3-Coder as the primary agent and Mellum 2 Q4_K_M as the fast second model for summarization, commit messages, and quick chat, which is precisely the multi-model-pipeline role JetBrains built it for.

On Apple silicon, the 8.1GB quant runs comfortably from 16GB of unified memory — the first model in this series we can say that about. For the broader what-fits-on-what table, runaihome.com’s local models by VRAM guide stays the reference, and aifoss.dev tracks the self-hosting and FOSS tooling side of the same build.

Verdict: the best model for the card most people actually own

The 2026 local coding scene keeps optimizing for the 24GB enthusiast. JetBrains just shipped the strongest option for everyone below that line, licensed it Apache 2.0, published the architecture trade-offs in a real technical report, and put official quants on Hugging Face and Ollama on day one. That’s how an open release should be done.

Just read the split honestly: this is a fast specialist. On a 12GB card it’s the best coding backend available, full stop. On a 24GB card it’s the second model in your stack, not the first — Qwen3-Coder-30B or a cheap cloud backend like DeepSeek V4-Flash still owns the primary-agent slot. A model that knows what it’s for beats a model that claims to be for everything, and Mellum 2 knows what it’s for.

FAQ

Is Mellum 2 the same thing as JetBrains AI Assistant? No. AI Assistant is the paid cloud subscription inside JetBrains IDEs (our review). Mellum 2 is the open-weight model, free to download and run anywhere — including inside Cursor, Cline, or Continue.dev, with no JetBrains IDE involved.

Can I use Mellum 2 for commercial client work? Yes. Apache 2.0 permits commercial use, modification, and redistribution with attribution. There’s no usage-restriction rider like some “open” model licenses carry.

Does it work for Cursor Tab autocomplete? No — Cursor’s Tab completion always uses Cursor’s cloud models; the local override only covers Chat and Cmd+K. If local autocomplete is the goal, use Continue.dev with the Mellum 2 Base (FIM) variant.

Which variant should Cline users pull? Instruct, Q4_K_M. The Thinking variant reasons better but responds slower, which compounds badly across Cline’s many tool calls per task. Save Thinking for hard single questions.

How does it compare to Gemma or the other small local models? Against the Gemma 4 QAT builds in the same VRAM class, Mellum 2’s edge is code-specific training lineage and the dedicated FIM Base variant; Gemma remains the better general-purpose chat model. For coding work on a 12GB card, we’d pull Mellum 2 first.

  • RTX 3060 12GB — the budget card that Mellum 2’s 8.1GB quant finally makes viable for serious local coding
  • RTX 4090 — 24GB of VRAM to run Mellum 2 alongside a primary 19–20GB agent model

Sources

Last updated August 5, 2026. Pricing and features change frequently; verify current state before purchasing.

Was this article helpful?