Mellum2 Open Source Release: JetBrains New 12B AI Model
Quick Answer: JetBrains open-sourced Mellum2 on June 2, 2026 under Apache 2.0 – a 12B Mixture-of-Experts model that activates only 2.5B parameters per token. Built from scratch on 10.6 trillion tokens, it targets routing, RAG summarization, sub-agent orchestration, and local deployment in software engineering pipelines. Six checkpoints are available on Hugging Face.
As AI-powered coding tools multiply, developers face a growing challenge: every agentic workflow, every RAG pipeline, and every multi-model system needs a fast, cheap model for the high-frequency steps. Running Claude or GPT-4 for routing and summarization burns through tokens and slows down iteration. Running them for every sub-agent call in a complex pipeline can multiply inference costs by an order of magnitude. That bottleneck is exactly what JetBrains set out to solve with Mellum2, a focused open-weight model that the company open-sourced on June 2, 2026 under the Apache 2.0 license. The model is available on Hugging Face now, and JetBrains has released six checkpoints covering the full training pipeline from base pre-train through RL-tuned instruct and thinking variants.
What Is Mellum2 and Why Did JetBrains Build It?
Mellum2 is a 12B-parameter Mixture-of-Experts (MoE) language model trained from scratch on approximately 10.6 trillion tokens. Its predecessor, the original Mellum released in April 2025, was a 4B-parameter dense model focused narrowly on code completion in JetBrains IDEs. Mellum2 expands the scope dramatically: it handles natural language and code, supports tool calling and function calling, and is designed for multi-step reasoning and agentic coding workflows. JetBrains describes it as a “focal model” – a fast, specialized component intended to sit inside larger AI systems rather than replace frontier models like GPT-5 or Claude Opus 4.6 (source: JetBrains AI Blog). The company’s own suite of IDEs – IntelliJ IDEA, PyCharm, WebStorm – already integrate AI features, and Mellum2 is positioned to power the infrastructure behind those features.
How Does Mellum2’s Architecture Make It Faster and Cheaper?
The 28-layer design with 2304 hidden size and 64 experts distributed across MoE layers means that most of the model’s capacity is available for learning diverse patterns during training, but only a small fraction is spent during any single inference call. This is the fundamental advantage of MoE over dense architectures: you get the knowledge capacity of a 12B model with the inference cost of a 2.5B model. For a developer running an AI-assisted code review pipeline that processes 10,000 pull requests per day, that difference translates directly into hardware requirements – Mellum2 can serve the same throughput on a single mid-range GPU that would require multiple high-end GPUs for a dense 7B model.
The key architectural decision is pure MoE efficiency. Mellum2 has 12B total parameters across 64 expert subnetworks, activating only 8 per token – equivalent to 2.5B active parameters per forward pass. Per-token compute cost matches a 2.5B dense model, while the 12B total preserves broad knowledge. The model uses Grouped-Query Attention with 32 query and 4 KV heads, plus Sliding Window Attention on three of every four layers. Its context window reaches 131,072 tokens. Crucially, Mellum2 includes a built-in Multi-Token Prediction head that doubles as a draft model for speculative decoding – no separate draft model required (source: MarkTechPost). Training used the Muon optimizer under FP8 across a three-phase curriculum shifting from general web data toward code and math.
What Benchmarks Does Mellum2 Excel At?
The benchmark story is nuanced, which reflects JetBrains’ honest positioning. Mellum2 leads the pack on function-level code generation (EvalPlus), holds its own on tool use (BFCL v3), and the Thinking variant brings competitive reasoning capability (LiveCodeBench v6 at 69.9%). But it trails on broad knowledge and math tasks – areas where Qwen3.5 9B and Ministral 3 14B excel. For developers evaluating Mellum2, the right question is not “how does it compare on GPQA Diamond?” but rather “can it route a prompt to the right tool in under 50ms with 90%+ accuracy?” – for that specific class of infrastructure tasks, Mellum2 is purpose-built.
JetBrains published self-reported benchmarks comparing Mellum2 against Qwen3.5 (4B and 9B), Ministral 3 (14B), OLMo-3 (7B), and Seed-Coder (8B). The standout is EvalPlus (function-level code generation), where Mellum2 Instruct scores 78.4% – ahead of Qwen3.5 9B at 71.8% and Ministral 3 14B at 74.1%. On BFCL v3 (tool use), it reaches 66.3%. The Thinking variant achieves 69.9% on LiveCodeBench v6 and 58.4% on AIME 2025+2026 (source: The New Stack). Knowledge benchmarks are lower – MMLU-Redux at 78.1% and GPQA Diamond at 40.9% – consistent with JetBrains’s positioning as a specialized model, not a general knowledge champion.
EvalPlus (Code Generation) – 78.4% (Instruct variant), tops the comparison set of 4B-14B models
LiveCodeBench v6 (Reasoning) – 37.2% Instruct, 69.9% Thinking (trails Qwen3.5 9B’s 63.7% Instruct)
BFCL v3 (Tool Use) – 66.3%, competitive with Qwen3.5 9B at 70.5%
Inference Speed – 2.5B active params means latency less than half of comparable dense 7B models
Context Window – 131,072 tokens via layer-selective YaRN extension
What Are the Real-World Use Cases for Mellum2?
JetBrains identifies four production scenarios. First: routing and orchestration in multi-model AI systems, analyzing prompts and selecting the optimal model for each task. Instead of sending every query to an expensive frontier model, a router running Mellum2 can triage requests, directing simple Q&A to a fast model and escalating only complex reasoning to a larger one. Second: low-latency RAG pipelines, retrieving context and generating responses at speeds larger models cannot match – critical for chatbot and customer support systems where users expect sub-second responses. Third: sub-agents within agentic workflows, breaking tasks into context-gathering, planning, and validation steps handled by specialized fast models. Fourth: fully local deployment under Apache 2.0, keeping code and data entirely within the developer’s infrastructure (source: Neowin).
How Does Mellum2 Compare to Qwen3.5, Ministral, and Other Open Models?
The competitive landscape for open-weight coding models in the 4B-14B range is crowded. Alibaba’s Qwen3.5 family leads on breadth: the 9B variant tops Mellum2 on LiveCodeBench v6 (63.7% vs 37.2% Instruct, though the Thinking closing to 69.9%) and on math benchmarks like AIME (58.3% vs 41.7%). Mistral’s Ministral 3 (14B) offers strong general performance and multimodal support that Mellum2 lacks entirely. Where Mellum2 distinguishes itself is inference economics: running a 2.5B-active-parameter model costs roughly a third of running a dense 7B model at the same throughput, and its MTP-based speculative decoding eliminates the need for a separate draft model. For developers building high-throughput pipelines that process thousands of requests per hour, Mellum2’s per-token cost advantage can translate into significant infrastructure savings.
How Does Mellum2 Fit Into the Open-Source AI Ecosystem?
Mellum2 launches into a rapidly maturing open-source AI landscape. June 2026 has already seen MiniMax release M3, Microsoft open-weight Phi-4-Medium, and Alibaba’s Qwen3.5 family. Within this crowded field, Mellum2 occupies a distinct niche: it is not trying to be the best model at everything. It is trying to be the best model for the infrastructure layer of agentic AI – the high-frequency, lower-cognitive-load tasks where speed and cost matter more than raw benchmark scores. As JetBrains’s blog puts it: “the future belongs to coordinated systems, not single models” (source: Hugging Face).
The Apache 2.0 license is significant: companies can fine-tune Mellum2 on proprietary codebases, deploy it behind firewalls, and redistribute modified versions without legal friction. Combined with the six released checkpoints, developers have full visibility into the training pipeline.
What Are the Limitations Developers Should Know?
Mellum2 is not multimodal – there is no image or video input support. Its knowledge benchmarks (MMLU-Redux at 78.1%, GPQA Diamond at 40.9%) are well below comparable models. On math like GSM-Plus (80.5%) it trails the comparison set. The Instruct variant’s LiveCodeBench v6 score (37.2%) is roughly half of Qwen3.5 9B’s 63.7%, though the Thinking variant closes much of that gap at 69.9%. JetBrains is transparent about these trade-offs. Developers should pair Mellum2 with larger models for tasks requiring deep reasoning or broad knowledge, and use the focal model for the high-frequency infrastructure work where it excels. The six-checkpoint release strategy helps here: teams can pick the Instruct variant for low-latency routing and the Thinking variant for complex sub-agent tasks that benefit from explicit reasoning traces. For function calling, vLLM supports Mellum2 with tool-call parsing via the Hermes parser, making integration into production agentic frameworks relatively straightforward.
Key Takeaways
Mellum2 is a specialized “focal model,” not a general-purpose replacement – JetBrains designed it for routing, summarization, and sub-agent tasks where speed and cost matter more than raw benchmark scores. It activates only 2.5B of 12B total parameters per token.
Apache 2.0 license makes it one of the most permissively released open-weight models – commercial use, self-hosting, fine-tuning, and redistribution are all permitted without royalties or restrictions.
Built-in MTP head enables speculative decoding without a separate draft model – this is a practical advantage for production deployments, reducing inference latency without adding infrastructure complexity.
EvalPlus code generation score of 78.4% leads the 4B-14B open-weight comparison set – but knowledge and math benchmarks trail competitors significantly, confirming the model’s specialized role.
Six checkpoints released including RL-tuned variants – developers can pick the right checkpoint for each use case, from base pre-train for fine-tuning to RL-tuned instruct or thinking for production inference.
Frequently Asked Questions
What is Mellum2 and who released it?
Mellum2 is a 12B-parameter Mixture-of-Experts language model open-sourced by JetBrains under the Apache 2.0 license on June 2, 2026. It activates only 2.5B parameters per token and is designed for routing, RAG pipelines, sub-agent tasks, and private AI deployment in software engineering workflows.
How does Mellum2 compare to other open-weight coding models?
On EvalPlus, Mellum2 Instruct scores 78.4%, ahead of Qwen3.5 9B at 71.8% and Ministral 3 14B at 74.1%. On LiveCodeBench v6 it trails at 37.2% versus Qwen3.5 9B’s 63.7%. Its MoE architecture keeps per-token compute at a 2.5B-equivalent level, making it significantly faster and cheaper to run than dense models of comparable total size.
What license is Mellum2 released under?
Mellum2 is released under the Apache 2.0 license, which permits commercial use, self-hosting, fine-tuning, and redistribution without royalties. This makes it one of the most permissively licensed open-weight models available for production AI infrastructure.
What hardware do I need to run Mellum2 locally?
With only 2.5B active parameters per token, Mellum2 can run efficiently on consumer-grade GPUs with as little as 8GB VRAM for inference. The model supports vLLM for optimized serving and speculative decoding via its built-in MTP head, which reduces latency further without requiring a separate draft model.
What are the main use cases for Mellum2?
JetBrains positions Mellum2 as a focal model for four scenarios: routing and orchestration in multi-model AI systems, low-latency RAG pipeline summarization, powering sub-agents within complex agentic workflows, and fully private on-premises deployment. It excels at high-frequency, latency-sensitive tasks where larger frontier models would be overkill.
Does Mellum2 support multimodal inputs like images or video?
No. Mellum2 is text and code only – it does not support image, video, or audio inputs. This is an intentional design choice by JetBrains to keep the model lean, fast, and specialized for software engineering infrastructure tasks where multimodal inputs are rarely needed.