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
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.
- Nov 18, 2026OpenAI Releases Legal AI: 95% Fewer Fabricated Facts Than Claude Opus 5.5
- Nov 18, 2026Claude SEO Plugin Runs Up to 17 Agents and Audits a Site with One Command
- Nov 18, 2026OpenAI agent fills out insurance paperwork: Luna scores 91.8% for 8.5 cents
- Nov 18, 2026In 94% of B2B shortlists, AI summaries barely show the companies' own websites
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.
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.
The AI world, distilled — once a week
Seven stories that actually mattered, hand-picked. No noise, no reposts, no press releases.
Done! Check your inbox for a confirmation.