9 Best Aider Alternatives in 2026 (and How to Test Them)

1. OpenCode

OpenCode is the closest open-source match for Aider's terminal-and-own-keys workflow.

OpenCode is an open-source AI coding agent available as a terminal-based interface, a desktop app, or an IDE extension. Build has every tool enabled, Plan sets file edits and bash commands to ask first, and Tab switches between them, while General, Explore, and Scout run as subagents.

• Runs in - the terminal, a desktop app, or an IDE; install with npm install -g opencode-ai, Homebrew, or the install script.
• Open source - MIT, with about 213k GitHub stars, the most on this list.
• Models - 75+ LLM providers through the AI SDK and Models.dev, plus local models through Ollama, LM Studio, or llama.cpp.
• Test hook - plugins can run a shell command on file.edited or session.idle events; /undo reverts the last change and /redo restores it.
• Pricing - free; OpenCode Zen and OpenCode Go are optional model subscriptions from the OpenCode team.
• Releases - v1.19.0 on October 11, 2026, and 35 stable releases in the last 90 days.
• Watch for - edits and bash commands run without asking by default, so set "bash": "ask" under permission in opencode.json if you want a confirmation step.

If you kept project rules in a CONVENTIONS.md loaded with Aider's --read flag, move them into AGENTS.md, which OpenCode's /init generates and Codex CLI also reads. The trade-offs against Anthropic's agent are covered in OpenCode vs Claude Code.

2. cecli

cecli, formerly aider-ce, is a fork of Aider with a full TUI, MCP support, and an agent mode. It is the only tool here that keeps Aider's default of a git commit after every edit, because it keeps Aider's command-line options: --auto-commits stays on, and --test-cmd with --auto-test still runs your suite after each change.

• Runs in - the terminal; install with uv tool install --native-tls --python python3.12 cecli-dev, or pip install cecli-dev, which resolves the current 1.8.0 on Python 3.13.
• Open source - Apache 2.0, inherited from Aider, with about 400 GitHub stars.
• Models - the same provider list as Aider, including Ollama for local models.
• Adds - MCP configuration, an agent mode with an UndoChange tool, subagents, skills, hooks, persistent memory, workspaces, and the Agent Client Protocol.
• Migration - option names stay the same, the config file becomes .cecli.conf.yml, and environment variables use the CECLI_ prefix.
• Pricing - free; you pay your model provider.
• Releases - v1.8.0 on October 12, 2026, and 20 stable releases in the last 90 days.
• Watch for - a small project, so the maintenance risk that pushes people off Aider has not gone away.

3. Codex CLI

Codex CLI is OpenAI's open-source agent for inspecting, editing, and running code from the terminal. You choose the model, reasoning effort, and permissions per session, and codex exec runs it non-interactively in scripts and pipelines.

• Runs in - the terminal and IDE extensions for VS Code, Cursor, and Windsurf; codex mcp manages external tool servers.
• Open source - Apache-2.0, with about 129k GitHub stars.
• Models - OpenAI models by default, or codex --oss for a local Ollama or LM Studio server; Ollama's Codex integration guide recommends a context window of at least 64k tokens.
• Test hook - a Stop hook that exits with code 2 sends Codex back to work, using your stderr text as the next prompt.
• Pricing - included in ChatGPT Plus, Pro, Business, Edu, and Enterprise plans, or billed through an API key with extra setup.
• Releases - rust-v0.162.1 on October 9, 2026, and 37 stable releases in the last 90 days, plus alpha builds.
• Watch for - hooks must be reviewed and trusted in /hooks before they run, and project hooks load only when the project's .codex folder is trusted.

Sandbox modes and output checks are covered in Codex CLI.

4. Claude Code

Claude Code is the closed-source pick: Claude models only, with the most complete hook system on this list. It needs a Pro, Max, Team, Enterprise, or Console account, or a cloud provider such as Amazon Bedrock, Google Cloud's Agent Platform, or Microsoft Foundry.

