Mellum2.1

JetBrains released Mellum2.1 on October 8, 2026, delivering an open-weights coding model engineered specifically for autonomous software agents and local execution. Built as a 12B parameter Mixture-of-Experts (MoE) network with only 2.5B active parameters per token, Mellum2.1 delivers the execution throughput of a sub-3B model while maintaining the reasoning capacity of a much larger dense network. The weights are distributed under an Apache 2.0 license, making it fully viable for commercial workflows, private on-premises code review, and embedded development tools.

Unlike generalist models that struggle with multi-step terminal interactions, Mellum2.1 targets the agentic loop: exploring a repository, planning changes, editing source files, and verifying modifications through shell commands and test runners. JetBrains developed the model primarily through extensive reinforcement learning inside millions of sandboxed environments. This focus resolves the core failure mode of earlier lightweight coding models, which often generated syntactically valid code snippets in isolation but failed when navigating real-world directory trees and build systems.

For engineers seeking a local AI model with 12B parameters in 2026, Mellum2.1 represents a practical shift toward specialized agent workers. It avoids the latency penalties and cloud privacy liabilities associated with hosted APIs, offering developers a dedicated, private engine for fast sub-agent execution, continuous test repair, and automated code review directly on consumer-grade hardware.

The core strength of Mellum2.1 lies in its sparse Mixture-of-Experts design. While the model contains 12B parameters in total memory, the routing layer activates only 2.5B parameters for any given forward pass. This split delivers significant advantages for local deployment:

• Total Parameter Count: 12B parameters (weights that must reside in memory).
• Active Parameters: 2.5B parameters (compute required per token generated).
• Context Window: 131K tokens, accommodating large codebases, deep call stacks, and multi-turn shell execution logs.
• Architectural Paradigm: Decoder-only MoE with extended reasoning (thinking tokens) and specialized tool-dispatch heads.
• License: Apache 2.0.

Understanding Mellum2.1 MoE efficiency requires separating memory capacity from compute throughput. Memory bandwidth and capacity dictate that your system must hold the full 12B parameters, requiring between 8 GB and 24 GB of memory depending on your quantization level. However, during token generation, the compute engine only evaluates 2.5B parameters per token. This low computational footprint translates to high generation speeds, even on memory-constrained GPUs or unified-memory Apple Silicon systems where raw compute is typically the bottleneck.

The native 131K context window is particularly relevant for software engineering tasks. It allows an agent to ingest full file trees, entire API documentation sets, and substantial debugging traces without forcing aggressive context truncation or relying solely on brittle retrieval heuristics.

Mellum2.1 was trained using reinforcement learning against verifiable outcomes: passing unit tests, valid bash execution, and correct math proofs. Consequently, it excels across several distinct local engineering workflows:

Mellum2.1 functions effectively inside agent frameworks such as Aider, JetBrains Air, or custom CLI loops. It evaluates directory structures, determines which files require edits, applies precise unified diffs, and inspects terminal error logs to fix syntax or runtime errors iteratively. On the SWE-bench Verified benchmark, Mellum2.1 reaches a 47.0% resolve rate, jumping significantly over previous iterations.

With a Berkeley Function-Calling Leaderboard (BFCL v4) score of 62.3%, the model handles structured JSON tool calls, database queries, and custom shell operations reliably. It knows when to emit raw shell commands, when to halt for tool output, and how to parse returned execution frames.

On core reasoning benchmarks, the model scores 82.0% on LiveCodeBench v6, 91.5% on HumanEval+, and 83.3% exact match on AIME 25/26. The integrated thinking mode allows Mellum2.1 to generate internal reasoning traces before returning code, making it particularly capable at complex algorithmic problems, dynamic programming challenges, and architectural refactoring.

Running Mellum2.1 locally gives development teams zero-latency code generation without data leakage. Because it is an MoE architecture, hardware planning requires enough VRAM to hold the 12B total parameters while sizing compute expectations around a fast 2.5B core.

