Agent editors and their approval models

Cline, Roo Code, OpenCode, Goose, and Plandex all edit code from a chat. What separates them is when they stop and ask.

Nov 20, 2026The avbbc desk
Agent editors and their approval models
Cline, Roo Code, OpenCode, Goose, and Plandex all edit code from a chat. What separates them is when they stop and ask.

Every agentic editor looks the same in a demo: type a task, watch files change. The differences show up on the third step, when the agent wants to touch a file you did not mention. Where it stops — and whether it asks — is the design decision that matters.

Five tools in the directory sit in this category: Cline, Roo Code, OpenCode, Goose, and Plandex.

The short answer

Choose by approval granularity. Per-file confirmation keeps you in the loop and is slow; plan-then-apply makes the plan the review surface; autonomous runs move review to the diff. All three are legitimate; mixing them without deciding is what produces surprise edits.

The four approval models

Model Tool example Review happens
Per step Cline Before each write
Plan then apply Plandex On the plan
Mode-based Roo Code Per mode's rules
Autonomous Manus, Devin On the result

The order is a sliding scale of when human attention is spent. Later review is cheaper per change and catches more at once, which is why it needs a better reviewer.

Cline: the confirm dialog as a feature

Cline asks before each file write. That is slower than an agent that batches, and it is the reason people trust it on a codebase they are still learning. The cost is attention: fifty confirmations a day trains you to click yes.

Plandex: the plan as the review surface

Plandex separates planning from execution, so the first thing you review is a plan. That is the right shape for a change you could describe but not yet want implemented. If the plan is wrong, you saved the edits; if it is right, you approved something you read.

Roo Code: modes as policy

Roo Code lets you define modes — architect, coder, reviewer — with different instructions and permissions. The interesting consequence is that the review mode cannot edit, which makes it a genuine second pass rather than the same agent re-reading itself.

OpenCode and Goose: the terminal layer

OpenCode and Goose run in the terminal with your own model key, and Goose leans on MCP servers for capability. Both are for people who already live in a terminal and want the agent there, not for teams wanting a managed product.

What actually predicts success

Three things, none of them the model: the size of the task, the quality of the tests, and the reviewer's willingness to say no. An agent editing a repository with no tests produces changes nobody can verify, whatever the approval model.

The configuration to start with

One editor agent, plan-first, with tests running on every change. Add mode-based permissions only if you hit the failure where the same agent plans and implements the plan it just wrote. Most teams do hit it, usually within a month.

Frequently asked questions

Is per-step approval safer? Safer per action and worse per week, because attention is finite. The useful question is what the approval is protecting.

Do these need their own API keys? Most do; that is the trade for model choice.

Which has the least setup? Cline. See Claude Code vs Codex for the terminal-agent comparison.

Related reading

All posts