• Runs in - the terminal, VS Code, JetBrains, and a desktop app.
• Open source - no; the GitHub repository is public, with about 150k stars, but its license reserves all rights to Anthropic.
• Models - Claude models only.
• Test hook - exit code 2 from a Stop hook sends Claude back to keep working with your stderr as the message, and a stop_hook_active field tells the script it is already in a retry.
• Pricing - included in paid Claude plans or billed through a Console account; the free claude.ai plan does not include Claude Code.
• Releases - v2.1.296 on October 9, 2026, and 73 releases in the last 90 days.
• Watch for - /rewind checkpoints do not track files changed by Bash commands and are not a replacement for version control, so Aider's commit-per-edit history has to come from your own git habits.

Aider vs Claude Code comes down to open models and automatic commits on one side and a stronger agent loop on the other. Hook recipes are collected in Claude Code hooks.

5. OpenHands

OpenHands is the pick for a self-hosted, model-agnostic agent.

The OpenHands CLI runs in your terminal and asks for confirmation on each action by default, close to the review-every-change rhythm of Aider, while openhands --headless -t "task" runs it from scripts and CI.

• Runs in - the terminal, IDEs through the Agent Client Protocol, and Agent Canvas, a self-hosted control center that runs locally, in Docker, on VMs, or in your own infrastructure and can also drive Claude Code, Codex, Gemini, OpenCode, or any ACP-compatible agent; install the CLI with uv tool install openhands --python 3.12 or the install script.
• Open source - MIT, with about 91k GitHub stars.
• Models - any LLM through LiteLLM, including local servers such as Ollama, LM Studio, vLLM, and SGLang.
• Test hook - lifecycle hooks in .openhands/hooks.json work across the CLI, Cloud, and local GUI, and a Stop hook that exits 2 keeps the agent from finishing.
• Pricing - free to run locally; the hosted Individual plan is free with your own key or OpenHands models at cost, and Enterprise is custom.
• Releases - v1.27.1 on October 12, 2026, and 28 stable releases in the last 90 days.
• Watch for - --always-approve (or --yolo) skips every confirmation, and the default local Agent Canvas setup gives the agent full access to your filesystem.

6. Goose

Goose is an open-source agent with a desktop app, a CLI, and an API, built in Rust. It is part of the Agentic AI Foundation at the Linux Foundation, which puts the project under neutral foundation governance rather than a single vendor.

• Runs in - a desktop app for macOS, Linux, and Windows, a CLI, and an API, with 70+ extensions through the Model Context Protocol.
• Open source - Apache 2.0, with about 55k GitHub stars; the repository moved from block/goose to aaif-goose/goose.
• Models - 15+ providers, including Anthropic, OpenAI, Google, Ollama, OpenRouter, Azure, and Bedrock, or an existing Claude, ChatGPT, or Gemini subscription through ACP.
• Test hook - plugin hooks cover PreToolUse, PostToolUse, and Stop events, and PreToolUse and Stop hooks can block.
• Pricing - free; you pay your model provider or use a subscription you already have.
• Releases - v1.54.0 on October 8, 2026, and 12 stable releases in the last 90 days.
• Watch for - Goose is a general-purpose agent rather than a coding-only tool, so git and test conventions are yours to configure.

7. Cline

Cline is an AI coding agent for your editor and terminal that reads and writes files, runs commands, and uses a browser. Every action requires your explicit approval by default, which suits Aider users who review each change before it lands.

• Runs in - VS Code, JetBrains IDEs, a CLI installed with npm i -g cline, and a desktop app for macOS and Windows; it also works in Cursor, Windsurf, and Zed.
• Open source - Apache 2.0, with about 70k GitHub stars.
• Models - any provider through your own keys, plus local inference through Ollama or LM Studio.
• Test hook - plugins add custom tools and hooks, MCP servers connect alongside them, and checkpoints commit your files to a shadow Git repository after each tool use.
• Pricing - Cline's usage-billed provider, a Cline subscription, or your own keys.
• Releases - 133 releases in the last 90 days across the SDK, CLI, and extension, the latest on October 8, 2026.
• Watch for - approvals slow down long unattended runs unless you turn on auto-approve.

