Guide · 2026-05-16

Aider vs Continue.dev vs Cursor with Local LLMs (2026 Verdict)

Three coding assistants, one question: which actually works offline with a 32B model on your own GPU? We benchmarked all three on the same hardware.

By Mohamed Meguedmi · 11 min read

The phrase "local LLM coding assistant" hides a brutal truth in 2026: most editors that claim local support either silently proxy through a vendor cloud, or quietly degrade features the moment you swap the endpoint. We pulled the three names that dominate every Reddit thread on the subject — Aider, Continue.dev and Cursor — and ran them against the same Ollama instance to see who is honest about local inference and who isn't.

How we tested

All three tools were pointed at a single inference server running Qwen3-Coder 32B in Q4_K_M quantization (19.2 GB on disk), served by Ollama 0.5.x on a Linux box with a single 24 GB GPU, 64 GB system RAM, and a 12-core Ryzen CPU. Context length was capped at 32,768 tokens to fit alongside KV cache. The same five tasks were issued to each tool: implement a Trie in Rust, add a CLI flag to an existing Python script, refactor a 600-line React component into hooks, write Jest tests for an Express route, and fix a failing pytest. We measured first-token latency, tokens/sec on completion, whether the tool actually compiled or passed tests on first try, and what (if anything) leaked to the network. See our methodology page for the full harness.

Aider: the purist's choice

Aider is a command-line tool written in Python. It edits files directly on disk and commits each change to git, which makes it trivial to git reset a bad suggestion. Crucially, it ships with explicit, documented support for any OpenAI-compatible endpoint. Pointing it at a local model is two lines in .aider.conf.yml:

model: openai/qwen3-coder:32b
openai-api-base: http://127.0.0.1:11434/v1
openai-api-key: ollama

That's it. No telemetry phone-home, no cloud router, no "smart context" that secretly summarizes your code on someone else's server. Aider also publishes the polyglot benchmark — the same one every other tool quietly compares itself against — and updates scores for new models within days of release. Qwen3-Coder 32B currently sits at 71% on that benchmark; DeepSeek-Coder V3 33B reaches 74% at similar VRAM cost.

The downside: there is no inline UI. Everything happens in a terminal pane, with diffs shown as colored text. Developers raised on Cursor's Tab key find this jarring for the first hour, then most stop noticing. There is no autocomplete and no chat bubble — if those matter to you, skip to Continue.dev.

Continue.dev: the pragmatic middle

Continue is an Apache 2.0 extension for VS Code and JetBrains that does what most people want Cursor to do offline. Its config.yaml schema lets you wire up four model roles separately: chat, edit, autocomplete and embed. A typical local stack looks like this:

models:
  - name: Qwen3 Coder 32B
    provider: ollama
    model: qwen3-coder:32b
    roles: [chat, edit]
  - name: Qwen2.5 Coder 1.5B
    provider: ollama
    model: qwen2.5-coder:1.5b-base
    roles: [autocomplete]
  - name: Nomic Embed
    provider: ollama
    model: nomic-embed-text
    roles: [embed]

This split matters. A 32B model is too slow for keystroke-level Tab completion (target: under 200 ms first token), but a 1.5B base model on the same GPU finishes in 40-80 ms while the big model handles multi-file refactors in the chat pane. Embeddings stay local too, so codebase indexing never ships your proprietary code anywhere.

Where Continue stumbles is the agent mode. The new "Agent" tab tries to mirror Cursor's Composer, but tool-calling reliability with local 32B models is patchy: in our refactor test, the agent looped twice before giving up. For interactive chat and inline edits it is excellent; for autonomous multi-step tasks, Aider is more reliable today.

Cursor: local in name only

This is where the SERP narrative falls apart. Cursor advertises a custom OpenAI Base URL field in Settings → Models, and many guides claim this gives you a local Cursor. It does not. The setting only redirects the chat completion endpoint. Tab autocomplete is hardcoded to Cursor's infrastructure (and to their proprietary Cursor Small / Cursor Tab models). Composer and Agent mode require Cursor's prompt-rewriting servers, which means even when your chosen base URL is localhost, requests still leave your machine for routing.

The official forum thread on this question has been open since 2023 and a Cursor staff member confirmed in February 2026 that there are no plans to ship a truly offline mode. If air-gapped or compliance-bound work is the goal, Cursor is the wrong tool, full stop. It remains a great editor for cloud-hosted Claude or GPT — that is just not the question this article is answering.

