How to Pick an Open-Source AI Coding Agent: 9 Tools, Four Different Jobs

OpenCode is the best default open-source coding agent, Cline wins inside an IDE, Aider gives you the cleanest Git-controlled terminal loop, and OpenHands is the call for autonomous queues. The software can cost nothing and still run a $60 monthly model bill: four developers using 20 million input and 2 million output tokens on Claude Sonnet 5 at its current promotional API rate.

The fast verdict

Pick the work surface first. OpenCode is the strongest general default, but it is the wrong answer if your developers refuse to leave VS Code, if every command needs explicit approval, or if the goal is a queue of unattended GitHub issues.

The decision flips on four questions:

• Where do you want to supervise it? Pick Cline or Continue in an IDE, OpenCode or Aider in a terminal.
• Do you want collaboration or delegation? Pick an interactive tool for live edits, OpenHands for a managed queue, or mini-SWE-agent for a transparent issue-solving harness.
• What may leave your network? An open client can still send repository context to a commercial model API.
• Who owns the permission policy? A convenient auto-approve toggle can erase the safety advantage you thought you bought.

The wider market includes stronger closed products for some jobs. The full AI coding-agent comparison is the better shortlist if source access, local deployment, and provider choice are not requirements.

Open source changes the harness, not the bill or the risk

Open source gives you inspectable orchestration code. It does not make frontier models, GPU time, identity controls, secret handling, or code review free.

Take a four-developer team that collectively sends 20 million input tokens and receives 2 million output tokens in a month. At Claude Sonnet 5's introductory API rate of $2 per million input tokens and $10 per million output tokens through August 31, 2026, that workload costs $60. The same workload costs $90 when the standard $3 and $15 rates begin. Anthropic also says the model's tokenizer can turn the same input into 1.0 to 1.35 times as many tokens, depending on the content, so a model switch can change both the unit price and the metered quantity.

The permission model matters just as much. A 2026 study of 500 validated scenarios and roughly 7,500 agent runs found out-of-scope action rates of 5.4% to 27.7% in its permissive framework cluster. OpenHands, which used an ask-to-continue framework in the study, landed between 0.2% and 4.5%. Those numbers do not crown one universal winner, but they make the operational lesson hard to miss: the same base model behaves differently when the harness changes what it may do without consent.

Privacy has three separate layers:

1. The client: Can you inspect and modify the agent code?
2. The runtime: Does the agent execute on your laptop, in your cloud, or in a vendor environment?
3. The model: Does repository context go to a hosted API, or to a model running inside your boundary?

An MIT-licensed terminal client connected to a hosted model is open source, but it is not fully local. A self-hosted runtime that forwards prompts to a commercial API still shares context with that provider. A local model keeps the data path private, but transfers the cost to hardware, deployment, and model-quality tradeoffs.

How these tools were picked

The shortlist requires an active open-source harness that can take multi-step action on code, files, or a shell. Each tool also needs current primary documentation, an identifiable license, and a distinct reason to choose it over the other eight.

That standard cuts several adjacent products. An open-source editor with autocomplete is useful, but it is not automatically an agent. A proprietary cloud worker with a visible client is not an open-source stack. A repository that has shut down or been superseded does not belong in an active recommendation.

The ranking turns on five criteria: supervision surface, permission design, model and provider flexibility, deployment boundary, and the first wall a professional team hits. Popularity is supporting evidence, not the verdict. A tool with fewer stars can still win when its control model fits the job.

OpenCode: the best default for terminal-first developers

OpenCode is the best default because it spans terminal, IDE, and desktop work without locking the harness to one model provider. It is MIT licensed, supports more than 75 providers through Models.dev, can use local models, and includes parallel sessions plus GitHub Copilot and ChatGPT account login. Its product site also says OpenCode itself does not store code or context data, though the privacy policy of whichever model provider you connect still applies.

OpenCode's built-in plan agent is read-only and asks permission before Bash commands; the build agent has full development access. That separation makes unfamiliar repositories easier to inspect before edits begin. The wall is ownership: provider selection, token cost, account policy, and upstream data handling all become your decisions.

