What does it actually change for a team?

The unit of work. Instead of writing a change, somebody describes it and later judges what came back. That suits well-specified jobs such as migrations, dependency upgrades and repetitive fixes, and suits exploratory work considerably less, because exploration is exactly the case where the brief cannot be written in advance.

Is it suitable for someone learning to code?

Generally not as a first tool, and the vendors say so. An agent expects a brief and returns work to be judged, which assumes you can judge it. Assisted editors are the gentler shape, because they keep the person in the writing rather than in the reviewing.

Usually by consumption rather than by seat, so the bill follows how much is delegated. That inverts the familiar arithmetic: with a per-person tool the cost is known and the usage is free, and here the usage is the cost, which means a vague brief is not merely unproductive but billable.

Can several run at once?

On the shapes that work in their own environment, yes, and that is where the leverage is claimed to compound. The limit is rarely the tool. Parallel sessions produce parallel results, all of which need reading by the same people, so review capacity becomes the constraint quite quickly.

Does it have to be a paid product?

No, and assuming otherwise distorts the comparison. Open-source agents run on your own machine, work with hosted or local models, and cost nothing for the software itself, so the only bill is the model usage drawn through your own keys. What you take on instead is running it, which is the same trade that applies anywhere else you self-host.

Where should it not be pointed?

At anything shipping without a human pass, and the vendors are unusually consistent about this. Payments, authentication and regulated data flows are the areas they name, not because the code is likely to be worse there but because that is where being wrong stops being recoverable.

Glossary

Coding agent

A coding agent works across a codebase over many steps, reading files, making changes and running things to check them, rather than completing a line at a time in an editor.

In plain terms

Autocomplete finishes the line you are typing. This is handed a job and goes away to do it: opening files, working out what needs changing, changing it, running the tests and coming back with the result. The difference is not how clever it is. It is that one helps while you work and the other works while you do something else.

Why it matters

Because the change is to how a team spends its attention rather than to how fast anybody types. Assisted editing makes an hour of coding more productive. Delegation replaces the hour with a brief and a review, which is a different activity with a different skill attached, and organisations that buy the second while measuring the first are consistently disappointed by both.

How it works

It runs in a loop rather than answering once. Read something, decide what to do, do it, look at what happened, decide again. That structure is what lets it handle a job whose shape is not known in advance, and it is why the same tool can take a minute on one task and a great deal longer on another with no obvious difference between them.

Access to the codebase is what makes it more than a chat window. It can open the files that matter, follow how something is used across a project, and see the error that came back from a command it ran. An assistant told about your code is guessing from a description; one that can read it is working from the thing itself.

Running commands is the second half, and the one that changes the risk. Executing tests turns a suggestion into something checked, which is genuinely valuable, and it also means the tool is doing things rather than proposing them. Products differ considerably in what they will run unattended and in what they ask about first.

Where it runs varies and that decides a lot about how it fits. Some live in the terminal, some inside an editor, some in an isolated environment somewhere else entirely, taking a brief and returning a pull request. The last shape supports several tasks in parallel, which is where the leverage compounds and also where a team can generate more review than it can absorb.

The work moves to specification and review, and neither is free. A vague brief produces confident work in the wrong direction, and the vendors say so plainly: one describes vague tasks as expensive lessons under compute-unit billing. What was an hour of writing becomes fifteen minutes of describing and a quantity of reading that nobody scheduled.

Cost tracks delegation rather than seats, which is a different budgeting shape from the tools it displaces. Metered access means the bill follows how much you hand over, so a team that delegates more pays more, and a team experimenting with vague briefs pays for the experiments. Assisted editors were a fixed per-person cost and this is not.

Not all of them are metered vendor products, which is worth knowing before the economics are treated as fixed. An open-source agent running on your own machine can be model-agnostic and cost nothing itself, with the only bill being the model usage it draws through your own keys. That separates the two costs that are usually quoted as one, and it moves the choice of model from a vendor decision to yours.

The review boundary is where every vendor draws a line, and they draw it in the same place. Agent-written code needs a human pass before it ships, and the caveat sharpens around payments, authentication and regulated data. That is not a caution about capability; it is a statement about where accountability sits, and it does not move as the tools improve.

Assisted and delegated, which are bought as though they were the same

