In-Depth Review of Mellum2.1: A Technological Leap in JetBrains' Open-Source Agentic Coding Model

1. What is Mellum2.1

Mellum2.1 is an open-source AI programming model launched by JetBrains, built on a 12B Mixture-of-Experts (MoE) architecture, activating only 2.5B parameters during each inference. The core breakthrough of this model lies in elevating reinforcement learning (RL) from the final stage of traditional training processes to the central training component. Combined with millions of runs in sandbox environments, the model is capable of autonomously exploring codebases, editing files, and verifying its own modifications, resulting in a significant leap in agentic coding capabilities. In high-load scenarios, Mellum2.1's throughput approaches twice that of Qwen3.5-9B, while also supporting private deployment. The model weights are available on Hugging Face for developers to freely access and use commercially.

Technical Positioning and Domain: Mellum2.1 is a large language model for programming that sits at the intersection of natural language processing and code intelligence. It focuses on agentic coding, code completion, tool calling, and general-purpose reasoning. Within JetBrains' product ecosystem, it serves as the intelligent foundation for IDEs, while being open-sourced to a broader developer community. The goal is to establish a differentiated competitive advantage in the AI programming assistant space.

Development Background: This model was developed by JetBrains' official team and continues the iterative path of the Mellum series. With years of deep expertise in the developer tools domain and widely used IDE products such as IntelliJ IDEA and PyCharm, JetBrains aims to deeply integrate large model capabilities into the developer workflow. Through an open-source strategy, the company seeks to attract community contributions and build an AI programming model ecosystem around its own product ecosystem. The release of Mellum2.1 marks an important step in JetBrains' transformation from a traditional IDE vendor to an AI-driven development platform.

Core Value: Mellum2.1 addresses the core pain points of traditional programming models in agentic tasks—lack of overall understanding of codebases, inability to autonomously perform multi-step operations, and difficulty in verifying the correctness of its own modifications. Through large-scale RL training, the model has learned a complete closed-loop of capabilities for exploration, editing, and verification in real coding scenarios, enabling it to identify the root causes of failed tests and draft repair solutions. Additionally, the combination of MoE architecture and Multi-Token Prediction (MTP) technology allows it to achieve high inference throughput while keeping computational costs under control, offering a practical solution for enterprise-level private deployment.

2. Key Features

• Agent Programming: The core capability of Mellum2.1, allowing the model to autonomously explore codebases, edit files, and self-check the results of its modifications. In real-world coding scenarios, it can identify the root cause of failing tests, draft repair solutions, and verify their effectiveness, forming a complete agent task loop. This ability stems from the accumulation of millions of real interactions in sandbox environments during the training phase.

• Code Completion and Generation: Building on Mellum2's established positioning, this feature provides fast code completion, snippet generation, and code-related Q&A capabilities for everyday coding workflows. When deeply integrated with JetBrains IDEs, it offers instant intelligent suggestions during coding, reducing the context-switching cost for developers.

• Tool Calling: Capable of dispatching external tools to accomplish tasks, this feature is suitable for building AI agent systems. The model can automatically select appropriate external tools based on task requirements and organize the calling sequence, achieving semantic mapping from natural language instructions to specific tool operations, and supporting complex automation processes.

• General Reasoning: Capable of handling everyday Q&A and progressively deriving solutions to mathematical and logical problems. In scenarios such as competitive programming and algorithmic reasoning, the model demonstrates strong logical chain construction capabilities and can be used as the reasoning core of a general-purpose AI assistant.

• Private Deployment: Supports local or on-premise infrastructure deployment, with all code and data remaining entirely within the enterprise. This meets the data security requirements of high-compliance scenarios such as finance and government affairs. Compared to API calling methods, private deployment eliminates the risk of data leakage and avoids the cost accumulation issues associated with pay-as-you-go billing.

• Multi-Token Prediction (MTP): The model can predict multiple subsequent Tokens in a single forward pass, increasing speed by approximately 1.6 times in single-request scenarios. Combined with the low-activation parameter design of MoE, Mellum2.1 achieves throughput close to twice that of Qwen3.5-9B under high load, significantly improving service response efficiency.

• Context Window Support: Supports a context window of up to 131K Tokens, capable of accommodating the content of large-scale code repositories. This meets the demand for global information in complex project-level tasks and provides ample context space for agent programming.

3. How to Use

1. Access the Model Page: Open the official JetBrains organization page on Hugging Face and locate the Mellum2.1 repository (model identifier: JetBrains/Mellum2.1-12B-A2.5B-Thinking). It is recommended to first review the technical documentation and license agreement in the model card to confirm whether the usage requirements are met.

