AI Coding Assistants and Agents in 2026: Which Does Which Job

The category split in two while everyone was still calling it "AI coding tools". On one side, assistants that work with you inside the editor. On the other, agents that take a task and disappear for an hour. They are bought for different reasons and they fail in different ways, and choosing between them on a single leaderboard is why so many teams end up with tools nobody uses.

This is organised by job, with live pricing from our catalogue and our own verification record for each tool — how many times we have independently re-checked it, since when, and what changed.

The assistants — you stay in the loop

Cursor — Free, then $20/mo

Still the fastest interactive experience in the category. The thing worth paying for is the completion model predicting your next edit rather than your next token — in a large codebase that is a different feeling from autocomplete, and it is what people mean when they say they cannot go back.

Skip it if your bottleneck is a queue of tedious well-defined jobs rather than typing speed. That is an agent problem, not an assistant one.

Windsurf — Free, then $20/mo

The closest competitor to Cursor, and genuinely preferred by some developers for its agentic flow feeling less interruptive. This is close enough that personal taste decides it — both have free tiers, and an afternoon in each will tell you more than any comparison.

GitHub Copilot — Free, then $10/user/month

The lowest-friction option if your team already lives on GitHub. It is not the quality leader in agentic work and the gap is real, but "already integrated, nobody has to change editors" is a legitimate reason to choose a tool, and for many teams it is the deciding one.

Skip it if you are choosing on capability rather than on integration.

The agents — they work unsupervised

Claude Code — Free, then $20/mo

The background worker. Hand it a well-defined job — refactor this module to the new API, write tests for these uncovered paths, migrate off this library — and come back to a diff. This is the tool most likely to clear the queue of jobs you keep postponing because they are boring rather than hard.

Devin — Paid

The most autonomous of the commercial agents, and priced accordingly — it is Paid with no free tier. It targets the "assign it a ticket" workflow rather than the "give it a task" one. Whether that is worth it depends entirely on how well-specified your tickets actually are, which is usually the real constraint rather than the model.

Manus — Paid

A general-purpose agent rather than a coding specialist — it targets multi-step work across tools, of which code is one. Consider it if your bottleneck spans research, data and code rather than sitting inside a repository.

The open-source layer

Three of the strongest options here cost nothing for the scaffolding — you pay only for model calls: Cline and Aider for interactive and git-disciplined work respectively, and OpenHands for autonomous runs in a sandbox. We cover the setup, including pointing them at local models, in the open-source coding agents self-hosting guide.

Worth knowing before you dismiss them as the budget option: Free, and the quality gap on everyday interactive work is much smaller than the price gap.

Where agents still fail

This is the section most comparisons skip, and it is the one that decides whether an agent earns its cost.

Ambiguity. An agent given a vague task does not ask — it picks an interpretation and commits to it confidently. The failure is expensive because it looks like progress until you read the diff.

Long horizons. Beyond roughly fifteen tool calls, most agents start to drift: they lose the original constraint, re-solve something they already solved, or wander into an adjacent problem. Breaking a big job into explicitly stated steps beats trusting the horizon.

Cost when wrong. A confused agent burns tokens being confused. This is the surprise on the first month's bill for most teams, and it is entirely preventable: set a spending cap at the API provider before your first long run, not after.

Judgement. Agents are good at work a test can grade and bad at work a person has to weigh. The reliable division of labour in 2026 is exactly that line — give the agent anything with a verifiable success condition, keep everything else interactive.

The cost model nobody explains before the first bill

Assistants are subscriptions. Agents are usage. That difference is the single most common budgeting surprise in this category, and it is worth understanding before you run anything long.

An interactive assistant costs a predictable ~$20/month because you are paying for a seat. An agent costs whatever it consumes, and consumption scales with how confused it gets, not with how much work it completes. A task that goes well is cheap. The same task with an ambiguous spec can cost several times more while producing nothing usable, because the agent keeps re-reading files and retrying.

Three controls that matter, in order:

1. A hard spending cap at the API provider. Not a reminder, a cap. This is the only control that cannot be defeated by a bad run at 2am.
2. Scope per run. An agent given one well-defined job costs less than the same agent given three, because it does not have to hold three sets of context.
3. A test it can grade itself against. An agent that can check its own work stops when it succeeds. One that cannot keeps going until it runs out of budget or patience.

The practical rule: if you cannot describe the success condition in one sentence, the task is not ready for an agent yet. That sentence is also, not coincidentally, what makes the task cheap.

Rolling this out to a team

Individual adoption and team adoption fail differently, and the team failures are more expensive.

Do not standardise on one assistant. Cursor versus Windsurf is close enough that it is genuinely taste, and forcing the losing half of your team onto their second choice buys you consistency nobody asked for. Standardise on the agent instead, where the workflow, the review conventions and the spending controls actually need to match.

Agree the review rule before the first agent PR, not after. The one that holds up: an agent diff gets the same review as a human diff from someone new to the codebase — read it properly, do not skim it because the tests pass. Teams that skip this step discover the cost in a month, in the form of code nobody understands.

Watch for the quiet failure, which is not bad code. It is a developer who stops reading the diffs because the last twenty were fine. That is the point at which the tool starts costing more than it saves, and it shows up as review latency dropping rather than as anything obviously broken.

Which to buy

| Your situation | Buy | |---|---| | You want one tool and you write code daily | Cursor | | Your team is on GitHub and won't change editors | GitHub Copilot | | You have a backlog of boring, well-defined jobs | Claude Code | | You want both and $50/mo is fine | Cursor + Claude Code | | Budget is zero | Cline or Aider + a local model | | Your bottleneck spans research and data, not just code | Manus |

The most common mistake is buying two assistants. Cursor and Windsurf do the same job; Cursor and Claude Code do different ones. If you are going to spend twice, spend across the split rather than within one side of it.

How to test this in an afternoon

Take the last three pull requests you actually shipped. Not toy tasks — the real ones, with their real context and their real awkwardness.

Give the same three to two candidates. Count the corrections you have to type, not the quality of the first answer. Output quality converges between frontier tools; the number of times you have to say "no, not like that" does not, and it is what you will feel every day for a year.

For agents specifically, add one test: give it something slightly under-specified and see what it does. The good ones stop or flag the ambiguity. The expensive ones guess confidently and hand you a clean-looking diff built on the wrong assumption.

The honest summary

One assistant, and one agent if you have a backlog worth clearing. Cursor plus Claude Code is roughly $50/month and covers most of the value in this category. Everything else is either taste (Windsurf), integration convenience (Copilot), or a genuinely different problem (Manus).

For a stack matched to what you are building rather than to a category, describe it in the Stack Planner.

---

Live pricing and every verification figure on this page are read from our catalogue at page load. Tool records are re-verified continuously — see what changed today.