Best for: Terminal-first developers who want provider choice without giving up a polished interface
Standout: Terminal, IDE, desktop, parallel sessions, and more than 75 providers in one MIT-licensed client
Pricing: Free client with free models available; paid provider usage or subscriptions may still apply
Free trial: Not needed for the open-source client

OpenCode wins when flexibility is useful and someone owns the configuration. A company looking for one centrally governed vendor experience may find that flexibility creates more policy work than value.

Cline: the best approval-first agent inside an IDE

Cline is the strongest choice when developers want to see the plan, diff, and terminal command inside the editor before anything changes. The Apache 2.0 project ships a VS Code extension, terminal CLI, SDK, multi-agent Kanban board, and JetBrains plugin. It can edit across a project, run commands, monitor compiler and linter output, browse the web, and restore checkpoints.

Plan mode explores and proposes a strategy; Act mode performs the work. Every file edit and terminal command requires approval unless auto-approve is enabled. That friction is a feature on a production repository and a nuisance during low-risk repetitive work. Strict open-source buyers should also note that Cline's repository says its JetBrains plugins are not currently open sourced.

Best for: Developers who stay in VS Code and want a visible approval gate
Standout: Plan and Act workflow with reviewable diffs, checkpoints, and command approval
Pricing: Free Apache 2.0 client; model provider usage is separate
Free trial: Not needed for the open-source client

Cline is the right call for a mid-market engineering lead who values inspectability over speed. Skip it when the desired product is an unattended queue rather than a developer-in-the-loop editor.

Aider: the best Git-controlled pair programmer

Aider is the cleanest fit for developers who treat Git history as the control surface. The Apache 2.0 terminal agent builds a repository map, edits files in a local Git repository, automatically commits its changes with messages, and can run linting and tests after edits. It connects to both hosted and local models, including Ollama and OpenAI-compatible endpoints.

That narrow design is the appeal. You can inspect a small diff, revert a commit, and keep the agent inside a familiar development loop. The same focus is also the wall: Aider is an interactive pair programmer, not a multi-user task board or managed cloud queue.

Best for: Senior developers who want precise terminal edits wrapped in reversible commits
Standout: Repository maps plus automatic Git commits, linting, and test loops
Pricing: Free Apache 2.0 client; model usage is separate
Free trial: Not needed for the open-source client

Aider beats a broader agent when the job is one developer making one controlled change. It loses when a team needs identity, budgets, queues, and integrations around long-running jobs.

OpenHands: the best self-hosted autonomous queue

OpenHands is the right pick when the agent must live beyond one developer's editor and work through a queue of delegated tasks. Its Agent Canvas starts a local browser UI and backend with one command, can be self-hosted on a virtual machine, and can connect to OpenHands Cloud. The Software Agent SDK can run locally or scale to thousands of agents in the cloud.

The license boundary needs careful reading. OpenHands core, Agent Canvas, agent-server, and core Docker images are MIT licensed. Cloud adds managed integrations, multi-user controls, role-based access, usage reporting, and budget enforcement; the Enterprise directory is source-available under a separate license and requires a purchased license after one month.

Best for: Teams building a self-hosted or managed queue for autonomous engineering tasks
Standout: MIT core with local Agent Canvas, a composable SDK, and a managed-cloud path
Pricing: Free MIT core; infrastructure, model use, Cloud, and Enterprise can add cost
Free trial: OpenHands Cloud can be tried free with GitHub sign-in

OpenHands earns its setup cost when tasks must continue without an editor open. For a solo developer making live changes, OpenCode or Aider is simpler and usually cheaper to operate.

Gemini CLI: the strongest bundled free quota

Gemini CLI is the easiest serious free start: a personal Google account includes 60 requests per minute and 1,000 requests per day. The Apache 2.0 terminal agent uses Gemini 3 models with a 1 million-token context window and includes file operations, shell commands, web fetching, Google Search grounding, MCP support, scripts, and GitHub workflows.

Google publishes a stable release every week, a preview every week, and a nightly build each day, which matters in a category where model APIs and tool contracts move quickly. The wall is strategic rather than functional: the bundled quota is a Gemini path, not provider-neutral routing. Choose it for the free allowance and Google integration, not because open source automatically guarantees model choice.

Best for: Individual developers who want a capable terminal agent with a large bundled quota
Standout: 1,000 free requests per day, 60 per minute, and a 1 million-token context window
Pricing: Free personal-account tier; paid API or Vertex AI options are available for higher needs
Free trial: The personal-account tier is already free

