TL;DR — Aider's two-model architecture (architect plans, editor applies) is the best cost/quality split in the ecosystem. Pair it with CodeRouter and you get an additional phase-aware layer on top — so even within "edit" mode, test generation routes to DeepSeek V3 while tool-error debugging routes to Sonnet 4.6. Set
OPENAI_API_BASEonce and your Aider bill drops 70–90%.
Why Aider is already half-optimized
Aider's --architect flag is a serious piece of engineering. It acknowledges something most agents ignore: planning and implementation are different problems that want different models.
- Architect = reason about the change, propose the diff structure. Wants a strong reasoning model (GPT-5.2, Claude Opus, DeepSeek R1).
- Editor = apply the diff mechanically, preserving formatting. Wants a fast, cheap, instruction-following model (DeepSeek V3, Sonnet 4.6, Haiku).
This is already a 3–5x cost reduction vs. running everything through Opus. But there's still optimization left on the table.
What Aider's own split doesn't solve
- Test writing is still using your editor model. If your editor is Sonnet 4.6, you pay $3/$15 per 1M for test generation. DeepSeek V3 does the same job at $0.28/$0.42 — that's 15× cheaper for no quality drop on test patterns.
- Documentation generation uses your editor model. Docstrings and README updates are template-heavy. Haiku 4.5 or Gemini Flash would handle this at 5–10× cheaper still.
- Small edits use your editor model. "Rename this variable to
user_id" on Sonnet is $3/$15/M. On Gemini Flash it's $0.50/$3/M.
The fix: a second layer of phase detection inside Aider's editor calls. CodeRouter does exactly this.
Setting up CodeRouter with Aider
# Install/update Aider
$ pip install -U aider-chat
# Point it at CodeRouter
$ export OPENAI_API_BASE=https://coderouter.io/api/v1
$ export OPENAI_API_KEY=cr_your_coderouter_key
# Architect mode — CodeRouter picks the best planner, then best implementer
$ aider --model auto --architect
# Or simpler — just auto everywhere
$ aider --model auto
When Aider starts --architect, it makes two distinct kinds of calls:
- A planning call (long reasoning, shorter output). CodeRouter's phase detector picks that up as phase=
planand routes to Opus 4.7 or GPT-5.2. - A diff-application call (short reasoning, longer output). The router picks up phase=
implementand routes to Sonnet 4.6 or DeepSeek V3.
You don't pass --editor-model — CodeRouter decides for you. If you prefer, you can still force it:
$ aider --model coderouter/opus-4.7 --editor-model coderouter/deepseek-chat
(Studio and Team plans allow explicit model pinning.)
Real daily cost comparison
One-day Aider workload: 4 architect turns (each producing ~8 edit cycles), 12 directly-edit turns, 15 tests written, 6 docstrings, ~30 small renames/formats. Total: ~18M tokens through Aider.
| Configuration | Monthly cost at this pace |
|---|---|
| Aider --model claude-opus-4.7 (common default) | ~$450/month |
| Aider --model claude-sonnet-4.6 --architect (manual split) | ~$120/month |
| Aider --model deepseek-chat (cheap-only) | ~$12/month — but quality drops on hard planning |
| Aider with CodeRouter Solo ($29) | ~$29/month (covers 5M) + minimal overage |
| Aider with CodeRouter Pro ($99) | ~$99/month all-in (30M tokens covers this workload) |
The manual split (Sonnet everywhere) is a 10× improvement over all-Opus — real respect to Aider's architect mode. CodeRouter adds another ~30% on top of that by picking cheaper models for the 40% of calls that don't even need Sonnet quality.
Advanced: Aider repo map + CodeRouter analytics
Aider builds an index of your repo that ships as context on every request. That's a lot of input tokens. Two tips:
.aiderignoreaggressively. Excludenode_modules,dist, generated files, vendored deps, and test fixtures. Every 10K tokens you strip from the repo map saves ~$0.07 per turn on Sonnet, less on DeepSeek.- Watch the CodeRouter dashboard's per-phase breakdown. If you see "documentation" phase taking 30% of your cost, you're generating too many docstrings — worth writing fewer but better ones.
FAQ
Does Aider's diff format survive routing to different models? Yes. CodeRouter routes to models we've verified emit valid Aider-style diffs. DeepSeek V3 and Sonnet 4.6 are both reliable; Haiku sometimes struggles with complex diffs, which is why the router doesn't use it for implement/refactor phases.
What about aider-chat the Python library?
Same config. OPENAI_API_BASE + OPENAI_API_KEY env vars work in library mode too. Or pass --api-base https://coderouter.io/api/v1 in code.
Can I use my own Anthropic key for Opus? Yes — enable BYOK in your CodeRouter dashboard and bind your Anthropic key. When CodeRouter routes a request to Opus, it uses your Anthropic key directly (you pay Anthropic, we take only the platform fee). Useful if you already have Anthropic credits.
What about aider-browser / web UI?
Works identically — Aider web just sends the same chat-completions calls.