JetBrains releases Mellum2.1: an open 12B "thinking" model for code agent infrastructure

JetBrains releases Mellum2.1: an open 12B "thinking" model for code agent infrastructure

🔎 An IDE vendor releases an LLM — and picks exactly the right niche

On October 8, 2026, JetBrains released Mellum2.1, an open 12-billion-parameter model under the Apache 2.0 license, downloadable without registration from the vendor's Hugging Face collection. At first glance, just another open source release.

Look at the positioning, and the picture changes. Mellum2.1 makes no claim to rival GPT-5.5 (98.2 on agentic benchmarks in 2026) or Claude Opus 4.7 (94.3). JetBrains built a worker: a model for low-latency routing, sub-agents, completion, and private deployments in the IDE. The plumbing — the kind that runs thousands of times a day without ever making the newsletter headlines.

This framing says two things about the market. First, the model race is segmenting: while the labs battle over tenths of a point at the top of the leaderboard, another competition is taking shape below — that of small specialized models that power agents without blowing up latency or the bill. Second, tool vendors no longer want to depend on frontier APIs. If you've been following the news, our AI news roundup shows this trend accelerating month after month.

The essentials

• A 12B MoE with ~2.5B active per token: 64 experts with 8 active, a 131,072-token context, text-only. Released October 8, 2026 under Apache 2.0.
• Only the Thinking variant is available: the model writes its reasoning in think tags before each final answer.
• SWE-bench Verified: from 2.0 to 47.0 in four months (JetBrains, October 2026), thanks to reinforcement learning on real repositories — figures not yet independently reproduced.
• An unapologetically specialist positioning: agent worker, routing, private deployments. Not a rival to frontier models.
• A 16 GB laptop is enough: the Q4_K_M GGUF weighs 8.1 GB and runs fully offline.

Recommended tools

To test and deploy Mellum2.1, the toolbox fits in four lines — and most of it is free, like the rest of our selection of free AI tools:

Mellum2.1 at a glance: the specs that matter

It's a compact mixture-of-experts derived from the Qwen3-MoE architecture, text-only, with 131,072 tokens of context — and only one variant released: Thinking.

Sources: model card relayed by Logeshwaran.org, architecture analysis by Tech-Insider and Mellum2 technical report on arXiv (2026).

The genealogy, for context: the Mellum2 family arrived on May 29, 2026, Mellum2 Thinking was open-sourced in June, and Mellum2.1 keeps the architecture exactly the same. All the progress lies elsewhere — we'll get to that.

Notable fact: JetBrains doesn't claim code only. Among the three target use cases is a "general reasoning assistant", alongside the worker agent and self-hosted private deployment. The company sees its model as a universal low-latency utility, not a mere completer.

Thinking, but no Instruct (for now)

Only the Thinking variant of 2.1 has been released. Concretely, the model emits its chain of thought in think tags before each final answer. If you chain it as a sub-agent, plan to parse or strip these tags. For direct answers without visible reasoning, Mellum 2's Instruct remains available — that's the current trade-off.

Why "12B" only costs 2.5B: the MoE mechanics

Thanks to mixture-of-experts routing, each token only activates a subset of parameters: the inference cost is closer to a 2.5B dense model, not a 12B dense model.

The checkpoint name literally encodes it: Mellum2.1-12B-A2.5B-Thinking. Out of 12 billion total parameters, the router selects roughly 2.5 billion active parameters per token from 64 experts (8 active). All the weight memory stays loaded, but the per-token computation — and therefore latency and energy cost — follows the small fraction. This is what Tech-Insider breaks down from the Hugging Face Transformers documentation.

Two architectural choices make the equation manageable in long contexts. First, interleaved attention: three out of four layers only have a 1,024-token sliding window, and only one layer in four sees the entire context — the memory price of 131,072 tokens remains reasonable. Next, built-in speculative decoding: a single Multi-Token Prediction head serves both as an auxiliary pre-training objective and as a draft model at inference, according to the technical report. The model ships with its own sampling accelerator, no separate auxiliary model required.