Gemini CLI is the budget winner for a solo technical builder. A team that needs provider routing, a visual approval loop, or a self-hosted queue should look elsewhere.

Continue: the best bridge from IDE assistance to CI checks

Continue fits teams that want one open client to span autocomplete, chat, direct editing, agent work, and pull-request checks. Its Apache 2.0 project offers VS Code and JetBrains extensions plus the cn command-line agent. Continue can also store AI checks in the repository and run them as GitHub status checks, returning a pass or a suggested diff.

The breadth makes adoption easier because developers can start with low-risk assistance before granting agent actions. It also blurs the product boundary: autocomplete and review checks are not the same operational problem as an isolated autonomous worker. Continue wins as a bridge, not as the best queue manager.

Best for: Teams that want open IDE assistance and source-controlled CI checks in one ecosystem
Standout: Agent, Chat, Edit, Autocomplete, CLI, and repository-defined checks
Pricing: Free Apache 2.0 client; configured models and CI resources add their own costs
Free trial: Not needed for the open-source client

Continue is a strong B2B choice when the organization wants guardrails in the repository. A founder looking for the fastest terminal agent will get less ceremony from OpenCode or Aider.

goose: the best agent when coding is only half the workflow

goose is a local general-purpose agent that happens to be good at code rather than a coding-only product. The Apache 2.0 project runs as a desktop app, CLI, and API on macOS, Linux, and Windows. It supports more than 15 model providers, more than 70 MCP extensions, and existing Claude, ChatGPT, or Gemini subscriptions through ACP.

Its home in the Agentic AI Foundation at the Linux Foundation gives the project a governance story beyond one vendor. The tradeoff is scope: research, writing, automation, data analysis, and coding all share the same agent surface. That is useful for an operator who crosses systems and extra configuration for a developer who only wants repository edits.

Best for: Technical operators whose workflow moves between code, data, research, and automation
Standout: Local desktop, CLI, and API with broad provider and MCP support
Pricing: Free Apache 2.0 client; provider subscriptions, API usage, or local compute are separate
Free trial: Not needed for the open-source client

goose pays off when one agent needs to query data, edit a script, and update another system in the same run. For disciplined Git changes, Aider remains the sharper tool.

mini-SWE-agent: the best transparent issue-solving harness

mini-SWE-agent is the best choice when understanding the agent loop matters as much as using it. Version 2 is MIT licensed, and its maintainers describe the default agent class as roughly 100 lines of Python. They report a score above 74% on SWE-bench Verified and support local environments, Docker or Podman, Singularity or Apptainer, bubblewrap, and other sandboxes.

The architecture is deliberately exposed: Bash is its only tool, every action runs independently through subprocess.run, and the message history stays linear. That makes trajectories easier to inspect and research easier to reproduce. It also means Bash is the power tool and the danger; a production rollout needs a sandbox and scoped credentials rather than trust in the agent's small codebase.

Best for: Researchers and platform teams that want a minimal, inspectable issue-solving loop
Standout: Roughly 100 lines of agent logic with a Bash-only, linear-history design
Pricing: Free MIT client; model calls and sandbox infrastructure are separate
Free trial: Not needed for the open-source client

mini-SWE-agent is the honest pick for a platform team building its own harness. It is not the easiest first agent for a designer, product manager, or developer who wants a polished editor experience.

Qwen Code: the best open model-and-harness stack

Qwen Code is the most ambitious option for buyers who want both an open harness and an open model family. The Apache 2.0 project supports subagents, agent teams, memory, skills, MCP, plan mode, LSP integration, sandboxing, Git worktrees, headless runs, IDE plugins, desktop apps, and SDKs. It also speaks OpenAI, Anthropic, Gemini, and Qwen protocols and can connect to Ollama or vLLM.

The current setup has two catches. NPM installation requires Node.js 22 or newer, and the Qwen OAuth free tier ended on April 15, 2026. New users need an Alibaba Cloud Coding Plan, a third-party API key, a custom provider, or a local model, so the client is open but the easiest bundled free path is gone.

