How Much To Run AI
Open weights

Mellum 2.1: GGUF Setup, Memory and Coding Costs

Mellum 2.1 Thinking is JetBrains’ open-weight text model for coding agents, tool use and reasoning. Its 12B-parameter mixture of experts activates 2.5B parameters per token. Official GGUF files are available for local runners alongside the BF16 checkpoint. Start with a small code task, then choose a quantization and context that leave room for the runtime.

Content reviewed:

Mellum 2.1 local workflow: choose an official GGUF, start with a bounded context and measure the complete task.
Setup diagram. GGUF download size is separate from runtime memory and task cost.

Use this model

Official model repository

Useful first Mellum tasks

  • Explain a failing unit test using the relevant function and test, then check the proposed change.
  • Ask for a small refactor with explicit behavior to preserve and inspect the resulting diff.
  • Use a coding agent to search a repository and test a bounded fix, retaining tool results and failed attempts.

Choose a thinking model for a bounded coding job

Mellum 2.1 fits a repository assistant or a smaller worker inside a coding system. Give it the relevant code, the failure and an acceptance test. A local chat runner is enough for an explanation; editing files and running tests require an agent harness that exposes those tools.

For a first trial, paste a short function and its failing test into chat. Check whether the explanation identifies the cause, whether the proposed patch changes unrelated behavior and whether the test passes after applying it. Keep automated tool execution separate until the model and runner behave as expected.

This is the Thinking checkpoint. Its responses can include <think> reasoning before the final answer, so allow output room for both and check how the client displays or parses them. It is a text model; use a vision model when your task starts from a screenshot.

Choose an official GGUF before downloading

The JetBrains GGUF repository contains single-file variants of the same Thinking model. The official files are available to download. Download one variant rather than the entire collection.

Q4_K_M is the variant used in the startup examples below. MXFP4_MOE is smaller, while Q6_K, Q8_0 and BF16 take more storage. The card’s quantization metrics compare logits on Wikitext-2 at 512-token context, not passed coding tasks. Check code quality and runtime support for your chosen format.

These decimal-GB figures are download sizes from the official file listing, not measured RAM or VRAM. Keep free disk space for the selected file and any download cache.

Official file suffixDownload sizeWhat to compare
MXFP4_MOE.gguf7.03 GBSmallest listed artifact; confirm backend support
Q4_K_M.gguf8.07 GBThe startup example below
Q6_K.gguf10.9 GBLarger quantized artifact
Q8_0.gguf12.9 GBLarger quantized artifact
BF16.gguf24.3 GBUnquantized weight format

Run Mellum 2.1 locally

Use a current runner and backend that support the Mellum architecture and your selected quantization. The following paths use the official JetBrains artifact; an older runtime can reject a model even when its file fits on disk.

llama.cpp: serve a Q4_K_M file

Install a current llama.cpp build for your operating system and accelerator, then start the local server with the command below. It downloads the selected quantization. The 8,192-token context is a deliberately smaller starting allocation than the model’s 131,072-token maximum.

Open the server’s web UI at http://127.0.0.1:8080 and submit the small function-and-test task. For a coding client, use the local OpenAI-compatible base URL http://127.0.0.1:8080/v1. Check the final answer, then record loading time, prompt processing and generation separately.

Illustrative local server; downloads about 8.07 GB of model weights
llama-server -hf JetBrains/Mellum2.1-12B-A2.5B-Thinking-GGUF:Q4_K_M \
  --host 127.0.0.1 --port 8080 --ctx-size 8192 \
  --temp 0.6 --top-p 0.95 --top-k 20

Ollama: pull the official GGUF route

With Ollama installed, the command below selects Q4_K_M from JetBrains’ Hugging Face repository. Start with one short conversation and inspect the reasoning and final-answer handling before connecting an agent.

If you already downloaded the GGUF, Ollama also supports importing a local file through a Modelfile whose FROM line names that file, followed by ollama create. Importing does not quantize the GGUF again. Preserve the model’s chat-template and stop-token behavior when changing the wrapper.

Official Hugging Face GGUF route in Ollama
ollama run hf.co/JetBrains/Mellum2.1-12B-A2.5B-Thinking-GGUF:Q4_K_M

