Terminal coding agents, and how to actually choose one

Every comparison of terminal coding agents starts with a feature table, and every feature table looks roughly the same: they all read your repository, edit files across it, run commands, and act on what comes back. On capability, the leaders are closer together than the marketing suggests.

So the table is not where the decision is. The decision is made by a question that most comparisons never ask:

Are the tool and the model vendor allowed to be the same decision?

Answer that first and the field collapses from nine options to three, which is a much easier problem.

The three families

1. Bundled with a subscription you already pay for

Claude Code and Codex CLI come with a plan you may already have. The agent is not a separate line item, the prompts are tuned by the same people who trained the model, and setup is close to nothing.

What you are buying is the model. The tool is the delivery mechanism, and it is not portable — leaving the vendor means leaving the tool.

2. Model-agnostic, bring your own key

opencode, goose and Crush supply the agent loop and let you point it at whatever model you want. Open licences, local execution, no vendor able to change the terms underneath you.

The cost is real and rarely stated: nobody has tuned the prompts for the model you chose. Quality varies more between setups than it does with a first-party tool, and you will spend configuration time you would not spend elsewhere.

3. Free-tier-first

Gemini CLI is the outlier. Its free tier attached to a personal account is large enough to do real work rather than a demo, which makes it the cheapest way to find out whether this category suits you at all.

Treat that as its role. Free quotas at this size are historically the first thing to change, so it is an evaluation path and a second opinion — not the thing you standardise a team on.

The editors, briefly

Cursor, GitHub Copilot and Devin Desktop (formerly Windsurf) are in the comparison because people ask, but they answer a different question. They put intelligence where you already edit or supervise agent work; terminal agents put it where you already run things.

The honest split: if the work is typing code, an editor tool wins on latency and context. If the work is making a change and verifying it works, the terminal agent wins, because it can run the tests and read the output. Most people end up using one of each rather than choosing.

What actually differs

	Bundled	Model-agnostic	Free-tier-first
Setup time	Minutes	An evening	Minutes
Quality out of the box	Highest	Depends on your model	High
Vendor lock-in	Total	None	Total
Cost model	Flat subscription	Metered API, you budget	Free, then metered
Who owns cost control	Vendor	You	You
Ecosystem size	Large	Largest for opencode	Smaller

Five criteria that actually move the decision

1. Do you have a policy against single-vendor dependency? If yes, families 2 is your only option and the rest of this page is academic. If no, do not pay the configuration tax for freedom you will never exercise.

2. Who is accountable when the bill is wrong? Bundled tools put a vendor between you and the meter. Bring-your-own-key means someone on your team owns model selection and spend, and that person needs to exist before you adopt.

3. How many hours a day will you watch it work? This sounds trivial and is not. Reading a badly formatted agent session for hours is genuinely worse, which is the entire argument for Crush and a legitimate one.

4. Can it run where the work is? Remote hosts and CI change the answer. Any agent that can only run interactively on your laptop excludes a large class of work.

5. What happens when it is wrong? Every one of these will occasionally report success on work that needs another look. The tool does not change that; your review habit and your sandbox do.

What none of them solve

Worth being explicit, because the category is sold on autonomy:

• Verification is still your job, and it is where the time goes. An agent that runs the tests has closed one loop, not all of them.
• Cost scales with steps taken, not questions asked. A long autonomous run is expensive in a way a chat session is not.
• They need real permissions over your files and shell. That is not a bug — it is what makes them useful — but it means the blast radius of a wrong action is larger than with a completion tool.
• Tasks with fixed, repeatable steps are cheaper as a script. If you can write the steps down, write the script.

Recommendations

If you are	Start with
Already paying for Claude or ChatGPT	The one you already pay for — Claude Code or Codex CLI
Under a no-single-vendor policy	opencode, the largest ecosystem of the model-agnostic options
Evaluating the category with no budget	Gemini CLI, then move once you know what you need
Doing environment and setup work, not just edits	goose, in a sandbox
Reading agent output all day	Crush
Mostly typing code in an editor	An editor tool, not a terminal agent

Once you have picked one and started running two or three at a time, a second question appears that this page does not answer: where they run, and how you tell which one is waiting for you. That is a different comparison — herdr vs tmux and Zellij.

A note on how this was written

Pricing, licences and capabilities were checked against vendor documentation and official repositories on the date above. The judgement about who should pick what is opinion, formed from public information and the design of each product; where an entry has not been verified through extended hands-on use, its detail page says so.

Confirm current pricing on the vendor’s own site before you commit to anything. In this category it changes faster than any directory can track.

The diagram is compiled from a typed specification of the three families described above, so it carries no claim this page does not make in words.