Open-Source Coding Agents 2026: Which One to Run

This article was originally published on aifoss.dev

TL;DR: Coding agents became a real product category in 2025–2026. Cline leads for VS Code users with cloud API access; Aider is the best terminal agent for local models at 32B+; OpenHands handles autonomous issue-fixing at 72% SWE-bench Verified. Using any of these is a cost and privacy play — commercial agents (Cursor, Claude Code) still outperform on pure capability.

Honest take: If you're a VS Code developer with a cloud API key, start with Cline. If you need tight git history and local model flexibility, use Aider. If you want an agent that fixes GitHub issues and opens a PR without you watching, OpenHands with Claude Opus 4.6 is currently the open-source best.

Coding agent vs. code completion vs. LLM chat

These three categories blur in marketing but matter for real usage:

Code completion (GitHub Copilot, Tabby, Continue.dev): autocompletes as you type. Zero autonomy. The model never touches your filesystem without you copying its output.

LLM chat (Open WebUI, LibreChat): you paste code, it suggests. You decide whether to apply the suggestion. The model has no access to your repo.

Coding agent: reads your repo, creates and modifies files, runs terminal commands, interprets errors, and loops until the task is done or it gives up. It has real side effects. It can delete a file you meant to keep.

That last point matters for security, for choosing the right tool, and for setting expectations with teammates. An agent running bash commands in your home directory is not the same risk category as an inline autocomplete.

The six agents covered here

The brief for this article called for five (Aider, Cline, Open Interpreter, SWE-agent, Plandex). OpenHands earns a spot because it's currently the best-performing open-source autonomous agent on the SWE-bench Verified leaderboard and raised a $18.8M Series A in June 2026.

Aider

• License: Apache 2.0
• GitHub stars: ~39K (June 2026)
• Interface: terminal (CLI)
• Editing approach: diff/patch — sends minimal diffs to the model, not the full file every round

Aider's design is git-first: every AI edit becomes a commit. You run aider from your repo root, describe the task, and it generates a focused commit. If the output is wrong, git diff HEAD~1 shows exactly what changed and reverting is a single command.

It supports 75+ model providers via litellm. Routing to a local Ollama endpoint is a single flag:

pip install aider-install && aider-install

# local model
aider --model ollama/qwen2.5-coder:32b --no-auto-commits

# architect mode: separate planner + editor for harder tasks
aider --architect \
  --model claude-opus-4-20250514 \
  --editor-model claude-sonnet-4-20250514

The tradeoff: Aider is a pair programmer, not an autonomous agent. Its SWE-bench Verified score in architect mode is 31.4% — lower than Cline or OpenHands in full-autonomy mode. That's an architecture choice, not a flaw. Aider assumes you're watching and guiding. The diff-patch approach also sends significantly fewer tokens per session than tools that pass full file contents each turn, which cuts cloud API costs.

Cline

• License: Apache 2.0
• GitHub stars: ~61K (June 2026)
• Version: v3.81
• Interface: VS Code sidebar (also JetBrains, Cursor, Windsurf, Zed, CLI preview)
• Editing approach: full-file rewrites with a diff view before applying

Cline reads your codebase, creates/edits files, runs terminal commands, drives a Puppeteer browser for web tasks, and pauses for approval at each consequential step. Provider support includes Ollama and LM Studio in the dropdown — no manual config files required.

SWE-bench Verified score: ~59.8% running Claude Sonnet 4.6 in autonomous mode. That's comfortably ahead of Aider's autonomous score and competitive with proprietary agents in the $20/month tier.

The token cost problem deserves a real callout: Cline passes the full file context to the model on most edits. A single complex task on a large repo can consume 500K+ input tokens. With Claude Sonnet 4.6 at $3/MTok input, that's $1.50 per task. Do ten tasks a day and it adds up to $450/month — more than a Cursor subscription. Use a local model for exploration and a cloud model for final implementation, or set Cline's context limits to cap per-session spending.

# Cline with a local Ollama model
# VS Code: Settings > Cline > API Provider > Ollama
# Model: qwen2.5-coder:32b
# Base URL: http://localhost:11434

See the Cline setup guide for full configuration including API keys, context settings, and VS Code workspace options.

OpenHands

• License: MIT
• GitHub stars: ~70K (June 2026)
• Interface: web UI + CLI + REST API
• Editing approach: CodeAct — generates executable Python to modify files, runs it, observes output, loops

OpenHands (formerly OpenDevin) is the most capable open-source autonomous agent currently available. It achieves 72% on SWE-bench Verified running Claude Opus 4.6 — second only to the commercial top-tier agents in published benchmark results. It raised a $18.8M Series A in June 2026 and has enterprise roadmap items including GitHub App integration and team workspaces.

Setup requires Docker:

git clone https://github.com/All-Hands-AI/OpenHands.git
cd OpenHands
cp config.template.toml config.toml
# edit config.toml: add your LLM API key and model name
docker compose up
# open http://localhost:3000

Local model support works via any OpenAI-compatible endpoint configured in config.toml. The quality drop is steep: at 7B parameters you'll mostly see failures; at 32B you can handle well-scoped tasks. For autonomous issue-fixing that reliably produces PR-quality output, use a cloud model.

The friction is real: Docker Compose, a config file, and a running server before you get started. That's more overhead than pip install aider. It's worth it when the task is "fix this GitHub issue" — not when the task is "help me understand this function."

SWE-agent and mini-SWE-agent

• License: MIT
• Interface: CLI / Python API
• Benchmark: mini-SWE-agent scores >74% on SWE-bench Verified

SWE-agent is Princeton's NeurIPS 2024 paper that started the benchmark arms race — a system that takes a GitHub issue URL and tries to fix it with an LM agent. The team's current development focus has shifted to mini-SWE-agent: a ~100-line Python script that scores above 74% on SWE-bench Verified and is dramatically simpler to read and extend.

Be clear about what this is: research infrastructure, not a daily driver. There's no IDE extension, no streaming output, no UX beyond a CLI. It's valuable for benchmarking your own models, for understanding how agent scaffolding works, and for running automated issue-fixing pipelines. For actual development work, Aider or Cline is a better fit.

pip install mini-swe-agent

# fix a GitHub issue
mini-swe-agent run \
  --issue "https://github.com/your-org/repo/issues/42" \
  --model claude-opus-4-20250514

Plandex

• License: AGPL-3.0
• Version: CLI v2.2.1 (July 2025; check github.com/plandex-ai/plandex for current)
• Interface: terminal
• Editing approach: streamed changes applied to a sandbox, staged for review before touching your working directory

Plandex targets large multi-file projects. It handles up to 2M context tokens directly, can index 20M+ token codebases via tree-sitter project maps, and supports 400+ models via OpenR