Is self-hosting a coding agent actually cheaper?

After the hardware, yes — there's no per-token bill and no rate limit, so heavy or repetitive use is free at the margin. But you pay up front (a capable Mac or a 24 GB GPU), and in time: setup, model management, and a real capability gap on hard tasks. It pays off for high-volume routine work or privacy-bound code; it doesn't if your bottleneck is the hardest 10% of problems, where cloud Claude still wins.

Why would I run a local coding agent instead of just using the cloud?

Three reasons: privacy (proprietary code never leaves the machine), cost (no per-token charge once the hardware is paid for), and resilience. The third got concrete in June 2026 when Anthropic was ordered to suspend Fable 5 and Mythos 5 for all customers overnight — a local agent can't be switched off by someone else's policy. The trade is capability: local is good, not frontier.

Local coding agents in 2026 — how close self-hosted gets to Claude Code, and when it's worth it

Q: Can a local coding agent replace Claude Code?

Not as a full replacement for hard, multi-file work — community reports put a good local model at roughly 70–85% of cloud Claude on everyday single-file tasks, with a wider gap on multi-file reasoning. But as a private, offline, zero-marginal-cost option for routine edits, boilerplate, and sensitive codebases — and as a hedge against a cloud model becoming unavailable — it's a real plan B. Most people run both: Claude Code for the hard problems, a local agent for the rest.

Q: What's the minimum Mac to run a local coding agent?

16 GB of unified memory on an Apple Silicon Mac (M1 or later) is the practical floor, running a 7B-class model like Qwen2.5-Coder 7B. 32 GB lets you run a 32B model (Qwen2.5-Coder 32B), which is noticeably better. The model has to fit in RAM alongside your OS and editor, so match the model to the machine rather than reaching for the biggest one.

On June 12, 2026, Claude Fable 5 was pulled offline by government order — for every customer, overnight. Access came back on July 1 after 18 days, but the episode answered a question most developers had filed under “hypothetical”: what happens to my workflow if the cloud model just isn’t there tomorrow? The outage was temporary; the fact that a frontier model can vanish on a few hours’ notice, for reasons its own maker disputes, is not.

A local coding agent is the most concrete answer. It runs on your machine, costs nothing per token, works offline, and can’t be switched off by someone else’s policy. It is also not Claude Code, and pretending otherwise helps no one. This page is the honest version: what the stack actually is, what it costs, how close it gets, and the rule for when self-hosting earns its keep.

The 30-second version

The stack: Ollama serves an open coding model on localhost:11434; an agent layer — Cline or Continue.dev (in VS Code) or Aider (CLI) — points at it. Ollama speaks the OpenAI API format, so most agent tools connect with a base-URL change.
The models: Qwen3-Coder, Devstral Small 2, DeepSeek-V4, and Kimi-class open models are the 2026 workhorses. On a Mac you’ll run a smaller variant sized to your RAM.
The gap is real: community reports put a good local model at ~70–85% of cloud Claude on single-file work, with a wider gap on multi-file reasoning. Good, not frontier.
When it’s worth it: privacy-bound code, high-volume routine edits, offline work, and hedging against cloud availability. When it isn’t: the hardest multi-file problems, or if you don’t want to own and maintain hardware.
Most people run both. This isn’t replace-Claude-Code; it’s add a plan B that can’t be taken away.

The stack, concretely

Three layers, and the only one that’s Mac-specific is the runtime:

Runtime — Ollama. Installs as a .app, pulls models with ollama pull qwen3-coder, serves them on localhost:11434 with an OpenAI-compatible API. Alternatives exist (Jan for a desktop ChatGPT-style UX, LocalAI for a server runtime), but Ollama is the path of least resistance on macOS.
Agent layer — your choice of three:
- Aider (CLI, git-native): aider --model ollama/qwen3-coder. The most file-system-honest of the three; commits each change.
- Cline (VS Code, autonomous): point it at your local Ollama for full agentic loops in the editor.
- Continue.dev (VS Code, lighter): completion + chat against local models, less autonomous than Cline.
Model — sized to RAM (see the table below).

The whole pipeline runs on your machine. After the initial model download, it’s air-gapped: source code never transits a third-party API.

The Mac RAM-to-model math

The model has to fit in unified memory alongside macOS and your editor. Match it to the machine:

