By JetBrains released Mellum 2.1 on October 8. The architecture did not change. The parameter count did not change. What changed is how they trained it — and the result is a 45-point jump on SWE-bench Verified, from 2% to 47%, with zero additional compute footprint. That single fact is the whole story: reinforcement learning in real software environments turned a mediocre code-completion model into a functioning coding agent.
What Actually Changed
Mellum 2 used reinforcement learning as a short final stage — a bit of polish after standard training. Mellum 2.1 made RL the main event. JetBrains ran the model through millions of sandboxed tasks drawn from real software environments: explore a repository, identify a bug, edit the relevant files, run the tests, and verify the fix holds. Over and over, at scale.
The model that emerged behaves differently than one trained primarily on static code. It learned to treat code as an environment to operate in, not a pattern to match. That is the difference between a model that suggests likely tokens and one that can close a GitHub issue.
Architecture and Efficiency
Mellum 2.1 is a 12-billion-parameter mixture-of-experts model with 64 experts and 8 active per token — which means only 2.5 billion parameters do actual computation on each forward pass. This is the deployment argument. You get inference costs similar to a 2.5B dense model inside a 12B body that has seen far more training signal. The context window is 131,072 tokens, and the model ships under Apache 2.0, meaning free commercial use, no copyleft restrictions, fully self-hostable.
In Q4_K_M quantization, Mellum 2.1 fits in 8.1 GB of VRAM. That is a single RTX 4090 or a MacBook with 16 GB of unified memory. Under heavy load on an H200, JetBrains reports the model serving nearly twice the token throughput of Qwen 3.5 9B. Throughput matters if you are running agent fleets where dozens of sub-agent calls happen in parallel.
Benchmark Honesty
The 47% SWE-bench Verified score is the headline, but it is worth reading the full table before routing production workloads through this model.
| Benchmark | Mellum 2.1 | Qwen 3.5 9B |
|---|---|---|
| SWE-bench Verified | 47.0% | 50.0% |
| LiveCodeBench v6 | 82.0 | 75.4 |
| AIME 25/26 | 83.3 | 86.7 |
| GPQA Diamond | 64.6 | 77.8 |
| HumanEval+ | 91.5 | — |
| Terminal-Bench 2.1 | 17.4% | — |
Qwen 3.5 9B actually leads on SWE-bench Verified (50.0 vs 47.0), reasoning, and general science tasks. Mellum 2.1 leads on competitive programming and serves tokens faster. The Terminal-Bench 2.1 score of 17.4% is the most honest signal about current limitations: long-horizon, multi-step repository-wide tasks are still hard. Independent analysis recommends waiting for third-party SWE-bench runs before moving anything important to this model — those typically appear two to four weeks after a major open-weight release.
How to Deploy It
Two model variants are available on Hugging Face: JetBrains/Mellum2.1-12B-A2.5B-Instruct and JetBrains/Mellum2.1-12B-A2.5B-Thinking. The Thinking variant is for tasks where you want explicit reasoning traces before a final answer.
# Download the Instruct variant
huggingface-cli download JetBrains/Mellum2.1-12B-A2.5B-Instruct
# Serve via vLLM with full context
vllm serve JetBrains/Mellum2.1-12B-A2.5B-Instruct --max-model-len 131072 --tensor-parallel-size 1vLLM, Hugging Face Transformers, SGLang, and Docker Model Runner work today. GGUF quantized builds for Ollama, llama.cpp, and LM Studio are listed as coming soon, though community-built GGUF variants may already be available on Hugging Face.
Where It Fits in an Agent Stack
Mellum 2.1 is not a replacement for frontier models on complex reasoning tasks. It is a sub-agent engine. The sensible architecture is: frontier model handles planning and difficult judgment calls, Mellum 2.1 handles the high-volume, lower-stakes operations — file edits, test runs, code lookups, routing decisions. At 2.5B active parameters and the throughput advantage, you can run many parallel sub-agent calls on a single GPU that would otherwise go to a hosted API at 5–10x the cost.
Self-hosting makes financial sense past roughly 2–5 million tokens per day on reserved capacity over a 12-month window. Below that, hosted APIs still win on total cost once you factor in GPU uptime, maintenance, and the accuracy gap on reasoning-heavy tasks. The clear use cases are privacy-sensitive environments where code cannot leave the network, and regulated industries where data residency is non-negotiable.
The Bigger Implication
The 2% to 47% jump without touching the architecture is a clear signal about where model improvement is heading. Parameter count stopped being the main differentiator some time ago; Mellum 2.1 demonstrates it as cleanly as any model has on a standard benchmark. JetBrains had an advantage here — years of IDE telemetry from real developer workflows gave them a training environment that is harder to replicate from web scrapes alone.
The question for the next few months is whether independent benchmarkers confirm the SWE-bench number. If the 47% holds, this becomes the default self-hosted sub-agent backbone for anyone with a GPU to spare. If it does not, Qwen 3.5 9B is sitting right there at 50%.