Measurable effect: under heavy load, Mellum 2.1 serves nearly twice as many tokens as Qwen3.5 9B, according to the chart published by JetBrains (October 2026). That's exactly the profile you want for a worker that chains hundreds of short calls. And efficiency is designed in from the ground up, not bolted on at deployment: Muon optimizer in hybrid FP8 precision, context extension to 128K via layer-wise selective YaRN.

From 2.0 to 47.0 on SWE-bench Verified: the method matters more than the number

That 47-point jump doesn't come from a bigger model — the architecture is unchanged — but from millions of reinforcement learning trials in real software environments.

The technical story is crystal clear. During the summer of 2026, JetBrains ran RL in sandboxes: real repositories, a shell, file-editing tools, and a reward granted only when the tests pass. That's RLVR — reinforcement learning with verifiable rewards — the same recipe documented in the technical report for the family: SFT first, then RL on math and executable coding tasks.

The training scale sets the tone (figures compiled by Groundy, 2026): ~47 billion tokens of SFT for the direct assistant, ~167 billion for the reasoning assistant, then an RLVR finishing pass on ~260,500 prompts with 500 RL steps. Upstream, the pre-training curriculum shifts from general web to curated code: 23%, then 42%, then 59% code.

The result, as The New Stack summarizes it: a small, self-hostable model that explores a repository, edits files, and verifies its own changes — going from 2.0 to 47.0 on SWE-bench Verified in four months. In its announcement, JetBrains embraces the utilitarian tone: a model built to work, not to shine.

The counterpoint JetBrains itself displays

Let's keep a cool head. On JetBrains' own chart, Qwen3.5 9B wins on 12 of the 17 published benchmarks, including all the difficult agentic benchmarks. Mellum 2.1 takes the lead on code puzzles and speed.

And the big caveat: those 17 benchmarks were measured by JetBrains with a single pipeline. Nobody outside the vendor has reproduced them yet. Treat the 47.0 as "promising, vendor-reported," not as an established fact.

That said, the economic argument does hold up. 47.0 with 2.5B active parameters, self-hosted, is not the same equation as a frontier score billed per token. For the 90% of unglamorous tasks in an agent loop, you don't need the model sitting at the top of the leaderboard.

The "focal model" thesis: a fleet of specialists, not a single brain

The future of AI-assisted development looks like a fleet: one or two large focal models for the hard decisions, a constellation of small specialists for everything else. Mellum2.1 is a piece of that constellation, not the brain.

The argument is economic first. An agent loop triggers dozens of model calls per task: reading a file, grepping, routing to a sub-agent, formatting output, verifying a diff. The majority is trivial. Paying the latency and price of a frontier model for that is like handing linting to a senior architect.

What the fleet would look like in 2026:

The evidence keeps piling up in this direction. Gemini 3.5 Flash: the fast model that beats Opus 4.7 and GPT-5.5 on agentic benchmarks — 289 tokens/second documents the rise of the "fast" class. Life-Harness: boosting LLM agents by 88.5% without touching the model — the runtime revolution shows that the orchestration layer is a lever as powerful as the model itself. And the harness layer becomes infrastructure confirms that what surrounds the models has become a market in its own right.

Two signals from the vendors complete the picture: Claude Code Mods, where Anthropic turns its coding agent into a platform — more platform means more calls, hence more routing — and Microsoft pushing local code with MAI-Code 1.1 Flash 137B running in 3-bit on a PC. The local tier is officially a strategy, not a niche.

Why is JetBrains better positioned than anyone to play this role? Because the vendor ships IDEs used by millions of developers. Every completion, every background refactoring, every sub-agent in IntelliJ is a model call. Apache 2.0 and self-hosting let companies keep their code at home. The IDE is a distribution channel; the model, an infrastructure. The labs sell intelligence, JetBrains sells the workbench.

My take: this is the most credible version of "small models" optimism, because it doesn't claim that small models replace large ones — it makes them orbit. To choose your focal brain, our comparison of the best LLMs for coding sifts through the options on the market; for the orchestration layer, head over to our guide to the best autonomous AI agents.

Running Mellum2.1 locally: one command, two pitfalls

With Ollama, a single command is all it takes — but raise the context to 64K first, and don't download the wrong model by mistake.