LM Studio: select the exact repository and file

Open Discover in LM Studio and paste the full JetBrains GGUF repository URL. Choose Mellum2.1-12B-A2.5B-Thinking-Q4_K_M.gguf, download it, then select it in Chat and load it. Use a current inference backend with Mellum support.

Begin with a modest context and the same function-and-test prompt. Review the loaded model, context and GPU-offload settings before comparing memory or elapsed time with another runner. A successful chat load does not by itself configure a tool-using coding agent.

Budget memory for all experts and the context

The full 12B model still needs a storage and memory-placement plan. The 2.5B active figure describes computation per token; it does not turn the downloaded checkpoint into a 2.5B-sized allocation. Runtime buffers, KV cache and other applications need memory beyond the selected file.

Load at a smaller context first and watch peak memory. Increase it only when the document or repository task needs it. The advertised 131,072-token context is a model limit, not proof that every laptop can serve that length. CPU offload can shift the allocation to system RAM and change latency.

Record system RAM, VRAM or unified memory, runner version, quantization, context, offload settings and concurrent requests. If loading fails, first check runtime support and available memory; avoid treating an unknown-architecture error as evidence that the quantization needs more RAM.

Read the coding and speed results with their setup

JetBrains’ own agent evaluation reports 47.0% on SWE-bench Verified for Mellum 2.1, compared with 2.0% for Mellum2 Thinking and 50.0% for Qwen3.5-9B. Those runs use Pi v0.73.1, shell/file tools, a 114K context and up to 16K output tokens per turn. They are publisher results, not an independent test of the GGUF you download.

The launch speed chart uses an H200 and includes multi-token prediction results. The MTP head remains described as forthcoming in the official model card. Do not use the advertised MTP speedup as the default throughput of a downloaded GGUF or an ordinary server without that head.

The main model card’s separate vLLM tool-use recipe selects qwen3 for reasoning parsing and hermes for tool-call parsing. Use the recipe for the original checkpoint when building that serving path, and validate tool calls through the client before giving an agent a larger repository task.

An RTX 3060 trial: decode speed and completed programs

Bancom’s October 16 AI-assisted, human-reviewed report uses official Q6_K (10.9GB), an RTX 3060 12GB, i5-12400, 32GB RAM and Ubuntu 24.04.4. Its upstream llama.cpp build is commit 620d222. At 32,768 context it reports about 11.1GB VRAM. The 127.1 tokens/s decode result comes from llama-bench: 128 generated tokens, averaged over two runs, with separate 512/4,096-token prefill tests.

Its HumanEval run passes 159 of 164 problems with a 16K output cap. The separate game exercise uses 65,536 context and a 48K output cap: none of 12 first attempts meets all acceptance criteria. After up to two corrections, two meet the criteria, four remain partial and six fail. Browser checks used predefined actions; this was not extended human playtesting.

Mellum used high reasoning and temperature 0.6 in these task tests. The report does not test a repository-agent workflow or full 131K context. Use this as one company’s task-specific report, and test completed programs as well as token speed on your own workload.

Measure the complete coding-task cost

The weights use Apache 2.0 terms. Local inference has no model-provider token bill; include hardware, electricity, storage and elapsed time in the budget. A rented server or hosted endpoint has a separate tariff.

For an assumed 200W whole-system draw over three hours at $0.20/kWh, electricity is 0.2kW × 3h × $0.20 = $0.12. This is a budget example, not a measured Mellum run. Count loading, reasoning, tool waits and failed attempts in the time you allocate to the task.

For a cloud deployment, multiply the full allocated instance rate by its reserved hours, including startup and idle time. Compare that amount with accepted fixes over the same task set. File size, active parameters and a vendor H200 chart cannot supply an unmeasured completion rate for your own hardware.

Before you use it

  • The Thinking model generates text and reasoning; repository edits and tests depend on the agent tools around it.
  • Choose a runner that supports the exact Mellum architecture and GGUF format, then allow working memory beyond the download size.

How to get started

Choose one official quantization, run a small checkable code task and record the complete session. Increase context or automate tools after checking the first result.

Sources

Sources (8)

Calculators