Memory requirements depend on the chosen precision and the length of your active context window. At deep context lengths (up to 131K), the Key-Value (KV) cache consumes additional memory:

• FP16 / BF16 (Unquantized): Requires 24 GB to 28 GB of VRAM. Best reserved for professional workstation cards (RTX 6000 Ada, dual RTX 3090/4090 configurations, or 64 GB+ Apple Silicon systems).
• Q8_0 (8-bit quantization): Requires roughly 14 GB to 16 GB of VRAM. Leaves enough room for a 16K to 32K context window on 16 GB cards.
• Q4_K_M (4-bit medium quantization): Requires 7.5 GB to 9 GB of VRAM. This is the sweet spot for consumer hardware, fitting comfortably on 12 GB and 16 GB GPUs with room for medium-to-long context windows.
• Q3_K_M (3-bit quantization): Requires around 6 GB to 7 GB of VRAM. Useful for running on laptops with 8 GB mobile GPUs, though with noticeable degradation in mathematical reasoning.

For most local practitioners, the best quantization for Mellum2.1 is Q4_K_M. It preserves the vast majority of the model's agentic and coding performance while keeping the base weight footprint under 8 GB.

• NVIDIA Desktop GPUs: The NVIDIA GeForce RTX 4090 (24 GB) or RTX 3090 (24 GB) is the best GPU for Mellum2.1, running full 16-bit weights or 8-bit quantized weights with full 131K context. For users wondering how to run 12B model on consumer GPU hardware like an RTX 4070 (12 GB) or RTX 4060 Ti (16 GB), running Mellum2.1 at Q4_K_M or Q5_K_M works smoothly with high generation speeds.
• Apple Silicon (Mac): A Mac equipped with an M3 Max or M4 Max and 36 GB or more of unified memory runs the model at FP16 or Q8 without offloading overhead. An entry-level Mac with 16 GB unified memory runs Q4_K_M effectively.

Because of its 2.5B active parameter compute load, Mellum2.1 tokens per second figures significantly outperform standard dense 12B or 14B models:

• RTX 4090 / RTX 3090: 85 to 120+ tokens/second at Q4_K_M.
• RTX 4070 (12 GB): 55 to 75 tokens/second at Q4_K_M.
• Apple M3/M4 Max: 60 to 90 tokens/second at Q4_K_M; roughly 35 to 50 tokens/second at FP16.

The quickest way to get started with the model locally is via Ollama or vLLM:

1# Using vLLM with the thinking parser
2vllm serve JetBrains/Mellum2.1-12B-A2.5B-Thinking --reasoning-parser qwen3 --max-model-len 32768
3
4# Using Ollama (once published or imported from GGUF)
5ollama run mellum2.1:12b

When serving Mellum2.1 in high-throughput local pipelines, using vLLM allows you to leverage continuous batching and multi-token prediction heads where supported.

To evaluate Mellum2.1 for coding pipelines, consider how it stacks up against similar small-footprint models:

Qwen3.5-9B is a dense model that delivers high baseline general reasoning and slightly edges out Mellum2.1 on raw SWE-bench Verified scores (roughly 50.0% versus Mellum2.1's 47.0%). However, Mellum2.1 holds two practical advantages for local deployments:

1. Generation Speed: With only 2.5B active parameters per forward pass, Mellum2.1 generates output noticeably faster under multi-request concurrency and on compute-limited hardware.
2. Coding Specialization: Mellum2.1 leads on synthetic programming benchmarks like LiveCodeBench v6 (82.0% vs 75.4%), making it a snappier engine for rapid inline edits, linter fixing, and test generation.

DeepSeek-Coder-V2-Lite uses an MoE design with 2.4B active parameters out of 16B total. While its base architecture is broadly comparable in active compute, Mellum2.1 benefits from a more compact overall memory footprint (12B total parameters vs 16B), requiring less VRAM to store the weight tables. Furthermore, JetBrains trained Mellum2.1 specifically inside modern tool-use sandboxes, resulting in stronger out-of-the-box reliability for unified terminal execution, shell tool use, and iterative patch verification.