Open-Source Coding Agent Platforms Compared

The autonomous coding agent market hit $6.4 billion in 2025 and analysts expect it to reach $91.2 billion by 2034. That's a 38.5% annual growth rate, and coding is the fastest-growing corner of the whole agent economy at a projected 52.4% CAGR through 2030. But here's the weird part: adoption intent and actual agent use don't match. The 2025 Stack Overflow Developer Survey (49,009 developers, 166 countries) found 84% of developers now use or plan to use AI tools, up from 76% the year before. Yet more than half, 52%, either avoid agents entirely or stick to simple assistants. That gap is the whole story here, and it comes down to three things: who controls the model, what happens to cost at scale, and where the code actually lives.

Open-source platforms exist specifically to answer those three worries. That's why this comparison matters, and it's why picking the wrong one costs more than a bad first impression.

What actually separates an AI coding agent from an AI coding assistant

An assistant waits for you to ask something and answers. An agent plans, touches multiple files, runs your test suite, and keeps going without you babysitting every step. Think of the difference between a coworker who answers questions when you tap them on the shoulder, versus one you hand a ticket to and they just... go do it, coming back when it's done or when it's stuck.

The capabilities that make something an agent instead of a chatbot: reading and writing files, running terminal commands, using a browser, running tests, and planning across multiple turns without constant hand-holding.

"Open-source" here means something specific too. It means the full source is published under a license like Apache 2.0 or MIT, and you bring your own model, either through an API key or a local model running on your own hardware. That's not a minor detail buried in the README. It's the entire architectural choice that determines who controls cost, who controls where your code travels, and who controls which model version you're locked into.

Pair an open-weights agent with something like Qwen3-Coder or DeepSeek, and per-task costs can be a fraction of closed commercial alternatives. That gap barely matters if you're running ten tasks a month, but past a few hundred tasks, it's the difference between a rounding error and a line item your CFO asks about.

The tradeoff nobody puts on the marketing page: you now own your sandbox setup, your secret management, and your observability. Worth knowing before any of the platform comparisons below make it sound easy.

The five dimensions that meaningfully differentiate these platforms

Five questions actually separate these tools, and everything else is decoration.

Model flexibility asks whether the platform locks you into one vendor, gives you a curated list, or accepts any OpenAI-compatible endpoint, local models included. Deployment model asks whether you're living in a terminal, a VS Code extension, a web UI, a desktop app, or a self-hosted server, because each of those implies a completely different daily workflow for your team. Sandboxing and execution safety asks how the agent is kept from doing something dumb to your host machine: Docker containers, process-level isolation, or nothing at all.

Task autonomy and approval modes asks how much say you get before the agent acts, suggestion versus auto-edit versus fully autonomous. Enterprise readiness rounds it out: role-based access control, audit trails, multi-agent delegation, and the maintenance signals that tell you whether this project will still exist in two years.

These five aren't a checklist for checklist's sake. They're the actual constraints that decide whether a platform fits how your team already works, or whether you're bending your workflow to fit the tool. Open Hands, an open-source platform for running autonomous coding agents at scale, is one example built explicitly around those constraints.

Platforms built around terminal and CLI workflows

OpenCode, MIT-licensed and built by Anomaly (the team behind SST), launched in June 2025 and by mid-2026 had racked up over 160,000 GitHub stars, 900 contributors, and 7.5 million monthly active developers. That makes it the most-starred open-source coding agent that's ever existed. It supports more than 75 LLM providers, including local models, works offline, and lives entirely in the terminal with no GUI at all. Good fit if your team basically never leaves the shell. Worth flagging: a public dispute with Anthropic over subscription login requirements raised governance questions, even with the MIT license sitting right there.

Aider, Apache 2.0, has more than 44,000 GitHub stars and over 6.6 million installs, making it one of the most widely used open-source coding assistants around. It works straight against Git repositories, and its diff-patch architecture sends 5 to 10 times fewer tokens per session than tools that push full files back and forth. On a large codebase, that's real money saved, not a rounding error. It supports nearly any LLM and automates the commit workflow, so "edit, commit, repeat" is where it shines. It's narrow by design, though, and you shouldn't expect multi-agent orchestration or browser-based tasks from it.

Gemini CLI, Apache 2.0, from Google, sits at 105,104 GitHub stars and launched in June 2025 with a generous free tier: 60 requests a minute, 1,000 a day, just a Google login required. That changed. Free and consumer access stopped serving requests on June 18, 2026, with Google folding the product into Antigravity CLI. Enterprise Code Assist license holders keep their access. Anyone evaluating Gemini CLI today should treat it as an enterprise product with a license fee attached, not a free tool.

OpenAI Codex CLI, Apache 2.0, has 89,991 stars and works with GPT-4.1, o3, and o4-mini. It offers three approval modes, Suggest, Auto-edit, and Full-auto, which is the cleanest autonomy dial of any CLI tool in this space, and it's sandboxed by default too. The catch: it requires a $20 to $200 monthly OpenAI subscription and only works with OpenAI models. If vendor independence matters to you, that lock-in is the deciding factor, full stop.

Plandex, MIT, is built for the big, ugly, multi-step tasks, with support for a wide range of models and local OpenAI-compatible endpoints. Its commercial cloud offering has since shut down, leaving self-hosting as the primary deployment path. That's a privacy win and an operational chore at the same time. Best fit is teams with genuinely large codebases who don't mind running their own server.

Platforms built around IDE integration and VS Code workflows

Cline, Apache 2.0, has 62,996 stars and lives entirely inside VS Code. It orchestrates multi-step tasks across files and commands, which gives it a wide action surface. It supports multiple leading models and local models, and it offers human approval controls along the way. One tradeoff: it edits full files rather than diffs, so token cost per session runs higher on large repos.

