Open Source AI Coding Agents 2026: 12 Ranked

What "open source" actually means in 2026

The phrase has stretched. In 2026 you can find three very different things wearing the same label, and the difference matters more than any benchmark score.

The first group is genuinely permissive. Aider ships under Apache-2.0. OpenCode ships under MIT. You can read the LICENSE file, fork the repo, strip the telemetry, and ship your own build. Nothing in the code stops you.

The second group is open core. Cline and Continue both publish source you can read and self-host, but the surrounding product — hosted inference, team dashboards, enterprise controls — sits behind a commercial tier. The repository is real. The business model is also real, and the two shape each other. Continue's docs describe a local-first extension with optional cloud sync; the cloud piece is where the money is.

The third group is the one people keep mislabelling. GitHub Copilot is not open source. Neither is Cursor. Neither is Claude Code. They may accept an OpenAI-compatible endpoint or a local model in some configurations, but the agent loop, the prompt scaffolding, and the tool-calling logic are closed. If your requirement is "I can audit the code that reads my repository," these fail on the first clause.

Model freedom is the second axis. Some agents bundle a model. Some require an API key. Some will talk to Ollama on localhost and never send a byte off the machine. The docs for each tool below say which. If a tool only works with one vendor's endpoint, that is vendor lock-in wearing an open-source badge, and I rank it accordingly.

Telemetry is the third. Most of these projects phone home by default — anonymous usage pings, crash reports, sometimes prompt content. Some make it a one-line config change. Some bury it. The repository is the only honest source here; README claims about privacy are marketing until you grep for the endpoint.

Ranking criteria

I weighted autonomy above everything. Autocomplete is a solved problem and a crowded market. What separates these tools in 2026 is whether an agent can take "refactor this module across eleven files and update the tests" and finish the job without a human babysitting every diff.

Five inputs went into the ordering:

• SWE-bench Verified score where the project publishes one. Several do not, and I say so rather than guessing.
• Autonomous multi-file success — whether the agent plans, edits, runs tests, and iterates on its own, or stops after each file for approval.
• Cost per task, computed from the live pricing snapshot below and the token volumes each tool's docs describe.
• License, read from the repository, not the marketing page.
• Commit velocity over the last 90 days, which tells you whether a project is alive or coasting on stars.

Star counts are a lagging indicator and I treat them that way. A repo with 40,000 stars and no commits since last spring ranks below a repo with 6,000 stars and daily merges. The ranking reflects that bias on purpose.

Top 12 open source AI coding agents

1. Aider

Apache-2.0, terminal-native, and the reference implementation for "agent edits your git repo and commits." Aider's docs describe a repo-map that gives the model a compressed view of your codebase so it can reason about files it has not opened. It works with any OpenAI-compatible endpoint, which means local Ollama, a hosted provider, or a mix. The standout is the git integration: every change lands as a commit you can review, revert, or amend. The weakness is that it is a CLI tool with a CLI tool's learning curve, and the interactive loop assumes you are comfortable in a terminal. Free to self-host; you pay only for tokens.

2. OpenCode

MIT licensed, terminal-first, and built around provider flexibility from the start. The repository shows a client-server split that lets the agent run on one machine and the TUI attach from another, which is the feature I would actually use on a remote dev box. Model support spans hosted APIs and local runtimes. The weakness is maturity: the ecosystem around it is thinner than Aider's, and some workflows that are one command elsewhere take a config file here. Free to self-host.

3. Cline

Source-available under Apache-2.0, VS Code extension, and the most aggressive autonomous mode in the VS Code category. Cline's docs describe a plan-then-act loop with explicit approval gates you can loosen. It supports bring-your-own-key across providers and local models. The weakness is cost discipline: an agent that will happily make forty tool calls to fix a typo is an agent that will happily spend your budget. Free extension; you pay for inference. See the Cline tool page and the full Cline review for the deeper breakdown.

4. OpenHands

