Aider

Aider is the terminal AI pair programmer for people who want the agent to live inside their git repo, not inside someone else's editor or cloud. On a stack that defaults to local Ollama and pays for nothing without a reason, most coding agents fail the first test — they are metered cloud services. Aider is the one that doesn't have to be: open source, model-agnostic, and happy to run against a local open-weight model for $0. This page is the orient-and-decide surface — the official docs at aider.chat own the exact commands, config keys, and the live model leaderboard, all of which move faster than any page here should mirror.

What it is

An open-source (Apache-2.0), Python, terminal-based AI pair programmer — pip install aider-chat and you're in a chat loop that edits files in your local git repo directly. It is editor-agnostic by design: it edits the files on disk, so you keep using VS Code, JetBrains, Vim over SSH, or a tmux split on a build server, and Aider just works the tree underneath you.

Two structural choices define it. First, it is wired into git — every change Aider makes lands as its own atomic commit with a generated message, so the AI's work is a reviewable, revertible history rather than an opaque diff you have to trust. Second, it builds a repo-map — before each request it parses the whole codebase with tree-sitter into a PageRank-ranked symbol index (class names, function signatures, cross-file imports) and feeds the model a condensed map, so the AI understands structure without loading every file into the context window. That map is why it holds up on larger repos where a naive "paste the files" agent falls over.

The model side is the reason it's on this shelf: Aider works with almost any LLM — the hosted frontier APIs, but equally any OpenAI-compatible endpoint and local models via Ollama or LM Studio. Point it at a local daemon and the entire edit loop runs offline, keyless, for zero cost, with nothing leaving the machine.

When to use

Reach for it when:

• You want a coding agent that is $0 and fully local — the code is sensitive, or you just refuse to pay per token, and a local Ollama model is strong enough for the task (see Ollama).
• The work is git-shaped and you want atomic, reviewable commits — small, well-scoped edits where "every change is its own revertible commit" is a feature, not overhead.
• You live in the terminal and don't want a new GUI editor — Aider edits on disk and leaves your workflow alone.
• You want one tool that spans models — start local for the cheap 80%, and repoint the same tool at a hosted model for the hard 20% without changing how you work.

Skip it when:

• The task genuinely needs frontier-grade capability and you're willing to pay for it — a paid cloud agent on a frontier model will out-code a local open-weight model, full stop (see Where it fits).
• You want a rich GUI, inline diffs, and tab-completion as the primary surface — that's Cursor's end of the spectrum, not Aider's.
• The repo is large and your only local model is small — repo-map plus a weak model still produces weak edits; capability is model quality, and a 3B model won't carry a serious refactor.
• You need deep, autonomous multi-step agentic runs as the headline mode — Aider is a tight pair-programming loop, strongest with a human in it.

At a glance

Signature features

Feature	What it does
Git auto-commits	Every AI edit lands as its own atomic commit with a generated message — reviewable, revertible history instead of an opaque diff.
Repo-map	tree-sitter parses the codebase into a PageRank-ranked symbol index, giving the model structural context without loading every file.
Any-model support	Hosted frontier APIs, any OpenAI-compatible endpoint, or local models via Ollama / LM Studio — the same tool spans the whole range.
Architect / editor mode	A stronger model plans the change in prose; a faster/cheaper model turns the plan into edits. Better on hard multi-file work.
Voice-to-code	Speak the change; Aider implements it.
Lint + test loop	Runs your linter/tests after edits and can iterate on failures.
In-place, editor-agnostic	Edits files on disk, so it works with whatever editor and repo you already have.

Model paths

Path	Notes
Local via Ollama / LM Studio	Keyless local daemon, fully offline, $0, data-stays-home. The whole reason it's on this shelf.
OpenAI-compatible endpoint	Any provider that speaks the OpenAI wire format — the escape hatch to hosted open-weight or cheaper inference.
Hosted frontier APIs	Top-tier edit quality at per-token cost — reach for it only when local demonstrably can't do the job.

Exact model IDs, config flags, and the current edit-benchmark leaderboard live on aider.chat — treat those as canonical over anything quoted here, which will drift.

Where it fits on the GL stack

Framed conditionally — this is watching, not adopted, and it fills a specific slot the paid agents can't.

• The $0, fully-local coding agent. Cursor, Claude Code, and Grok Build are all metered cloud services on frontier models — capable, but paid, and every prompt leaves the machine. Aider pointed at local Ollama is the counterweight: open source, keyless, offline, and free. That is the honest reason it's on the shelf — the local escape hatch when the work shouldn't cost money or leave the box.
• The trade is explicit. A local open-weight model is weaker than frontier, so Aider-on-Ollama won't match a paid agent on the hardest edits. You're buying $0 cost and total data control at the price of some raw capability — a good trade for the routine 80%, a bad one for the gnarly 20%.
• It sits next to the other local-Ollama tools. Ollama is the substrate; OpenWiki is the other local-Ollama agent tool already evaluated here. Aider is the coding-loop member of that same $0, local-first family.

Gotchas

• Capability is model quality. Repo-map and architect mode are real, but they don't rescue a weak local model — the edits are only as good as the model behind them. Benchmark your local model on a repo you know cold before trusting it on one you don't.
• Auto-commit means a noisy history. Every edit is its own commit, which is great for revertibility and messy for a clean feature branch — you'll want to squash before a PR, and the feature → beta → main flow still applies.
• It expects a git repo. Aider's whole model is commit-per-change; run it outside git (or on a dirty tree you haven't staged) and you lose the safety net that makes it worth using.
• Architect/editor doubles the calls. The plan-then-edit split improves hard edits but issues two model calls per turn — fine on local ($0), a cost multiplier the moment you point it at a paid endpoint.

Risks

• Local-model ceiling. The $0 path is only as good as the open-weight model you can run on your hardware; if the task outgrows it, you're back to a paid endpoint and the data-stays-home guarantee goes with it. Know which tasks belong on which side of that line before you start.
• Single-maintainer open source. It's genuinely open (Apache-2.0) and yours to fork, but it's a small-team project — velocity, model-support currency, and edit-format tuning track the maintainers. The code is yours; the upstream pace is theirs.
• Prompt-leaves-machine the moment you go hosted. The privacy story holds only on the local path. Repoint Aider at a hosted model for a hard task and the same prompt-shipping risk as any cloud agent applies — gate hard on what's allowed over the wire.

Related

• Claude Code — the paid daily-driver CLI; Aider is the $0 open-source alternative.
• Cursor — the GUI editor end of the spectrum.
• Grok Build — xAI's cloud coding agent.
• Ollama — the local-LLM substrate Aider runs against for the $0 path.
• OpenWiki — the other local-Ollama agent tool on the shelf.