Project status: quiet since May 2026

We check the health of every open-source tool we recommend. Aider's numbers, pulled from the GitHub API on 2026-08-31:

A year without a release is a long time in AI tooling, where model names, APIs and pricing change monthly. Aider's own model list is a good illustration — the last thing merged was an expansion of the Anthropic model names, and anything released since then won't be there by default.

What this means in practice. The code is Apache 2.0 and it runs fine; nothing has broken. But new model support, provider quirks and bug fixes are not arriving right now. If you use it, expect to specify models manually and to work around issues yourself. For a project you'll maintain with other people, pick something under active development — we'd suggest Cline or one of the other free AI coding assistants we've reviewed.

We'd be glad to be wrong about this — if development resumes, we'll update the page. Verify for yourself in one call:

curl -s https://api.github.com/repos/Aider-AI/aider |   grep -E '"pushed_at"|"open_issues_count"'

Aider launches inside a Git repo and turns every code change into a conversation. Unlike editor-based agents like Cline, Cursor, and Windsurf, it keeps everything text — so it fits tmux, SSH, and vim/emacs workflows with no extension or IDE lock-in. Maintained since 2023 by Paul Gauthier (tens of thousands of GitHub stars), it's also one of the few tools publishing a real, reproducible benchmark.

Aider vs Cline, Cursor, and Copilot

These tools share the same backbone — an LLM that reads files and proposes edits — but differ in where they live, how they edit, and how they treat Git.

Bottom line: if you live in an editor, Cline or Cursor fit naturally. If you live in a terminal — SSH into remote boxes, work in tmux, pair with vim/emacs, or run on a GUI-less server — Aider is the only tool here built for that from day one.

The Aider Polyglot Benchmark

Instead of marketing copy, Aider publishes a benchmark. The Aider Polyglot leaderboard tests every major model against 225 hand-curated exercises across C++, Go, Java, JavaScript, Python, and Rust. Each has hidden unit tests; a model passes only when its edits make tests go green, with at most one self-correction round.

It tests the full pipeline — reading the problem, locating files, producing a valid edit, getting the diff format right, and writing code that passes. It's multi-language (a model strong in Python but weak in Rust won't top it), and it's re-run for every notable model release. The practical use is choosing a model: sort by the latest column and pick the highest-ranked model with a free tier. As of 2026 the strongest free-tier options include DeepSeek's reasoning models, Gemini 2.5 Pro on Google AI Studio, and Llama 3.3 70B on Groq or Together AI.

Five Features Worth Your Terminal Time

1. The Repo-Map

Instead of dumping every file into the prompt, Aider uses tree-sitter to parse each source file and extract a structured summary (class names, function signatures, exported types), then ranks symbols by relevance using a PageRank-style graph. The result is a compact map — a few hundred lines for most projects. See it with /map, cap it with --map-tokens, and scope large monorepos with .aiderignore (same syntax as .gitignore).

2. Multiple Edit Formats

Most agents use one edit format; Aider supports four, because models differ at each: whole (full file — highest token cost, lowest failure), diff (SEARCH/REPLACE blocks), udiff (unified-diff hunks — compact), and diff-fenced. Aider auto-picks per model from benchmark history; override with --edit-format if edits keep failing to apply.

3. Architect Mode

Frontier reasoning models plan well but produce messy edits; cheap fast models are the reverse. Architect mode assigns a model to each role:

aider --architect \
  --model openrouter/z-ai/glm-5.2 \
  --editor-model openrouter/anthropic/claude-3-5-sonnet

The architect produces a plan; the editor emits the actual SEARCH/REPLACE blocks. This two-stage approach consistently beats single-model runs on the polyglot benchmark, often by ten-plus points on harder languages.

4. Auto-Commit With Real Messages

Aider commits after every accepted change with a one-line message from the diff. This sounds cosmetic until your first git bisect on AI-generated code — granular commits turn a debugging nightmare into a five-minute regression hunt. Pass --no-auto-commits to stage changes instead, or let Aider git init for you on first run.

5. /web: Drop a URL Into the Chat

Type /web https://docs.example.com/api and Aider scrapes the page, converts it to clean Markdown, and adds it as context — giving the LLM the actual current API reference instead of stale training knowledge, without a separate RAG pipeline.

