Free tools Windows power users keep installed
One-click scans. No signup required.
Sub-agents save time or money only when a task splits into genuinely independent pieces, each of which can be handed to a worker with one narrow question and a bounded output. For short jobs, dependent chains, or work that already fits comfortably in one context, a single agent is usually the cheaper and simpler choice. Vendor measurements show both large gains and clear losses, so the dependable test is to compare the full multi-agent run, including planning, duplicated context, retries and synthesis, against a single-agent baseline on your own tasks.
When should I use sub-agents?
Use a coordinator with workers when three conditions hold together: the pieces are independent of one another, each piece can be described in a few sentences, and each worker’s output is small compared with the material it has to read. OpenAI’s multi-agent guide for the Agents API draws the same line: “Use subagents for independent tasks, such as reviewing separate documents or investigating different causes of a failure.” The same guide adds: “Keep short tasks and dependent steps in the main agent.” (OpenAI, Agents API multi-agent guide)
As an Amazon Associate I earn from qualifying purchases.
Anthropic’s cost guidance is blunter about when not to build an orchestrator: “If the work is one chain, fits in one context without a long cost tail, or a single model at lower effort already meets your bar, don’t build an orchestrator.” (Anthropic, Claude platform cost-and-intelligence guidance)
Recommended Free Tools
In practice, that reduces to a short set of decisions:
#1 Best Overall
- Delegate when you can name several independent questions, such as reviewing separate modules, testing separate failure hypotheses, or auditing separate dependency manifests.
- Stay single-agent when the task is a short sequence, such as changing one function and running its tests.
- Stay single-agent when each step needs the output of the previous one, such as a design, then an implementation built on that design, then a migration that depends on the implementation.
- Stay single-agent when the whole input fits comfortably in one context and no worker would need to re-read the same material.
- Consider partitioning when the input is larger than one context, because splitting the material can reduce repeated reading or make parallel work possible.
Where the extra cost comes from
Anthropic reports, from its own observed data, that “agents typically use about 4× more tokens than chat interactions, and multi-agent systems use about 15× more tokens than chats.” (Anthropic engineering article, approximately 2025; exact publication date not confirmed) The same article says these economics only make sense for tasks valuable enough to justify the performance gain. Treat the multiplier as a starting point for your own budget, not a constant: it describes one vendor’s traffic, and your overhead will depend on how much context each worker must load.
The overhead comes from places a single-agent budget does not include:
| Cost component | Where it appears | What to measure |
|---|---|---|
| Coordinator planning | Breaking the task down, writing each worker’s brief, and deciding what to delegate | Tokens spent before the first worker starts |
| Worker context | Each worker’s instructions, tool definitions and the material it reads; shared material is loaded once per worker | Input tokens per worker, and how much of it repeats across workers |
| Tool calls | Searches, file reads, test runs and API calls made by each worker | Calls per worker compared with the single-agent run |
| Retries | Workers that return incomplete or wrong output and need another pass | Share of worker tasks that had to be rerun |
| Synthesis | The coordinator reading worker outputs, resolving conflicts and checking integration | Tokens and time from the last worker finishing to a final answer |
| Human review | Checking the merged result; delegation does not remove this step | Review time compared with the single-agent baseline |
Do AI agents save time or money when coding?
Sometimes, but the published evidence does not yet give a general answer for coding work. The figures below come from vendor-run tests on research tasks, a large document corpus, a web-browsing benchmark slice and one same-model timing test. No independent, cross-provider study of coding cost savings was established as of October 2026, so read each row as an attributed vendor result.
Rank #2
| Vendor test (source and date label) | Configuration | Reported result | Qualification stated by the source |
|---|---|---|---|
| Internal multi-agent research system evaluation (Anthropic engineering article, approximately 2025; exact date not confirmed) | Claude Opus 4 lead with Claude Sonnet 4 subagents, compared with single-agent Claude Opus 4 | 90.2% improvement | Internal evaluation of a research workload, not a coding productivity guarantee |
| Corpus benchmark, elapsed time (Anthropic platform documentation, 2026; exact date not shown) | 25-worker coordinator compared with a solo run; models not stated on the cited page | About 2.3 hours, compared with 15–20 hours solo | Vendor’s 21.6-million-token corpus benchmark, far larger than ordinary engineering tickets |
| Corpus benchmark, cost and score (Anthropic platform documentation, 2026; exact date not shown) | One Claude Fable 5.1 lead with 25 Claude Sonnet 5 workers, compared with the solo configuration described | 47%–55% lower cost; scores 10–12 points below the solo configuration | Quality tradeoff is material; the same benchmark |
| DRACO test (Anthropic platform documentation, 2026; exact date not shown) | Same-model agents given time instructions and an elapsed-time clock | 33% less elapsed time and 54% lower cost per task; score 1.5 points lower | Clock not measured with lower-cost workers; coordinator-only clock visibility not tested |
| BrowseComp slice (Anthropic platform documentation, 2026; exact date not shown) | Claude Fable 5 coordinator with one Claude Sonnet 5 worker, compared with solo runs on 10 problems | About half the average cost; 90th-percentile cost $12 versus $33; the costliest solo run cited was $84 and was wrong | Deliberately easy 10-problem slice; not representative of harder traffic |
Each vendor result pairs a savings figure with a condition: a quality drop, a limit on what the clock measured, or an easy sample. None of them is a measured coding outcome. The useful translation for your own work is to ask what the same split would cost if the baseline were a cheaper single-agent setup, and whether the quality difference is one your team would accept.
How do I orchestrate multiple agents?
The working pattern has five steps. Each one is a place where a multi-agent run can go wrong, so the order matters.
1. Classify the task
Before writing any prompt, list the work packages, the dependencies between them, the files each one touches, and whether the total input exceeds one practical context window. If the list collapses into a single sequence, keep the work serial and stop here.
Rank #3
2. Write a task contract for each worker
Each worker should receive one question or deliverable, only the context and tools it needs, and a concise statement of the output you expect. Anthropic’s Managed Agents documentation describes specialization as the lever here: a specialist’s narrower prompt and tool set define what it has to load and which actions it can take. (Anthropic, Managed Agents multi-agent orchestration) A contract should state:
- Question or deliverable: one sentence describing what the worker must answer or produce.
- Scope: the files, directories, sources or tools it may use.
- Output: a fixed format and rough length, such as a list of file paths with a one-line finding for each.
- Done condition: what counts as complete, and what to return if the worker cannot finish.
Avoid sending the same broad prompt to every worker unless diversity of approach is the goal. Identical briefs usually duplicate reading without adding coverage.
3. Set concurrency and stop conditions
Choose a concurrency ceiling before you launch, and define when each worker stops: a time limit, a tool-call budget, or a found-answer condition. Coordinate any workers that touch shared files, since parallel edits to the same file are the usual source of conflicting changes. Platform defaults for concurrency differ, and beta and API settings change, so check the current OpenAI Responses multi-agent documentation at https://developers.openai.com/api/docs/guides/responses-multi-agent rather than copying a number from an older example.
Rank #4
4. Synthesize and verify
The coordinator resolves conflicts between worker outputs, checks the evidence and integration, and returns one result. Parallel outputs are not a finished answer. The tests and human review a single-agent change would need still apply to the merged result.
5. Measure the whole run
Compare the orchestrated run against a single-agent baseline on representative tasks, and count everything: coordinator planning, duplicated worker context, tool calls, retries, synthesis, and integration effort. These measurement steps are practical recommendations inferred from the documented orchestration and cost mechanisms; no published universal formula exists for them.
Do these 3 things before closing this tab:
1Fix the driver behind crashes, sound loss and screen glitches2Clear out junk files and repair common Windows errors3Scan for outdated or missing drivers - takes under a minuteHow do I keep multi-agent workflows from wasting tokens?
Most waste comes from a short list of patterns. Check for these symptoms first:
- Workers re-reading the same material. Give each worker only the files and sections its question needs, or have the coordinator extract the relevant excerpt once and pass it along.
- A coordinator that reprints everything. Ask workers for compact outputs in a fixed format, so the synthesis step reads summaries rather than full transcripts.
- Parallel edits to shared files. Assign file ownership to one worker, or serialize those steps. Resolving conflicts after the fact usually costs more than preventing them.
- Retry loops. Set a retry budget per worker, and escalate to the coordinator or a person once it is spent, rather than letting failed workers rerun indefinitely.
- Parallelism that does not shorten the run. If the tasks form a dependency chain, extra workers add overhead without reducing elapsed time, because concurrency cannot shorten a chain.
- Savings measured against the wrong baseline. A comparison against an expensive single model at high effort may not hold against a cheaper single-agent setup at lower effort.
Platforms to check before you build
Two vendor platforms implement this pattern directly. OpenAI’s Agents API overview describes managed sessions, orchestration, context compaction, recovery, and sub-agent delegation. Anthropic’s Managed Agents documentation describes a coordinator and worker pattern in which agent contexts are isolated from one another. Availability, model choices, and pricing change over time, so confirm them on the official pages before you budget a workflow around any of these features.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
