Mellum2.1 Brings an Apache-2.0 LLM to Coding Agents

Coding-agent teams can now download Mellum2.1’s weights and evaluate the model on their own infrastructure. JetBrains is positioning the Apache-2.0 LLM as a worker for exploring repositories, editing files and checking changes, giving teams an alternative to sending every task through a hosted model.

Some announced deployment options are still pending. GGUF builds for llama.cpp, Ollama and LM Studio are forthcoming, along with the multi-token prediction head intended for speculative decoding in vLLM. The weights are available; the local-runtime packaging is not yet complete.

In its October 8 Mellum2.1 announcement, JetBrains describes a 12-billion-parameter mixture-of-experts model with 2.5 billion active parameters. The architecture carries over from Mellum2. The substantive change is post-training, particularly reinforcement learning in environments where the model can practice repository-level work.

For teams building coding agents, this offers a specific test: can a smaller, self-hosted worker handle bounded tasks reliably enough to reserve larger hosted models for work that needs them?

The Weights Are Available, but Runtime Packaging Is Incomplete

The downloadable release includes Mellum2.1-12B-A2.5B-Thinking on Hugging Face. JetBrains says Mellum2.1 is released under Apache 2.0 and explicitly identifies private, self-hosted deployment as a use case.

For anyone planning an evaluation, the release status is:

• Available now: Mellum2.1 model weights on Hugging Face.
• Announced, not yet shipped: GGUF builds for llama.cpp, Ollama and LM Studio.
• Also forthcoming: The multi-token prediction, or MTP, head for speculative decoding in vLLM.

The MTP head is a particular inference artifact. Its pending status does not mean every form of vLLM deployment must wait. Likewise, the forthcoming GGUF builds do not confirm that an official Ollama or LM Studio package is ready today.

Teams with existing model-serving infrastructure can assess the published weights and integration requirements now. Deployment plans that depend on the promised packages still have pending dependencies. JetBrains has not provided a firm delivery date for them in the announcement.

Why 2.5B Active Parameters Does Not Mean a 2.5B Model

Mellum2.1’s mixture-of-experts design separates its total parameter count from the parameters active during inference. It contains 12 billion parameters overall, while activating a smaller portion, reported as 2.5 billion, for processing.

Sparse activation can reduce computation compared with using all of a model’s parameters for every token. The remaining weights still matter for storage, loading and memory planning.

The active-parameter figure alone therefore cannot serve as a hardware recommendation. Teams need to check the actual model representation, serving implementation, context requirements and intended concurrency before deciding where it will fit. The announcement does not establish a universal minimum GPU or memory configuration.

Repository access also depends on the surrounding agent system. A downloadable LLM does not acquire file-editing permissions or a test runner simply because it was trained for agentic work; the system must supply those tools.

The published Hugging Face chat template includes tool definitions and function-call formatting, consistent with that intended role. It provides an interface for an agent loop, not a complete sandbox or permission policy.

Repository-Based Reinforcement Learning Is the Main Upgrade

JetBrains says Mellum2.1 keeps Mellum2’s architecture but substantially changes what happened after pre-training. Reinforcement learning moved from a short final stage to the main part of training.

According to the company, that work involved millions of sandboxed runs across thousands of environments. JetBrains also added reinforcement-learning tasks covering software engineering, tool use, competitive programming, mathematics and science, combining public datasets with internally built tasks. It says it filtered those sources before training because public tasks could contain broken tests, unverifiable answers or difficulty levels unsuitable for the model.

Working through a repository task requires more than generating a plausible code answer. An agent has to choose what to inspect, interpret tool output, make a change and decide what evidence would establish that the change works.

JetBrains says Mellum2.1 can now explore a codebase, edit files and check its changes, and identifies agentic coding as its largest improvement over Mellum2. These are vendor capability claims. They do not guarantee that the model will complete an unfamiliar repository task without supervision.

Still, the training description gives teams a concrete reason to evaluate this version separately. JetBrains is claiming better learned behavior within the same architectural footprint, so the unchanged architecture does not make Mellum2.1 merely a repackaging of the earlier model.

The Performance Claims Describe Different Serving Conditions

JetBrains compared Mellum2.1 with Mellum2, Qwen3.5-9B and Gemma 4 E4B, saying it used the same evaluation setup for all four. Its headline speed claims cover two different situations.

Under heavy load, the company reports that Mellum2.1 serves almost twice as many tokens as Qwen3.5-9B. Separately, it reports an approximately 1.6x single-request speedup with multi-token prediction.

Neither result supports a general claim that Mellum2.1 makes every agent task twice as fast. Loaded throughput measures serving capacity when a system is busy; single-request speed concerns an individual generation. An entire repository repair also includes searches, tool execution, tests and any unsuccessful attempts.

The MTP result has a release-status qualification, too. JetBrains reports the acceleration in its setup, but the MTP head intended for vLLM speculative decoding is still forthcoming. Downloading the main weights should not be assumed to reproduce that configuration or its speedup.

For quality, the Hugging Face model metadata reports a 47% resolved rate on SWE-bench Verified and 28% on SWE-bench Pro for Mellum2.1 Thinking. These are JetBrains-reported results, not independently verified measurements.

Repository benchmarks are more directly relevant to the release’s intended use than isolated code-generation examples. Even so, each result belongs to an evaluated model-and-agent setup. Tool access, execution limits and the surrounding workflow affect what gets resolved.

The published comparisons support investigating Mellum2.1 as a compact coding-agent model. They do not establish parity with larger hosted models or show that it can replace one across an entire engineering workflow. Prospective users still need a task-specific evaluation.

Evaluate It as a Worker Inside an Agent System

The most useful initial test is a bounded assignment with an observable outcome. JetBrains suggests tasks such as identifying the root cause of a failing test or drafting and checking a fix. Those provide clearer evaluation targets than asking whether the model is generally “good at coding.”

A team could give Mellum2.1 and its existing hosted model the same failure report, repository snapshot, tools and execution budget. The comparison should record whether each finds the relevant code, produces a correct patch and runs appropriate validation.

Measure the completed task as well as generated tokens. A fast response that sends the agent down the wrong path can cost more execution time than a slower, correct one. Retry counts, unnecessary tool calls and escalation to another model all belong in the assessment.

A self-hosted worker need not replace the system’s primary model. One reasonable deployment experiment would assign Mellum2.1 a limited role, such as repository investigation or a narrowly scoped edit, while retaining another model for planning or difficult failures. Whether that division helps depends on measured reliability and total operating cost, not parameter count alone.

Privacy needs an equally concrete boundary. Running inference on infrastructure the team controls can keep that model’s processing local, but the complete agent may still contact external services. Repository tools, logging, telemetry and fallback-model calls need their own review.

The Apache-2.0 weights give teams something they can inspect, host and benchmark before every promised runtime build arrives. They can evaluate a deployable model now instead of relying only on a hosted endpoint or a future deployment promise. Its place in the agent loop depends on whether it can complete their chosen subtasks reliably enough.