JetBrains Mellum2.1 is a 12B open-weight model that went from almost useless at agentic coding to solving 47% of SWE-bench Verified tasks, with nothing changed but the training recipe. JetBrains released it in early October 2026 under Apache 2.0, and it runs with only 2.5B parameters active per token.
That is the headline. The part JetBrains is less loud about sits in its own benchmark table: Alibaba’s Qwen3.5-9B still beats Mellum2.1 on every agentic coding benchmark JetBrains reports. I went through the JetBrains announcement, the Hugging Face model card and the GGUF repo to work out who should actually run this thing.
What Is JetBrains Mellum2.1?
Mellum2.1 is a 12B-parameter mixture-of-experts model with 2.5B active parameters, built to act as a fast worker inside coding agents rather than as the main brain. It is the third model in the Mellum line.
The history matters here. The original Mellum was a 4B model for code completion inside JetBrains AI Assistant. Mellum2 arrived on June 1, 2026 as a 12B MoE that added natural language, aimed at routing, RAG pipelines and controlling subagents. JetBrains called it a “focal model”, meant to sit next to frontier models, not replace them.
Mellum2 had a problem, and JetBrains says so plainly in the launch post: “Mellum2 was fast, but it couldn’t work inside a repository at the level we wanted.”
Mellum2.1 keeps the exact same architecture. Every change is in post-training. JetBrains turned reinforcement learning from a short final stage into the main part of training, with millions of sandboxed runs across thousands of environments covering math, competitive programming, science, tool use and software engineering.
The specs from the Hugging Face model card:
- Parameters: 12B total, 2.5B active, 64 experts with 8 active per token
- Layers: 28, grouped-query attention with 32 query heads and 4 KV heads
- Attention window: sliding window of 1,024 tokens in three of every four layers
- Context: 131,072 tokens
- License: Apache 2.0, weights in bfloat16
- Mode: a “Thinking” model that reasons before answering
The sliding-window layers are why this model is cheap to serve at long context. Only one layer in four pays the full attention cost, so KV cache memory grows far slower than in a dense 12B model.
Mellum2.1 is a small, permissively licensed reasoning model whose whole upgrade over Mellum2 came from reinforcement learning, not a bigger network.
Mellum2.1 Benchmarks: The 2% to 47% Jump
The number everyone is quoting is SWE-bench Verified. Mellum2 scored 2.0%. Mellum2.1 scores 47.0%.
I have not seen a jump that size from post-training alone on a model this small. It tells you Mellum2 was never short of raw capability, it simply had no idea how to behave inside a repository: when to read a file, when to run a test, when to stop.
Here is the agentic slice of JetBrains’ table. All four models were run by JetBrains through the same pipeline: the Pi v0.73.1 harness with shell and file tools, a 114K-token context and up to 16K tokens per turn.
- Qwen3.5-9B 50%
- Mellum2.1 47%
- Gemma 4 E4B 23%
- Mellum2 2%
Source: JetBrains, Mellum2.1-12B-A2.5B-Thinking model card (Oct 2026)
And the wider picture across categories:
| Model | SWE-bench Verified | SWE-bench Pro | Terminal-Bench 2.1 | LiveCodeBench v6 | BFCL v4 |
|---|---|---|---|---|---|
| Mellum2.1 | 47.0% | 28.0% | 17.4% | 82.0% | 62.3% |
| Qwen3.5-9B | 50.0% | 38.0% | 21.7% | 75.4% | 58.5% |
| Gemma 4 E4B | 23.0% | 4.0% | 3.4% | 69.4% | 52.5% |
| Mellum2 | 2.0% | 0.0% | 0.6% | 69.4% | 49.6% |
(Source: JetBrains Mellum2.1 model card, vendor-reported, thinking mode)
Read that table twice. Qwen3.5-9B leads Mellum2.1 on all three agentic coding benchmarks, and the SWE-bench Pro gap is 10 points. Pro is the harder, less contaminated benchmark, so that is the column I trust most.
Mellum2.1 wins on competitive programming, with 82.0% on LiveCodeBench v6, and on function calling, with 62.3% on BFCL v4. It also beats Qwen3.5-9B on MBPP+ (79.4% vs 69.8%) and HumanEval+ (91.5% vs 89.6%).
Qwen3.5-9B takes math and knowledge: AIME 86.7% vs 83.3%, GPQA Diamond 77.8% vs 64.6%.
One honest note on safety. Mellum2.1 cut its HarmBench score (lower is better) from 21.5% to 8.5%, but Qwen3.5-9B sits at 6.6%. Neither number is alarming for a model that lives behind your own firewall.
For scale, Claude Opus 4.6 was reported at 80.8% on SWE-bench Verified back in February. Different harness, different setup, so do not subtract one from the other, but it tells you where a 12B model sits: useful for scoped steps, not for owning a whole ticket.
On JetBrains’ own numbers, Mellum2.1 is the better tool caller and competitive programmer, and Qwen3.5-9B is the better repository agent.
Mellum2.1 Speed: Where JetBrains Makes Its Case
If Qwen wins on agentic accuracy, why would you pick Mellum2.1? Throughput.
JetBrains says that under heavy load on a single NVIDIA H200, Mellum2.1 serves nearly twice as many output tokens per second as Qwen3.5-9B. For a single request, multi-token prediction makes it about 1.6x faster. Zeniteq’s coverage points out the obvious caveat: these are company measurements with no independent replication yet, and the exact tokens-per-second figures only appear in a chart image.
The architecture backs the claim up, though. A model with 2.5B active parameters does roughly a quarter of the per-token compute of a dense 9B model, and the sliding-window layers keep memory traffic low. A 2x serving advantage is plausible.
There is a catch on the 1.6x figure. The MTP head for speculative decoding in vLLM is listed as “coming soon” in the announcement. Until that ships, the single-request speedup is not something you can reproduce with the published weights.
This is where the tradeoff becomes concrete. Subagent work is high-volume and short: grep this, summarise that file, check whether the test passes. If your agent fans out 20 subagents per task, throughput matters more than three points of SWE-bench. If you run one long agent loop, Qwen3.5-9B’s accuracy matters more.
Mellum2.1’s real advantage is tokens per GPU-second, which makes it a better fit for many small parallel subagent calls than for a single long agent run.
How to Run Mellum2.1 Locally
This part is easier than the announcement suggests. The blog post says GGUF builds for llama.cpp, Ollama and LM Studio are “coming soon”, but the GGUF repository is already live on Hugging Face with five quantisations:
| Build | Size | Fits on |
|---|---|---|
| BF16 | 24.3 GB | 32 GB+ GPU or Mac |
| Q8_0 | 12.9 GB | 16 GB GPU, tight |
| Q6_K | 10.9 GB | 16 GB GPU |
| Q4_K_M | 8.1 GB | 12 GB GPU or 16 GB Mac |
| MXFP4_MOE | 7.0 GB | Smallest option |
(Source: Mellum2.1 GGUF repo on Hugging Face; “fits on” is my estimate from file size plus KV cache headroom)
JetBrains marks Q4_K_M as the recommended build. With Ollama:
ollama run hf.co/JetBrains/Mellum2.1-12B-A2.5B-Thinking-GGUF:Q4_K_MWith llama.cpp, which gives you an OpenAI-compatible endpoint at http://localhost:8080/v1 that most agent harnesses can point at:
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 20For a GPU server running an agent fleet, use vLLM with tool calling switched on:
vllm serve JetBrains/Mellum2.1-12B-A2.5B-Thinking \
--max-model-len 131072 \
--reasoning-parser qwen3 \
--enable-auto-tool-choice \
--tool-call-parser hermesTwo details tripped me up reading the model card. First, the sampling settings: the quickstart uses temperature 0.6, but JetBrains ran the agentic benchmarks at each model’s default sampling, which is temperature 1.0 for Mellum2.1. If you want to reproduce the 47%, use 1.0. Second, the quickstart allows max_tokens of 81,920. A thinking model can burn a lot of that on reasoning before it writes a line of code, so cap it lower for subagent calls.
Mellum2.1 runs today in Ollama, llama.cpp, LM Studio, vLLM and SGLang, and the recommended 8.1 GB build fits on most developer machines with a recent GPU or 16 GB of unified memory.
Mellum2.1 vs Hosted Small Models: When Self-Hosting Wins
The obvious alternative is not another open model. It is a cheap hosted one.
Claude Haiku 5.5 launched on October 7 at $0.10 per million input tokens and $0.50 per million output for prompts up to 100K tokens. GPT-6 Luna lists at the same price. At those rates, most solo developers will spend less on API calls than on the electricity and attention a local model costs. The current numbers for every model are on our AI model pricing tracker.
So who should run Mellum2.1?
Teams that cannot send code off the machine. Regulated industries, defence contractors, anyone whose security review rejects a hosted API. An Apache 2.0 model that runs air-gapped is the whole point here, and a 12B MoE is small enough to deploy without a dedicated ML platform team.
Teams running large subagent fleets on hardware they already own. If you have idle H100s or H200s, 2x throughput over Qwen3.5-9B turns into real capacity. Size is the other half of the argument: the full DeepSeek-R1 needs roughly 685GB of FP8 weights and more than one 8x H100 node, as our DeepSeek-R1 production analysis works out, while Mellum2.1’s BF16 weights are 24.3 GB.
JetBrains IDE users who want a local model in Air. The standalone JetBrains Air app added local models through Ollama and LM Studio in July, so Mellum2.1 slots straight in. JetBrains’ launch post does not connect the two, so treat that as a combination you can build today, not an official integration.
If you just want to swap a cheaper open model into Claude Code without running hardware, the Together Link guide covers routing to hosted GLM 5.3 and similar models, which is a very different trade.
And if you are in the habit of applying for startup credits to cover API bills, note that Anthropic just paused the biggest part of its offer, as covered in our Claude for Startups breakdown. Credits are not a plan.
Self-hosting Mellum2.1 makes sense for privacy-bound teams and for anyone with spare GPUs; for everyone else, a $0.10-per-million hosted small model is cheaper and stronger.
The Bigger Picture for Small Open Coding Models
What interests me most about Mellum2.1 is not the model. It is the recipe.
JetBrains took an architecture that scored 2% on SWE-bench Verified and, without adding a single parameter, got it to 47% with reinforcement learning in sandboxed repositories. That is the same lesson Reflection AI’s Beam leaned on at 501B parameters with over 100 million RL rollouts. RL in real environments is where agent capability now comes from, and JetBrains shows it works at the small end too.
JetBrains’ own framing is “Open source is how better models get made.” That is partly marketing for an IDE company that needs developers to trust its AI stack. It is also true that an Apache 2.0 model with a public eval pipeline is easier to trust than a closed one with a press release.
My read: Mellum2.1 is not the best small open coding agent in October 2026. On JetBrains’ own table, Qwen3.5-9B is. Mellum2.1 is the fastest one in that comparison and a credible subagent model, and the RL result is the most useful thing JetBrains has published about agent training so far.
If you need one small open model for repository work, start with Qwen3.5-9B; if you need many fast subagent calls on your own hardware, Mellum2.1 is the one to benchmark first.
