The best local LLM for coding agents is not a single model name. It is the local route that beats Claude Code or OpenAI Codex on a specific job: private code, repeatable patches, low-latency edit-test loops, or work where you already own enough hardware and can keep review cost low.
For complex architecture, long-context refactors, shared cloud tasks, and team-visible review, the cloud agents still have the safer default. OpenAI describes Codex as a coding agent that runs in your terminal, IDE, web, and cloud surfaces, while current Codex plan limits and API-key usage depend on plan windows, model choice, cloud usage, and token billing. Anthropic's Claude Code cost docs make the same practical point from the other side: context size, model choice, background usage, and team agent behavior change the real bill.
Use the route that minimizes cost per accepted change, not the route with the most impressive benchmark row. If a local model creates more rework, loses context, or turns every patch into a manual rescue, route that task back to Claude Code, Codex, or an API-backed workflow.
The Short Answer
Local beats Claude Code or Codex when the task is bounded and repeatable. Good examples are private repository cleanup, repeated migration edits, local test loops, code explanation on sensitive files, and small refactors where the model only needs a narrow slice of the repo.
Cloud wins when the task is ambiguous, cross-cutting, or team-facing. Architecture decisions, multi-package refactors, repo-wide context, long planning sessions, managed background tasks, and audit-heavy workflows usually benefit from Claude Code, Codex, or API-backed agents even when the headline subscription price looks higher.
A local model is also not the same as a local agent. The model may run locally through Ollama, llama.cpp, LM Studio, Qwen Code, OpenCode, or another wrapper, but the agent harness still decides how files are selected, how tools run, how diffs are applied, and how tests feed back into the next turn.
Route Fit Matrix
Use this matrix before choosing a model. The question is not whether Qwen, Devstral, Claude, or Codex is more fashionable this week. The question is whether the task can be routed to the cheapest reliable path without increasing review burden.
| Task class | Local LLM | Codex | Claude Code | API or hosted agent |
|---|---|---|---|---|
| Private repo explanation | Best fit when files stay on device | Good if policy allows cloud | Good if policy allows cloud | Usually unnecessary |
| Repetitive mechanical patches | Strong if smoke tests pass | Strong for integrated workflows | Strong when reasoning is needed | Good for batch automation |
| Offline edit-test loop | Best fit | Weak if network or plan window blocks | Weak if network or plan window blocks | Weak |
| Complex architecture | Guardrails only | Strong | Strong, especially when deeper planning is needed | Strong if you own orchestration |
| Long-context refactor | Guardrails only unless local memory is large | Strong with plan limits in mind | Strong with context discipline | Strong but watch token spend |
| CI or team automation | Usually not enough alone | Good through managed surfaces | Good with team controls | Best when repeatability and budgets matter |
The matrix should change per repo. A private monorepo with strict data policy may route more work local. A product team with strong review automation may route more work to Codex or Claude Code because shared visibility matters more than shaving model runtime cost.
Evidence Boundaries Checked on July 8, 2026
The current official docs do not support an absolute winner claim. OpenAI's Codex CLI docs frame Codex as a coding agent that can work from the terminal and other surfaces, and the Codex pricing page separates ChatGPT plan usage from API-key billing and cloud features. That means a subscriber may already have a strong included route before buying hardware.
Anthropic's Claude Code overview and cost guidance frame cost as token and usage behavior, with /usage, context management, model selection, workspace spend limits, and team behavior all affecting the bill. That makes Claude Code hard to judge by a single monthly price or one anecdotal benchmark.
Open local models have become much more agent-oriented. Qwen's Qwen3-Coder materials and Ollama's Qwen3-Coder / Qwen3-Coder-Next model cards position those models for agentic coding, tool use, and long context. Mistral describes Devstral as an agentic software-engineering model. Sebastian Raschka's local-agent writeup shows the practical attraction: transparent, inspectable, and under user control.
Those sources justify a route guide, not a crown. Local model cards can prove availability and intended use, but they do not prove that your repo, harness, GPU, quantization, and review process will accept patches faster than Claude Code or Codex.
Measure Cost per Accepted Change
The useful metric is cost per accepted change. Count the loaded time spent prompting, waiting, reviewing, fixing failed patches, running tests, managing context, and maintaining the runtime. Then divide by changes that actually land.
A local route has hidden costs: GPU or unified-memory amortization, power, model downloads, quantization experiments, wrapper setup, context packing, failed patches, and human rescue. It looks cheap only after the setup is stable and the task repeats enough times.
A cloud route has different hidden costs: plan windows, API tokens, cloud task runtime, organization controls, audit needs, and the cost of moving work between tools. It looks expensive only if you ignore the value of stronger default models, managed environments, or team traceability.
The route is local only when the local loop lowers total accepted-change cost. If the local output saves model spend but doubles review time, it did not save money.
Where Local Models Actually Win
Local models win on privacy-sensitive reading and bounded edits. If a repo cannot leave a laptop or private workstation, the local route may be the only acceptable path. In that case the comparison is not local versus cloud quality; it is local versus no agent at all.
They also win on repeated low-risk patches. Examples include logging cleanup, import rewrites, simple test scaffolds, config migrations, local documentation edits, lint-driven changes, and small helper refactors. The agent does not need to understand the whole company architecture; it needs to apply one rule repeatedly and stop when tests fail.
Local can also win on latency. A short local loop that reads one file, proposes a patch, runs a nearby test, and retries fast may beat a stronger remote model if the human stays in flow and the patch remains easy to review.
The best local candidates are usually coding-tuned open models with a wrapper that respects your file boundary. Qwen3-Coder, Qwen3-Coder-Next, Devstral, and smaller code-specialized models belong in the pilot list, but hardware and context budget decide which one is usable. For 16GB VRAM selection specifically, use the adjacent 16GB local coding LLM route guide.
Where Claude Code, Codex, or Hosted Agents Still Win
Cloud agents win when the task is under-specified. The more the agent must infer architecture, navigate a large repo, choose a migration plan, or weigh product tradeoffs, the more you should pay for stronger reasoning, better context handling, and managed workflows.
Codex has an advantage when you already live in the ChatGPT/Codex toolchain and need a consistent terminal, IDE, web, or cloud-task workflow. The included plan route can be cheaper than local hardware for developers who mostly need high-quality bursts rather than constant private loops.
Claude Code has an advantage when your work benefits from its planning style, model choice discipline, and established CLI habits. Anthropic's cost guidance also makes it clear that context management and model choice are part of operating Claude Code responsibly, not afterthoughts.
Hosted API agents win when the workflow must be repeatable, shared, budgeted, or integrated into CI. They are not always cheaper per attempt, but they can be cheaper per accepted team change because logs, budgets, and orchestration are easier to standardize.
Run a Seven-Day Pilot
Do not replace Claude Code or Codex with a local model after one demo. Run the same task through both routes and score accepted changes, review minutes, failed attempts, privacy fit, and context failures.
Day 1: define accepted-change cost. Day 2: run a local smoke test on one function plus the nearest test. Day 3: run the same task in Codex or Claude Code. Day 4: count review and rework. Day 5: check privacy and context boundaries. Day 6: build the route table by task class. Day 7: keep, split, or stop the local route.
A fair smoke test asks for a minimal patch, names the files the model saw, runs a real verification command, and records whether the patch could be accepted without a human rewrite. Toy prompts do not prove coding-agent readiness.
The result should be a router, not a migration slogan. Local gets the bounded loops it actually wins. Codex, Claude Code, and hosted agents keep the work where they produce safer accepted changes.
Stop Rules
Stop the local route when context spill becomes the main bug. If the model forgets files, misses constraints, invents APIs, or needs repeated reminders of the same repo fact, the task no longer belongs in that local session.
Stop when review cost rises. A patch that looks plausible but forces a senior engineer to audit every line is more expensive than a cloud agent that returns a smaller, more reliable diff.
Stop when setup becomes the work. Quantization, model swaps, wrapper configuration, and context experiments are valid during a pilot, but they should not dominate routine delivery.
Stop when team visibility matters more than local speed. Shared logs, PR review, policy controls, and budget ceilings can make a managed route the cheaper engineering system even if local inference is cheaper per token.
FAQ
What is the best local LLM for coding agents right now?
There is no universal winner. Qwen3-Coder, Qwen3-Coder-Next, Devstral, and smaller code models are credible candidates, but the best route is the model and harness that lower cost per accepted change in your repo.
Can a local model replace Claude Code or Codex?
It can replace some work, not all work. Use local for private, repetitive, bounded loops. Keep Claude Code, Codex, or hosted agents for ambiguous architecture, long context, and shared team workflows.
Should I buy a GPU instead of paying for Codex or Claude Code?
Only if the repeated local workload is large enough to amortize hardware and maintenance. If most work is occasional high-stakes reasoning, the subscription or API route can remain cheaper.
Does running Codex CLI mean the model is local?
No. Codex CLI runs on your machine as the agent surface, but the model route can still be tied to ChatGPT plan usage or API-key billing. Treat it as a local tool surface with hosted model economics unless you explicitly connect a local model through a compatible wrapper.
What should I measure during a local pilot?
Measure accepted changes, review minutes, failed patches, verification passes, setup time, context failures, and reroutes. Token price alone is too narrow.
When should I route back to the cloud?
Route back when the task needs broader architecture reasoning, long context, managed execution, team auditability, or when local rework exceeds the time and cost saved.