AutomaterOpen-Source Coding Agents: Aider, Cline, OpenCode, Goose, and Friends
Field review of six open source coding agents — Aider, Cline, OpenCode, Goose, OpenHands, Crush — with maintenance health, BYOK math, and honest picks.
Go deeper. Build your own.
Gemini CLI went dark on June 18, 2026, and took working CI pipelines with it. Roo Code, iFlow, and Phind followed the same arc this year, per mid-2026 reporting; the great harness die-off is now a running series, not a one-off event. If you daily-drive one or two vendor CLIs, you have watched enough of this to want the thing this article is about: an open source coding agent — at least one lane that nobody can deprecate, re-price, or rate-limit out from under you.
This is a field review of the six projects that matter as of August 2026 — Aider, Cline, OpenCode, Goose, OpenHands, and Crush — each scored against the same rubric, with the maintenance-health question asked out loud rather than politely skipped. Around the reviews: the BYOK economics that flipped this year, the sovereign pairing with open-weight models, and the due-diligence checklist for adopting a tool that runs your shell.
The trade is stated in the first breath, because it is real: going open means giving up some polish, the integrated cloud sandboxes, and a support number. Project facts below were checked on August 27, 2026; FOSS changes faster than vendor products, so re-verify before you commit.
Why the open source coding agent is a category now
An open source coding agent is a harness — the agent loop, tools, permission gates, and terminal or editor surface around a model — whose code you can read, fork, and point at any backend. You hold the config and the code, so no vendor pivot, plan re-price, or model deprecation can take the lane away.
Four freedoms do the work. BYOK and bring-your-own-model: any API key, any endpoint, any open-weight model, swapped the day it ships. Auditability: this is software that executes shell commands with your permissions, and you can read exactly what it does before it does it. Hackability: system prompts, hooks, and tool definitions are yours to edit. And no session silo: your transcripts live on your disk, not in a vendor’s cloud.
Against the vendor field mapped in our agent harness field guide, these projects are the survivability play, and 2026 keeps supplying the evidence. Every deprecation this year followed the same script: a business decision upstream, a short notice window, and users discovering their muscle memory, configs, and CI wiring were rented. An open harness cannot promise the project lives forever — this article covers a shutdown in its own roster — but it changes what a death means: an archived repo you can still run, fork, and patch, instead of an endpoint returning 410.
One more piece of context makes the whole category work: per mid-2026 reporting, every serious CLI harness now accepts at least one of the OpenAI-compatible or Anthropic-Messages endpoint formats, so open harnesses plug into the same model economy as everything else. Scope note: this piece reviews harnesses only — which open-weight models can drive them, and the rest of the stack, are covered separately below.
The rubric: how each project is scored
Every review below follows one template — best for / standout / limits / cost model / maintenance health — so the entries compare instead of accumulating adjectives. Scored silently throughout: control and reviewability (diffs before writes, permission gates), model freedom, maintenance health, and token-burn behavior under real agent loops. That last one matters more in a BYOK world than in a flat-plan one: a harness that re-reads the repo on every turn is a personality quirk on a subscription and a line item on an API key.
Verification stance, up front: statuses, licenses, and health characterizations were checked August 27, 2026, and FOSS projects change faster than vendor products.
Disclosure: none of these projects is ours and none pays us. Automater is a session-archive and metering layer that sits above harnesses; it is not a harness and does not compete with anything reviewed here.
Aider: the git-native original
Aider set the pattern most of this field still follows: a tree-sitter repo map so the model sees structure instead of raw file dumps, disciplined diff-based edits, and — its signature — every change landing as an automatic git commit, so undo is git revert and review is git log. It is also the most scriptable tool here: batch mode via --message, plus a Python API for wiring it into pipelines. License: Apache-2.0.
pip install aider-chat
aider --model deepseek/deepseek-chat \
--message "add type hints across src/utils" src/utils/*.py
# any OpenAI-compatible endpoint works, local servers includedTwo details show the design philosophy. The repo map is built from tree-sitter parses and ranked by relevance, so a 200-file repo costs a few thousand tokens of structure rather than a context window of source — one reason Aider’s burn profile stays polite where newer agents gorge. And watch mode turns any editor into an Aider surface: leave a comment ending in AI! in any watched file, and the running session picks up the instruction.
Aider’s polyglot benchmark deserves its own credit line: it became a community standard for ranking models on real edit discipline rather than puzzle-solving.
- Best for: surgical, reviewable edits and scripted batch changes across a repo.
- Standout: git discipline nobody else matches.
- Limits: a single-loop design in a field moving to multi-agent tool-callers; no IDE surface.
- Cost model: pure BYOK — any key, any local endpoint, no plan of its own.
- Maintenance health: the honest characterization is stable but slower — commit and release cadence has eased well off its 2024–2025 peak, and the bus factor is thin. The tool works and the design is finished in the good sense, but adopters should watch the repo, not assume momentum.
Cline and the fork lineage: Roo Code, Kilo Code
Cline is the VS Code-native agent with the plan/act split the category copied: Plan mode reasons about the change and proposes an approach, Act mode executes it, with checkpoints snapshotting the workspace along the way so any step can be rolled back without touching your git history. It has the deepest MCP story of any editor-resident agent — a server marketplace, plus the ability to build itself a new MCP tool mid-task — and BYOK across every major provider. License: Apache-2.0.
The known gotcha is token burn. Cline-class agents stuff full files into context and re-read eagerly, which is exactly what you want for correctness and exactly what you don’t at frontier list prices. The standard mitigations: plan on a strong model and act on a cheap one, scope the workspace so the agent cannot wander, and watch the context meter like a fuel gauge.
The fork lineage is the category’s civics lesson, compressed to three lines:
- Roo Code forked from Cline, adding custom modes and profiles — then, per mid-2026 reporting, shut down this year.
- Kilo Code forked from Roo, aiming to merge the Roo and Cline lines, and remains active as of August 2026.
- The lesson cuts both ways: forks die like anything else, but the code survives its project — the escape hatch open source actually sells is the license, not any one team’s longevity.
Fork freedom and fork mortality in one map: projects end; permissively licensed code gets carried forward.
- Best for: IDE-resident agent work with plan-first discipline.
- Standout: MCP depth inside an editor.
- Limits: VS Code dependency and the burn profile above.
- Cost model: free extension, pure BYOK.
- Maintenance health: very active, venture-backed, fast release cadence — the healthiest line in the family that spawned it.
OpenCode: the terminal-native Claude Code alternative
If you searched “open source Claude Code alternative,” OpenCode is the answer that matches the shape of the question: a polished terminal TUI with sessions and session sharing, LSP awareness so edits respect the language server’s view of the code, and configurable agent modes. License: MIT; stewarded by the SST team.
Provider freedom is the standout, and it is not a bullet point — it is the architecture. OpenCode’s provider registry covers dozens of backends: frontier APIs, the budget Chinese endpoints, aggregators, and local servers, swappable per session. In practice that means the harness UX stays constant while the engine changes with the job — the strongest version of the BYOK argument this field makes. The session model earns a mention too: sessions persist, resume, and can be shared as links, which quietly solves the “what did the agent do last Tuesday” problem most terminal tools ignore.
- Best for: terminal daily-driving with real model freedom.
- Standout: the closest FOSS user experience to a vendor flagship.
- Limits: a young codebase moving fast; documentation chases the code, and behaviors shift between releases.
- Cost model: pure BYOK.
- Maintenance health: extremely active — the opposite failure mode from Aider: change outpacing documentation rather than quiet.
Goose: Block’s extensible MCP-native agent
The Goose AI agent is the extensibility play: an open-source agent from Block where extensions simply are MCP servers — the protocol is the plugin system, so anything with an MCP surface becomes a Goose capability without bespoke integration. Recipes package repeatable multi-step jobs into something you can rerun and share: a dependency-audit recipe or a release-notes recipe becomes a one-command chore instead of a prompt you reconstruct from memory. License: Apache-2.0.
Form factors and model config are pragmatic: CLI and desktop app, fully model-agnostic, with per-role model assignment — a cheap model for routine steps, a strong one for planning. Governance is the notable 2026 development: per mid-2026 reporting, Goose moved from Block to the Linux Foundation — the strongest neutrality signal in this roster, since foundation governance survives any single company’s strategy shifts.
- Best for: automation beyond pure coding — ops chores, tool-heavy workflows, MCP-connected business tasks.
- Standout: MCP-native architecture, before most of the field got there.
- Limits: less coding-specialized polish than the Aider/OpenCode class on pure repo work.
- Cost model: pure BYOK.
- Maintenance health: active, with corporate stewardship transitioning to foundation governance — a maturity marker, not a retreat.
OpenHands: the autonomous platform with research pedigree
OpenHands (formerly OpenDevin) is the heavyweight: not a CLI you chat with but a sandboxed autonomous platform — a Docker-isolated runtime with browser and shell tools, driven through a GUI or headless for automation. License: MIT.
The research pedigree is concrete rather than decorative: it grew out of academic work on software agents, and it has been a consistent presence on SWE-bench-class leaderboards — the reference open implementation many papers benchmark against. That cuts both ways in daily use: the architecture is unusually principled about isolation and evaluation, and the product edges are correspondingly less sanded than the venture-backed tools above. Headless mode is the underrated feature — the same agent that runs a GUI session will run a scripted batch of tickets overnight.
- Best for: delegated end-to-end tickets and agent research — the “delegate a ticket” tool in a roster of “drive a session” tools.
- Standout: sandbox-first safety posture; the isolation is the design, not an option.
- Limits: the heaviest setup here, and overkill for interactive editing.
- Cost model: BYOK, with a hosted cloud option if you want the sandbox managed.
- Maintenance health: active on both company (All Hands AI) and community energy; regular releases.
Quick hits: Crush and the boundary cases
- Crush, the compact review: Charm’s terminal agent, carrying the codebase lineage of the OpenCode split forward under the company that defines terminal UI craft. Multi-model, MCP-capable, LSP-aware, and — being Charm — the best-looking session in this roster. Best for: terminal-first work where session ergonomics matter; standout: interface craft nobody else invests in; limits: younger agent loop than the majors, and check the license before assuming OSI-open — the lineage has not always been straightforwardly permissive; cost model: pure BYOK; maintenance health: active under Charm’s stewardship.
- The boundary cases: vendor-published open-source CLIs — Codex CLI, Qwen Code, and until June, Gemini CLI — are open code with vendor gravity: real license freedom, roadmaps serving the vendor’s models, defaults nudging toward the vendor’s endpoints. They belong in a vendor-tools comparison, not this roster. Gemini CLI’s shutdown made the distinction concrete: the license outlived the product, which helped forkers and migration tooling, but nobody’s CI was saved by it that morning.
- The inclusion bar for this roster: active maintenance, a real agent loop, and non-trivial adoption. The newest entrants — Amp, OpenClaw, Hermes Agent and company — get their own new-wave harness field report rather than a padded line here.
BYOK economics: the counterintuitive math
Here is the part the FOSS romantics skip: agent loops burn tokens in multiples chat never did. A single afternoon session can read hundreds of files, retry failed builds, and re-plan twice. At frontier list prices, heavy BYOK use does not undercut a vendor flat plan — it can exceed it several times over. The subscription, decoded elsewhere, is often the subsidized path.
What changed in the last twelve months is the other row of the table. Per mid-2026 reporting, open-model API pricing dropped roughly 80 percent year over year , and the floor became explicit: DeepSeek V4 Flash lists at $0.14 per million input tokens and $0.28 output, with GLM-5.2 around a quarter of frontier output price and Qwen3-Coder-Next at $0.11/$0.80 via Alibaba Cloud.
One heavy week, costed three ways — 50M input and 2.5M output tokens through an agent loop, caching ignored for simplicity:
| Lane | Heavy week | Month, at that pace |
|---|---|---|
| Frontier BYOK (reference class, ~$3 in / $15 out per M) | ~$188 | ~$750 |
| Open-weight BYOK (DeepSeek V4 Flash at $0.14/$0.28) | ~$7.70 | ~$31 |
| Vendor flat plan, top consumer tier | — | ~$100–$200 |
Read the crossover both ways. At frontier prices, BYOK blows past a $200 plan inside the first serious week — the plan wins. At open-weight floor prices, BYOK undercuts every plan by a factor of three to six — BYOK wins. The 80 percent drop is what moved the middle row from consolation prize to strategy, and it is the economic engine under this whole category. Caching complicates the picture in the plan’s favor — vendor harnesses are aggressively tuned for their own prompt caches, and a naive BYOK setup that skips cache-friendly request shaping pays list price for repetition — so treat the table as the honest bounds, not a quote.
The line that moved: open-weight BYOK now sits under every flat plan at any realistic volume — frontier BYOK still crosses them in week one.
Two practical notes. First, the aggregator lane: OpenRouter-class services give you one key, automatic fallbacks, and unified billing across dozens of providers for a small percentage fee — the sane BYOK default when you want model freedom without an account per vendor. Second, plan-credential reuse: consumer-plan logins from Claude or ChatGPT inside third-party harnesses sit outside those vendors’ terms and have drawn enforcement, while some coding plans — Z.ai’s GLM plan, Moonshot’s Kimi plan — explicitly permit harness use. Stay inside the terms, full stop; the compliant paths above are cheap enough now that there is no argument left for the gray zone.
Product note: BYOK means no vendor dashboard ever sees your whole spend — it’s scattered across raw API keys. Automater Lite meters tokens locally per provider, one ledger across every lane, and archives sessions from any CLI that writes transcripts — OSS harnesses included. Free on automater.ai.
The sovereign pairing: OSS harness plus open weights
- The endgame this category enables: an open harness driving open-weight models on hardware you control — air-gap capable, auditable end to end, with the license as the only contract.
- The mechanics are one config line: every harness reviewed here speaks to OpenAI-compatible endpoints, so Ollama for one-box convenience or vLLM for serving throughput slots straight in.
ollama pull qwen3-coder # ~46GB-class one-box coder
OPENAI_API_BASE=http://localhost:11434/v1 \
aider --model openai/qwen3-coder- The hardware bar dropped with the model sizes: a Qwen3-Coder-Next-class coder runs in roughly 46GB of unified memory, which is one well-specced workstation, not a rack.
- Which weights can actually hold the engine slot is its own question — our open-weight models guide ranks them for agent work, and the full open-source stack blueprint covers everything around the harness.
- The honest price: fully sovereign means giving up frontier quality. Right for privacy-bound and cost-floor work; wrong as a blanket default.
When an open source coding agent wins — and when it honestly doesn’t
| The OSS harness wins on | The vendor harness wins on |
|---|---|
| Compliance and air-gap requirements | Frontier-lab tuning — harness and model trained toward each other: caching, thinking modes, tool formats |
| Deep customization: prompts, hooks, forks | Integrated cloud sandboxes and delegation surfaces |
| Hard cost ceilings via BYOK plus cheap models | Onboarding polish that costs zero setup hours |
| Day-one freedom to adopt any new model | A support channel and someone accountable |
| Longevity — a fork outlives a vendor pivot | Velocity — vendor teams ship weekly |
The heuristic, without advocacy: go OSS-first when constraints bind — data residency, budget ceilings, model freedom, or the need to still be running this tool in three years regardless of anyone’s roadmap. Go vendor-first when throughput on hard tasks is the only metric that matters, because the frontier labs tune their own harnesses to their own models and that co-tuning is real. Most readers of this site land on both, which is what the coexistence section is for.
Due diligence: project health for a tool that runs your shell
A harness executes commands with your permissions; adopting one is a supply-chain decision, not an app download. That framing is not alarmism — it is what the tool is: software that takes natural-language input from many sources, including files and web pages it reads, and turns some of it into shell commands. The ten-minute health check, runnable this afternoon:
- Release cadence and recency — releases page, anything in the last 90 days?
- Bus factor — how many maintainers land meaningful commits, not drive-by typo fixes?
- Issue-response latency — pick three real bug reports and read the timestamps.
- Security posture — sandboxing defaults, permission gates on by default, a disclosure process that exists.
The agent-specific risks go beyond ordinary dependency hygiene, and they are covered in depth in our agent security guide: prompt-injection-to-shell paths, auto-approve and YOLO modes that turn one bad web page into executed commands, and the third-party supply chains of extensions and MCP servers. Mitigation defaults: keep permission gates on, sandbox where the tool offers it, pin versions, and read a harness update’s diff the way you would read any dependency bump that can run rm.
Coexistence: running an OSS lane beside a vendor primary
The realistic pattern is not migration; it is addition. Keep the vendor primary that earns its subscription, and add one OSS harness as a second lane: rate-limit overflow, scripted batch edits, cheap-model grind work, or the one repo that can never touch a vendor cloud.
Two pairings that work today: Aider for scripted refactors beside a Claude Code primary — batch mode makes it the cron job of coding agents — and OpenCode pointed at a budget endpoint for when the plan window runs dry mid-sprint.
Two lanes is already a fleet, with two transcript formats, two spend meters, and two places work happens — the command-center problem in miniature. Solve it early, and the OSS lane becomes what it should be: the lane you own, running quietly beside the one you rent.
FAQ: open-source coding agents
What is the best open source coding agent?
There is no single answer — fit decides. Aider for git-disciplined, scriptable edits; OpenCode for terminal daily-driving with model freedom; Cline for VS Code-resident plan/act work; Goose for MCP-heavy automation beyond coding; OpenHands for sandboxed, delegated tickets. All are BYOK; statuses checked August 2026.
Is there an open source alternative to Claude Code?
Yes. OpenCode is the closest in shape: a polished terminal TUI with sessions, LSP awareness, and agent modes, driven by any of dozens of providers instead of one vendor’s models. The trade: a fast-moving young codebase and docs that chase the code.
Is Aider still maintained?
Yes, but cadence has slowed from its 2024–2025 peak, and development concentrates in few hands. For adopters that means a stable, finished-feeling tool rather than a fast-evolving one: fine for scripted and surgical work, worth watching before betting a team workflow on it.
Why does Cline use so many tokens?
Cline reads whole files into context and re-reads eagerly as it works — good for correctness, expensive at frontier list prices. The standard mitigations: run Plan mode on a strong model and Act mode on a cheap one, and scope the workspace so context stays small.
Can I use my Claude subscription with open-source tools?
Consumer-plan credentials inside third-party harnesses sit outside Anthropic’s terms of service, and enforcement has happened. The compliant paths: BYOK API keys, aggregator keys, or coding plans that explicitly permit harness use, such as the GLM and Kimi coding plans — now cheap enough to remove the temptation.
