Use an editor agent when you steer continuously, a terminal agent when you delegate bounded repository work, a cloud agent when the task should run away from your machine, an open-source harness when provider control or self-hosting matters, and a workbench when several sessions create an orchestration problem. Cursor and Copilot lead the editor class; Claude Code and Codex lead terminal delegation; Devin leads managed asynchronous work; OpenCode, OpenHands, and Aider cover different open-source needs; Conductor and Continuum manage parallel agents rather than replacing them.
- Choose the work surface first: editor, terminal, cloud queue, open-source platform, or workbench.
- A model benchmark cannot tell you about permissions, branch hygiene, review time, or quota failure.
- Cursor and Copilot optimize steering; Claude Code and Codex optimize delegation.
- OpenCode, OpenHands, and Aider are three different open-source product shapes.
- Devin sells managed distance from the loop; that is useful only when the task survives distance.
- A workbench earns its place when session state and review queues become the bottleneck.
The comparison table
Read the second column before any feature. Product shape predicts how the tool feels, what it can contain, and when the human returns. A terminal agent can be better at a whole ticket while an editor agent is better for the next ten minutes. Neither result contradicts the other.
Public product and pricing material checked in August 2026. Free software can still incur model, hosting, or hardware cost.
| Tool | Shape | Code runs | Cost entry | Best fit |
|---|---|---|---|---|
| Cursor | AI-first editor + CLI | Local or Cursor cloud agent | Hobby free; Pro $20/mo | Continuous steering and predictive editing |
| GitHub Copilot | Editor extension + CLI + cloud agent | Local editor, CLI, or GitHub cloud | Free allowance; Pro $10/mo | Existing editors and GitHub-centered teams |
| Claude Code | Terminal + desktop/web surfaces | Local, remote, or Anthropic cloud surface | Included by eligible Claude plans or API | Bounded repository delegation |
| OpenAI Codex | Terminal + app + cloud | Local sandbox or cloud | Included by ChatGPT plan level or API | ChatGPT users and sandboxed terminal work |
| OpenCode | Open-source TUI, desktop, editor, server | Local or your chosen provider path | MIT software; model cost separate | Provider choice and local models |
| Aider | Open-source terminal harness | Local process | Apache 2.0 software; model cost separate | Small harness, automatic commits, model control |
| OpenHands | Open-source autonomous platform | Docker sandbox, hosted, or self-hosted | MIT core; compute and model cost separate | Self-hosted autonomous workflows |
| Devin | Managed autonomous service + desktop/CLI | Managed environments | Free entry; paid individual and team plans | Asynchronous ticket delegation |
| Conductor | Mac multi-agent workbench | Local worktrees or cloud sandboxes by plan | Free local tier; paid cloud tiers | Dense parallel work on macOS |
| Continuum | Multi-provider, multi-device workbench | Enrolled local or remote hosts | Free app; hosted inference optional | Several agents, accounts, devices, gauges, and one ledger |
The table intentionally avoids a single quality winner. Cursor's best feature is present while you type. Devin's best feature is that you do not have to be present. Aider's best feature is source-level control and a git trail. Continuum's best feature is seeing several independent agent sessions as one operating system. Converting those into one number would hide the choice rather than clarify it.
The first split: steer, delegate, or assign
Every switcher query becomes easier after one verb. You either steer code as it changes, delegate a bounded task while remaining close to the repository, or assign work to run elsewhere and return later. The interfaces follow from those verbs.
| Working mode | Human loop | Best product shape | Typical tools |
|---|---|---|---|
| Steer | Seconds: read, accept, reject, redirect | Editor agent | Cursor, GitHub Copilot |
| Delegate | Minutes: describe, inspect plan, review diff | Terminal agent | Claude Code, Codex, OpenCode, Aider |
| Assign | Hours: submit ticket, check status, review result | Managed cloud agent | Devin, OpenHands Cloud, vendor cloud agents |
| Orchestrate | Across many sessions: route, approve, queue review | Multi-agent workbench | Conductor, Continuum |
Problems begin when a team buys one shape and expects another. An editor agent feels needy if the goal was to assign a ticket and leave. A hosted agent feels opaque if the engineer wants to watch every tool call. A terminal agent feels fragmented when six branches are running and nobody can see which one is blocked. Product dissatisfaction is often interface mismatch mislabeled as model quality.
Permissions and isolation compared
A coding agent is a process acting with credentials on files and instructions it did not write. The meaningful comparison is not whether a settings page contains the word security. It is which boundary remains when the model makes a bad decision or reads a hostile instruction.
Control shapes, not a certification claim. Verify exact defaults in the linked documentation before deployment.
| Tool class | Primary control | Useful boundary | Common mistake |
|---|---|---|---|
| Cursor / Copilot editor | Per-action approvals and organization policy | Editor workspace plus cloud-agent isolation where used | Assuming a familiar editor makes shell access harmless |
| Claude Code | Permission modes, allow/deny rules, hooks | Filesystem and command policy; worktree isolation for parallel sessions | Using bypass mode on the normal laptop because prompts seem trustworthy |
| Codex | Approval policy plus sandbox mode | OS sandbox using Seatbelt on macOS and Landlock on Linux | Granting network or broad writes to an unattended run without a need |
| OpenCode / Aider | Configurable permissions or process permissions | Your OS account, container, VM, or local model boundary | Confusing open source with sandboxed execution |
| OpenHands | Docker sandbox and mount policy | Container boundary around agent commands | Mounting a broad host path read-write and treating the container as isolation |
| Managed cloud agent | Vendor environment, repo token, organization policy | Short-lived remote workspace if configured correctly | Giving the installation access to every repository and production secret |
| Worktree workbench | One checkout and branch per session | Collision and rollback boundary, not a secret boundary | Believing git isolation also isolates Keychain, SSH agent, or network credentials |
Worktrees prevent two agents from overwriting the same checkout and make each diff attributable. They do not isolate processes, credentials, databases, ports, or the network. Containers and OS sandboxes narrow process reach. They do not fix an overpowered token mounted inside the boundary. Repository-scoped credentials, short lifetimes, and an explicit network policy still matter.
The safest default for unfamiliar work is read-only planning, followed by workspace-scoped writes, followed by human review before any external side effect. Full autonomy belongs in an environment that can be discarded and whose credentials cannot deploy, merge, delete data, or enumerate unrelated repositories.
Cost and limits are different product decisions
A $0 label can mean free software, free inference, a small quota, a local model, or a workbench that expects you to bring a paid provider. Those are different economics. Compare the complete route from prompt to model and back.
| Cost shape | Examples | What happens under heavy use |
|---|---|---|
| Seat with usage window | Claude Code on Claude plans, Codex on ChatGPT plans | The window closes or credits extend it, depending on plan |
| Seat with monthly allowance or credits | Cursor, GitHub Copilot | Premium work slows, stops, or moves to metered usage by product |
| Pay per token | Aider, OpenCode, SDK use with API keys | Nothing stops unless you set a provider budget |
| Managed subscription and quota | Devin and cloud-agent products | Included work ends, then the product stops or sells more usage |
| Free app plus your providers | Continuum | The app stays free; each selected provider enforces its own bill or quota |
| Local model | OpenCode, Aider, OpenHands with local inference | No token invoice, but hardware, power, latency, and maintenance remain |
The practical comparison is interruption versus exposure. A hard quota protects the budget and can strand a task. Metered overflow preserves the task and can produce an invoice. Local inference protects against both vendor meters and can be slower or weaker on the repository you care about. None is inherently best. Pick the failure you can schedule around.
For a team, price review time separately from model spend. A $10 seat that produces twice the rejected code of a $20 seat is not cheaper. Track completed tasks, review minutes, rework, and model cost together for at least two weeks. A provider dashboard can show tokens. It cannot tell you whether the diff was accepted.
Context, rules, and extension surfaces
Agent quality depends on what the harness loads before and during the task. Every serious tool now supports project instructions, but the files and extension points differ. Cross-tool teams should keep durable rules in the simplest shared form and add vendor files only for behavior that has no portable equivalent.
| Need | Portable route | Tool-specific depth |
|---|---|---|
| Repository conventions | AGENTS.md where supported | CLAUDE.md, Cursor rules, tool settings |
| On-demand workflows | Plain scripts and documented commands | Claude skills, Cursor rules, agent-specific commands |
| External systems | MCP where the client supports the same server | Vendor connectors and managed integrations |
| Deterministic policy | CI checks, branch rules, OS permissions | Hooks, permission callbacks, organization policy |
| Programmatic agent | Headless CLI with structured output | Claude Agent SDK, OpenHands SDK, OpenCode server and SDK paths |
The portability rule is simple: place facts close to the code, place enforcement outside the model, and keep vendor prompts thin. Build commands, architecture boundaries, and test gates belong in version control. Merge protection belongs in GitHub or the forge. Secret scope belongs in the credential issuer. A model instruction may repeat those facts, but it should not be the only place they exist.
Extension count is not a pure advantage. Hooks, MCP servers, subagents, rules, skills, and custom commands all consume context or add failure modes. Load what a task needs. A small repository with one build command does not benefit from a forty-page agent constitution.
Editor agents: Cursor versus GitHub Copilot
Cursor and Copilot overlap more each year, but the adoption decision remains different. Cursor is the editor. Copilot enters the editor you already use. Cursor can tune the full interaction between index, completion, chat, and agent. Copilot can meet a mixed organization in VS Code, Visual Studio, JetBrains, and GitHub without asking everyone to move.
| Decision | Cursor | GitHub Copilot |
|---|---|---|
| Best reason | Predictive editing and one coherent AI-first surface | Broad editor coverage and GitHub-native procurement |
| Free start | Hobby with limited usage and no expiry | Monthly free completion and chat allowance |
| Paid entry | $20/mo Pro | $10/mo Pro |
| CLI / headless | Cursor agent CLI | Copilot CLI and GitHub automation surfaces |
| Cloud work | Cursor cloud agents | GitHub coding agent and pull-request workflow |
| Switching cost | Editor migration | Extension and account rollout |
Choose Cursor when predictive editing is the product you are buying and the team accepts an editor standard. Choose Copilot when editor diversity, GitHub policy, and low-friction rollout dominate. If autonomous ticket work is the main requirement, compare their agent surfaces with Claude Code, Codex, or Devin separately instead of letting autocomplete decide the purchase.
Terminal agents: Claude Code, Codex, OpenCode, and Aider
Terminal agents share the same visible loop: read files, call tools, edit, test, report. They differ in the machinery around the loop. Claude Code offers the deepest first-party extension system. Codex offers explicit sandbox and approval controls plus a strong path for ChatGPT subscribers. OpenCode offers open code and broad providers across several surfaces. Aider offers the smallest harness and the strongest default git trail.
| Priority | Best starting point | Reason |
|---|---|---|
| Deep project automation and agent extensions | Claude Code | Hooks, skills, subagents, MCP, headless mode, and Agent SDK |
| OS sandbox and an existing ChatGPT bill | Codex | Explicit sandbox modes and plan inclusion |
| Provider choice, local models, source access | OpenCode | MIT client and broad models.dev provider route |
| Automatic commits and minimal machinery | Aider | Each edit becomes a reviewable git boundary by default |
| A neutral comparison | The same task in two worktrees | Repository evidence beats a generic winner |
Do not trial terminal agents on a one-file function. Give them a task that requires locating code, respecting a constraint, changing a test, and running the real gate. The point of the harness is the loop. A prompt that never exercises tools measures the model and misses the product.
Autonomous and workbench products
Devin and OpenHands occupy the autonomous side. Conductor and Continuum occupy the orchestration side. The former pair do work in environments. The latter pair organize sessions run by other agents. They can appear similar because all show tasks, terminals, and diffs, but the ownership boundary differs.
| Question | Autonomous platform answer | Workbench answer |
|---|---|---|
| Who is the agent? | The product or its configured runtime | Claude Code, Codex, Cursor, OpenCode, or another hosted CLI |
| Who owns compute? | Vendor cloud or your self-hosted platform | Your enrolled machine, plus optional cloud paths by product |
| Primary value | Work continues away from the developer | Many sessions remain visible and isolated |
| Review unit | Returned task, branch, or pull request | One live session and worktree at a time |
| Choose when | Asynchronous assignment is the goal | Parallel local or remote agents are already the reality |
Conductor is the focused Mac answer for parallel worktrees and a dense board. Continuum spans more providers and devices, adds per-account quota gauges and a local cost ledger, and keeps the app free with your own subscriptions. This site builds Continuum, so verify those claims on the product and pricing pages rather than treating this comparison as independent review.
A workbench should not increase the number of active agents by default. Its first job is to make existing work legible: ownership, plan state, diff, tests, quota, and review queue. Add concurrency only after those signals are reliable.
A switcher test that survives the next model release
Model leads move. A useful migration test measures the product around the model and can be repeated after any release. Use one normal repository task, one risky read-only task, and one failure. The failure is important because agents look most alike when everything works.
Normal task
Choose a two-hour issue with a known test. Record elapsed time, human prompts, files touched, checks run, and review minutes.
Risky task
Ask for a plan involving auth, data, infrastructure, or a destructive migration. Confirm the tool can stay read-only and makes the boundary visible.
Failure task
Use a deliberately failing test or unavailable dependency. Observe whether the agent diagnoses, loops, broadens scope, spends without a ceiling, or stops cleanly.
Parallel task
If multi-agent work matters, run two independent tasks in separate worktrees and measure the review queue rather than the number of running sessions.
Exit test
Export or inspect the diff, session record, configuration, and branch without the product. Switching cost is part of the score.
| Metric | Why it matters |
|---|---|
| Accepted lines after review | Output volume without acceptance is noise |
| Human interventions per task | Shows steering burden more honestly than elapsed runtime |
| Review minutes | The scarce resource once generation is cheap |
| Rework within seven days | Catches plausible code that did not hold |
| Model and software cost per accepted task | Makes free, seat, and token routes comparable |
| Time to recover from failure | Tests whether git, session history, and isolation are operational |
Keep the tool that reduces total time from issue to accepted change. That answer may be a pair: an editor agent for steering and a terminal agent for delegation, or a native agent plus a workbench once parallel sessions become routine. Buying one product for ideological simplicity is not simpler if the work still has two shapes.
Questions people ask
Start with work surface: steering in an editor, delegating in a terminal, assigning to a cloud environment, owning an open-source platform, or orchestrating several sessions. Then compare task completion, review time, isolation, cost behavior, and switching cost on the same repository task.
An AI editor keeps the human in a seconds-long loop around completion and edits. A coding agent can read files, run tools, change several files, execute tests, and return a diff after minutes. Modern products overlap, but the dominant interaction still matters.
Claude Code offers a deeper first-party harness for many workflows. Codex offers explicit sandbox controls and can be the better value when ChatGPT already covers it. The same bounded task in clean worktrees is a better answer than a generic benchmark.
Cursor is the stronger choice when predictive editing and one AI-first editor justify migration. Copilot is the stronger choice when a team wants AI in its existing editors with GitHub-native policy and a lower paid entry.
OpenCode is a polished open-source coding agent with several surfaces and many providers. OpenHands is a self-hostable autonomous platform with Docker sandboxes and SDK paths. Aider is a smaller terminal harness with broad model choice and automatic git commits.
No. Worktrees isolate checkout and branch state, which prevents collisions and improves rollback. They do not isolate credentials, processes, network access, ports, or external services. Use an OS sandbox or container plus scoped credentials for those boundaries.
Sometimes only the software is free. Check model inference, cloud compute, hardware, and the review time the tool creates. A free harness using a paid frontier API is metered; a local model avoids the token bill but consumes hardware and maintenance.
When two or more sessions create a visibility problem: branch ownership, plans waiting for approval, diffs waiting for review, quota state, or spend spread across providers. If one terminal session is legible, stay native.
Sources
Every figure above was read from these pages on August 2026. Vendors reprice without notice; if you find a stale number, tell us.