Aider

Aider is a free, Apache-2.0 coding agent that runs in your terminal. It builds a map of your repository, edits files through a chat, and commits each change to git so you can undo it. Install with python -m pip install aider-install then aider-install. It works with almost any model. Its release pace has slowed since mid-2025. Checked 31 October 2026.

At a glance

What Aider is

The README's headline is "AI Pair Programming in Your Terminal." You start it inside a git repository, add the files you want to work on, and describe changes in plain language. Aider sends your request to a model, applies the edits to your files and makes a git commit.

Three ideas distinguish it from the newer agents.

1. Git is the safety net. Every accepted change becomes a commit, so git diff and git reset are your review and undo tools.
2. A repository map. Aider builds a compact map of your codebase and gives it to the model, so the model knows what exists without reading every file. The README says it "makes a map of your entire codebase" and has added map support for more languages over time; the changelog mentions MATLAB and Clojure.
3. Model neutrality. The README says it works best with certain models but "can connect to almost any LLM, including local models". The model list in the README is dated, so check the current guidance in the docs.

The README claims 6.8 million installs, 15 billion tokens a week and a top-20 rank on OpenRouter, and that 88 percent of the new code in the last release was written by Aider. Those are the project's own badges, not independent measures.

Install

The docs give several routes. The quick one:

python -m pip install aider-install
aider-install
cd /to/your/project
aider --model sonnet --api-key anthropic=<key>

aider-install puts Aider in its own Python environment, and installs a separate Python 3.12 if needed. It needs Python 3.8 to 3.13 to bootstrap.

Other routes from the install page:

The docs advise against system package managers because they "often install it with incorrect dependencies". If you see "aider command not found" after a pip install, try python -m aider.

Modes

Aider's chat modes, from its docs:

Switch for one message with /code, /architect, /ask or /help. Switch persistently with /chat-mode <mode>. Start in a mode with --chat-mode <mode>; --architect is a shortcut. The prompt shows the mode: > for code, ask> and architect> for the others.

The docs recommend alternating /ask to agree on a plan and /code to apply it, after which "go ahead" is enough. Architect mode lets you pair a strong reasoning model with a cheaper editing model, set with --editor-model; the docs recommend the "editor-diff" and "editor-whole" edit formats there.

Models

Aider is built to be model-agnostic. The changelog on the main branch lists support added for Claude 4.5 and 4.6 with updated sonnet, haiku and opus aliases, Gemini 2.5 Flash and Flash-Lite and Gemini 3 preview models, DeepSeek Reasoner, and GPT-5.1 through 5.4 variants across OpenAI, Azure and OpenRouter. Earlier releases added Grok-4 and Kimi K2. Some of that is in unreleased main-branch code, so a pip install of the latest release may lack it.

Aider uses litellm for provider access (the changelog mentions bumping it to 1.75.0), which is how it reaches so many providers. For a local model, point it at an OpenAI-compatible endpoint such as Ollama. See local coding agent with Ollama.

Aider also publishes a polyglot coding leaderboard; see Aider polyglot and how to read AI benchmarks.

Cost

Aider is free; your model bill is the cost. Because it sends a repo map and the files you add, token use is modest on small tasks and grows with large files. Tips from how the tool works:

• Add only the files that need to change. Aider can read others through the map.
• Use architect mode with a cheaper editor model for big refactors.
• Use ask mode for planning, which never edits files.

For per-token prices see LLM API prices. If you use a subscription instead of an API key, check whether the provider allows it in a third-party tool.

A first session, step by step

Commands below come from Aider's in-chat command reference.

A typical loop:

1. Start aider on a clean branch and /add the two or three files involved.
2. Use /ask to agree on an approach. Nothing changes yet.
3. Switch to /code and say "go ahead".
4. Read /diff. If it is wrong, /undo and refine the request.
5. Run /test with your test command. If it fails, the output goes back into the chat and Aider tries to fix it.
6. When you are happy, push the branch and open a pull request as usual.

