JetBrains released a new open-weight coding model on Hugging Face on October 8, 2026, and the release is already reshaping how developers talk about local AI coding agents. Mellum 2.1, a 12-billion-parameter mixture-of-experts (MoE) model, landed under the Apache 2.0 license with a reasoning variant that activates just 2.5 billion parameters per token. For a company best known for IntelliJ IDEA and PyCharm rather than foundation models, it is a notable bet: JetBrains is betting that a small, fast, openly licensed model can do more for coding agents than another oversized proprietary one.
The timing matters. Coding-agent tooling has exploded in 2026, from Cursor and Devin Desktop competing with VS Code Copilot to a wave of open models chasing the same workloads that used to require a hyperscaler API key. Mellum 2.1 is JetBrains’ clearest statement yet that it intends to control its own AI supply chain rather than renting intelligence from OpenAI, Anthropic, or Google for every autocomplete suggestion inside its IDEs.
Don't miss new tech stories on Google
Add Tech Insider once in the Google app and our stories appear in your news suggestions.
What JetBrains Actually Shipped With Mellum 2.1
Mellum 2.1 is listed on JetBrains’ Mellum collection on Hugging Face as JetBrains/Mellum2.1-12B-A2.5B-Thinking, alongside quantized GGUF builds for local inference. According to JetBrains’ own architecture documentation hosted on Hugging Face, “Mellum is a code-focused Mixture-of-Experts language model developed by JetBrains,” built on a Qwen3-MoE-derived architecture with per-layer-type rotary position embeddings and interleaved sliding-window attention, according to Hugging Face’s Transformers documentation.
The naming convention spells out the model’s core trick. “A2.5B” means that although the model carries 12 billion total parameters, only roughly 2.5 billion are active for any given token. That is the defining characteristic of a mixture-of-experts design: instead of running every parameter on every request, a router selects a small subset of specialized sub-networks (“experts”) to handle each token. JetBrains describes the setup directly: “This model features 12B total parameters, but because it uses a MoE design, only 2.5B parameters are active per token,” the company said in its announcement, cited via its official AI blog.
Per Hugging Face’s technical documentation, the model routes across 64 experts and activates 8 of them per token, spread across 28 transformer layers with 32 query heads and 4 key/value heads. Attention uses a 1,024-token sliding window on 3 of every 4 layers. The “Thinking” variant also emits a visible chain-of-thought inside <think>...</think> blocks before producing its final answer, a pattern that has become common among reasoning-tuned open models over the past year. JetBrains lists the model’s context window at 131,072 tokens for the Mellum 2 Thinking family, enough to hold a mid-sized repository’s worth of surrounding code in a single prompt.
Why a Mixture-of-Experts Model, and Why Now
Mixture-of-experts architectures have become the default way frontier labs squeeze more capability out of a given compute budget. DeepSeek’s V3 family, Mistral’s larger releases, and Qwen’s coder lineup have all leaned on MoE designs to get dense-model-level quality with sparse-model-level inference costs. JetBrains is applying the same logic at a much smaller scale, and that scale is the point. A 12B model with a 2.5B active footprint can plausibly run on a single high-end consumer GPU or a modest on-prem server, which matters enormously for an IDE vendor whose customers include regulated banks, defense contractors, and privacy-sensitive enterprises that will not send proprietary source code to a third-party API.
JetBrains frames the goal explicitly as solving “the hardest parts of production AI: latency, throughput, and cost,” and says Mellum2 is “built for routing, Q&A, sub-agents, and private AI use in software engineering systems,” per the company’s open-source announcement. That phrasing is a deliberate pivot from the original Mellum, which JetBrains introduced in October 2024 as a narrow, purpose-built completion model for Java, Kotlin, Python, Go, and PHP, according to the company’s original launch post. Mellum 2.1 is explicitly positioned as a generalist building block for coding agents, not just a faster autocomplete engine.
From Proprietary Autocomplete to Open-Weight Agent Backbone
The Mellum lineage is worth tracing, because it shows how fast JetBrains’ AI strategy has shifted. The original Mellum launched in late 2024 as a closed, in-house model powering cloud code completion inside JetBrains AI Assistant. By April 2025, JetBrains open-sourced the base completion model on Hugging Face under Apache 2.0, telling developers the move was meant “to invite transparency, collaboration, and contribution,” according to the company’s own messaging at the time. A few months later, JetBrains shipped “Mellum-all,” expanding language coverage to JavaScript, Go, Rust, and Java, and by September 2025 the original Mellum reached the Amazon Bedrock Marketplace as a free listing.
Mellum 2, the 12B MoE generation, followed as a more ambitious rebuild aimed squarely at the agentic-coding wave that took over the industry through 2025 and into 2026. Mellum 2.1 is the follow-up that went live on Hugging Face on October 8, 2026, trained by JetBrains with reinforcement learning across millions of sandboxed tasks, with both a standard build and a “Thinking” reasoning variant, plus GGUF quantizations (including a Q4_K_M build) for developers who want to run it locally without a data-center GPU.
Mellum’s Evolution: Version-by-Version Comparison
| Version | Released | Architecture | Primary Role | License |
|---|---|---|---|---|
| Mellum (original) | October 2024 | Dense, purpose-built completion model | Cloud code completion in JetBrains AI Assistant (Java, Kotlin, Python, Go, PHP) | Proprietary at launch |
| Mellum (open-sourced) | April 2025 | Same dense base model | Public Hugging Face release for transparency and local use | Apache 2.0 |
| Mellum-all | Mid-2025 | Dense, expanded language training | Broader completion across JavaScript, Go, Rust, Java and more | Apache 2.0 |
| Mellum 2 | Mid-2026 | 12B MoE, 64 experts, 8 active, 2.5B active params | Routing, Q&A, sub-agents, private AI in software engineering systems | Apache 2.0 |
| Mellum 2.1 | October 2026 | 12B MoE, 28 layers, 131K context, Thinking variant | General-purpose backbone for coding agents | Apache 2.0 |
That progression tells its own story. JetBrains spent roughly two years moving from a single-purpose, closed completion model to an openly licensed reasoning model built to sit inside multi-step agent pipelines, not just suggest the next line of code.
How Mellum 2.1 Fits the Coding-Agent Market
Coding agents in 2026 are not just inline autocomplete. They plan multi-file changes, call tools, run tests, and loop until a task passes, the same pattern behind products like GitHub Copilot’s agent mode and the sandboxed agent workflows inside VS Code 1.141’s Copilot agent sandbox. That architecture needs more than one model call. A full agent loop typically involves a planner, a router that decides which sub-task goes where, a fast model for routine edits, and occasionally a larger model for the genuinely hard problems.
JetBrains is explicitly positioning Mellum 2.1 for that routing and sub-agent layer rather than as a standalone chat model competing with GPT-6 or Claude Opus 5.5 head-on. Its own description, “built for routing, Q&A, sub-agents, and private AI use in software engineering systems,” reads like a deliberate scope decision: let the big proprietary frontier models handle the hardest reasoning steps, and let a fast, cheap, self-hostable MoE model handle the high-volume, latency-sensitive work that makes up most of an agent’s actual token spend. That is a meaningfully different pitch than, say, Anthropic’s Claude Opus 5.5 API, which is built to be the top-end reasoning engine rather than the cheap workhorse underneath an agent stack.
The Open-Weight Coding Model Landscape Mellum 2.1 Enters
Mellum 2.1 does not arrive in a vacuum. Open and open-weight coding models have multiplied fast. DeepSeek’s coder lineup, Mistral’s code-tuned releases, Qwen’s Coder family, and a growing list of smaller specialist models have all targeted the same audience: developers and enterprises who want strong code generation without routing every request through a hyperscaler’s metered API. JetBrains’ own October 2026 report gives Mellum2.1 a score of 47.0 on SWE-bench Verified, versus 2.0 for Mellum2, and October 2026 reporting lists 82.0 on LiveCodeBench v6, but JetBrains has not published head-to-head benchmark tables pitting Mellum 2.1 against Codestral, Qwen Coder, StarCoder, or DeepSeek Coder on standard suites like HumanEval, MBPP, or SWE-bench, so any claim of Mellum 2.1 “beating” a specific rival on a specific leaderboard should be treated with skepticism until JetBrains or an independent evaluator publishes verified numbers.
What differentiates Mellum 2.1 is not a claimed leaderboard win, it is where it sits in the stack. JetBrains is not trying to out-benchmark DeepSeek or Qwen on raw capability. It is trying to own the layer that actually touches a developer’s keystrokes inside a JetBrains IDE, with a model small enough to run on infrastructure a mid-sized engineering org can control. That is a different competitive axis than the one tracked by general leaderboards like the ones covered in our LMArena vs. Artificial Analysis comparison, and it is also a different axis than the raw throughput comparisons we ran in our look at DeepSeek V4.1 Flash vs. Claude Haiku 5.5 vs. Gemini 3.8 Flash, where cost-per-token and latency were the deciding factors rather than headline intelligence scores.
Competitive Snapshot: Mellum 2.1 vs. Other Open Coding Models
| Model family | Approx. parameters | Architecture type | License | Primary positioning |
|---|---|---|---|---|
| JetBrains Mellum 2.1 | 12B total / 2.5B active | MoE (64 experts, 8 active) | Apache 2.0 | Low-latency routing, sub-agents, private IDE deployments |
| DeepSeek Coder / V-series | Varies by release, large MoE flagships | MoE | Open weights (model-specific terms) | General-purpose and coding capability at scale |
| Qwen Coder family | Multiple sizes, dense and MoE variants | Dense and MoE | Open weights (model-specific terms) | Broad language and coding support across sizes |
| Mistral Codestral | Dense, mid-size | Dense transformer | Commercial and research terms vary | IDE-integrated completion and generation |
| StarCoder family | Multiple sizes | Dense transformer | Open, responsible-AI license terms | Research-friendly, permissively licensed baseline |
Note that exact parameter counts and benchmark positions for rival families shift with each release cycle, and JetBrains has not published a reproducible, apples-to-apples benchmark run against any of them as of this writing. The table above reflects architectural positioning, not a verified performance ranking.
Licensing: Why Apache 2.0 Is the Real Headline
For an enterprise tooling vendor, the license matters as much as the architecture. Apache 2.0 is one of the most permissive open-source licenses available, allowing commercial use, modification, and redistribution with minimal obligations beyond preserving attribution and license notices. JetBrains has used Apache 2.0 consistently across the Mellum lineage since the original model’s open-sourcing in April 2025, and Mellum 2.1 continues that pattern, with JetBrains keeping it under Apache 2.0 in October 2026.
That consistency is a signal in itself. JetBrains sells developer tools to banks, government contractors, and large enterprises that often cannot legally or contractually send source code to a third-party model provider. A model they can download, inspect, fine-tune, and run entirely inside their own network removes an entire category of procurement friction. It is the same logic that pushed Reflection AI toward its open-weight Beam model and that underpins Nvidia’s broader push toward open models, detailed in our coverage of Nvidia’s $20 billion open-source bet: permissive licensing is increasingly a competitive weapon, not a charitable afterthought.
Running Mellum 2.1 Locally: What Developers Need to Know
Mellum 2.1 ships in multiple formats on Hugging Face, including a full-precision “Thinking” release and quantized GGUF builds such as a Q4_K_M variant, which trades some precision for a dramatically smaller memory footprint. Because only 2.5 billion parameters activate per token, inference cost scales closer to a small dense model than a 12B dense model would, even though the full weight set still needs to be loaded into memory or storage somewhere. That is the standard MoE tradeoff: lower compute per token, but a larger total disk and RAM footprint than a dense model of equivalent active-parameter size.
# Example: pulling the GGUF build via Hugging Face CLI
huggingface-cli download JetBrains/Mellum2.1-12B-A2.5B-Thinking-GGUF \
--local-dir ./mellum-2.1-gguf
# Run with a standard GGUF-compatible inference server
# (exact flags depend on your runtime of choice)
./server -m ./mellum-2.1-gguf/mellum-2.1-q4_k_m.gguf --ctx-size 131072
The 131,072-token context window listed for the Thinking variant is large enough to hold a substantial slice of a real codebase, which matters for agent workflows that need to reason across multiple files rather than a single function. For comparison, that is in the same general range as the context windows developers have come to expect from mid-tier commercial coding assistants, though JetBrains has not published independent verification of effective context utilization at that length, something that varies widely between models even when the advertised window is identical.
What This Means for JetBrains AI Assistant Users
JetBrains’ earlier Mellum generation already powered cloud code completion inside JetBrains AI Assistant, and the company has continued expanding where Mellum models can run, including a free listing on the Amazon Bedrock Marketplace in September 2025. Whether Mellum 2.1 specifically becomes the default completion model inside the current JetBrains AI Assistant product has not been confirmed in JetBrains’ public materials as of this release; the company’s messaging focuses on the open-weight release itself rather than a specific product rollout timeline. Developers who want the new model today can pull it directly from Hugging Face rather than waiting for it to appear inside a specific IDE build.
That gap between “model released” and “model shipped inside the flagship product” is common across the industry. Hugging Face’s own documentation already lists Mellum as a natively supported architecture inside the Transformers library, which lowers the integration bar for any JetBrains product team that wants to wire it into AI Assistant, or for third-party tool builders who want to bolt Mellum 2.1 into their own agent frameworks, similar to how GitGuardian’s ggshield and other security-focused coding tools have adapted to the rise of AI-assisted development.
Market Impact: A Signal to the Open-Model Economy
Mellum 2.1’s release lands in a market where open-weight models are increasingly treated as infrastructure rather than novelty. A developer-tools company the size of JetBrains choosing to build and openly license its own MoE model, rather than exclusively reselling access to a frontier lab’s API, adds weight to the argument that the “model layer” of the AI stack is becoming commoditized faster than many assumed a year ago. It echoes a broader pattern across the industry this year, where firms with deep domain data (developer behavior, in JetBrains’ case) see more strategic value in owning a small, specialized model than in remaining purely a distribution channel for someone else’s general-purpose model.
It also puts pressure on other IDE and dev-tool vendors to show their own model strategy. Microsoft has leaned on OpenAI for Copilot, while a growing list of smaller players have started shipping their own fine-tuned or from-scratch models rather than depending entirely on a single external provider. Mellum 2.1 strengthens the case that “bring your own model” is becoming a baseline expectation for serious developer tooling companies, not a differentiator reserved for AI-native startups.
Risks and Open Questions
Several details remain unverified as of this release. JetBrains has not published a technical report with reproducible benchmark scores against named rivals, has not disclosed detailed training-data composition, and has not confirmed a specific programming-language quality breakdown for Mellum 2.1 the way it did for the original Mellum’s Java/Kotlin/Python/Go/PHP focus. Enterprises evaluating the model for production agent pipelines will likely want to run their own internal evaluations rather than relying on vendor framing alone, which is standard practice with any newly released open-weight model regardless of who ships it.
There is also the open question of maintenance cadence. JetBrains has iterated Mellum roughly every few months since late 2024: the original launch, the April 2025 open-sourcing, the mid-2025 Mellum-all language expansion, the Bedrock listing, Mellum 2, and now Mellum 2.1. That pace suggests JetBrains is treating the model as a living product rather than a one-off release, but it also means today’s version could be superseded again within a quarter or two, a dynamic coding teams should factor into any long-term dependency on a specific Mellum checkpoint.
Predictions: Where Mellum Goes From Here
- JetBrains will likely publish an official benchmark comparison against at least one named rival (plausibly a Qwen Coder or DeepSeek variant) within the next release cycle, once it has numbers it is confident defending publicly.
- Expect Mellum 2.1 or a near-term successor to appear as a selectable backend inside JetBrains AI Assistant for self-hosted or enterprise customers, extending the pattern set by the original Mellum’s cloud completion role.
- Other IDE vendors and dev-platform companies will face more pressure to disclose or ship their own specialized models rather than relying solely on third-party frontier APIs, following the same logic that pushed JetBrains down this path.
- Quantized, locally runnable builds of Mellum 2.1 will likely see adoption among privacy-conscious enterprises and regulated industries faster than cloud-hosted alternatives, given the Apache 2.0 license and existing GGUF support.
- JetBrains will continue its roughly quarterly Mellum release cadence, meaning a Mellum 2.2 or Mellum 3 announcement within the next two to four months would not be surprising given the pace since late 2024.
How Mellum 2.1 Compares on the Agent-Stack Decision
For engineering teams deciding where a model like Mellum 2.1 fits, the practical question is not “is it smarter than GPT-6 or Claude Opus 5.5,” it almost certainly is not meant to be. The real question is whether it is fast and cheap enough to handle the high-frequency, lower-stakes parts of an agent loop (routing decisions, boilerplate edits, quick Q&A against a codebase) while a larger model is reserved for genuinely hard reasoning steps. That tiered approach, pairing a small open model with an occasional call to a frontier model, is becoming the default architecture for cost-conscious agent deployments across the industry, and JetBrains is explicitly building Mellum 2.1 to be the small, fast half of that pairing.
Teams already running local inference stacks for other open models should find Mellum 2.1 straightforward to slot in, given its native support inside Hugging Face Transformers and the availability of pre-quantized GGUF builds. Teams without existing local-inference infrastructure face a steeper initial setup cost, though that is true of any self-hosted model, not something specific to Mellum.
Frequently Asked Questions
What is JetBrains Mellum 2.1?
Mellum 2.1 is a 12-billion-parameter mixture-of-experts open-weight language model from JetBrains, built for coding-agent workflows such as routing, sub-agents, and private AI deployments inside software engineering systems. It activates roughly 2.5 billion parameters per token.
Is Mellum 2.1 open source?
Yes. JetBrains released it under the Apache 2.0 license, the same license used for the original Mellum’s open-sourcing in April 2025 and the Mellum-all release that followed.
Where can I download Mellum 2.1?
The model is hosted on Hugging Face under JetBrains’ organization page, including a full “Thinking” reasoning variant and quantized GGUF builds for local, lower-resource inference.
How is Mellum 2.1 different from the original Mellum?
The original Mellum, launched in October 2024, was a dense model purpose-built for code completion in a handful of languages. Mellum 2.1 is a much larger mixture-of-experts model positioned as a general backbone for coding agents, with a 131,072-token context window and a visible chain-of-thought reasoning mode.
Does Mellum 2.1 beat DeepSeek Coder or Qwen Coder on benchmarks?
JetBrains has not published independently verifiable benchmark comparisons against those models as of this release, so no specific performance ranking can be confirmed. The differentiation JetBrains is emphasizing is architecture, licensing, and self-hosting cost rather than a published leaderboard win.
Will Mellum 2.1 power JetBrains AI Assistant?
JetBrains has not confirmed a specific product rollout timeline tying Mellum 2.1 directly to JetBrains AI Assistant. Earlier Mellum versions have powered cloud code completion in that product, so a similar integration path is plausible but not yet officially confirmed for this version.
What hardware do I need to run Mellum 2.1 locally?
Because only about 2.5 billion parameters activate per token, inference compute needs are closer to a small dense model than a full 12B dense model, though the complete weight set still needs to be loaded into memory or storage. Quantized GGUF builds, including a Q4_K_M variant, reduce the memory footprint further for consumer-grade hardware.
What license governs commercial use of Mellum 2.1?
Apache 2.0, which permits commercial use, modification, and redistribution with minimal obligations, primarily preserving attribution and license notices.