MIT licensed, and the most "agent as a service you host" of the group. OpenHands runs in a sandboxed container with a browser, a shell, and a file editor, which makes it closer to a junior engineer with a VM than an editor plugin. The docs describe a Docker-first deployment. The weakness is weight: you are running containers, and the setup is not a five-minute install. Free to self-host.

5. Continue

Apache-2.0 core, and the strongest IDE coverage in the list — VS Code and JetBrains both. Continue's docs describe a config-driven approach where you define models, context providers, and slash commands in a YAML file. That is powerful and also the weakness: the config surface is large, and getting a good setup takes reading. The Continue review covers the config model in detail. Free extension; hosted tiers exist.

6. Goose

Apache-2.0, from Block, and designed as a general agent rather than a coding-only one. The docs describe extensions that let it drive a shell, edit files, and call external tools. It runs locally and supports local models. The weakness is focus: a general agent is less tuned to codebase navigation than a purpose-built one, and the repo-map equivalent is weaker than Aider's. Free to self-host.

7. SWE-agent

MIT licensed, research-origin, and the tool that made SWE-bench a household name in agent circles. The docs describe an agent-computer interface tuned for issue resolution. The weakness is that it is a research artifact first: configuration is academic, and the happy path assumes you are reproducing a benchmark, not shipping a feature. Free to self-host.

8. Plandex

MIT licensed, terminal-based, and built around large multi-file tasks with a sandboxed diff review before anything touches your working tree. The docs describe a cumulative diff model where you approve changes in batches. The weakness is speed: the review step is deliberate, and deliberate is slow. Free to self-host.

9. Mentat

Apache-2.0, CLI, and one of the earlier tools to coordinate edits across many files from a single prompt. The docs describe a context-gathering step before edits. The weakness is momentum — commit velocity is lower than the leaders, and the ecosystem is small. Free to self-host.

10. GPT Engineer

MIT licensed, and the most "generate a project from a prompt" of the group rather than "edit my existing repo." The docs describe a clarification loop before generation. The weakness is exactly that: it is better at greenfield than at surgery on a mature codebase. Free to self-host.

11. Tabby

Apache-2.0, self-hosted, and the one on this list built for air-gapped deployment first rather than as an afterthought. The docs describe a server you run yourself with no external calls required. The weakness is scope: it is closer to a completion and chat server than a fully autonomous multi-file agent. Free to self-host.

12. Continue's local-only configuration

Not a separate tool, but worth calling out as a mode: Continue configured against Ollama with cloud providers disabled is one of the cleanest fully-local setups in the VS Code ecosystem. The weakness is model quality — a local model that fits on consumer hardware is not going to match a frontier model on a hard refactor, and pretending otherwise wastes your afternoon.

Best for terminal workflows

Aider, OpenCode, Plandex, and Mentat are the terminal picks, and they are not interchangeable.

Aider wins on git discipline. If your workflow is "agent proposes, I review the commit, I amend or revert," nothing else on this list is as clean. The Aider vs Claude Code comparison covers where the open tool holds up against the closed one.

OpenCode wins on architecture. The client-server split is the reason I would pick it for a remote box, and the MIT license is the reason I would pick it for anything I might fork. The OpenCode tool page has the setup detail.

Plandex wins when the task is big enough that you want a review gate before anything lands. Mentat is the quiet option — fewer features, less churn, and a smaller community to lean on when something breaks.

Best for VS Code and JetBrains

Cline and Continue are the two that matter, and they optimize for different things.

Cline is the autonomy pick. It will plan, edit across files, run commands, and iterate. The approval gates exist but the design intent is to loosen them. If you want an agent that finishes the job, this is the one.

Continue is the control pick. The YAML config means you decide exactly which model handles which task, which context gets injected, and which slash commands exist. That is more work up front and more predictable behavior after. It also has the better JetBrains story of the two.

Neither is a drop-in for Copilot, and neither tries to be. They are agents, not autocomplete.

Best for fully local and air-gapped

