JetBrains’ Mellum2 is a 12B-parameter mixture-of-experts model that activates 2.5B parameters per token, with weights released under Apache 2.0 (JetBrains announcement). That combination makes it worth examining for private coding assistants and smaller components of an AI application. It does not tell you which GPU to buy. All performance results discussed here are JetBrains’ own reports; we have not independently tested this model.
The family succeeds the completion-focused 4B dense Mellum and covers a wider set of coding and assistant tasks. The Instruct model card describes direct answers and tool use, while the technical report describes both Instruct and Thinking variants. JetBrains’ training-content summary records May 29, 2026 as the market-placement date. These are existing release materials, not evidence of a new September launch.
For a local-deployment decision, the release settles four things and leaves two open. Settled: the architecture, the license, the variant map, and the training provenance. Open: how much memory your deployment will need, and how fast it will run. The distance between those two lists is where the actual evaluation happens.
Two parameter counts, two budgets
Mellum2 stores 64 experts and activates 8 per token (model card). That is where the two headline numbers come from: 12B total parameters, 2.5B active on each forward pass. The technical report states the payoff as competitiveness with open-weight baselines in the 4B-14B range “while running at the per-token compute of a 2.5B dense model.”
The two numbers govern different budgets. Compute per token tracks the active 2.5B, which is what makes low-latency serving plausible on modest hardware. Memory tracks the full 12B, because the unselected experts still need storage. Offloading can change where those weights live and how quickly they are accessed; it does not eliminate them. An MoE model is a small model’s compute bill attached to a large model’s storage bill, and a sizing exercise that uses 2.5B for both will order the wrong machine.
JetBrains also claims “more than 2x faster inference” than similarly sized open models (launch post). That is a vendor measurement from the company’s own evaluation. Treat it as evidence of design intent, not as a capacity-planning input.
Instruct or Thinking: the variant decision comes first
The model card tells you how to choose. Use Instruct “when you want direct, low-latency answers without an explicit chain of thought”: interactive chat, code assistance, tool use, and instruction following. Switch to Thinking “if you need explicit reasoning before the answer”: complex debugging, planning, and multi-step agentic flows (model card).
The variant map is documented stage by stage in the training-content summary. Base-Pretrain is the pre-trained model with a native 8,192-token context. Base adds a long-context extension to 131,072 tokens, done with layer-selective YaRN per the report, trained on roughly 117B additional tokens. Instruct-SFT and Thinking-SFT add supervised fine-tuning, about 47B tokens for the direct assistant and 167B for the reasoning-trace assistant. The final Instruct and Thinking checkpoints finish with reinforcement learning from verifiable rewards, on the order of 260,500 training prompts and 500 RL steps for Instruct.
This choice is a deployment decision, not a preference. A Thinking model emits its reasoning before its answer, so each query produces more output tokens, and latency and cache behavior follow output length. An Instruct deployment keeps generations short for interactive use. And if your workload is not conversational at all, such as routing, prompt classification, retrieval post-processing, or sub-agent planning and validation, the launch post positions the family for exactly those latency-sensitive jobs (launch post). Pick the variant against the workload before sizing anything, because the variants are different serving problems.
The weights are not the memory bill
The model card specifies a context window of 131,072 tokens. Treat that as a supported limit, not a sensible default for every application. Working memory includes the KV cache and runtime overhead as well as model weights. A workload with short prompts and one active request is a different sizing problem from long documents and concurrent users.
The technical report describes grouped-query attention with four KV heads and sliding-window attention on three of every four layers. Those choices affect cache requirements. It also describes a multi-token-prediction head for speculative decoding, a separate feature aimed at inference efficiency. Check what your chosen serving implementation supports before assuming that an architectural feature translates into a measured gain.
Start with the context length and concurrency your application needs. Measure memory use and latency with that configuration, then raise each separately. If the plan depends on quantization, identify the exact artifact, precision and runtime before comparing results. A memory figure for another quantization or a single idle request is an incomplete answer to your deployment question.
What Apache 2.0 settles, and what it does not
Every checkpoint in the family, base, instruct, and thinking, is out under Apache 2.0 (technical report, model card). Apache 2.0 is a permissive license; commercial self-hosting, modification, and fine-tuning sit within its grant, subject to the license terms. The model license is one part of deployment review, alongside the data and software you put around it.
For regulated teams, the more interesting document is the public training-content summary. It names the provider (JetBrains s.r.o., with a contact address), lists all six versioned model identifiers, records pre-training at roughly 10.65 trillion tokens with a latest data-acquisition date of May 2026, and states the market-placement date. It is the kind of provenance disclosure that general-purpose AI rules increasingly require, and its existence means the first questions an auditor asks have a primary-source answer. Whether that answer satisfies your specific regulator is a question for counsel, not for a model card.
The training story behind it comes from the report: roughly 10.6T tokens across a three-phase curriculum that shifts from diverse web data toward curated code and math, optimized with Muon under FP8 hybrid precision. The provenance is documented; the quality judgment still has to be yours.
How fast is it, and how good?
The reported evidence is JetBrains’ in both cases. The model card publishes scores across code generation (EvalPlus, the mean of HumanEval+ and MBPP+), math and reasoning (AIME 2025 and AIME 2026), tool use (BFCL v4), knowledge (MMLU-Redux, GPQA Diamond), conversational behavior (IFEval, MixEval), and safety (HarmBench, XSTest). One row carries its own caveat in the card’s notes: “JetBrains pairwise” is a win rate against Qwen2.5-7B-Instruct on an internal benchmark. Internal comparisons are directional evidence, not third-party validation, and the card is forthright enough to label it as such.
The report’s headline claim, competitiveness in the 4B-14B open-weight band at the per-token compute of a 2.5B model, is the right hypothesis to test against your own workload. Code models earn their keep on your codebase, your language mix, and your latency budget, none of which appear in a published table.
What to measure before you spend
In order of consequence:
- Variant. Instruct for direct answers and interactive latency; Thinking when the task needs a reasoning trace; Base if you are post-training your own assistant. The choice changes the serving problem, not just the prompt.
- Memory at your context length. Use a compatible serving runtime with the context length and concurrency you need, on the GPU you have, and record the footprint. That measurement is your floor; no article’s figure substitutes for it.
- Quantized artifacts, if your budget requires them. If your hardware plan depends on lower precision, verify the exact available artifact and evaluate its quality before sizing the deployment.
- Speed, against the claim. JetBrains reports more than 2x faster inference than similarly sized open models. Reproduce a throughput measurement on your own stack and treat any gap as your real number.
- Quality on your corpus. Run the suites that matter to you, or run the model on representative tasks. Weight the internal pairwise win rate as the weakest evidence in the set.
- Compliance paper. The Apache 2.0 text plus the training-content summary, dated and scoped to the exact versioned identifiers you deploy.
The verdict, on the evidence the release provides: Mellum2 is a well-documented open-weights family whose license, architecture, and training provenance you can check against primary sources today. Its hardware fit you cannot check against any of those sources; you measure it. That division of labor, facts you can cite and numbers you must produce, is the honest shape of any self-hosting decision, and this release is unusually cooperative about the first half.