ollama run hf.co/JetBrains/Mellum2.1-12B-A2.5B-Thinking-GGUF:Q4_K_M
>>> /set parameter num_ctx 65536

First pitfall: the Mellum entries already present in the Ollama library (mellum2-thinking-q4_k_m and friends) correspond to the June models — Mellum 2, capped at 2.0 on SWE-bench Verified. Until an official 2.1 entry appears, explicitly go through the hf.co path above.

Second pitfall: the context. The model supports 131,072 tokens — enough to fit a medium-sized repo in a single prompt, according to Tech-Insider — but Ollama starts with a lower window. Set num_ctx to 65536 at the very least before handing it a repo to chew on.

On the hardware side, the Q4_K_M GGUF weighs 8.1 GB and runs entirely offline on a 16 GB laptop — Windows 11, Mac or Linux, with integrations ranging from Ollama to IntelliJ and VS Code. No datacenter GPU required: that's exactly the point of the "focal" positioning. And remember that the model thinks out loud: its think tags precede every response and should be filtered out in a pipeline.

For a team, Apache 2.0 covers commercial self-hosting, modification, and fine-tuning. A VPS from Hostinger can be enough to serve a few developers, and private IDE deployments are among the three use cases JetBrains explicitly targets. To build on top of it, our guide to open source AI agents with Ollama details local orchestration patterns, and our pick of the best AI tools for code covers the IDE ecosystem.

❌ Common Mistakes

Mistake 1: downloading Mellum 2 thinking you're getting Mellum2.1

The mellum2 entries in the Ollama library date from June and cap out at 2.0 on SWE-bench Verified. The right move: use the path hf.co/JetBrains/Mellum2.1-12B-A2.5B-Thinking-GGUF until an official 2.1 entry becomes available.

Mistake 2: reading 47.0 as "it replaces Opus"

The score comes from benchmarks measured by JetBrains with a single pipeline, and Qwen3.5 9B wins 12 of the 17 published tests. The fix: benchmark on your own repos before architecting anything around it.

Mistake 3: forgetting that the model "thinks" out loud

Only the Thinking variant is published: think tags precede every response. In a sub-agent pipeline, you need to parse them or strip them out, otherwise you pollute your outputs and inflate your token counts.

Mistake 4: relying on vision

Mellum2.1 is text-only — no screenshots, no diagrams. For multimodal tasks, you'll need another model in the fleet. That's the corollary of the thesis: every specialist has a bounded scope.

❓ Frequently Asked Questions

Is Mellum2.1 really free for commercial use?

Yes. The Apache 2.0 license explicitly permits commercial self-hosting, modification, and fine-tuning. Checkpoints and GGUF builds are downloadable from Hugging Face with no registration required. Only your infrastructure costs apply.

What kind of machine do you need to run it?

A laptop with 16 GB of RAM is enough with the Q4_K_M GGUF (8.1 GB), fully offline, on Windows 11, Mac, or Linux. To serve a team, a VPS or an internal server does the job thanks to the 2.5B active parameters per token.

Can Mellum2.1 replace Claude or GPT in my IDE?

No, and that's not the goal. JetBrains positions it as an agent worker and low-latency routing model. Frontier models remain necessary for planning and hard debugging — hence the fleet architecture, big brain included.

How does it differ from Mellum 2, open-sourced in June?

The architecture is identical; all the progress comes from reinforcement learning in real-world environments, which takes SWE-bench Verified from 2.0 to 47.0 in four months. Only the Thinking variant is being released for 2.1, whereas Mellum 2 also existed as Instruct.

Why would an IDE maker release its own model?

Because the IDE is both a distribution channel and a private use case: low-latency completion, sub-agents, code that never leaves the company. With its Apache 2.0 model, JetBrains controls its AI stack end to end, with no dependency on frontier APIs.

✅ Conclusion

Mellum2.1 won't win any head-to-head benchmark competition, and that's precisely the point: JetBrains has just validated that there's an entire career path for small specialized models living in the shadow of the big ones. To decide where to place it in your stack, our top of the best AI tools, updated every quarter, remains the simplest starting point.