Anthropic is turning Claude Code into something that looks a lot less like “just an AI in your editor” and a lot more like a small engineering team you can spin up on demand. With its new dynamic workflows feature, Claude doesn’t just respond to prompts anymore – it writes its own orchestration scripts, spins up tens to hundreds of parallel subagents, argues with itself, and only then shows you the result.

If that sounds like a mouthful, it’s because this is one of the clearest steps yet toward genuinely agentic coding tools – systems that can plan, coordinate, and execute complex work over hours or days, not just autocomplete your next line.

Anthropic’s new idea: let Claude be the conductor, not just the soloist

At the heart of dynamic workflows is a simple shift in responsibility: instead of you painstakingly orchestrating a multi-step process (“scan this repo, list risky endpoints, propose fixes, apply them, run tests, summarize diffs”), Claude now writes the orchestration layer itself as a JavaScript script. That script decides how to break the work apart, how many subagents to spawn, what each one should do, how they should talk to each other, and when to stop.

In practice, triggering a workflow doesn’t feel particularly exotic. Ask Claude Code to “create a workflow” in auto mode, or flip on the new ultracode effort setting, and it quietly switches from “chat mode” to “orchestra mode.” Under the hood, instead of drafting a single linear answer, Claude generates an orchestration script, fans work out across parallel agents, and starts iterating toward a result.

Anthropic says these workflows are built for the kind of projects you normally roadmap in quarters: company-wide bug hunts, large-scale refactors, language migrations, or safety reviews that touch hundreds of files. Those are classic “too big for one pass” problems where a single agent’s answer is more likely to miss edge cases, regressions, or subtle architectural constraints. Dynamic workflows push those tasks into a script-driven, multi-agent run that can extend over hours or days, resuming from checkpoints if something gets interrupted.

How dynamic workflows actually work behind the scenes

Anthropic’s own docs describe the system in a way that’s remarkably concrete for a marketing page. When a workflow kicks off, Claude:

• Reads your prompt and builds a high-level plan, tailored to your specific codebase and request.
• Breaks that plan into subtasks and distributes them to specialized subagents running in parallel – tens to hundreds of them for big jobs.
• Has some agents try to solve the problem while others try to refute or stress-test those solutions, iterating until the answers converge.
• Checks and consolidates the results before returning a single, coordinated answer back to you.

The orchestration script acts as the loop that holds everything together: it encodes branching logic, loops, intermediate variables, and which agents do what. Instead of jamming a giant plan and all intermediate output into one chat history, the plan lives outside the conversation, and agents fetch context or tools as needed. That design matters, because Anthropic has been writing for a while about “context pollution” – the tendency for long-running chats to accumulate noise and stale information that make agents less reliable over time.

Dynamic workflows lean on techniques Anthropic has discussed before: subagent architectures, structured note-taking, and “just-in-time” context loading. Rather than one model trying to remember everything about your repo and every decision so far, specialized agents handle focused tasks with clean context windows, while the orchestration script and external notes track the big picture. It’s closer to how an engineering manager coordinates a team than how a single developer works in their own head.

The adversarial angle is arguably the most interesting part. Anthropic describes workflows where one set of agents proposes changes while another set tries to break them, refute assumptions, or surface hidden risks. The run keeps iterating until those agents essentially run out of new objections, which is when the system decides it has converged on a robust answer. For high-stakes work – say, security-sensitive services or compliance-heavy systems – that built-in back-and-forth is a lot closer to a real code review process than “LLM says it’s fine, ship it.”

From “AI pair programmer” to project-level co-owner

Dynamic workflows land at an interesting moment in the evolution of AI coding tools. GitHub Copilot, OpenAI’s GPT-powered coding experiences, and earlier iterations of Claude Code mostly behaved like enhanced autocomplete plus a chat window: extremely useful, but largely reactive and confined to a single “pass” at a problem. You still had to act as planner, coordinator, reviewer, and project manager.

Anthropic is explicitly going after a different layer of abstraction: let the AI actually run the project. With workflows, Claude can:

• Map out a system architecture across a large repo before touching anything.
• Plan migrations or refactors, assign different parts to different subagents, and track progress.
• Apply changes in a scoped, staged way, running checks and tests as it goes.
• Save progress as checkpoints, so a multi-hour or multi-day run can be paused and resumed without losing work.

The company’s messaging is bold: “work you’d normally plan in quarters now finishes in days.” That might sound like classic AI hype, but it does line up with the direction a lot of power users have already been heading in manually – cobbling together scripts, agents, and prompt engineering tricks to get LLMs to handle broader project scopes.

