Junie Local is free. The 64 GB M5 Mac is the price.
JetBrains has taken the assembly work out of running a coding agent offline. What it could not take out is the hardware, and that is now the thing deciding who adopts.
The Engineer · Build desk
What happened
- JetBrains released Junie Local, a free build of its coding agent that runs inference on the developer's own machine from a single /local command.
- It uses Qwen3.6-27B at 4-bit, around 20 GB of downloads, and requires macOS 26, an Apple M5 or newer, and at least 64 GB of unified memory.
- JetBrains picked April's Qwen3.6 over August's 3.8 because 3.8 needs reasoning enabled, which made tasks run about four times slower.
- On JetBrains' private test set the local model matched Sonnet 4.5 at a 10,000-token reasoning limit, with GPT-5 at medium effort slightly ahead.
Why it matters
- What it costs cost The bill moves from metered tokens to capital equipment: 64 GB pushes MacBook Pro buyers into M5 Pro or M5 Max, one machine per developer, paid by whoever owns the hardware budget rather than the...
- What's now possible capability Shops that could not clear a cloud coding agent through NDA review now have an option where there is no provider to assess, and it keeps working with the network unplugged.
- What it limits constraint The free path is JetBrains' model at JetBrains' quantization, because the fixes that made it usable were fitted to how this specific model behaves; bring your own weights and the tuning does not...
- What doesn't add up contradiction The parity score and the warning about architectural reasoning sit awkwardly together, since the local number was produced with reasoning off against cloud models that had it on.
Next story · Build · Sep 3
NVIDIA PAIR schedules each subagent call onto whichever LAN box already holds the modelConfirmed5 publishers
Qwen3.6-27B at four bits is roughly 13.5 GB of weights [29]. JetBrains asks for 64 GB of unified memory [11], close to five times that footprint [30], and the download is about 20 GB [10], leaving some 6.5 GB the weights alone do not account for [31]. Both gaps point the same direction, and the company's own engineering write-up says where: prefill.
With a cloud model, when the agent needs a file again it simply reads it again, because prefill is fast and the context window can be pruned to whatever is relevant [c13a]. On local inference it is not fast [c13a]. So JetBrains changed the loop to append every new request directly to the rolling context, keeping files the model has already read resident so the KV cache survives from one task to the next [4], and reordered the session-start payload so the engine can cache the whole prefix up to the user's request and reuse it across tasks in the same project [6]. Read that against the memory floor and it looks less like a model-size requirement than a working-set one. The 64 GB is not there to hold the weights. It is there to hold everything the agent has decided never to read twice.
The chip floor has the same origin. JetBrains says most of an agent's wall-clock time goes on prefill rather than generation [3], and that Junie Local starts at M5 because the Neural Accelerator carries 8-bit arithmetic instructions the M4 lacks, worth around 40% more prefill throughput [23]. That part is software, and JetBrains says the patch is going upstream as a PR to MLX-VLM [23]. Its engine sits on mlx-vlm and Apple's MLX [16]; Ollama moved its Apple Silicon engine onto MLX back in March [17]. If the patch lands, the do-it-yourself crowd inherits the same throughput without buying anything.
What the free tier actually buys is a harness fitted to one quantized model. Qwen 3.6 ignores Junie's request for XML-style progress blocks, so JetBrains scrapes the model's plain-text narration of its tool calls instead, and notes that this kind of adaptation is model-specific [14]. Optional LLM calls and multi-agent mode are switched off, the latter because sequential processing is what an M5 handles best [15]. Point Junie at your own model in Ollama, which has been possible for a while [21], and you are back to picking weights and tuning settings yourself.
The quality claim needs reading carefully too. Parity with Sonnet 4.5 at a 10,000-token reasoning limit [32] is the local model with reasoning disabled entirely, measured against cloud models that had it on [13], because reasoning cost two to three times the tokens for very little quality [13]. Qwen3.8 needed it on and ran roughly four times slower for the privilege [1]. Everything here is a speed budget wearing different clothes, and JetBrains is blunt about the bill: 64 GB on an M5 is what a 27B model costs to run well today, and it is the number they are working hardest to bring down, according to head of marketing Dmitry Savelev [20][26].
What to watch
- Whether the 8-bit prefill patch actually lands in MLX-VLM, which would hand the same throughput gain to Ollama-based setups nobody is paying JetBrains for.
- Whether JetBrains can drop below 64 GB or below M5, and which smaller model it has to accept to get there.
- Whether a Junie Local build appears for anything that is not Apple Silicon.
Clarity's read
What the record supports and how the coverage leans. The claims behind it follow.
Reality
- Evidence56
- Adoption18
- Hype gap+16
- Incentives72
- Confidence63
Claim ledger
Ranked by verification strength, evidence, and original report placement.
- [1]
JetBrains deliberately chose Qwen3.6 over the newer 3.8 because 3.8 needs reasoning enabled to work reliably, and with reasoning on tasks run roughly four times slower; "On today's Macs, 3.6 wins."
- [2]
Qwen3.6-27B is a 27-billion-parameter open-weight model released in April; the newer Qwen3.8-27B arrived earlier in August with improvements.
- [3]
JetBrains says generation speed is the wrong number to chase for a coding agent because most of the time is spent on prefill while the model reads files, so optimising prefill is where the real gains were.
- [4]
For local inference JetBrains changed Junie's logic so every new request is added directly to the rolling context, letting KV caches from the previous task be reused so a file the model has already read stays in the context window.
- [5]
With cloud models the agent can take only relevant pieces of context into the window and re-request file contents because prefill is fast; for local models prefill is not fast and it takes significant time to read files.
- [6]
JetBrains reordered the data sent at the start of a session and added logic to the inference engine to cache the prefix all the way up to the user's request, so it is reused for subsequent tasks in the same project.
- [7]
Junie Local ships a model JetBrains chose and tuned against its own agent loop, installs with a single /local command, runs entirely on the user's machine, and is free.
- [8]
Junie Local also uses KV-cache reuse across tasks and a speculative decoding setup that roughly doubles generation speed.
- [9]
Running /local inside Junie downloads the model and inference engine, starts a local server and switches the agent over automatically, with no separate Ollama or LM Studio installation, endpoint to configure or model profile to write.
- [10]
The model is Qwen3.6-27B at 4-bit, with about 20 GB to download, and it needs an M5 Mac with 64 GB of RAM.
- [11]
JetBrains confirms Junie Local involves about 20 GB of downloads and requires macOS 26, at least 64 GB of unified memory, and an Apple M5 chip or newer.
- [12]
The 64 GB requirement puts MacBook Pro users into M5 Pro or M5 Max territory, making Junie Local firmly a high-end Mac proposition.
- [13]
JetBrains ships the local model with reasoning disabled entirely because its tests found reasoning added very little quality and cost two to three times as many tokens; the reported results are the model without reasoning against cloud models that had it switched on.
- [14]
Qwen 3.6 mostly ignores Junie's request for an XML-like progress-update block, so JetBrains instead uses the plain text the model writes alongside its tool calls as the user-facing update, and notes such adaptations are model-specific.
- [15]
JetBrains disabled all optional LLM requests, including the logic that produced a short task description, and completely disabled multi-agent mode because sequential processing is the most efficient way to process LLM requests on an M5.
- [16]
JetBrains runs Qwen3.6-27B at 4-bit using an inference engine based on mlx-vlm, which uses MLX, Apple's machine-learning framework for Apple Silicon.
- [17]
Ollama moved its Apple Silicon engine onto MLX in March to take advantage of the chips' unified-memory architecture.
- [18]
Junie Local works with no network at all; once the weights are on disk it behaves the same on an airplane as at a desk.
- [19]
JetBrains frames Junie Local as turning the cost-efficiency dial to zero, making multifile refactors and renames, ignored test coverage gaps, dependency upgrades and framework migrations worth handing to the agent.
- [20]
"We know that an M5 Mac with 64 GB of RAM is a big ask. We are not going to pretend otherwise. That is simply what it costs to run a 27B model well today, and it is the number we are working hardest to bring down."
- [21]
Junie has been able to connect to local model runtimes such as Ollama or LM Studio for some time, with the developer loading whichever model they want, but that leaves picking the model, tuning settings and manual setup to the developer.
- [22]
JetBrains says that for everyday work you most likely would not notice the quality gap, but on complex architectural reasoning you definitely would.
- [23]
Junie Local starts at Apple M5 because the M5 Neural Accelerator has 8-bit arithmetic instructions the M4 lacks; using them gave around 40% more prefill throughput, and JetBrains says it will send that patch as a PR to MLX-VLM.
- [24]
Tools such as Cline, Continue and Aider can already be pointed at runtimes like Ollama or LM Studio, and GitHub added local-model support to Copilot CLI in April, including an offline mode for fully air-gapped setups.
- [25]
JetBrains says there is no vendor data policy to review because there is no vendor in the loop, which for work under client NDAs moves the conversation from "we assessed the provider" to "no provider was involved."
- [26]
Dmitry Savelev is JetBrains' head of marketing and wrote the Junie Local post published on Monday.
- [27]
JetBrains launched Junie in January 2025 as an AI coding agent embedded in its IDEs, able to plan tasks, modify code, run tests and inspections and work with project context, and has since expanded it into a standalone CLI.
- [28]
Existing Junie setup carries over to the local build: plan mode, live prompting, guidelines, skills and /commands behave the same way, because the engine changed and the agent did not.
- [29]
A 27-billion-parameter model quantized to 4 bits is roughly 13.5 GB of weights.
- [30]
The 64 GB memory requirement is about 4.7 times the size of the quantized weights.
- [31]
About 6.5 GB of the roughly 20 GB download is not accounted for by the quantized weights.
- [32]
On JetBrains' own private test set, Qwen3.6-27B scored on par with Sonnet 4.5 at a 10,000-token reasoning limit, while GPT-5 at medium effort scored slightly higher.
Sources
2 independent publishers whose own reporting we read for this story.
- blog.jetbrains.comJunie Can Now Run Entirely on Your Mac – No Tokens, No Cloud
2 articles · August 24, 2026
- thenewstack.ioJunie now runs entirely offline. Can you spare a 64 GB M5 Mac?
1 article · August 24, 2026
Topics and entities
Topics
- Hardware cost of local AI
- Apple Silicon ML stack
- On-device coding agents
- Local inference optimization
- Open-weight model selection
- AI coding tool economics
- Code privacy and air-gapped development