Holding these apart explains most of the disappointment in this category. A team adopts an agent on the strength of demonstrations that look like very good autocomplete, measures the result in the way it measured autocomplete, and concludes the tool is roughly as good as what it had. What has actually changed is the shape of the work: the person who used to write the change now writes a description of it and then reads what came back, which is a different activity requiring different skill, and it is one that gets slower as more is delegated rather than faster. The compounding constraint is review. An agent can produce more work than a reviewer can absorb, and unlike the tool the reviewer does not scale by opening another session. The teams that report the clearest gains are the ones that noticed this early and treated review capacity as the thing to plan around, rather than as an overhead that would shrink once everybody got used to it.

Seen in the wild

A terminal-native agent pointed at a repository, planning multi-file changes, running commands and tests, and delivering edits at refactor and migration scale.
Claude Code
An agent handed a scoped task that works in its own environment and opens the pull request, with parallel sessions running several tasks at once.
Devin Cloud
An editor rebuilt around models, where you slide between manual coding, assisted edits and delegated tasks without changing tools.
Cursor
A free, open-source agent that runs on your own machine and is model-agnostic, where the software costs nothing and you pay only for the model usage it draws.
OpenClaw

Common misconceptions

People assume

It is autocomplete with a bigger context window.

In fact

The difference is the loop and the permissions, not the size of the window. Autocomplete proposes and you accept. An agent decides, acts, reads what happened and decides again, and it can run things. Those are different products with different risks, and comparing them on suggestion quality misses what actually changed.

People assume

It removes the need for review.

In fact

It moves the review and makes there be more of it. Every vendor in this category says the same thing, that agent-written work needs a human pass before shipping, with the caveat sharpened around payments, authentication and regulated data. A team that delegates more without adding review capacity has built a queue, not a speed-up.

People assume

The value is measured in code written.

In fact

Code is the cheap part and always was. What an agent changes is who holds the problem: a brief goes out, work comes back, and somebody has to judge it. Teams that measure lines or pull requests reliably conclude the tool is working while the review backlog says otherwise.

Telling them apart

Coding agent vs AI assistant

Coding agent

Given a job, works across many steps, acts on the codebase.

AI assistant

Answers a question or drafts a passage when asked.

One works while you do something else; the other works while you work. That decides the skill you need and where the cost lands.

Questions

What does it actually change for a team?: The unit of work. Instead of writing a change, somebody describes it and later judges what came back. That suits well-specified jobs such as migrations, dependency upgrades and repetitive fixes, and suits exploratory work considerably less, because exploration is exactly the case where the brief cannot be written in advance.
Is it suitable for someone learning to code?: Generally not as a first tool, and the vendors say so. An agent expects a brief and returns work to be judged, which assumes you can judge it. Assisted editors are the gentler shape, because they keep the person in the writing rather than in the reviewing.
How is it charged?: Usually by consumption rather than by seat, so the bill follows how much is delegated. That inverts the familiar arithmetic: with a per-person tool the cost is known and the usage is free, and here the usage is the cost, which means a vague brief is not merely unproductive but billable.
Can several run at once?: On the shapes that work in their own environment, yes, and that is where the leverage is claimed to compound. The limit is rarely the tool. Parallel sessions produce parallel results, all of which need reading by the same people, so review capacity becomes the constraint quite quickly.
Does it have to be a paid product?: No, and assuming otherwise distorts the comparison. Open-source agents run on your own machine, work with hosted or local models, and cost nothing for the software itself, so the only bill is the model usage drawn through your own keys. What you take on instead is running it, which is the same trade that applies anywhere else you self-host.
Where should it not be pointed?: At anything shipping without a human pass, and the vendors are unusually consistent about this. Payments, authentication and regulated data flows are the areas they name, not because the code is likely to be worse there but because that is where being wrong stops being recoverable.

Key takeaways

The loop and the permissions are the difference, not the size of the context window.
Reading the codebase and running commands is what separates it from an assistant.
Work moves to specification and review, and review capacity becomes the constraint.
Charged by delegation rather than by seat, so a vague brief is billable.
Every vendor draws the review line in the same place, and it does not move.

Tools that use this

Claude Code
Terminal-native, reads the repository, runs commands and tests.
Devin Cloud
Works in its own environment and opens the pull request.
Cursor
An editor where assisted edits and delegated tasks sit together.
OpenAI Codex
Delegated cloud tasks running in parallel, returning finished work.
OpenClaw
Open source and model-agnostic, so only the model usage is billed.