Now Claude Code has workflows too. Here's how Forge's are different.

On May 28, 2026, Anthropic shipped Dynamic Workflows in Claude Code as a research preview, alongside Opus 4.8. Say “create a workflow” (or turn on ultracode) and Claude “dynamically writes orchestration scripts that run tens to hundreds of parallel subagents in a single session” — with a built-in adversarial check where “other agents try to refute what they found, and the run keeps iterating until the answers converge.”

It’s very good. We know, because we used it to research this post — fanning agents out across Anthropic’s writing, the docs, and the wider discourse, then having them refute each other before we wrote a word.

So the lazy version of this article — “Claude Code can’t do workflows, Forge can” — is dead on arrival. Claude Code does workflows now. The interesting question is which kind. Because there are two very different things hiding under the same word, and the difference is the whole reason Forge exists.

Two things called “workflow”

Back in Building Effective Agents (Dec 2024), Anthropic drew the canonical line:

• Workflows — “systems where LLMs and tools are orchestrated through predefined code paths.”
• Agents — “systems where LLMs dynamically direct their own processes and tool usage.”

Here’s the irony worth sitting with: Dynamic Workflows is named a workflow, but it’s Claude dynamically writing the orchestration on the fly from your prompt. By Anthropic’s own 2024 definition, model-authored, per-task orchestration is closer to the agent side of the line. It’s a brilliant agent that scripts itself a workflow for one task, then throws the script away.

Forge sits on the other side on purpose. A Forge workflow is a declared, approved, reusable spec — a named team with named transitions and a designated management agent. It’s a predefined code path in the truest sense, and it outlives the task that created it.

That’s the fork in the road:

• Claude Code Dynamic Workflows — ephemeral, model-authored, code-centric orchestration that scales one task across many subagents and then collapses to a report.
• Forge — a durable, human-governed, audited team process you name once, then reuse, schedule, and ship to production.

Credit where it’s due

Dynamic Workflows is a real advance, and several of its ideas overlap with ours:

• Coordination lives outside the chat. “Because the coordination happens outside the conversation, the plan stays on track no matter how big the task gets.” That’s the same instinct behind our event-sourced runtime.
• Adversarial verification. Agents attack from independent angles and others try to refute them until they converge. This is the evaluator-optimizer pattern, and it’s the right one.
• A confirmation gate. “The first time a workflow triggers, Claude Code shows what’s about to run and asks you to confirm.”
• In-run durability. “Progress is saved as the run goes, so a job that’s interrupted picks up where it left off.”

If your problem is “take this one large coding task and parallelize it safely across hundreds of agents,” Dynamic Workflows is excellent, and you should use it. We do.

Three ways Forge is different

1. Governed handoffs, not just convergence

Claude Code’s verification is automatic adversarial refutation until the answers converge, plus one confirmation the first time a workflow runs. That’s great for correctness on a single task.

Forge governs the process. A management agent sits between every transition and issues a structural verdict on each handoff:

• advance — the handoff is good; the next persona starts.
• enrich — specific gaps; the previous persona re-runs with explicit instructions, on a bounded retry budget.
• escalate — the gaps won’t be fixed by another LLM round, so a human operator is pulled in.

stateDiagram-v2
    [*] --> AwaitingHandoff
    AwaitingHandoff --> Validating: previous persona finished
    Validating --> Advancing: verdict = advance
    Validating --> Enriching: verdict = enrich (within budget)
    Validating --> Escalating: verdict = escalate (or budget exhausted)
    Enriching --> AwaitingHandoff: re-dispatch previous persona
    Advancing --> [*]
    Escalating --> OperatorReview
    OperatorReview --> Advancing: operator force-advances
    OperatorReview --> [*]: operator aborts

The difference is convergence vs. governance. Claude Code converges agents toward a correct answer. Forge gates a team toward an approved outcome, with a real human escalation path at every step — not just once at the start.

2. Durable, audited, with memory that survives the run

Dynamic Workflows persists within a run — an interrupted job resumes. But the announcement describes no persistence across runs, no named personas that carry forward, and no audit trail beyond the PRs a run opens at the end.

Forge runs on LLMOS, an event-sourced runtime, which buys two things a single-session orchestration doesn’t:

• A real audit trail. Every persona’s handoff is a commit on a workflow-scoped branch (forge/workflow/{workflowId}/run/{runId}). You can git diff between enrich attempts. Auditors get a git log and they’re done. With Simple Container underneath, the release at the end is signed (Cosign, SBOM, SLSA provenance).
• Memory across runs. Forge’s character agents carry experience forward, organization-wide — the reviewer that caught a class of bug last sprint still remembers it next sprint. Ephemeral subagents start from zero every time.

3. A durable workflow anyone can author, schedule, and ship to prod

You trigger a Claude Code workflow by asking Claude, in a coding tool, to “create a workflow” for the task in front of you. It’s authored for that task, by the model, and it’s gone afterward.

A Forge workflow is an artifact. You describe the team once in plain English — any language — Forge generates a WorkflowSpec, you approve the visual flowchart, and then you reuse it, version it, and schedule it on a cron or webhook. “Describe your team in English; Forge runs it.” No one needs to be at a terminal, and no one needs to write code.

And “production” means production. Forge personas shape the PM, architecture, code, and review; SC owns the infra, secrets, build, and signed release. Agents call SC through typed MCP tool calls and never hold plaintext credentials. Claude Code stops, correctly, at the PR — deployment, secrets, and provenance are out of its scope.

The honest comparison

This isn’t a knock on Claude Code

The fact that Anthropic shipped Dynamic Workflows validates the thesis we’ve been building on: at scale, you don’t want one unbounded agent — you want orchestration, verification, and a gate. We agree so completely that we run Anthropic’s models inside Forge, and we run Claude Code’s Dynamic Workflows for our own research.

The difference is layer and lifetime. Dynamic Workflows makes one developer’s task enormously more powerful. Forge makes a team’s process durable, governable, auditable, and shippable — by people who never open a terminal. Different tools for different jobs, and we’re happy to use both.

The line Anthropic drew in 2024 is still the right one. We just build on the side of it that ships — and stays.

Try it

If you have a workflow that needs to be named, governed, audited, scheduled, and taken all the way to prod, that’s Forge. Read the Workflow Engine page, or describe your team to us at [email protected] .