Best for: Teams that want an open agent paired with open Qwen models or broad protocol support
Standout: Open harness and model path with subagents, teams, skills, sandboxing, and worktrees
Pricing: Free Apache 2.0 client; a current provider plan, API key, or local compute is required
Free trial: No Qwen OAuth free tier since April 15, 2026

Qwen Code is the fit for an AI platform team that wants to own the stack. Gemini CLI is the easier free start; OpenCode is the cleaner provider-neutral default.

Who should pick what

The winner changes when the supervision model changes. Do not shortlist nine tools and ask developers to vote on screenshots. Choose the operating pattern, then trial the one or two tools that serve it.

Pick Cline when developers work in VS Code and every edit or command should be visible before execution. Continue is the alternative when autocomplete, chat, editing, and repository-defined checks need to share one open client.

Pick OpenCode when terminal work is the center but model and interface flexibility matter. Pick Aider instead when automatic Git commits and a tight pair-programming loop matter more than parallel sessions or a desktop surface.

Pick OpenHands when the organization needs a queue, identities, budgets, integrations, and a path from local experiments to managed operations. Pick mini-SWE-agent when the goal is to inspect, benchmark, or extend the issue-solving loop rather than buy a finished operational platform.

Pick Gemini CLI when the 1,000-request daily quota is the decisive constraint. Pick Qwen Code when the organization wants an open model path and is prepared to configure a provider or local runtime. Pick goose when the job crosses code, data, research, and external tools.

Set up the top pick without giving it the keys to production

OpenCode is easy to start, but the safe sequence begins with inspection rather than full-access automation.

1. 1

   Create a disposable branch and remove ambient credentials

   Start from a clean working tree on a new branch. Keep production deployment keys, database administrator credentials, and unrelated cloud tokens out of the agent process.

2. 2

   Install the client from the official source

   Use the official installer, curl -fsSL https://opencode.ai/install | bash, or one of the documented package-manager options. Start it inside the repository you intend to inspect, not from a broad parent directory.

3. 3

   Connect the narrowest suitable model account

   Choose a provider whose data policy fits the repository. A local model keeps prompts inside your boundary; a hosted model usually gives better results but sends selected context to that provider.

4. 4

   Begin in plan mode

   Use the built-in read-only plan agent to map the change, identify files, and propose tests. Review the plan before switching to the full-access build agent.

5. 5

   Build, test, inspect, then merge

   Let the agent edit on the disposable branch, run the repository's test and lint commands, and inspect the diff. Merge only after a human confirms scope, behavior, and any changes to dependencies, permissions, infrastructure, or secrets.

For a solo builder, that sequence adds minutes. For a larger engineering organization, it is the difference between a useful standard and many private configurations with unknown permissions.

The ones to avoid

Two familiar names should not begin a new rollout.

Roo Code shut down its extension on May 15, 2026. Its repository now directs users to the community ZooCode fork or to Cline. An Apache license keeps the old code available, but it does not supply active product maintenance, current model integration, or a security response. Choose Cline for the closest established approval-first path.

Legacy SWE-agent has been superseded by mini-SWE-agent. The maintainers say current development is focused on mini-SWE-agent and recommend it as the default for new users. Use the older project only when research specifically needs its configurable tool interfaces or history processors.

The broader warning is simple: a repository being public does not make a product active. Check the current maintainer guidance, release activity, license boundary, and authentication path before standardizing it.

FAQ

Are open-source AI coding agents free?

The client software in this list is free to download, but model APIs, local GPU capacity, cloud sandboxes, storage, and operating time are separate. A four-developer Sonnet 5 workload of 20 million input and 2 million output tokens costs $60 at the promotional rate and $90 after August 31, 2026.

What is the best free AI coding agent for VS Code?

Cline is the best approval-first VS Code agent because its Plan and Act workflow keeps diffs and commands visible. Continue is the better free open client when you also want autocomplete, chat, direct editing, and source-controlled pull-request checks.

Where can I find open-source AI coding agents on GitHub?

Use the official repositories linked from each tool's own documentation, not a similarly named fork. The license and current README reveal details a directory page misses, including Cline's JetBrains source boundary, OpenHands' Enterprise license, and Qwen Code's current authentication requirements.

Get the Claude Code + Codex Setup Checklist and the next evidence-led tool breakdown by joining the newsletter.