This article was originally published on aifoss.dev
TL;DR: Aider v0.86+ is the strongest local coding agent — Qwen2.5-Coder 32B via Ollama hits 73.7 on Aider's benchmark, matching GPT-4o. Open Interpreter needs 34B+ to reliably complete multi-step OS tasks. Claude Code technically connects to local models but the agentic tool loop breaks in practice.
| Aider | Open Interpreter | Claude Code (local) | |
|---|---|---|---|
| Best for | File editing, multi-file refactors, git commits | OS automation, shell + Python + JS execution | Teams already paying for Claude API |
| Min viable model | Qwen2.5-Coder 14B | Codestral 22B | 32B+ (unreliable in practice) |
| Monthly cost (local) | $0 | $0 | $0 (degraded agentic performance) |
| The catch | No terminal control or code execution | Unreliable below 22B; needs explicit trust grants | tool_use blocks break in Ollama API translation |
Honest take: Pull Qwen2.5-Coder 32B via Ollama, point Aider at it. That's the only local setup where benchmark-verified results match GPT-4o and the workflow is actually usable.
Why this question matters now
Cloud AI coding subscriptions have compounded. Copilot at $10/month, Claude Pro at $20, Cursor Pro at $20 — and if you want anything Devin-like, prices jump to $500+. The pitch for local agents is obvious: zero API cost, zero data leaving your machine, no rate limits.
The question every developer hits is: does local actually work? All three tools reviewed here claim local model support. The honest answer varies significantly by tool and by how much GPU you have.
This comparison focuses on what happens when you swap GPT-4 for a 14B or 32B model running via Ollama. The benchmark data, the failure modes, and a realistic cost breakdown — below.
What "runs locally" actually means
"Local LLM support" means three different things, and it helps to separate them:
- Inference local: the LLM runs on your GPU. Zero API cost.
- Execution local: the agent runs code, edits files, or runs shell commands on your machine.
- Framework local: the agent software itself (Aider, Open Interpreter, etc.) runs on your machine.
All three tools tick boxes 2 and 3. The variable is box 1 — whether the agent's logic holds up when you replace GPT-4 with a 14B or 32B open-weight model. That's where they diverge.
Aider
Aider is a terminal-based AI coding agent that edits files, manages git commits, and works across multiple files simultaneously. It routes to any LLM via LiteLLM, which makes Ollama a first-class backend. License: Apache 2.0.
Setting it up (Aider v0.86+, tested June 2026):
# Pull a capable model
ollama pull qwen2.5-coder:32b
# Install Aider
pip install aider-chat
# Point Aider at your local Ollama instance
cd ~/your-project
aider --model ollama/qwen2.5-coder:32b
# Expected output:
# Aider v0.86.x
# Model: ollama/qwen2.5-coder:32b with diff edit format
# Git repo: /home/user/your-project
Why Aider succeeds with smaller models: Instead of asking the LLM to reproduce entire files, Aider uses structured edit formats — unified diffs, or targeted block replacements. The model only outputs the changed lines. This dramatically reduces the failure rate on 14B models that lose coherence when generating long outputs.
On Aider's own benchmark, Qwen2.5-Coder 32B scores 73.7 — the same as GPT-4o. The 14B variant scores lower but handles most code editing and refactoring tasks correctly.
Critical Ollama configuration: Since Aider v0.65.0, Aider automatically sets Ollama's context window to 8k tokens. This matters because Ollama defaults to a 2k context window and silently discards data that exceeds it. The effect is dramatic: a properly-configured Qwen2.5-Coder 32B approaches GPT-4o performance; the same model with a 2k window drops to GPT-3.5 Turbo territory. If you're using an older Aider version or a custom Ollama wrapper, always set OLLAMA_NUM_CTX=8192 or higher.
Strengths:
- Git integration out of the box — auto-commit, diff display,
/undoto revert - Works with any OpenAI-compatible API or Ollama endpoint
- Multi-file context via
/add— add as many files as your model's context allows - Edit formats tunable per model (
--edit-format wholefor models that fumble diffs)
Limitations:
- No terminal execution or code running — purely file editing and git
- Planning-heavy tasks (architect a feature from scratch) degrade faster on 14B than straightforward refactoring does
- Terminal only — no GUI, no IDE integration (see Cline or Continue.dev if you need that)
For a detailed Aider walkthrough including setup with multiple models, see the Aider setup guide.
Open Interpreter
Open Interpreter is a different product entirely. It's not a file editor — it's a natural language interface to your operating system that executes Python, bash, JavaScript, AppleScript, and other code in a live shell. Think of it as a local Code Interpreter from ChatGPT, except with full OS access and no cloud dependency. License: AGPL-3.0.
Setup with Ollama (last updated March 2026):
# Start Open Interpreter with Codestral via Ollama
interpreter --model ollama/codestral:22b
# Or use the built-in local profile
interpreter --local
# Prompts you to choose a model from what's available in Ollama
# First run asks:
# "Open Interpreter would like to execute code on your machine. (y/n)"
# Type y to allow — required for any real task
The model size problem: Open Interpreter runs a multi-turn agentic loop where the model must understand a task, write working code, read the output, then decide whether to continue, fix, or stop. Steps 3 and 4 are where small models fail. A 14B model frequently misinterprets an error trace and either loops indefinitely or gives up without flagging the failure.
The practical minimum is Codestral 22B for tasks with predictable outputs. For complex multi-step workflows — "analyze this CSV, fix the outliers, regenerate the chart, and email me the results" — 34B+ is where reliable execution starts (DeepSeek-Coder 33B, Qwen2.5 72B Q4).
A concrete failure pattern: On 14B, Open Interpreter will often claim "Done" while producing incorrect output, and won't self-correct. This is worse than an obvious crash. At 32B+, the model reads its own output, catches the error, and retries. That behavioral gap is real and large.
Strengths:
- True OS-level agent: runs shell commands, Python scripts, edits any file, queries APIs
- Multi-language code execution in one session
- Built-in profiles for Llama 3, Codestral, Qwen — preconfigured for local use
- Desktop app for non-terminal users
Limitations:
- Unreliable with models below 22B for anything non-trivial
- Requires trust grants for OS access — adds friction, but correct security behavior
- No git integration — you manage version control separately
- Slower feedback loop than Aider for pure code editing tasks
Claude Code with local LLMs
Claude Code is Anthropic's CLI agent, built around the Anthropic Messages API with tool_use content blocks. Since early 2026, it supports connecting to local models via an LLM gateway config that bridges Ollama's OpenAI-compatible API to the format Claude Code expects.
What works: Basic chat, simple single-file edits, question-answering about your codebase. The gateway setup takes about 15 minutes.
What breaks: Claude Code's agentic loop — reading files, editing them, running tests, iterating — depends on tool_use content blocks in the Anthropic Messages format. Ollama's OpenAI-to-Anthropic translation doesn't preserve these blocks cleanly. Multi-step agent tasks produce garbled output or silently fail. This isn't configurable; it's a format translation gap.
Honest assessment: If you already have an Anthropic API key and want a local fallback when you hit rate limits, the gateway workaround is worth setting up.
Top comments (0)