The pattern makes the model's work easy to inspect, because each step is a small commit. It also keeps costs down, since you control which files enter the context. Run /tokens now and then to see what you are sending.

Working on a large codebase

Aider is not tied to loading everything. The map lists classes, functions and signatures, and the model asks for files it needs. For large repositories, keep the /add list small, use /read-only for reference files, and give the model a clear starting point such as the module name. If results drift, /drop files you no longer need so the context stays sharp.

Project status: read this before choosing

Here is what the repository shows on 31 October 2026:

• Last push: 22 May 2026, a merge of a pull request that expanded the Anthropic model list.
• Latest GitHub release: v0.86.0 on 9 August 2025. The HISTORY page also lists v0.86.1 and an unreleased main-branch section.
• Stars: about 50,000.

Compare Cline (release on 26 October), OpenCode (28 October) and Goose (28 October). Aider is not archived, and it still works, but five months without a push and over a year without a GitHub release is a different pace. Models and tools keep changing, and a tool that does not keep up tends to fall behind on new model names, new APIs and new features.

What that means for you: for a personal project with models Aider already knows, it is fine. For a team standard, check the issue tracker for open problems with the models you use, and keep an alternative ready.

What it does well

• Git-native workflow. Atomic commits, easy review, easy undo.
• Repo map. Good context without sending everything.
• Any model. Including local ones, which is rare among polished tools.
• Simple. One process, no editor needed, works over SSH.
• Free and open. Apache-2.0.

Limits

• Slower upkeep than the active alternatives, as above.
• Terminal only. No editor or desktop surface.
• Less autonomy. It edits what you add and propose; it is not built for long, unattended runs like cloud agents.
• Fewer agent features. The pages we read do not describe hooks, subagents or skills as in Claude Code.
• Setup. You manage keys and Python environments.

Aider versus the others

For the field see open source AI agents.

Who should pick it

Choose Aider if you like git history as your review tool, work mostly in a terminal, want to use local or unusual models, and prefer a small, steady tool to an agent that tries to do everything. Skip it if you need an IDE, cloud agents, or a vendor-backed roadmap.

Tips from the docs and the workflow

• Commit before you start. A clean tree makes /diff and /undo meaningful.
• Use `/read-only` for reference files such as type definitions, so the model sees them but cannot change them.
• Keep the chat short. Long histories cost tokens on every message. Use /drop for finished files and start a fresh session for a new task.
• Run tests through Aider. /test adds failing output to the chat so the model can fix it.
• Pair strong and cheap models. Architect mode with --editor-model lets a strong model plan and a cheaper one edit.
• Check the model name. Aliases such as sonnet change between releases, so confirm which model you are actually calling.

Troubleshooting

• "aider: command not found". Try python -m aider, or reinstall with aider-install so it gets its own environment.
• Edits fail to apply. Add fewer files and make the request smaller; large multi-file edits are where diff formats break.
• Wrong model answers. Run /model to see which model is active, and check that the alias you used still points where you expect.
• Costs climb. Run /tokens, then /drop files you no longer need.
• A bad change landed. Run /undo to revert the last Aider commit, then restate the request with a tighter scope.

Our take

This is an editorial reading of the repository and docs, not a hands-on test.

Aider earned its place by getting the basics right early: a repo map, git commits and wide model support. Many newer tools copied those ideas. What it offers now is a calm, scriptable workflow that does not try to be a platform.

The honest caution is momentum. For a tool that sits between you and fast-moving models, a quiet repository is a risk, not a verdict. If you use Aider daily and it works, keep using it, and pin the version. If you are choosing today for a team, OpenCode or Cline give you the same freedom with more activity. Both read project instructions from files you can keep in git, so switching later costs little.

Checklist

• Install with python -m pip install aider-install then aider-install
• Work inside a clean git branch
• Add only the files you need to the chat
• Try /ask then /code for planning and applying
• Try architect mode with a cheaper editor model
• Pin the Aider version and check model names before relying on one
• Look at the repository's recent activity before standardising on it