Glossary
Subagent
A subagent is a helper handed one narrow piece of a larger job, so that piece can be worked on with only the material it needs rather than everything gathered so far.
In plain terms
A helper sent off with one specific errand. It gets told what is needed, works on that alone, and comes back with a result. The rest of the job carries on without holding everything the helper looked at, which is the whole reason for doing it this way.
Why it matters
Because the constraint being worked around is attention rather than ability. A long job accumulates material, and everything accumulated is carried forward and paid for on every subsequent step. Sending a piece elsewhere keeps that accumulation off the main thread, which is a cost decision as much as a quality one.
How it works
The helper starts with only what its errand requires. That is the point: it is not carrying the history of everything else, so its attention is on a smaller and more relevant set of material. Where a job involves reading a great deal to extract a little, this is the difference between the main thread carrying all of it and carrying the little.
Only the result comes back, which is both the saving and the loss. What returns is a summary or an answer rather than everything the helper saw, so the main thread stays manageable. It also means anything the helper noticed and did not think worth reporting is gone, and nothing downstream knows it existed.
Several can run at once, which is where the time saving is claimed. One editor in this guide describes parallel helpers splitting a task, with the plan reviewable before anything is built. Running in parallel does not reduce the total work or the total bill; it reduces how long you wait for it.
It is a delegation rather than an arrangement, which is the distinction from a standing multi-part system. The helper exists for the errand and then it is over. Nothing has to coordinate it afterwards, nobody has to decide what happens when two of them disagree, and there is no ongoing structure to maintain.
What crosses back, and what does not
Seen in the wild
An editor whose agent layer splits a task across parallel helpers, with the plan reviewable before builds and cloud work returning asynchronously.
CursorA framework where roles, goals and tools are defined per participant, which is the same delegation expressed as a standing structure instead.
CrewAIA terminal-native tool where parallel sessions work separate tasks, which is the same idea applied at the level of whole briefs.
Claude Code
Common misconceptions
People assume
It makes the work cheaper.
In fact
It changes where the cost sits rather than removing it. The helper runs its own cycle and bills for it, and what is saved is the main thread carrying that material forward on every later step. On a long job that saving is real; on a short one the extra cycle is simply an extra cycle.
People assume
The main thread knows what the helper knew.
In fact
It knows what came back, which is a summary of a judgement somebody else made about relevance. Anything the helper saw and did not report is unavailable, and nothing downstream can tell the difference between a thing that was not there and a thing that was not mentioned.
Telling them apart
Subagent vs Multi agent system
Subagent
A delegation inside one piece of work, over when the errand is done.
A standing arrangement with responsibilities and coordination.
One ends; the other has to be maintained. That is the difference between a helper and an organisation.
Questions
- What is the actual benefit?
- Keeping accumulated material off the main thread. A job that reads a great deal to extract a little would otherwise carry all of it forward on every subsequent step, and pay for it each time. Sending the reading elsewhere and receiving only the extract is what that buys.
- What gets lost at the handover?
- Everything the helper saw and did not report. What returns is filtered by a judgement about what mattered, made without the wider picture. That is usually acceptable and it is worth knowing, because the main thread cannot distinguish absent from unmentioned.
- Is running several at once faster?
- In elapsed time, yes; in total work and total cost, no. Parallel helpers each run their own cycle and each bill for it. What is compressed is the waiting, which is genuinely valuable and is a different claim from the work being smaller.
Key takeaways
- A helper handed one errand, starting with only what that errand needs.
- The benefit is attention and accumulated cost, not capability.
- Only the result returns, so anything unreported is gone.
- Parallel helpers compress elapsed time, never total work or total bill.
- A delegation that ends, rather than an arrangement to maintain.
Tools that use this
- Cursor
Parallel helpers splitting a task, with plans reviewable first.
- CrewAI
Roles, goals and tools per participant, as a standing structure.
- Claude Code
Parallel sessions working separate tasks from separate briefs.
Last checked July 2026