The difference here is that Anthropic is baking that orchestration into the product itself. You don’t have to design a multi-agent system from scratch; you signal intent (via prompts or the ultracode setting), and Claude decides when to escalate into a workflow, how many agents to spin up, and when to stop. For most working developers, that abstraction level is the only practical one: the alternative is spending more time building your agent framework than shipping features.

Where you can actually use this

Dynamic workflows are launching in research preview, and Anthropic is seeding them pretty widely across the Claude ecosystem. If you’re on Claude Code Max or Team, they’re on by default in the CLI, desktop app, and VS Code extension; you can just ask Claude to “create a workflow” or enable ultracode in the effort menu. For Enterprise plans, admins have to opt in, which makes sense given the governance and safety questions that come with letting an AI orchestrate large-scale changes in production-sized codebases.

On the platform side, workflows are also exposed through the Claude API and are available via Amazon Bedrock, Google Cloud’s Vertex AI, and Microsoft’s Foundry program. That means teams building custom developer tools, CI/CD pipelines, or internal platforms can tap directly into workflow capabilities without forcing everyone into a specific editor. A lot of the agentic coding work is actually happening in backends and devops automation, not just in IDEs, so this broader availability matters.

Anthropic frames the feature as “research preview,” which is doing a lot of work here. It’s a clear nod that while the core architecture is in place, the company is still gathering data about where workflows shine, where they overreach, and what the right defaults should be for different kinds of organizations. If you’re imagining hitting “run” and letting Claude rewrite your entire monolith unsupervised, Anthropic would almost certainly prefer you treat this as a power tool, not a magic button.

Why this matters for the broader AI coding race

From a competitive standpoint, dynamic workflows are Anthropic’s answer to a question that’s been hanging over the AI coding space: can these tools move beyond suggestions and into ownership of complex tasks? OpenAI, Google, and others have been talking up “agents” for months, but much of what’s shipped so far has been loosely coupled tools layered on top of chat. Anthropic, by contrast, is shipping a very explicit orchestration model: a script, a swarm of subagents, and a convergence loop built for long-running work.

There’s also a clear throughline from Anthropic’s earlier writing on “effective context engineering” and multi-agent architectures to what we’re seeing now. The company has been fairly transparent about the limits of giant context windows and monolithic agents; workflows look like the productization of those ideas. Instead of just giving Claude more tokens, Anthropic is restructuring how work gets split and recombined, which may matter more for reliability than raw scale.

For developers and engineering leaders, the implications fall into a few buckets:

• Productivity and scope: if workflows work as advertised, they could make the idea of “one engineer plus one AI” handling what used to require small teams more realistic, especially for maintenance, migrations, and systematic cleanups.
• Process and trust: a system that debates itself before shipping changes sounds reassuring, but it also introduces new black boxes – you may need new observability and review patterns for AI-led runs.
• Skills and expectations: using workflows effectively will likely become a skill of its own, somewhere between prompt design and project management. Knowing when a task warrants a workflow, and how to phrase that intent, will matter.

The risks and unanswered questions

For all the excitement, dynamic workflows also raise some uncomfortable questions that the launch materials don’t fully answer. When an orchestration script decides to fan changes across hundreds of files, who is ultimately accountable if something subtle breaks in production? How do teams diff not just the code output, but the reasoning process and the adversarial back-and-forth that led there?

Anthropic’s emphasis on checkpoints and resumable runs hints at one way forward: treat AI-led workflows as first-class citizens in your tooling, with logs, audit trails, and rollback strategies just like human-led operations. But that will require real work in the ecosystem – better integration with version control, testing frameworks, monitoring, and incident response. The company’s decision to frame this as research preview and give Enterprise admins explicit control suggests it’s well aware that technical capability and organizational readiness are two very different things.

There’s also the question of cost. Running tens or hundreds of agents in parallel on a large context window is not cheap, even if it’s faster in wall-clock time than traditional processes. Anthropic’s documentation talks about effort levels and settings like ultracode that give Claude more freedom to spin up workflows, but teams will likely need guardrails to avoid turning every medium-size task into a sprawling multi-agent run.

A step toward “teams in a box”

Viewed in the broader arc of 2026 AI tooling, dynamic workflows feel like an early, opinionated answer to an increasingly common question: what does it look like when AI doesn’t just help with code, but actually runs the project? Anthropic’s answer is to lean on orchestration scripts, parallel subagents, adversarial checking, and long-running, resumable runs – all largely hidden behind a fairly simple developer experience.

Whether this becomes the dominant pattern or just one notable experiment will depend on how it performs in real-world codebases over the coming months. But it’s hard to shake the sense that we’re watching the early shape of “AI teams” emerge: not as a marketing term, but as a technical reality where your editor can quietly spin up a roomful of specialists, argue with itself for a while, and hand you back a plan – and a patch – that would’ve taken a human team weeks.