Continue, Apache 2.0, supports multiple editors including VS Code and JetBrains, which matters a lot if your team is split across editors and nobody wants to fight about it. It bundles multiple coding assistance modes into one package and lets you bring your own models, including fully local setups. If code can't leave the network under any circumstance, Continue's local model support makes it a strong option. Team plan runs $20 per seat a month; local model use costs nothing on top of that, which rewards teams willing to invest in their own inference hardware upfront.

Platforms built for autonomous, multi-step task execution across the full stack

OpenHands, MIT, has more than 70,000 stars, 490-plus contributors, and raised an $18.8 million Series A, making it the most popular self-hosted autonomous agent around. It ships a web UI with a built-in VSCode instance, multi-agent delegation, RBAC, and audit trails, the most complete enterprise feature set of any open-source platform in this comparison. It scores 72% on SWE-bench Verified when paired with Claude Sonnet 4.5 and extended thinking, and solves more than half of real GitHub issues thrown at it. Docker sandboxing is the core safety mechanism, isolating agent actions from your host machine, though Docker needs to be running with real headroom and startup latency is the main operational cost. It's free to self-host; you only pay for model inference, and it's model-agnostic by design. Strongest fit for teams that need to audit exactly what the agent did and why, at scale.

Goose, Apache 2.0, comes from Block (the company formerly known as Square) and runs as both a desktop app and a CLI. It connects to more than 3,000 MCP servers and is genuinely model-agnostic, even supporting multiple model configurations running at once. It moved under the Linux Foundation's Agentic AI Foundation, a governance signal worth real weight in any enterprise adoption decision. It goes past code generation into full development workflows: building projects from nothing, debugging failures, orchestrating multi-step tasks end to end. Block's backing gives it credibility, and the Apache 2.0 license keeps it genuinely open, a combination few platforms here can match.

SWE-Agentis research-born. Its Agent-Computer Interface reflects a research-grade design sensibility, and published benchmark results show competitive performance on SWE-bench Verified. It includes a built-in cybersecurity-focused mode among its capabilities. Best fit is security research, learning how agents actually work under the hood, or academic benchmarking, not production deployment at scale.

How benchmark scores should and should not factor into platform selection

SWE-bench Verified is the industry standard for a reason: real GitHub issues, from real repositories, checked by human evaluators. That's a lot more meaningful than a synthetic test written to make a demo look good. OpenHands at 72% marks one of the highest documented scores for open-source platforms on this benchmark.

What the benchmark doesn't tell you: startup latency, token cost per session, how approval workflows feel to your team day to day, observability once the thing is in production, or how well any of this handles your specific codebase's quirks. The 2025 Stack Overflow survey found 46% of developers don't trust the accuracy of AI outputs, up from 31% the year before. A benchmark score doesn't fix that, but visibility into what the agent actually did, step by step, does.

A platform scoring a few points lower on SWE-bench but offering full audit trails and granular approval controls is very often the better enterprise pick. Treat benchmark scores as a floor, not a leaderboard: use them to cut the platforms that clearly underperform, then make the real decision on the five dimensions that match how your team works.

How the five comparison dimensions map to common team situations

A solo developer or small team on a large repo, watching cost closely, fits Aider best. The diff-patch architecture and Git-native workflow cut token spend without giving up model quality.

A team that's already committed to VS Code and wants approval on every single action should look at Cline, which covers the widest action surface inside the editor; Continue is the better pick if local inference or JetBrains support is a requirement rather than a nice-to-have.

Teams under strict data-residency rules, or working fully air-gapped, should run Continue with Ollama or llama.cpp to keep code off the network entirely, or Plandex if the context window needs to be enormous and self-hosting isn't a dealbreaker.

Teams running long, multi-step autonomous workflows under audit and compliance pressure need OpenHands' RBAC, audit trails, multi-agent delegation, and Docker sandboxing, with Goose's MCP extensibility and Linux Foundation backing as a strong second option.

Organizations already locked into OpenAI and comfortable paying the subscription should look at Codex CLI, with eyes open about the total lack of model flexibility that comes with it. Security research or CTF work points straight at SWE-Agent's EnIGMA mode, understanding that it's not built for production.

Only 17% of agent users, per the same Stack Overflow survey, say agents actually improve team collaboration. That's the gap that RBAC, audit trails, and multi-agent delegation are trying to close, and it's a bigger gap than most vendor pitches let on.

What the governance and maintenance signals tell you about long-term platform risk

Gemini CLI cutting off free access in June 2026 is the clearest recent proof that who owns a platform determines how long it stays useful to anyone who isn't paying for an enterprise license. That's not a knock on the tool; it's just what happens when a free product sits inside a company with other priorities.

Governance signals worth actually weighing: foundation backing, like Goose moving under the Linux Foundation's Agentic AI Foundation; institutional research roots, like SWE-Agent's ties to Princeton and Stanford; commercial funding, like OpenHands' $18.8 million Series A; and corporate stewardship, like OpenCode under Anomaly or Goose under Block.

License matters at the infrastructure level too. MIT and Apache 2.0 both allow commercial use and modification freely, but Apache 2.0 adds an explicit patent grant, which matters more than people expect once legal gets involved in a procurement decision.

Contributor count is a decent proxy for whether a project survives its founder losing interest. OpenCode's 900 contributors and OpenHands' 490-plus make both a lot harder to abandon than something one person maintains on nights and weekends. Plandex Cloud shutting down is the cautionary tale here: any platform blending open-source code with a hosted business model carries that risk, and self-hosting capability is the only real hedge against it.

Treat an agent platform like infrastructure, not a tool you swap out next quarter. License, funding, governance, and contributor activity all belong on the same checklist as features, because the feature list won't matter much if the project isn't around to maintain it.