Claude Can Now Run Up to 1000 Subagents and Find 66 of 70 Bugs

Anthropic is adding dynamic workflows to Claude Managed Agents. A lead agent can now distribute tasks among subagents, and up to 1000 of them can run at the same time. The headline number of the release comes from a test on a codebase with 70 pre-planted bugs. A single agent found no more than 27 of them, while the multi-agent workflow consistently reached 66. That is roughly 94% versus 39%.

How it works

The setup has two levels. The lead agent analyzes the task, decides how to split it up, and sends the pieces to subagents. They work in parallel, and the results flow back to the lead. Judging by the name, the developer does not define the workflow structure in advance; it is built as the task unfolds. That sets the approach apart from rigid pipelines, where the number and order of steps are known before launch.

The feature is part of Claude Managed Agents, a managed platform for agents. Anthropic, apparently, handles the infrastructure for launching and coordinating agents, rather than the team writing its own orchestrator.

Key parameters from the announcement:

• upper limit: 1000 subagents running at the same time;
• role of the lead: decomposing the task and handing out subtasks;
• test task: finding 70 hidden bugs in a codebase;
• single agent: a maximum of 27 bugs found (about 39%);
• multi-agent workflow: consistently 66 (about 94%);
• gap: 2.4 times in the number of bugs found.

What the test showed

The word "consistently" matters. If the multi-agent setup had won once, that could be written off as a lucky run. Here the result repeated, while even the best run of the single agent stayed at 27.

Why parallelism helps specifically with bug hunting can be explained without magic. A large codebase does not fit entirely into one agent's working attention. It scans some of the files, draws conclusions, and drifts off course. When each subagent gets a narrow slice and is responsible only for that, coverage grows. The four bugs missed out of 70 show that there is still a ceiling.

The caveats are obvious. This is a single test, and the company set it up itself. The material from The Decoder has no data on the cost of such a run, on execution time, or on the number of false positives. For bug hunting, the last metric is critical: 66 found issues are worth little if another 200 invented ones come attached. It is also not disclosed how well the result carries over to other tasks.

How to approach adoption

You should not start with a thousand agents. It makes more sense to pick a task that naturally splits into independent pieces and compare a single-agent run with a multi-agent one on your own data.

Suitable candidates include repository audits, vulnerability searches, per-module test generation, checking a migration to a new library version, and processing a large set of documents. Tasks where steps depend tightly on one another are a poorer fit: parallelism will give almost nothing there.

Before scaling up, measure three things: the cost per confirmed bug, the share of false findings, and the time to a finished report. On top of that, you need a budget and a cap on the number of subagents, or the bill will arrive before the result does. It is better to leave the final verification of findings to a human or a separate verifier agent rather than take the lead's report on faith.