JetBrains Mellum2.1: small 12B MoE coding-agent model, Apache 2.0

What it's about

JetBrains, known for IntelliJ IDEA and PyCharm, has released the model Mellum2.1 Thinking (JetBrains/Mellum2.1-12B-A2.5B-Thinking) on Hugging Face. It is a Mixture-of-Experts (MoE: many sub-networks, of which only a few compute per token) model with 12 billion parameters in total and 2.5 billion active. The license is Apache 2.0, so commercial use is allowed. According to the Model Card, it is designed for complex agentic tasks, such as working in a repository, running commands and calling tools, as well as for hard problems in programming, math and logical reasoning.

A note on dates: the Reddit post is dated November 2, 2026, while tech-insider.org gives October 8, 2026 as the release date. The two don't clearly line up. The version with the MTP head is probably the newer one.

What's new: reinforcement learning in real environments

Mellum2.1 is the successor to Mellum2 Thinking. The architecture stayed the same, and nearly all the work went into post-training, mainly reinforcement learning (RL: the model is rewarded for good results). According to JetBrains, RL went from a short final phase to the main part of training:

• More and more strictly filtered data: new RL tasks in math, competitive programming, science, tool use and software engineering, partly from open datasets and partly built in-house. Every source was filtered before training.
• Real environments: For software engineering, the model trains in real repositories with a shell and file editor, and is rewarded when tests pass.

After millions of sandbox runs, the model should be able to explore a codebase, edit files and check its own changes. Tech-insider.org speaks of thousands of environments.

Specs

Before answering, the model outputs visible reasoning in <think> blocks. According to the Hugging Face documentation, the architecture is based on Qwen3-MoE with layer-specific rotary embeddings and alternating sliding-window attention.

Benchmarks

JetBrains ran all figures itself with the same pipeline in thinking mode. They are not independent results. The comparison is against the predecessor, Gemma 4 (E4B) and Qwen3.5 (9B).

The jumps over Mellum2 are huge, especially on the agent benchmarks. The predecessor scored close to zero there, possibly because it wasn't trained for this kind of agentic work. Against Qwen3.5 (9B), Mellum2.1 leads in coding (LiveCodeBench, HumanEval+, MBPP+) and tool use (BFCL), but trails on agent benchmarks, knowledge (GPQA Diamond: 64.6 vs. 77.8) and safety. The agent tests used the open-source harness Pi v0.73.1 with shell and file tools, 114K context and up to 16K tokens per turn.

Deployment and speed

For serving, the card recommends vLLM with --max-model-len 131072 --reasoning-parser qwen3, plus --enable-auto-tool-choice --tool-call-parser hermes for tool calling. SGLang and Docker Model Runner are also listed. For sampling, the card specifies temperature 0.6, top_p 0.95 and top_k 20, with up to 81,920 output tokens.

According to the Model Card, GGUF builds for llama.cpp, Ollama and LM Studio are still "coming soon." Tech-insider.org, however, already mentions GGUF quantizations such as Q4_K_M, which the Model Card doesn't yet confirm.

New is an MTP head (Multi-Token Prediction): an extra transformer block, trained alongside the model, that predicts the token after the one just chosen. The main model checks every suggestion, so the output stays unchanged. According to JetBrains, decoding runs 1.4–1.8x faster with about 90% of drafts accepted. Requirements: vLLM 0.33 or later (--speculative-config '{"method": "mtp", "num_speculative_tokens": 1}'), transformers 5.20 or later (use_mtp=True), or llama.cpp with the GGUF variant (--spec-type draft-mtp --spec-draft-n-max 1). According to tech-insider.org (a vendor claim), under heavy load the model serves almost twice as many tokens as Qwen3.5-9B, and for single requests MTP makes it about 1.6x faster.

What you need to try it

• Graphics card: In bfloat16, 12B parameters take up about 24 GB. Once GGUFs are available, 4-bit quantizations should need roughly 8–10 GB of VRAM (estimate). Since only 2.5B parameters are active, generation is relatively fast.
• RAM: With MoE models, some of the experts can sit in RAM. The source gives no figures.
• Storage: about 24 GB for the bf16 weights, much less for quantized versions.
• Mac/CPU/Colab: The Model Card links Google Colab and Kaggle notebooks. For CPU and Mac, you'll probably need the GGUF builds with llama.cpp or LM Studio.

Our take

Mellum2.1 is a sensible step toward small, fast, openly licensed coding agents that run locally or on-premises. According to tech-insider.org, JetBrains positions the model less as a rival to the largest proprietary models and more as a building block for routing, Q&A and sub-agents.

The caveats: all benchmarks are self-reported. JetBrains compares only against Gemma 4 (E4B) and Qwen3.5 (9B), not Codestral, Qwen Coder or DeepSeek Coder. Tech-insider.org points out that claims of beating specific rivals deserve skepticism without independent testing. The card itself also shows Qwen3.5 (9B) ahead on SWE-bench Verified, Terminal-Bench, GPQA and AIME. Safety scores (XSTest 88.8, HarmBench 8.5) are better than the predecessor's but worse than Qwen3.5's. For local users, the model becomes truly practical once the GGUF builds arrive.