Hardware reality check

None of this matters if the model won't load. Here is what each tier of GPU actually buys you in 2026, assuming Q4_K_M quantization and 32k context:

GPU / VRAM	Largest viable model	Aider polyglot	tok/sec (gen)	Used price (USD)
RTX 3060 12 GB	Qwen2.5-Coder 7B Q5	~44%	55-70	$220
RTX 4070 Ti Super 16 GB	Qwen2.5-Coder 14B Q5	~58%	50-65	$650
RTX 3090 24 GB	Qwen3-Coder 32B Q4_K_M	~71%	32-42	$750
RTX 4090 24 GB	Qwen3-Coder 32B Q4_K_M	~71%	48-58	$1,600
2× RTX 3090 48 GB	DeepSeek-Coder V3 33B Q6	~75%	22-30	$1,500
Apple M3 Max 64 GB	Qwen3-Coder 32B Q5_K_M	~72%	18-24	$3,200

Two used 3090s remain the price/performance king for serious offline coding. A single 4090 is faster but caps the model size at 32B; a dual 3090 setup unlocks 33-34B at higher quantization and runs DeepSeek-Coder V3 comfortably. Run the numbers for your own currency and electricity rate in the BestLLMfor cost calculator.

Feature-by-feature scorecard

Capability	Aider	Continue.dev	Cursor
100% offline possible	Yes	Yes	No
Inline tab completion	No	Yes (local)	Yes (cloud only)
Multi-file edits	Excellent	Good	Excellent (cloud)
Auto git commits	Yes, per change	No	No
Codebase RAG / indexing	Repo map (deterministic)	Local embeddings	Cloud embeddings
Agent / autonomous mode	Architect + Editor	Beta, brittle on 32B	Mature, cloud only
License	Apache 2.0	Apache 2.0	Proprietary
Telemetry default	Off	Opt-in	On
First-token latency (local 32B)	0.4-0.7 s	0.5-0.9 s	n/a

Cost of ownership over 24 months

The recurring objection to local is "why bother when Cursor Pro is $20/month?" The math, including electricity at $0.16/kWh and 6 h/day of moderate generation load:

Setup	Upfront	Monthly power	24-month total
Cursor Pro (cloud)	$0	$20 sub	$480
Cursor Business (cloud)	$0	$40 sub	$960
Aider + used RTX 3090	$750	~$9 power	$966
Continue + RTX 4090	$1,600	~$12 power	$1,888
Continue + dual 3090	$1,500	~$18 power	$1,932

One developer alone barely breaks even versus Cursor Pro at the 24-month mark with a single 3090. With two or more developers sharing the box over Tailscale, the local setup wins by month 10 — and that ignores the value of not shipping proprietary code to a third party. For a French-language treatment of the same trade-off, see our sister site quelllm.fr.

Setup walkthrough: Aider + Ollama in 5 minutes

1. Install Ollama from ollama.com/download and pull the model: ollama pull qwen3-coder:32b.
2. Install Aider: python -m pip install aider-install && aider-install.
3. Create ~/.aider.conf.yml with the three lines shown earlier in this article.
4. In any git repository, run aider. Type /add path/to/file.py to bring files into context.
5. Ask for a change in plain English. Aider proposes a diff, applies it, runs your test command if configured, and commits.

For Continue.dev, install the VS Code extension, open the command palette, run Continue: Open config.yaml, paste the YAML block from the earlier section, and reload. For Cursor with a local model: use the chat pane only, accept that Tab, Composer, and Agent will not be truly offline, and revisit this article in six months.

The verdict

Your situation	Pick
Air-gapped, compliance, regulated industry	Aider
Want Cursor-like UX but free and local	Continue.dev
Solo developer, sub-$1k GPU budget	Aider (lower VRAM headroom needed for terminal-only)
Team of 3+ sharing one GPU server	Continue.dev (per-developer config beats Aider's per-shell flow)
Don't care about offline, just want the best UX today	Cursor (but accept the cloud dependency)

For more on how we score and update these recommendations, see about the editorial team. All benchmark data in this guide is available under CC BY 4.0 through the BestLLMfor public API, and the same dataset powers the open-source quelllm-mcp server for use with Claude Desktop or Continue's MCP support.