8. Qwen Code

Qwen Code is an open-source terminal agent that began as a fork of Gemini CLI v0.8.2 and has developed independently since its v0.1 release. It is the closest option for former Gemini CLI users and for anyone running Qwen's open-weight models.

• Runs in - the terminal, IDE plugins, a desktop app, and a web UI; install with npm install -g @qwen-code/qwen-code@latest or Homebrew.
• Open source - Apache 2.0, with about 28k GitHub stars.
• Models - OpenAI, Anthropic, Gemini, and Qwen APIs, any third-party provider, or local models through Ollama or vLLM, switchable at runtime.
• Test hook - hooks, alongside subagents, MCP, plan mode, LSP integration, and a headless mode.
• Pricing - free to install; model usage is billed by the provider you connect.
• Releases - v0.25.1 on October 11, 2026, and 33 stable releases in the last 90 days, plus preview builds.
• Watch for - the project describes deep integrations with Qwen models, so other providers may need more configuration.

9. Devin

Devin CLI is Cognition's local coding agent for the terminal on macOS, Linux, WSL, and Windows. Its /handoff command sends longer tasks to a cloud Devin session, the autonomous software engineer that writes, runs, and tests code in its own virtual machines.

• Runs in - the terminal through Devin CLI, Devin Cloud sessions, Devin Desktop, and @Devin tags in Slack and Teams; install the CLI with the install script, Homebrew, or the Windows installer.
• Open source - no.
• Models - Anthropic, OpenAI, Google, and Cognition models plus open models such as DeepSeek and Kimi; Cognition recommends Fusion, which pairs a frontier lead model with a cheaper sidekick.
• Test hook - Devin CLI hooks include PostToolUse and Stop events, a hook blocks by exiting with code 2, and existing hooks in .claude/ directories are picked up automatically.
• Pricing - Free, Pro, Max, and Teams self-serve plans share a daily and weekly usage quota across Devin sessions, Devin CLI, and Devin Desktop, with on-demand credits past it; larger teams buy Enterprise.
• Releases - Devin's release notes list updates on October 2, 5, 7, and 9, 2026.
• Watch for - closed source and quota-billed, so it trades Aider's free, bring-your-own-key setup for cloud autonomy.

If Devin works alongside another agent on your team, the same Kane CLI check covers its branches too; see Devin app testing.

Test What the Agent Did With Agent Assurance

Agent Assurance tests how your agents actually behave across workflows, tools, and actions, and catches failures and vulnerabilities before they ship. It runs from your terminal as rook: it reads the codebase to work out what the agent does, writes functional, non-functional, and adversarial scenarios, invokes the agent for real, and grades each criterion against the files, artifacts, and tool calls the run produced, as Pass, Fail, or Unable to Verify.

Discovery runs before any scenario. Point rook explore at the incident-scribe sample in the public Rook repository, a Python CLI agent that looks services up over MCP, writes a customer note and an incident record to disk, and hands the note to a tool-less subagent:

$ rook explore --yes

incident-scribe: 6 features

agents analysed
  AGENT            FEATURES  FINDINGS  WORST
  incident-scribe  6         5         high

1 analysed, 0 unchanged, 23.13 credits
active agent: incident-scribe - the only one registered
on disk only - nothing has been recorded upstream

The high-severity finding is stale state: a later turn can reuse the previous turn's service record and transcript instead of doing a fresh lookup. The other findings include injection handling that lives only in the prompt and a customer-note sanitizer that can leak internal hostnames or team names, none of which show up in the agent's own summary of a run.

