Conductor, CC Mirror, and Codex add Claude-style Dynamic Workflows

• Anthropic framed Dynamic Workflows as a research-preview Claude Code feature where Claude writes an orchestration script, fans work across tens to hundreds of subagents, and verifies results before returning them, according to ClaudeDevs' launch post and _catwu's product thread.
• Within a day, daniel_mac8's Codex port, charlieholtz's Conductor rollout, and nummanali's CC Mirror demo all treated the feature less like a proprietary magic trick and more like a reusable orchestration pattern.
• The portable core is simple: as daniel_mac8 put it, you write a workflow script, split work into sub-agent packets, synthesize results, and loop until verification passes.
• Anthropic's own team and outside users kept the same warning attached to the launch: sidbid's usage note said workflows get expensive because of all the parallel agents, and koltregaskes' docs link pointed readers to the official workflow docs.

You can read Anthropic's launch post, skim the new workflow docs, and inspect the Codex skill repo. The weirdly fast part is how quickly the idea escaped its original runtime: nummanali's video shows the UX running against GLM 5.1, charlieholtz's demo packages a similar stack as Ultracode in Conductor, and swyx's quote-tweet latched onto Anthropic's claim that instructions can be updated mid-task without breaking prompt cache.

Anthropic shipped Dynamic Workflows as a Claude Code research preview on May 28. ClaudeDevs' announcement described an agent that writes its own orchestration script, then coordinates a large background fleet inside one session.

The official rollout added a few concrete usage details that matter more than the marketing phrase. ClaudeDevs' availability post said the feature was live on Max, Team, Enterprise, and the API, while ClaudeCodeLog's changelog said users can inspect runs with /workflows and that the same release paired the feature with Opus 4.8 support and higher-effort defaults for hard tasks.

Anthropic also kept pointing at bulk, multi-stage work rather than one-shot coding prompts. In the blog post, the examples range from repo-wide bug hunts to migrations touching hundreds of files, and _catwu's example post claimed Jarred Sumner used the system to help port Bun from Zig to Rust across roughly 750,000 lines.

The most useful outside reaction came from people who immediately decomposed the feature into steps. daniel_mac8's thread flattened Dynamic Workflows into a four-part pattern that could be transplanted into other tools.

That pattern is:

1. Write a workflow script.
2. Split the task into packets for sub-agents.
3. Synthesize the sub-agent outputs.
4. Run a goal loop until verification says the task is complete.

The accompanying GitHub repo, linked in daniel_mac8's follow-up, packages that logic as a free Codex-installable skill. Daniel's key caveat is also the cleanest definition of what Anthropic still uniquely provides: the orchestration layer ports easily, but Claude Code's execution runtime does not come along for free.

Jason Zhou's thread reached the same conclusion from a different angle. jasonzhou1993's breakdown argued that subagents and agent teams solve per-task context limits, while workflow scripts handle large batched jobs with multi-stage ordering, closer to on-demand DAG generation than a fixed LangGraph pipeline.

Once you look at the feature as orchestration plus runtime, the rapid ports make sense. daniel_mac8 moved the pattern into Codex, charlieholtz rolled out Ultracode inside Conductor, and nummanali updated CC Mirror so the same UX could run against GLM 5.1.

The three implementations already diverge in what they preserve from Anthropic's original stack:

• Codex keeps the planning pattern, but daniel_mac8 says it still lacks Claude Code's execution runtime.
• Conductor combines x-high effort with dynamic orchestration, according to charlieholtz's rollout.
• CC Mirror keeps the workflow UX while swapping in a different model backend, with nummanali's demo explicitly showing GLM 5.1.

That is a fast leak of abstraction boundaries. Anthropic shipped a product feature, but the market response treated it like a harness recipe.

The ports also surfaced the part that is harder to clone: reliable large-scale execution. Anthropic's own posts kept stressing background coordination, verification, and auto mode, with mikeyk's note saying the feature works best there and _catwu's launch post describing runs across hundreds of subagents.

Cost showed up almost immediately as the practical limit. sidbid warned that workflows can get expensive because parallel agents pile up token usage, koltregaskes said the feature will chew through tokens, and nummanali called the original UX expensive enough that model portability mattered once Opus 4.8 entered the picture.

The same release notes hint at why runtime quality is part of the product, not just the prompt. ClaudeCodeLog's changelog lists fixes for stuck background sessions, subagents bypassing worktree isolation, pinned sessions respawning, and workflow UI glitches. Those are not orchestration-theory problems. They are the messy systems problems that appear when you try to run lots of agents in parallel inside a real coding tool.

Anthropic's own examples suggest the company had been using the feature internally before the public preview. sidbid's thread opener said the team built it months earlier and that it had become a daily driver for a bunch of people at Anthropic.

The early use cases skew toward long, boring inventory work that benefits from parallelism more than cleverness:

• _catwu said Dynamic Workflows processed hundreds of A/B test flags in under 10 minutes to find stale 0 percent and 100 percent rollouts.
• mikeyk said he had used it for full codebase migrations and other complex projects.
• jasonzhou1993's thread opener highlighted lead qualification, SEO audits, and invoice processing as the kind of batch jobs that were previously painful for single-agent runs.

That usage mix is probably the clearest signal from the launch. The first wave of copies did not imitate Claude Code's model. They imitated its way of turning bulk work into a scripted packetized loop.