2. Download the Model Weights: Click the download button on the model card page or use the git lfs clone command to pull the model files. If the model has usage restrictions, you must agree to the relevant usage agreements before obtaining the complete weight files. Ensure that your local storage has sufficient space before downloading; the 12B MoE model weight files typically require tens of gigabytes of disk space.

3. Select a Deployment Framework: The official recommendation is to use Transformers or vLLM for deployment. For functional verification and prototyping, the Transformers library offers a more straightforward integration method. For production-level high-concurrency services, vLLM provides higher throughput performance and more efficient GPU memory management, making it more suitable for real-world business scenarios.

4. Configure the Inference Environment: Prepare a GPU environment; the official benchmark tests are based on a single NVIDIA H200 GPU. After loading the model, set the context parameter to 131K. Depending on the GPU memory configuration, adjust parameters such as concurrency and batch size to achieve optimal performance.

5. Enable Acceleration Options: Configure the Multi-Token Prediction (MTP) feature according to the official guidelines, which can increase the speed of a single request by approximately 1.6 times. Enabling MTP requires setting the corresponding parameters in the inference framework and ensuring that the model weights include support for the MTP module.

6. Initiate Inference Calls: Send prompt requests for code generation, repository-level editing, or agent tasks via the API interface to obtain model outputs. Developers can design custom Prompt templates based on their specific needs to integrate Mellum2.1 into existing development toolchains or CI/CD workflows, enabling automated code review and correction.

4. Pros and Cons Analysis

5. Comparative Analysis with Similar Tools

Selection Recommendations: For development teams whose core requirement is agent programming and who need the model to autonomously resolve complex repository-level tasks, especially those using JetBrains IDEs, Mellum2.1 is currently a cost-effective choice. Its MoE architecture with 2.5B activated parameters offers advantages in inference costs, and its RL training provides agent capabilities that are relatively rare among open-source models. If the team prioritizes general-purpose capabilities and ecosystem maturity, Qwen3.5-9B, as a general-purpose large model, has stronger advantages in Chinese support and community resources, making it suitable for integrated applications that require both code tasks and general QA.

For teams with limited computational resources and a focus on lightweight deployment, CodeGeeX4's 9B dense architecture runs more smoothly on consumer-grade GPUs, making it ideal for daily coding assistance scenarios where code completion is the primary need. DeepSeek-Coder-V2, on the other hand, demonstrates solid performance in complex code generation and mathematical reasoning due to its massive MoE parameter scale, making it suitable for research teams with high generation quality requirements and ample GPU resources.

6. Editor's Summary

The release of Mellum2.1 has injected a new technical variable into the open-source AI programming model landscape. The most noteworthy innovation is not the parameter scale or a single inference speed metric, but rather a shift in training methodology—elevating reinforcement learning from a supplementary closing phase to the core of the training process. Through millions of interactions in real sandbox environments, the model acquires the exploration, editing, and verification capabilities essential for agent programming in practical scenarios. This methodological innovation provides the industry with a new path distinct from the traditional SFT+RLHF paradigm: model capability improvements no longer solely depend on the accumulation of data volume, but instead achieve qualitative leaps through deep utilization of real environment feedback.

From a practical value perspective, Mellum2.1's performance on agent tasks makes it an ideal base model for building autonomous programming assistants. The MoE design with 2.5B active parameters significantly reduces deployment costs, enabling mid-sized and smaller teams to independently run programming models with agent capabilities within their organizations. A 131K context window and the MTP acceleration mechanism ensure a high-quality user experience by addressing both breadth and speed dimensions.

For JetBrains, the release of this model is not only a complement to product capabilities, but also a strategic move to establish its voice and influence in the AI programming competition landscape.

In terms of target users, this model is most suitable for developers who deeply utilize JetBrains IDEs, enterprise R&D teams requiring private deployment, and academic laboratories researching agent programming methodologies. The community ecosystem is still in its early stages of development, with Chinese resources and third-party toolchains gradually becoming more abundant. At this stage, it is more appropriate for developers with certain model deployment capabilities to use it directly. Looking ahead, if the Mellum series can continue to accumulate RL training data from sandbox environments and create a data flywheel effect, its competitiveness in the niche field of agent programming will further increase, and it has the potential to become a core pillar of AI capabilities within the JetBrains ecosystem.

7. Application Scenarios

