JetBrains’ Junie Local runs a coding agent fully offline on a 64 GB M5 Mac
On August 24, 2026, JetBrains shipped Junie Local, a free version of its coding agent that runs entirely on the machine, using a 4-bit Qwen3.6-27B model. The entry cost is steep — macOS 26, an M5 chip, and 64 GB of unified memory — but it is the first local agent with no assembly required.
August 24, 2026. Qwen3.6-27B. 64 GB. On August 24, 2026, JetBrains announced Junie Local, a free version of its coding agent that runs entirely on the developer’s machine, with no network call. The model choice is deliberately conservative: Qwen3.6-27B, a 27-billion-parameter open model released in April 2026, rather than the newer Qwen3.8-27B. The reason says everything about the state of the art: on today’s Macs, the newer model runs four times slower once its reasoning mode is enabled.
The gap between “local” and “usable”
Most AI-assisted coding tools default to hosted models. Local execution has become a credible alternative for developers who want to keep code on their own machines, avoid per-request API costs, or work without a connection. Tools such as Cline, Continue, and Aider can already point at runtimes like Ollama or LM Studio, and GitHub added local-model support to Copilot CLI in April 2026, including an offline mode for fully air-gapped setups.
The catch is that “local” still leaves most of the assembly to the developer: pick a model and the quantization that suits your hardware, configure the runtime and context window, then find the combination that actually performs with the agent. And that last part matters: a model small enough to run comfortably on a laptop can still struggle with the tool use, reasoning, and long-running tasks a coding agent demands.
That is exactly what Junie Local removes. JetBrains — the company behind IntelliJ IDEA, PyCharm, and WebStorm — launched Junie in January 2025 as a coding agent embedded in its IDEs, able to plan tasks, modify code, and run tests and inspections. It has since expanded into a standalone CLI. With Junie Local, the vendor picked the model, quantized it, and tuned the inference engine and agent harness around that exact combination.
Under the hood: why Qwen3.6 over 3.8
The model choice is the most instructive part. Junie Local runs Qwen3.6-27B at 4-bit, on an inference engine built on mlx-vlm, which uses MLX, Apple’s machine-learning framework for Apple Silicon. It is the same underlying approach Ollama adopted in March 2026 when it moved its Apple Silicon engine onto MLX to exploit the chips’ unified memory.
Why not take Qwen3.8-27B, released in early August 2026 with improvements? Dmitry Savelev, JetBrains’ head of marketing, explains plainly: to work reliably with the agent, Qwen3.8 requires its reasoning mode, and that mode makes tasks roughly four times longer. “On today’s Macs, 3.6 wins,” he writes. The message applies across the industry: locally, the best model is not the newest — it is the one that stays fast and reliable within the hardware’s memory constraints.
The hardware floor is nonetheless high. 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. In practice, those 64 GB push MacBook Pro users into M5 Pro or M5 Max territory: this is firmly a high-end Mac proposition.
JetBrains owns that threshold. “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,” Savelev writes. The vendor says it is working to bring those requirements down.
The real bottleneck: prefill, not generation
The most counterintuitive technical point in the announcement concerns performance. Tokens per second measures generation speed, but an agent spends much of its time first ingesting source files, prompts, and context — the prefill stage — before producing an answer.
“Everyone benchmarks generation speed,” Savelev notes. “For a coding agent, that turns out to be the wrong number to chase, because most of the time is spent on prefill, while the model reads files to work out what is going on. Optimizing for prefill is where the real gains were.”
That reframes the optimization target: for a local agent, the value is won in context-ingestion speed, not output throughput. It is a lesson worth keeping for any team benchmarking its own local runtimes.
# Junie Local hardware prerequisites: macOS 26, M5+ chip, 64 GB unified memory
sysctl -n machdep.cpu.brand_string # check the chip
sysctl -n hw.memsize # unified memory in bytes (64 GB = 68719476736)What local really costs versus cloud
The hardware floor forces an honest calculation. An M5 Max MacBook Pro with 64 GB of unified memory runs into thousands of dollars. Against it, a cloud agent bills per token: small daily tasks cost a few dollars a month, and only massive refactors or large teams push the bill up.
So local is not justified by raw savings, except in specific cases. It is justified by what it removes: network dependency, per-request billing that can spike on a long task, and above all sending code outside the perimeter. In regulated industries — finance, healthcare, defense — where source code must not leave the workstation, the cloud is simply not an option, and the question becomes “which hardware” rather than “local or cloud”.
The 4-bit quantization is a reminder of the trade-off accepted: the model fits in unified memory, at the cost of a slight loss of precision. For the mechanical work Junie Local targets — renames, dependency upgrades, filling in tests — that loss is negligible. For fine reasoning over a delicate architecture, a larger hosted model will still win. Knowing which of the two you lack is already half the decision.
The market signal matters as much as the hardware spec. Junie Local is not the first local agent — Cline, Continue, and Aider have offered the path for a while — but it is the first time a major IDE vendor ships a turnkey local option: model picked, quantized, engine tuned, one command to switch. When a vendor the size of JetBrains treats local inference as a first-class product rather than a hobbyist configuration, it signals that on-device agenting has crossed from experiment to supported workflow. Expect the hardware floor to fall as the stack matures, and the cloud-versus-local decision to become a routine procurement question rather than an engineering project.
Verdict
If isolation, privacy, or cost force you local — an air-gapped workstation, sensitive code, a heavy load of mechanical work — and you have an M5 Mac with 64 GB, Junie Local is today’s simplest option: the /local command downloads the model and engine, starts a local server, and switches the agent over, with no Ollama or LM Studio to install. It shines on long, repetitive work: multi-file refactors, filling test-coverage gaps, dependency upgrades, and framework migrations.
If your hardware sits below the threshold, or a hosted model’s throughput is still acceptable, do not force it: a cloud agent often costs less in practice than an M5 Max MacBook Pro bought for local inference alone.
The whole picture fits in one sentence: the local coding agent stops being a tinkerer’s project, but its entry cost — a 27B model and 64 GB of memory — is a reminder that “local” and “free” do not mean “no hardware”.
References
- JetBrains’ Junie now runs entirely offline. Can you spare a 64 GB M5 Mac? — The New Stack, August 24, 2026
- Junie — JetBrains, accessed August 25, 2026
- Qwen3.6 — official repository, accessed August 25, 2026