JetBrains pushed a new open-weight coding model onto Hugging Face on October 8, 2026, and the numbers inside its model card are the kind that make developers stop scrolling. Mellum 2.1, the follow-up to last year’s Mellum2, jumped from a 2.0 score on SWE-bench Verified to 47.0 without changing its underlying architecture at all. JetBrains says the entire gain came from post-training, not a bigger model, which is itself the more interesting story here than the benchmark chart. The release, detailed in JetBrains’ own announcement, arrives as every major lab from OpenAI to Google is racing to ship agentic coding models, and it puts a free, self-hostable 12-billion-parameter option back into a conversation currently dominated by subscription APIs.
Don't miss new tech stories on Google
Add Tech Insider once in the Google app and our stories appear in your news suggestions.
JetBrains Ships Mellum 2.1, a Free Coding Model Anyone Can Run
JetBrains published its Mellum 2.1 announcement on its official AI blog on October 8, 2026, under the headline “Mellum2.1 gets to work: a fast open model for coding agents,” a description the company uses to frame the model’s purpose rather than its size. Unlike the trillion-parameter frontier models that OpenAI, Anthropic, and Google have been shipping through October, Mellum 2.1 is a 12-billion-parameter mixture-of-experts model released under the Apache 2.0 license, meaning any developer, startup, or enterprise can download it, fine-tune it, and run it commercially with no royalty and no API key.
The model is distributed through JetBrains’ Hugging Face collection, with the flagship checkpoint labeled Mellum2.1-12B-A2.5B-Thinking alongside Base and Instruct variants. GGUF builds are also published for local inference through llama.cpp, Ollama, and LM Studio, which is the detail that matters most for the privacy-conscious enterprise crowd JetBrains appears to be courting: a model that never has to leave a company’s own infrastructure. That pitch sits in direct contrast to the cloud-first, pay-per-token model that GPT-6.1 Sol, Gemini 4 Argon, and Claude’s latest releases all depend on.
What Changed Between Mellum2 and Mellum 2.1
JetBrains’ model card is unusually candid about where the improvement actually came from. The company states that the architecture is identical to Mellum2: still a 12-billion-parameter MoE design with 2.5 billion active parameters per token. Nothing about the model’s size or shape changed. Instead, JetBrains says almost all of the engineering effort went into post-training, primarily reinforcement learning run inside real coding environments where the model could explore repositories, execute commands, call tools, and check whether its own edits actually worked.
That distinction matters for how the industry should read the benchmark jump. A 45-point gain on SWE-bench Verified without a parameter increase suggests that a meaningful share of what separates a mediocre coding model from a competent one isn’t raw scale, it’s whether the model was trained to operate like an agent instead of a pattern-matcher. JetBrains isn’t alone in reaching that conclusion, but Mellum 2.1 is one of the clearest open-weight demonstrations of it so far, and it is a theme that keeps surfacing across the coding-tools space this quarter, from Codex CLI’s 0.163 release hitting 78% on SWE-Bench to the broader push toward agentic, repository-aware tooling.
Inside the Architecture: 12B Total, 2.5B Active, 64 Experts
Mellum 2.1’s model card describes a mixture-of-experts layout with 64 total experts, 8 of which activate per token. That sparsity is what lets a 12-billion-parameter model run with the inference cost of something closer to 2.5 billion active parameters, a design choice that keeps latency and hardware requirements low enough for the model to realistically run on a single workstation GPU rather than a data-center rack. The context window sits at 131,072 tokens, enough to hold a mid-sized repository’s worth of code and still leave room for a multi-step agent transcript.
JetBrains positions the Thinking checkpoint specifically for complex agentic tasks: repository navigation, command execution, tool calling, mathematics, and multi-step reasoning, on top of straight code generation. That framing puts Mellum 2.1 in the same conceptual bucket as the small open reasoning models Nvidia shipped with its Nemotron 3.5 family and Liquid AI’s LFM2.5 release earlier this quarter, a growing lane of right-sized, efficient models built to be run locally rather than rented by the token.
Benchmark Results: SWE-Bench Verified Jumps From 2.0 to 47.0
The headline number in JetBrains’ own comparison table is the SWE-bench Verified score, which moved from 2.0 for Mellum2 Thinking to 47.0 for Mellum 2.1 Thinking. SWE-bench Verified tests whether a model can resolve real GitHub issues end to end, so a near-flat score followed by a jump into the high 40s is a meaningful signal that the model went from barely functional as an autonomous coding agent to genuinely competitive with some mid-tier commercial systems.
Every other benchmark JetBrains reports moved in the same direction. LiveCodeBench v6 climbed from 69.4 to 82.0. HumanEval+ rose modestly from 90.9 to 91.5, suggesting the easier, single-function coding tasks were already close to saturated for the older model. MBPP+ improved from 75.4 to 79.4. The largest relative gains, unsurprisingly, showed up on the tasks that reward agentic behavior over raw code synthesis: Terminal-Bench 2.1 went from 0.6 to 17.4, and SWE-bench Pro, a harder variant of the SWE-bench suite, moved from 0.0 to 28.0.
| Benchmark | Mellum2 Thinking | Mellum 2.1 Thinking | Point Change |
|---|---|---|---|
| LiveCodeBench v6 | 69.4 | 82.0 | +12.6 |
| HumanEval+ | 90.9 | 91.5 | +0.6 |
| MBPP+ | 75.4 | 79.4 | +4.0 |
| SWE-bench Verified | 2.0 | 47.0 | +45.0 |
| SWE-bench Pro | 0.0 | 28.0 | +28.0 |
| Terminal-Bench 2.1 | 0.6 | 17.4 | +16.8 |
How Mellum 2.1 Stacks Up Against Qwen3.5 9B
JetBrains’ model card also places Mellum 2.1 alongside Alibaba’s Qwen3.5 9B and Google’s Gemma 4 E4B, two of the other small open models competing in the same weight class. The published figures show Qwen3.5 9B still ahead on SWE-bench Verified at 50.0 versus Mellum 2.1’s 47.0, a narrow three-point gap given that Qwen3.5 9B is a smaller dense model. On LiveCodeBench v6, Qwen3.5 9B posted 75.4 against Mellum 2.1’s 82.0, flipping the lead to JetBrains. HumanEval+ also favors Qwen3.5 9B slightly, at 89.6 versus Mellum 2.1’s 91.5, though both scores are close enough that the practical difference for most coding tasks would be minimal.
JetBrains did not publish a full side-by-side table against Gemma 4 E4B’s specific scores in the material reviewed for this story, and the company has not released a direct comparison against other popular open coding families either. That’s a gap worth flagging rather than filling with a guess: anyone deciding between Mellum 2.1 and the rest of the open-weight coding field should treat JetBrains’ own benchmark table as a starting point, not the full picture, until independent evaluations circulate.
| Model | Params (Total / Active) | SWE-bench Verified | LiveCodeBench v6 | HumanEval+ |
|---|---|---|---|---|
| Mellum 2.1 Thinking | 12B / 2.5B (MoE) | 47.0 | 82.0 | 91.5 |
| Qwen3.5 9B | 9B (dense) | 50.0 | 75.4 | 89.6 |
| Mellum2 Thinking (prior gen) | 12B / 2.5B (MoE) | 2.0 | 69.4 | 90.9 |
Apache 2.0 Licensing and Why That Matters for Enterprises
The licensing choice is arguably as newsworthy as the benchmark table. Apache 2.0 is a permissive license that allows commercial use, modification, and redistribution with minimal restrictions, and JetBrains has kept that choice consistent across the Mellum line since the original release. For enterprises that have spent 2026 wrestling with data-residency rules, export-control uncertainty around Chinese open models, and rising per-token API costs from the frontier labs, a European company offering an Apache 2.0, self-hostable coding model is a meaningfully different value proposition than a hosted subscription.
It also puts JetBrains in competition with its own commercial product line. The company sells Junie, its agentic coding assistant, as a hosted offering that has been benchmarked against GitHub Copilot and Cursor in past comparisons. Mellum 2.1 being free and open doesn’t replace Junie’s IDE integration and workflow tooling, but it does give budget-constrained teams a path to run comparable coding-agent capability without a per-seat license, a tension JetBrains will have to manage as it tries to monetize the assistant layer while open-sourcing the model underneath it.
Where to Get It: Hugging Face, GGUF, and Local Runtimes
Mellum 2.1 is distributed through JetBrains’ Hugging Face organization, with the Thinking checkpoint as the flagship release alongside Base and Instruct variants. GGUF quantized builds are published for compatibility with llama.cpp, Ollama, and LM Studio, which lowers the barrier to running the model on consumer hardware rather than requiring a dedicated inference server. One independently published macOS MLX port documented on GitHub reports roughly 9GB of downloaded weights for a 6-bit quantized build, though that figure comes from a third-party implementation rather than an official JetBrains hardware specification.
# Example: pulling a GGUF build for local inference with Ollama
ollama pull jetbrains/mellum2.1-12b-thinking-gguf
ollama run jetbrains/mellum2.1-12b-thinking-gguf "Refactor this function to remove the nested loop"JetBrains has not published specific pricing or IDE-by-IDE integration details for how Mellum 2.1 plugs into its own AI Assistant product, nor has it published a supported-languages list or exact training-token count for the model. Those are reasonable questions for anyone planning to standardize on it in production, and they remain open as of this writing.
The Post-Training Bet: Reinforcement Learning Over New Architecture
The decision to hold the architecture flat and pour resources into reinforcement learning instead is a bet that JetBrains is making explicitly, and it mirrors a pattern showing up across the wider coding-tools cluster this year. Rather than chasing ever-larger parameter counts, several teams are now optimizing smaller models to behave like competent agents: taking actions, checking their own output, and correcting course inside a sandboxed environment before a human ever sees the result.
That approach has an obvious cost advantage. A 2.5-billion-active-parameter model is dramatically cheaper to run at scale than a trillion-parameter frontier system, even before accounting for the fact that it can run entirely on local hardware with no API bill at all. If JetBrains’ benchmark gains hold up under independent testing, Mellum 2.1 becomes a case study for how far reinforcement learning in realistic coding environments can close the gap with far larger, far more expensive models.
Industry Data: How Developers Are Actually Using AI Coding Tools
Mellum 2.1 is landing into a developer population that has already largely committed to AI-assisted coding as a daily habit. According to the Stack Overflow 2025 Developer Survey, 84% of developers said they use or plan to use AI tools in their development process, up from 76% in 2024. The same survey found that a large majority of respondents had hands-on experience with specific commercial models: 82% of developers indicated that they used OpenAI GPT models for development work in the past year, according to Stack Overflow’s technology survey data.
Usage is far from a single-vendor story, though. Stack Overflow also reported that 43% of developers used Claude Sonnet models, while 35% reported using Gemini Flash models, according to the company’s 2025 Developer Survey press materials. That spread of adoption across multiple vendors is precisely the environment in which a free, self-hostable, Apache 2.0 option like Mellum 2.1 has room to find a niche, particularly among teams that want coding-agent capability without adding another line item to their AI vendor bill.
Market Impact: Open Models Pressure the Subscription Stack
The broader coding-tools market in October 2026 is crowded with closed, subscription-gated models. GPT-6.1 Sol, Claude Sonnet 5.5, Claude Haiku 5.5, and Gemini 4 Argon have all shipped new versions within the same six-week window as Mellum 2.1, each priced per million tokens and each requiring an API account or a ChatGPT, Claude, or Gemini subscription to access. Against that backdrop, an Apache 2.0 model that a company can download once and run indefinitely at zero marginal API cost is a different kind of competitive pressure, even if its raw benchmark ceiling sits below the frontier labs’ best agentic models.
That pressure is most acute for teams with strict data-residency or compliance requirements, where sending proprietary source code to a third-party API is a non-starter regardless of benchmark scores. For those teams, a 47.0 SWE-bench Verified score running entirely on in-house hardware can be more valuable than a 70-plus score that requires routing code through an external vendor. It also gives IDE and platform vendors building on open weights, rather than reselling frontier-model API access, a credible option to point to when pitching self-hosted or air-gapped deployments.
Historical Context: From Autocomplete to Agentic Coding
The Mellum Lineage
JetBrains originally built the Mellum line as a focused code-completion model, aimed squarely at fast, low-latency autocomplete inside its own IDEs rather than general-purpose chat or broad reasoning. Mellum2 extended that into a mixture-of-experts design, trading some of the narrow efficiency of the first generation for more flexibility. The jump to Mellum 2.1’s near-zero-to-competitive SWE-bench Verified score marks the point where the lineage fully pivoted from a completion engine into something explicitly built for multi-step, tool-using coding agents.
A Crowded Field of Small Open Models
Mellum 2.1 arrives alongside a wave of other right-sized open releases this quarter, including Nvidia’s Nemotron 3.5 family and Liquid AI’s LFM2.5, each chasing a similar goal: deliver agent-capable reasoning and coding without requiring frontier-scale compute. The common thread across all of them is that 2026 has become the year efficient, locally runnable models started closing a benchmark gap that used to require ten times the parameter count to overcome.
What JetBrains Hasn’t Confirmed Yet
Several details that would normally accompany a model launch of this size are still missing from JetBrains’ public materials. The company has not disclosed the exact token count or source composition of the training data used for Mellum 2.1’s reinforcement-learning stage. It has not published a definitive list of supported programming languages, nor official minimum hardware requirements for running the model locally at full precision. There is also no confirmed detail yet on whether Mellum 2.1 exposes a dedicated fill-in-the-middle interface for autocomplete-style use, separate from its agentic tool-calling mode, and no adoption, download, or integration-partner numbers have been announced.
None of that undermines the benchmark gains JetBrains has published, but it does mean that enterprises evaluating Mellum 2.1 for production use are currently working from a partial picture. Expect JetBrains to fill in some of those gaps, particularly around IDE integration and AI Assistant pricing, as the release matures over the coming weeks.
Competitive Comparison: Where Mellum 2.1 Fits in the Coding-Tools Stack
Positioned against the current coding-tools landscape, Mellum 2.1 is not trying to beat GPT-6.1 Sol or Claude Sonnet 5.5 on raw capability, and JetBrains isn’t claiming it does. Its pitch is efficiency and openness: a model small enough to run on a single GPU, licensed permissively enough to embed in a commercial product, and specifically trained to act as a coding agent rather than just a smarter autocomplete. That makes its closest competitive set the other open, small-model releases like Qwen3.5 9B rather than the trillion-parameter frontier systems dominating the top of every leaderboard this month, including the models covered in tech-insider.org’s open-source LLM rankings.
For teams already standardized on a commercial assistant like JetBrains Junie, GitHub Copilot, or Cursor, Mellum 2.1 is less a replacement than an escape hatch: an option to fall back on if API costs rise, if a vendor relationship sours, or if a client contract requires code never leave the building. For teams evaluating options from scratch, it’s now a legitimate line item on the list of coding assistants and models worth testing in 2026, particularly for cost-sensitive or compliance-heavy deployments. An early third-party technical breakdown of the release, published by Shattered.io, reached a similar conclusion about where the model fits competitively.
Predictions: Where This Goes Next
- Expect JetBrains to publish a direct comparison against DeepSeek-Coder, Qwen2.5-Coder, and other popular open coding families within the next few release cycles, closing the gap flagged by early reviewers.
- IDE integration details for Mellum 2.1 inside JetBrains AI Assistant are likely to follow within weeks, given the company’s pattern of shipping model and tooling updates close together.
- Independent benchmark reproductions from third parties will probably narrow or contest some of JetBrains’ self-reported SWE-bench Verified gains, as is typical whenever a vendor publishes its own comparison table.
- Competitive pressure from Mellum 2.1’s Apache 2.0 licensing is likely to push at least one other IDE vendor to open-source a comparable small coding model within the next two quarters.
- Enterprise interest will concentrate disproportionately among regulated industries and government-adjacent teams, where self-hosting requirements outweigh the benchmark gap with frontier closed models.
Frequently Asked Questions
What is JetBrains Mellum 2.1?
Mellum 2.1 is an open-weight, 12-billion-parameter mixture-of-experts coding model released by JetBrains on October 8, 2026, under the Apache 2.0 license. It is built for coding agents, with Base, Instruct, and Thinking checkpoints available.
Is Mellum 2.1 free to use commercially?
Yes. The Apache 2.0 license allows commercial use, modification, and redistribution without royalty or attribution requirements beyond standard license compliance.
How does Mellum 2.1 compare to Mellum2?
The architecture is unchanged, still 12B total parameters with 2.5B active per token across 64 experts. The performance gain, including a jump from 2.0 to 47.0 on SWE-bench Verified, came from post-training reinforcement learning rather than a larger model.
Where can I download Mellum 2.1?
JetBrains distributes Mellum 2.1 through its Hugging Face collection, with GGUF builds available for local inference through tools like llama.cpp, Ollama, and LM Studio.
What is the context window for Mellum 2.1?
The model supports a 131,072-token context window, according to JetBrains’ published model card.
How does Mellum 2.1 compare to Qwen3.5 9B?
JetBrains’ own comparison shows Qwen3.5 9B slightly ahead on SWE-bench Verified (50.0 versus 47.0) and HumanEval+ (89.6 versus 91.5 favors Mellum 2.1), while Mellum 2.1 leads on LiveCodeBench v6 (82.0 versus 75.4). The two models are broadly competitive with each other.
Does Mellum 2.1 replace JetBrains’ Junie assistant?
No. Junie is JetBrains’ commercial, hosted coding assistant with IDE integration and workflow tooling. Mellum 2.1 is the underlying open-weight model, which can be run independently but lacks Junie’s packaged product experience.
What hardware does Mellum 2.1 require to run locally?
JetBrains has not published official hardware requirements. One third-party macOS MLX implementation reports roughly 9GB of downloaded weights for a 6-bit quantized build, but that figure is implementation-specific rather than an official specification.