• Agent Programming: Developers can integrate Mellum2.1 into automated programming workflows, enabling the model to autonomously explore codebases, edit files, and verify modification results, completing the full process from identifying test failures to fixing them. This scenario is particularly suitable for defect repair and feature iteration in large-scale projects, reducing repetitive work for developers during troubleshooting and fixing phases.

• Enterprise Private Assistant: Deploy the model on internal enterprise servers to serve as a code assistant for the entire team. Code and data remain entirely within the internal network, meeting the confidentiality requirements of highly regulated industries such as banking, government affairs, and defense. Enterprises can dynamically adjust resource allocation based on actual workload, achieving cost-effective AI services.

• Deep IDE Integration: Embed Mellum2.1 into JetBrains IDEs (such as IntelliJ IDEA, PyCharm, WebStorm, etc.) or third-party editors, offering real-time code completion, intelligent Q&A, and refactoring suggestions. The model's contextual understanding can be combined with the project indexing information from the IDE to provide recommendations that better align with the actual coding style.

• Sub-Agent Scheduling: In multi-agent systems, Mellum2.1 can leverage its low-latency, high-throughput characteristics to act as a sub-agent, performing specific subtasks such as code generation and test analysis, or serving as a routing node to distribute complex requests to more specialized models. Its tool calling capability supports flexible interaction with external APIs.

• Mathematical and Logical Reasoning: In scenarios requiring rigorous reasoning chains, such as math problem-solving, algorithm competition training, and technical Q&A, Mellum2.1 can progressively display the derivation process, helping developers verify their ideas or serving as an educational aid. This capability can also be extended to professional applications such as code complexity analysis and algorithm optimization suggestions.

8. FAQ

Q: How significant is the practical difference between Mellum2.1 and Qwen3.5-9B in agent programming?
A: Mellum2.1's core advantage lies in the inclusion of millions of real sandbox environment runs during training, which enhances the model's task completion capabilities in repository-level exploration, file editing, and self-check verification. While Qwen3.5-9B supports tool calling, it does not emphasize repository-level agent operations as a key selling point. In practical testing, Mellum2.1 demonstrates superior success rates in tasks such as identifying the root cause of failed tests and drafting repair solutions.

Q: What are the advantages of Mellum2.1's MoE architecture compared to dense models?
A: Mellum2.1 employs an MoE architecture with a total of 12B parameters, activating only 2.5B parameters per inference. This means the model has the knowledge capacity of a 12B model, but the computational load is similar to that of a 2.5B dense model. As a result, it achieves higher throughput and lower inference costs under the same computational resources, making it particularly suitable for high-concurrency service scenarios.

Q: How can MTP acceleration be enabled? Is any additional configuration required?
A: To enable MTP, corresponding configuration must be performed within the inference framework. In frameworks that support MTP, such as vLLM, it can be activated by setting relevant inference parameters. Official guidelines recommend combining MTP with speculative decoding for further performance optimization in production environments. Once enabled, the speed per request can increase by approximately 1.6 times, with a significant improvement in throughput.

Q: Can the model run on consumer-grade GPUs?
A: While the official benchmarks are based on a single H200 GPU, the design of Mellum2.1 with 2.5B active parameters makes it feasible to run on consumer-grade GPUs with 24GB or more of VRAM (such as RTX 3090/4090). However, the inference speed will be lower than in the H200 environment. For production environments, it is recommended to use at least an A100 or H200-level GPU to ensure efficient processing of agent tasks.

Q: What are the specific criteria for the training data filtering mechanism?
A: Training data undergoes strict filtering before being added to the repository, primarily excluding three types of tasks: data with test defects, data with unverifiable answers, and data with inappropriate difficulty levels. This mechanism ensures the quality of the RL training signals, preventing the model from learning from incorrect feedback, and is a crucial guarantee for the reliability of model outputs.

Q: How does the model perform in Chinese scenarios?
A: The official documentation does not provide dedicated evaluation data for Chinese scenarios. From the composition of the training data, the model's understanding and generation capabilities for Chinese mainly come from knowledge transfer from general corpora. For scenarios such as Chinese comment generation and technical Q&A, developers are advised to conduct targeted testing before use. For Chinese code completion in projects, performance may differ from that in English scenarios.

9. Project Links

• Project Website: https://blog.jetbrains.com/ai/2026/10/mellum2-1-gets-to-work-a-fast-open-model-for-coding-agents/ (Official announcement)
• Hugging Face Model Repository: https://huggingface.co/JetBrains/Mellum2.1-12B-A2.5B-Thinking (Official model repository)