Claude Code Can Now Write the Code That Manages Its Own Army of Agents

Anthropic has introduced dynamic workflows for Claude Code: the assistant writes a JavaScript script for a task, then uses it to coordinate subagents in the same session. Anthropic says those scripts can run tens to hundreds of parallel subagents, check their outputs, and return consolidated results to the main conversation.

The shift isn’t just that Claude Code can spawn helpers. According to Anthropic’s documentation, Claude writes the workflow program on the fly instead of following a fixed, preconfigured agent graph. That program can split a task into independent pieces, launch them in parallel, collect the responses, and decide what goes back for synthesis. Anthropic positions this for work like codebase analysis, audits, and migrations, where many files or components can be examined independently before a final result is put together.

The orchestrator is now model output. Instead of an engineer defining every branch, stage, and handoff in advance, Claude Code can generate a temporary control program for the request. That matters because orchestration logic decides whether parallel agents actually save time. A well-built workflow runs independent searches at once, adds later steps based on earlier findings, and passes back only selected results, so the main model doesn’t have to absorb every intermediate exchange.

Anthropic also says users can ask for smaller models on stages that don’t need the strongest one, and its Opus 5.5 guidance recommends spreading large audits, migrations, and reviews across parallel subagents and then checking the individual results. That suggests a split: a stronger model for planning, integration, and hard judgment, and smaller models for narrow investigations and repeatable checks. Anthropic doesn’t publish a universal recipe for which model fits which task.

The agent count is the headline. The check step is the feature to watch. Parallel investigation can produce a large volume of plausible findings, and volume isn’t reliability. A big audit can yield duplicates, misread local conventions, or false positives that get harder to tell apart once aggregated. A verification stage gives the workflow a place to challenge or filter results before they reach the main session.

What isn’t shown. Anthropic doesn’t publish an error-rate comparison between dynamic workflows and a standard Claude Code session, or evidence that verification catches every faulty subagent conclusion. It establishes that checks can be included, not that they produce a measured reliability gain. The same goes for cost: smaller models can be used for lighter stages, but nothing shows dynamic workflows save money across workloads, and poor task decomposition could create redundant calls and overlapping investigations.

Because the workflow is generated code, it can make consequential decisions about delegation and tool use. Teams trying it should check its boundaries: what it can read, which tools its subagents can call, whether agents can change shared state, and how proposed code changes get independently reviewed. Those are controls you set, not guarantees the feature provides.

Bottom line: Dynamic workflows make Claude Code more programmable in a real way, since it can now produce the short-lived program that coordinates the work, not only the code changes. For jobs that split cleanly, it’s a credible alternative to one assistant working through a codebase serially. The evidence supports calling it programmable delegation with verification hooks, not a self-managing swarm that delivers software on its own.