Mellum2.1-12B-A2.5B-Thinking

Mellum2.1-12B-A2.5B-Thinking

A 12B mixture-of-experts thinking model with 2.5B active parameters, trained with reinforcement learning on real repositories for coding agents, math and hard reasoning. Built by JetBrains, with a 131,072-token context.

Made by JetBrains on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

About

What it is: Mellum2.1 Thinking is a reasoning model from JetBrains with 12B parameters in total and 2.5B active per token. It is the next version of Mellum2 Thinking with the same architecture, and nearly all the changes came from post-training. Reinforcement learning became the main training stage, including runs inside real repositories where it earns a reward when tests pass.

Who it suits: It suits developers who build coding agents or want a compact thinking model for hard coding, math and reasoning problems.

Industry | Who uses it | How they use it | Example
Software development | Teams that build coding agents | Serve it with vLLM and turn on tool calling | Let it explore a repository, edit files and check its changes
Developer tools | Makers of coding assistants | Use thinking mode for hard coding questions | Ask it to find a bug in a short function and explain the fix
AI research | Researchers who study reinforcement learning | Read how RL became the main training stage | Compare its scores with those of Mellum2

If you want short replies without a thinking phase, you can skip it.

Where to use it:

• A vLLM server, with or without tool calling
• Python code that talks to an OpenAI-compatible endpoint
• Agents that explore code, run shell commands and call tools
• Windows, macOS or Linux with Python, to download the files

Use case | Who | What they get back
Repository work | Agent builders | Steps that explore code, edit files and check results
Hard coding and math | Developers | Reasoning first, then an answer
Tool use | Automation teams | Tool calls from a server with a tool parser enabled

How to set it up: What you need first:

• Python and the Hugging Face command line
• A GPU with room for about 24.3 GB of BF16 weights, or about 6.1 GB at 4-bit, which is an estimate
• vLLM for the serving examples

1. Install the Hugging Face tools with pip.
2. Download the model files to your computer.
3. Start a vLLM server with the model name.

pip install -U huggingface_hub
hf download JetBrains/Mellum2.1-12B-A2.5B-Thinking

How to use it: Start a vLLM server with a context of 131,072 tokens and the qwen3 reasoning parser. Add the tool choice flags if the model should call tools. Then talk to the server from Python with an OpenAI-style client.

# Without tool calling
vllm serve JetBrains/Mellum2.1-12B-A2.5B-Thinking \
  --max-model-len 131072 \
  --reasoning-parser qwen3

# With tool calling
vllm serve JetBrains/Mellum2.1-12B-A2.5B-Thinking \
  --max-model-len 131072 \
  --reasoning-parser qwen3 \
  --enable-auto-tool-choice \
  --tool-call-parser hermes

from openai import OpenAI
# Configured by environment variables
client = OpenAI()

messages = [
    {"role": "user", "content": "Find the bug in this function and explain the fix: def mean(xs): return sum(xs) / len(xs) - 1"},
]

chat_response = client.chat.completions.create(
    model="JetBrains/Mellum2.1-12B-A2.5B-Thinking",
    messages=messages,
    max_tokens=81920,
    temperature=0.6,
    top_p=0.95,
    extra_body={"top_k": 20},
)
print("Chat response:", chat_response)

Tool | What it does
vllm serve | Starts the model server with the reasoning parser, and optionally tool calling
OpenAI client | Sends chat requests to that server and prints the response

Example: You send a short function that computes a mean but subtracts one at the end, and ask for the bug and the fix. The model reasons first, then points to the stray subtraction and explains how to correct it.

For newcomers and experts: A good first try is the short bug-finding request above against a local server. It shows you the thinking step before the answer.

For experts, the model has 28 layers, a hidden size of 2304, 64 experts with 8 active, and grouped query attention with 32 query heads and 4 key-value heads. Three of every four layers use a sliding window of 1,024 tokens. Training included millions of sandboxed attempts inside actual code repositories, where the model had a shell and editing tools. The card says agentic results rose sharply over Mellum2.

Start from the Mellum2 architecture
Train with RL on math, code, science and tool tasks
Run sandboxed attempts in real repositories
Reward the model when the tests pass

Good to know:

Title: SWE-bench Verified score
Mellum2.1 Thinking: 47.0%
Mellum2 Thinking: 2.0%
Gemma 4 (E4B): 23.0%
Qwen3.5 (9B): 50.0%

Title: Selected scores, higher is better
Benchmark | Mellum2.1 Thinking | Mellum2 Thinking | Qwen3.5 (9B)
LiveCodeBench v6 | 82.0 | 69.4 | 75.4
AIME 25/26 | 83.3 | 60.1 | 86.7
Terminal-Bench 2.1 | 17.4 | 0.6 | 21.7
BFCL v4 | 62.3 | 49.6 | 58.5

• Scores: JetBrains reports every value itself, using one pipeline in thinking mode.
• Context: 131,072 tokens.
• Coming soon: the card promises GGUF files for use in llama.cpp, Ollama and LM Studio, plus a vLLM speculative decoding head.
• Language: English.
• License: Apache 2.0
• Cost to run: no API key or paid service named. You need a GPU.
• Data it reaches: it downloads files from Hugging Face, and the example client sends requests to a server you run, with settings from environment variables.
• Not for: none named.

On Hugging Face, 13 November 2026

• Task: text generation
• Library: transformers
• Parameters: 12.1B
• Weights: about 24.3 GB in BF16; about 6.1 GB at 4-bit (estimate)
• Formats: Safetensors
• Downloads in the last 30 days: 14,512
• Likes: 197
• License: apache-2.0
• Languages: en
• Based on: JetBrains/Mellum2-12B-A2.5B-Base
• Quantized versions: 26
• Fine-tunes: 2
• Tags: transformers, safetensors, mellum, text-generation, conversational, model-index

Links

• Model: https://huggingface.co/JetBrains/Mellum2.1-12B-A2.5B-Thinking
• Files: https://huggingface.co/JetBrains/Mellum2.1-12B-A2.5B-Thinking/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download JetBrains/Mellum2.1-12B-A2.5B-Thinking

Then follow the usage in its model card. Nothing in this kit runs by itself.