Live Nov 18 · Cohort 3Nov 18, 19:00 MSK — free hands-on AI agents live workshop · Live Cohort 3 starts Nov 23Join Nov 18 Live →Cohort 3 (Nov 23)
ReleaseInsight · On RadarHabr AI→ original

JetBrains' Mellum Runs Locally in an IDE: 5 Out of 10 on a MacBook M3 Pro

Cloud agents like Claude Code, Codex and Cursor can go dark when access is blocked, and token bills keep climbing. The author of a Habr guide built a replacement on a MacBook M3 Pro: JetBrains' Mellum2.1 model, LM Studio Bionic, the OpenCode agent and the OpenIDE environment. Everything runs without internet or a subscription. He rates the setup 5 out of 10. It handles small tasks, but large ones are still too slow.

AI-processed from Habr AI; edited by Hamidun News
JetBrains' Mellum Runs Locally in an IDE: 5 Out of 10 on a MacBook M3 Pro
Source: Habr AI. Collage: Hamidun News.
Listen to article
Article Fact Sheet & Key Figures
ParameterDetails
Primary sourceHabr AI ↗
Editor-in-Chief
Key metric #1Revolut moved ~2000 engineers to its own GLM; the company says costs fell by 90%
Mellum2.1 is a MoEabout 2.5 billion of its 12 billion parameters are active per token
Key metric #3The Q4_K_M build weighs about 8.1 GB, and the weights are open under Apache 2.0

Cloud assistants for programmers — Claude Code, Codex, Cursor — are convenient as long as you can reach them. But access gets blocked, and subscription and token bills keep growing. The author of a Habr guide decided to test an alternative: run a model directly on a laptop and use it like an ordinary agent inside a development environment.

He took JetBrains' open Mellum2.1 model, the LM Studio Bionic app to run it, the OpenCode agent, and an IDE called OpenIDE. He tested it on a MacBook with an M3 Pro chip.

He rated the result 5 out of 10: a request like "find the method and explain what it does" works without internet and without a subscription, but large tasks run slowly.

Why run a model locally at all

The main argument is predictability. A cloud agent can change its capabilities or shut off without warning, and a token bill can suddenly spike. The author cites Revolut: the company moved about 2000 engineers to a GLM model running on its own servers, keeping Claude Code and Codex only for specific tasks. According to Revolut, AI coding costs fell by roughly 90%. That figure comes from the company itself and has not been independently verified, but the direction is clear.

For an ordinary developer, a local model offers the same thing on a smaller scale, especially if your employer doesn't pay for the subscription. It also works on a plane, on a train, and whenever your connection is bad.

How the stack fits together

The example uses Mellum2.1 12B A2.5B Thinking. The first Mellum handled code autocompletion. In version 2.1, JetBrains specifically improved work with a repository: finding the relevant code, editing files and verifying changes. The name breaks down like this:

  • 12B — about 12 billion parameters;
  • A2.5B — a MoE architecture: only about 2.5 billion parameters work on each token, so there is less computation, but all the weights still sit in memory;
  • Thinking — the model reasons before answering, and that takes time.

The weights are open under Apache 2.0. The author uses the official GGUF build with Q4_K_M quantization.

Quantization means storing weights at lower precision: the file gets smaller and takes up about 8.1 GB. If you have enough memory, you can try 6 or 8 bits and compare the answers on your own tasks.

One important caveat: the file size is not all the memory you need. You also need room for the context, the operating system, a browser and the IDE itself. On a Mac with Apple Silicon, memory is shared between the CPU and GPU, so all of these compete for the same gigabytes.

For other computers, the author recommends the canirun.ai service, but you should measure real speed yourself.

The chain works like this. LM Studio Bionic downloads and runs the model and exposes a local OpenAI-compatible API at http://127.0.0.1:1234/v1. OpenCode, which you can install via Homebrew, for example, connects to it. Then the same agent is connected in OpenIDE. The advantage is that project rules and MCP servers configured in OpenCode also work inside the IDE, so you don't need to build a separate agent for the environment. Git, a database client, debugging and Docker are all within reach. OpenCode alone can't do this: it has no DB client, browsing files is awkward, and diffs are not displayed perfectly.

You don't have to use Mellum. Models from the Qwen or Gemma families will work, and if you have a lot of memory, so will Muse Glimmer from Meta. The key is to check for tool-calling support: for an agent, being able to write code in a chat is not enough.

How it works in practice

The rating is honest: 5 out of 10. To complete a task, the agent has to call the model several times: read files, make an edit and check it. On a laptop, these steps are slow. According to the author, results will be noticeably better on more powerful hardware, but for large daily tasks he is not moving to local models yet.

The practical takeaway: a local stack is already good enough as a fallback if the cloud gets blocked, for offline work and for small tasks. It has not yet become a replacement for cloud agents on serious work, especially on a mid-range laptop. If you want to try it, start with the 4-bit build, measure speed on your own repository, and only then decide whether you need more powerful hardware. For teams, the Revolut example shows a "own model for routine work, cloud for hard problems" approach. In the next article, the author promises to cover free cloud options: limits and IDE integration.

Story

Key Questions Answered

Why run a model locally at all?

The main argument is predictability. A cloud agent can change its capabilities or shut off without warning, and a token bill can suddenly spike. The author cites Revolut: the company moved about 2000 engineers to a GLM model running on its own servers, keeping Claude Code and Codex only for specific tasks. According to Revolut, AI coding costs fell by roughly 90%. That figure comes from the company itself and has not been independently verified, but the direction is clear.

How the stack fits together?

The example uses Mellum2.1 12B A2.5B Thinking. The first Mellum handled code autocompletion. In version 2.1, JetBrains specifically improved work with a repository: finding the relevant code, editing files and verifying changes. The name breaks down like this: 12B — about 12 billion parameters; A2.5B — a MoE architecture: only about 2.5 billion parameters work on each token, so there is less computation, but all the weights still sit in memory; Thinking — the model reasons before answering, and that takes time.

How it works in practice?

The rating is honest: 5 out of 10. To complete a task, the agent has to call the model several times: read files, make an edit and check it. On a laptop, these steps are slow. According to the author, results will be noticeably better on more powerful hardware, but for large daily tasks he is not moving to local models yet. The practical takeaway: a local stack is already good enough as a fallback if the cloud gets blocked, for offline work and for small tasks.

ZK
Zhemal Khamidun — CPO at Alpina Digital, product manager of AlpinaGPT. Building AI products since 2019. Hamidun News is a pet project that grew into a production aggregator with 6,000+ readers.
✦ Hands-On AI Engineering · Hamidun Academy

Build & Ship Production AI Agents Without Boilerplate Code

Start your free 72-hour trial at Hamidun Academy (academy.hamidun.com) — interactive lessons on Claude Code & Cursor, live Tech Radar, and production agent templates.

Start 72h Free Trial →Vibe-Coding Intensive
What do you think?
Loading comments…