Install Aider

Aider is a Python package. The official installer handles version and dependency isolation via uv:

python -m pip install aider-install
aider-install

Prefer your own venv? pipx install aider-chat (or pip install aider-chat). Then set a key for your provider — Aider reads env vars and a project .env:

export OPENROUTER_API_KEY=sk-or-v1-...
# or GEMINI_API_KEY / DEEPSEEK_API_KEY

That's it. cd into a Git repo, run aider, start typing.

Connecting Aider to Free LLM APIs

Aider speaks LiteLLM, so it supports nearly every provider with one --model flag. Four zero-cost setups for 2026:

• Gemini free tier (most generous) — Gemini 2.5 Pro with a 1M-token context and generous limits: aider --model gemini/gemini-2.5-pro. Keeps most personal projects running indefinitely with no card on file.
• OpenRouter free models — OpenRouter exposes :free models behind one endpoint: aider --model openrouter/z-ai/glm-5.2:free. Tighter limits, unmatched variety, good fallback.
• Ollama (fully local) — Ollama runs on your own GPU: aider --model ollama_chat/qwen2.5-coder:14b. Quality drops below frontier, but no tokens leave your machine — useful for NDA code.
• DeepSeek direct — near-frontier quality with off-peak discounts; free trial credits to evaluate: aider --model deepseek/deepseek-v4-flash (thinking effort is switchable on V4).

Mix free tiers with architect mode — Gemini for the plan, OpenRouter's free Llama for the edit, total cost zero:

aider --architect \
  --model gemini/gemini-2.5-pro \
  --editor-model openrouter/openrouter/free

Cost Reality: 60 Hours a Month

The first three rows are the point: a serious engineering workflow at $0/month is just a matter of pairing a free tool with a free API.

Production Tips: Don't Burn Tokens

• /drop aggressively — files stay in context until removed; drop them once Aider has edited them.
• Add .aiderignore for noise (node_modules, generated code, large fixtures). The repo-map respects it.
• Cap the map — --map-tokens 1024 is plenty for most repos.
• /clear between unrelated tasks to flush chat history — can halve token cost.
• Auto-test only at task boundaries — --auto-test after every edit adds up on large suites; run /run pytest manually instead.

Frequently Asked Questions

Is Aider really free?

The tool itself is free and open-source under Apache 2.0. Model calls go through whichever provider you point it at, and you can run it for $0/month with free providers (Gemini, OpenRouter free tier, Ollama). You only pay, optionally, to upgrade to a paid model when free-tier limits slow you down.

Does Aider work without Git?

Technically yes, with --no-git, but you lose auto-commit, the diff-aware repo-map, and easy rollback. On a fresh project Aider offers to git init for you — one keypress. Just let it.

Is Aider an autonomous agent like Cline's Act mode?

No, by design. Aider treats you as the loop: it proposes edits, you approve, it commits, you run tests, you describe the next step. For codebases where every line matters, that's a feature. If you want fully autonomous "fix this issue" workflows, pair it with Cline.

Does Aider support MCP?

As of mid-2026 Aider's primary tools are file editing, /run, and /web. MCP integration is on the roadmap, but the minimal-core, scriptable-shell philosophy means much of what MCP servers provide is achievable today via /run and shell pipes.

When to Use Aider vs Cline vs Cursor

• You live in vim/emacs/a terminal multiplexer or SSH into remote boxes: Aider. Nothing else respects that workflow.
• You want autonomous, multi-step "go fix this issue" with browser verification: Cline.
• You want a managed product with one bill and polished UI: Cursor — less friction, less cost transparency and model choice.
• You want Git-aware, surgical edits with a full audit trail: Aider.

Many serious developers in 2026 use both — Aider for terminal-native pairing, Cline or Cursor for autonomous IDE work. They fit different parts of the day. If you've never tried a terminal-native AI pair programmer, give Aider an afternoon on a small side project; there's no lock-in and no sunk cost.

Related Reads

• Cline Free VS Code Agent: Which Models Finish the Job
• Google Gemini Free API Tested: 34s to First Token
• OpenRouter Free Tier Tested: 18 Free Models, One API Key
• Ollama: Run AI Models Locally for Free