• Install the CLI with npm install -g @testmuai/rook or Homebrew, then sign in with rook login.
• Run rook explore in your repository, then rook generate, which writes functional and adversarial scenarios by default; add --class functional,non_functional,adversarial for latency, cost, and reliability.
• Add a command profile that invokes the candidate agent, such as claude -p "{{goal}}" for Claude Code, run the suite against a staging branch, and gate CI on the verdicts in rook report --json rather than on the exit code.
• To run the same workflow from inside Claude Code, Codex CLI, or Gemini CLI, install the skill with npx @testmuai/rook-skill, as described in Rook with coding agents.

Agent Assurance is pre-alpha, so its command surface and stored file formats can still change; keep its runs pointed at staging.

Test What the Agent Built With Kane CLI

Kane CLI checks the running app. It drives a real Chrome browser from a plain-English objective, streams NDJSON in agent mode, and exits 0 on a pass, 1 on a failed assertion, 2 on setup or authentication errors, and 3 on a timeout. The script below turns a failed assertion into exit code 2, which Claude Code, Codex CLI, OpenHands, and Devin CLI treat as "keep working" from a Stop hook, and writes everything to stderr because Codex rejects plain text on stdout from a Stop hook that exits 0:

#!/usr/bin/env bash
# kane-check.sh: one real-browser check whose exit code Aider, Claude Code, and Codex all act on
APP_URL="${APP_URL:-https://www.testmuai.com/selenium-playground/simple-form-demo/}"
OBJECTIVE="${KANE_OBJECTIVE:-type 'Aider handoff' into the Enter Message field, click the Get Checked Value button, assert the Your Message output shows 'Aider handoff'}"

out="$(mktemp)"
kane-cli run "$OBJECTIVE" --url "$APP_URL" --agent --headless --timeout 300 > "$out" 2>/dev/null
code=$?

case "$code" in
  0) echo "kane-cli: passed" >&2
     exit 0 ;;
  1) echo "kane-cli: the UI check failed. run_end event:" >&2
     tail -n 1 "$out" >&2
     exit 2 ;;
  *) echo "kane-cli could not run (exit $code): check auth, Chrome, or the URL" >&2
     exit 1 ;;
esac

Pass it to Aider or cecli with --test-cmd ./kane-check.sh --auto-test. In Claude Code, register it as a Stop hook in .claude/settings.json; Codex CLI reads the same hook shape from .codex/hooks.json once you trust it in /hooks:

{
  "hooks": {
    "Stop": [
      {
        "hooks": [
          { "type": "command", "command": "${CLAUDE_PROJECT_DIR}/kane-check.sh", "timeout": 360 }
        ]
      }
    ]
  }
}

Against the TestMu AI Selenium Playground, the default check passes in six steps and about 96 seconds of browser time, from navigation to the final assertion:

Change the expected text to 'Aider handoff complete', a value the form never shows, and the script exits 2 with the run_end event on stderr. Trimmed, this is what Aider, Claude Code, or Codex reads before its next attempt:

{
  "type": "run_end",
  "status": "failed",
  "reason": "Final verification failed: \"the Your Message output shows 'Aider handoff complete'\"",
  "result_code": 710,
  "reason_code": "assertion_error.final_verification",
  "verdict": {
    "status": "broken",
    "family": "automation_bug",
    "category": "test_data_issue"
  }
}

• Bug detection - Kane CLI classified the failure as a test-data issue rather than a product bug, which points the agent at the expectation instead of at code that already works.
• Retry cap - Claude Code and Codex both pass a stop_hook_active field in the hook's JSON input, so the script can stop after one retry and hand a failing check to a human.
• Other agents - OpenHands reads the same Stop hook from .openhands/hooks.json and Devin CLI from .devin/, and both treat exit code 2 as a block; OpenCode, Goose, and Qwen Code can call the script from a plugin or hook, with OpenCode's session.idle event closest to a Stop hook.