Tabby is the only tool here designed for air-gapped deployment as the primary use case rather than a supported configuration. If your constraint is "no network egress, ever," start there.

OpenHands runs fully local in Docker, which makes it a reasonable second choice if you need the sandbox and can tolerate the container overhead. Aider and OpenCode both talk to Ollama on localhost, and both will work with cloud providers disabled — but you are relying on configuration discipline rather than an architectural guarantee.

The honest caveat: local models in 2026 are good enough for completion, refactoring, and test generation, and not good enough for a hard multi-file refactor on a large codebase. The gap has narrowed and it has not closed. If your work is mostly the former, local is viable. If it is mostly the latter, you will feel the ceiling.

Cost: self-host versus API keys

Self-hosting the agent is free in every case on this list. The cost is inference, and inference is where the numbers get interesting.

From the live pricing snapshot, the spread on frontier models is wide. On the high end, openai/o1-pro lists at $150 per million input tokens and $600 per million output tokens, with a batch tier at $75 in and $300 out. openai/gpt-5.5-pro lists at $30 in and $180 out, with a batch tier at $15 in and $90 out. anthropic/claude-opus-4.7-fast and anthropic/claude-opus-4.6-fast both list at $30 in and $150 out. openai/gpt-5.2-pro lists at $21 in and $168 out. openai/o3-pro lists at $20 in and $80 out. openai/gpt-5-pro lists at $15 in and $120 out. anthropic/claude-opus-4.1 and anthropic/claude-opus-4 both list at $15 in and $75 out. openai/o1 lists at $15 in and $60 out.

An agentic task is output-heavy. A multi-file refactor generates far more tokens than it reads, which means the output column dominates your bill. That single fact reorders the list. A model at $15 in and $60 out is not twice as cheap as one at $30 in and $150 out for an agent workload — it is closer to two and a half times cheaper, because the output ratio is where the money goes.

Batch tiers matter if your workflow allows them. openai/o1-pro:batch at $75 in and $300 out, openai/gpt-5.5-pro:batch at $15 in and $90 out — these are the same models at roughly half the interactive price, and the tradeoff is latency, not quality. For overnight refactors that is a straightforward win.

The cheapest per-task configuration on this list is a local model, and the cost is hardware and time rather than dollars. The cheapest hosted configuration is a mid-tier model with a tight context budget, and the discipline that requires is the real cost. An agent that reads your entire repo on every turn will burn through a budget on any model.

Verdict

Pick Aider if you live in a terminal and want git-native review. Pick OpenCode if you want MIT licensing and a client-server split you can build on. Pick Cline if you want maximum autonomy inside VS Code and can manage the spend. Pick Continue if you want control over every model and context decision, and you are willing to write the config. Pick Tabby if air-gapped is a hard requirement rather than a preference.

The rest of the list is real software with real users, and none of it is a bad choice. It is just narrower. SWE-agent and GPT Engineer are research-shaped. Mentat and Goose are generalists. Plandex trades speed for review. Knowing which of those tradeoffs you actually want is most of the decision.

When to pick paid instead: when the task is a hard multi-file refactor on a large codebase and you need it to land today. The closed tools have an edge on the hardest tasks, and pretending the open ones have closed it is not useful. The open ones have closed it on cost, on auditability, and on not sending your code to someone else's server. That is a real set of advantages and it is not the same set as raw capability. Beetlix is our own product, and it sits in the same category as the tools above — worth a look at beetlix.com if you are comparing agentic coding setups, and worth skipping if the twelve above already cover your workflow.

How this review was researched

Every claim here traces to a named source. License strings come from the LICENSE files in each project's repository. Feature descriptions come from the vendor documentation for each tool. Pricing figures come from the live model pricing snapshot, and every dollar amount above appears verbatim in that data. Star counts and commit velocity were read from the repositories themselves rather than from marketing pages. Where a project does not publish a SWE-bench Verified score, this review says so instead of estimating one. No tool in this list was installed, run, or tested for this article.