Mac RAM	Model that fits	Realistic use
16 GB (M1+)	Qwen2.5-Coder 7B	Completion, single-file edits, boilerplate — the practical floor
32 GB	Qwen2.5-Coder 32B	Noticeably better reasoning; usable for small multi-file tasks
64 GB+ / 24 GB GPU	Qwen3-Coder 30B, Devstral Small 2	The closest local gets to cloud on a workstation

Two traps that catch almost everyone, both documented across the setup guides:

Ollama defaults to a 2048-token context even when the model supports 128K. For any multi-file task in Cline or Aider, raise it explicitly — otherwise the agent silently forgets half the files it just read.
Don’t run ollama serve by hand after installing the .app. The app already manages the background service; a second one fights it. (Install via the app, or via Homebrew — not both.)

How close does it actually get?

Honestly: good for the routine, not a frontier replacement. The numbers people report cluster around 70–85% of cloud Claude on everyday single-file work, and the gap widens on the things agents are bought for — multi-file refactors, long-horizon planning, holding a large codebase in context. One setup guide pitches “80–90% as good”; the community’s lived-in number is lower and, more importantly, uneven: a local 32B model can nail a function and then lose the thread three files into a refactor.

What you gain in exchange is not capability — it’s the three things cloud can’t give you:

Privacy. The code never leaves the machine. For some codebases that’s not a preference, it’s a requirement.
Cost at the margin. No per-token bill, no rate window. Once the hardware is paid for, the 500th refactor of the day costs the same as the first: nothing.
Resilience. This is the one that changed in June. A local agent has no off-switch that belongs to someone else — no directive, no suspension, no rate-limit-at-the-worst-moment.

The decision rule

Self-host when at least one of these is true:

The code can’t leave. Regulated, classified, or contractually bound source. Local isn’t the cheap option here; it’s the only option.
The work is high-volume and routine. Boilerplate, test scaffolding, mechanical edits — where a 7B–32B model is already good enough and the per-token savings compound.
You need offline or you need a hedge. On a plane, in a SCIF, or simply unwilling to have your toolchain depend on one vendor’s continued availability after watching Fable disappear overnight.

Stay on cloud Claude Code when:

Your bottleneck is the hard 10%. Large multi-file reasoning is exactly where the local gap is widest. Paying for frontier capability on the problems that actually block you is usually the right call.
You don’t want to own hardware. A capable Mac or a 24 GB GPU is real money and real maintenance. If your usage doesn’t justify it, the cloud’s metered model is cheaper than a depreciating GPU.

The honest answer for most working developers is both: Claude Code (or another frontier cloud agent) for the problems that are hard, a local agent for the bulk that isn’t — and as the thing that’s still there if the cloud one isn’t.

What would change this page

A local open model that genuinely closes the multi-file gap (the 2026 trend line is pointed that way — Qwen3-Coder and Devstral are much closer than last year’s models); Apple Silicon with enough memory bandwidth to run 70B-class models comfortably on a laptop; or Ollama/Cline shipping sane context defaults so the 2048-token trap stops catching people.

Companion reading

Claude Fable 5 suspended, then restored — the government order that made “what if the cloud model disappears” concrete, and how it was reversed on July 1
What AI coding agents write to your disk — where Aider, Continue, and the others store their state locally
Aider vs Claude Code — the git-native agent that pairs most naturally with a local model
Best AI coding agents — the cross-vendor verdict — where the cloud agents land when capability is the only axis

Sources

FAQ

Can a local coding agent replace Claude Code? Not for hard, multi-file work — a good local model is roughly 70–85% of cloud Claude on single-file tasks, with a wider gap on multi-file reasoning. But as a private, offline, zero-marginal-cost option for the routine bulk — and a hedge against a cloud model becoming unavailable — it’s a real plan B. Most people run both.

What’s the minimum Mac to run a local coding agent? 16 GB unified memory on Apple Silicon (M1 or later), running a 7B model like Qwen2.5-Coder 7B. 32 GB lets you run a 32B model, which is noticeably better. The model must fit in RAM alongside your OS and editor.

Is self-hosting actually cheaper? After the hardware, yes — no per-token bill, no rate limit. But you pay up front (a capable Mac or 24 GB GPU) and in setup/maintenance, plus a real capability gap on hard tasks. It pays off for high-volume routine work or privacy-bound code; not if your bottleneck is the hardest problems.

Why run local instead of just using the cloud? Privacy (code never leaves the machine), cost (no per-token charge after hardware), and resilience — which got concrete when Fable 5 and Mythos 5 were suspended for all customers overnight. A local agent can’t be switched off by someone else’s policy. The trade is capability: local is good, not frontier.