JetBrains Mellum2.1: Specs, Benchmarks and How to Run the Open 12B Coding-Agent Model Locally

JetBrains released Mellum2.1, an Apache 2.0 mixture-of-experts model with 12B total and 2.5B active parameters trained for coding agents. Self-reported benchmarks against Qwen3.5-9B and Gemma 4, GGUF sizes, and how to evaluate it before using it in your workflow.

PUBLISHED // UPDATED
DURATION // 06 MIN READ
Developer workstation with a JetBrains-style IDE on one monitor and a printed model card showing 12B total and 2.5B active parameters, cool desk lamp, no logos
FIG.01 // VISUAL DOCUMENTATION Developer workstation with a JetBrains-style IDE on one monitor and a printed model card showing 12B total and 2.5B active parameters, cool desk lamp, no logos

JetBrains released Mellum2.1 in October 2026, an open-weight model built to act as a coding agent or a fast sub-agent on your own hardware. It keeps the architecture of Mellum2 (12 billion parameters in total, 2.5 billion active per token, Apache 2.0 licence) and changes almost everything after pre-training, with reinforcement learning in real software environments now the main part of training. JetBrains’ own benchmarks show a large jump in agentic coding over Mellum2, but the model still trails Qwen3.5-9B on several agent tasks, and all results are self-reported. This guide covers the specs, the numbers, how to run it locally and how to test it safely.

What changed from Mellum2

According to JetBrains’ announcement, Mellum2 was fast but “couldn’t work inside a repository at the level we wanted”. For version 2.1 the team:

  • made reinforcement learning the main training stage rather than a short final step;
  • added RL tasks in math, competitive programming, science, tool use and software engineering, filtering open datasets for broken tests and unverifiable answers;
  • trained the model inside real repositories with a shell and file-editing tools, rewarding it when tests pass, over millions of sandboxed runs across thousands of environments.

The result, JetBrains says, is a model that can explore a codebase, edit files and check its own changes.

Specifications

From the Hugging Face model card:

SpecValue
Parameters12B total, 2.5B active
Experts64, with 8 active per token
Layers28
Context length131,072 tokens
AttentionGQA, 32 query and 4 key/value heads; 1,024-token sliding window on 3 of every 4 layers
Precisionbfloat16
LicenceApache 2.0

Mellum2.1 is a “thinking” model: it writes its reasoning inside <think> blocks before the final answer. JetBrains positions it for agentic tasks and hard coding, math and reasoning problems.

Benchmarks (self-reported)

JetBrains evaluated Mellum2.1, Mellum2 and two open models of a similar class with the same pipeline. The model card states plainly that “all values are self-reported by JetBrains”. Selected results:

BenchmarkMellum2.1Mellum2Gemma 4 E4BQwen3.5 9B
SWE-bench Verified47.02.023.050.0
SWE-bench Pro28.00.04.038.0
Terminal-Bench 2.117.40.63.421.7
LiveCodeBench v682.069.469.475.4
AIME 25/2683.360.145.086.7
BFCL v4 (tool calling)62.349.652.558.5
GPQA Diamond64.651.053.177.8
HarmBench (lower is better)8.521.538.16.6

Three things stand out:

  1. The agentic gain is real on JetBrains’ numbers. SWE-bench Verified went from 2.0 to 47.0, which shows how much the RL work changed behaviour in repositories.
  2. Qwen3.5-9B still leads on agent benchmarks. It scores higher on SWE-bench Verified, SWE-bench Pro and Terminal-Bench. Mellum2.1’s advantage is in competitive programming (LiveCodeBench) and tool calling (BFCL), plus speed.
  3. The agentic results depend on the harness. All agentic tests used the same open-source harness (Pi v0.73.1 with shell and file tools), a 114K-token context and up to 16K tokens per turn. Your results with a different agent framework may differ.

Speed

Because the architecture is unchanged, Mellum2.1 is as fast as Mellum2. JetBrains says that under heavy load it serves almost twice as many tokens as Qwen3.5-9B, and that multi-token prediction (MTP) makes a single request about 1.6 times faster. These are JetBrains’ measurements; with only 2.5B active parameters, high throughput is plausible, but test it on your own hardware.

Running it locally

At launch, JetBrains listed GGUF builds and the MTP head as “coming soon”. As of our check on November 12, 2026, both are published:

  • GGUF builds for llama.cpp, Ollama and LM Studio. Q4_K_M (8.1 GB) is the recommended balance; Q8_0 is 12.9 GB, Q6_K 10.9 GB, and the smallest MXFP4 build 7.0 GB. A separate 1.8 GB file provides the MTP head for speculative decoding in llama.cpp.
  • An MTP variant for vLLM 0.33 or newer, with weights identical to the main release plus the prediction head.

The main repository can be served with vLLM using the qwen3 reasoning parser and, for tool use, the hermes tool-call parser, as shown on the model card. As a rough guide, the Q4_K_M file plus context should fit on a GPU or Apple Silicon machine with 16 GB of memory, although long contexts will need more.

How to evaluate it for your team

  1. Rerun a small agent benchmark with your own harness. Pick 20 to 50 real issues from your repositories with tests attached, and compare Mellum2.1 with the model you use now.
  2. Use it as a sub-agent first. Its strengths (speed, tool calling, low cost) suit focused jobs such as finding the root cause of a failing test or drafting a fix for review, with a larger model handling planning.
  3. Sandbox the agent. The sandboxes used in training are not your CI. Run it in a container or runner with no push rights to protected branches and no access to production secrets. Our guide on securing AI coding agent plugins covers related precautions.
  4. Check licences and data flow. Apache 2.0 allows commercial use, and self-hosting keeps code on your own infrastructure, which is the main reason to choose an open model over a hosted agent.

For comparison with hosted options, see our coverage of Claude Code’s parallel agents and OpenAI Codex cloud environments.

Our analysis

Mellum2.1 is a good example of how much post-training can change a small model: the same 12B architecture went from nearly useless on SWE-bench to competitive with the best models in its class. It is not the strongest small agent model on every benchmark, since Qwen3.5-9B leads on most agentic tests, but its speed, permissive licence and now-available GGUF builds make it a practical candidate for self-hosted sub-agents. Treat the published scores as a starting point and measure it on your own repositories before relying on it.