Dynamic Workflows in Claude Code: How One Prompt Ran 160 Agents for 3 Hours

01.The Run: 3 Hours, 160 Agents, One Prompt

Here is the screenshot that prompted this article. It is a single line from my terminal, taken near the end of a run I kicked off with one instruction and then walked away from. Read it slowly, because every number on it would have been science fiction a year ago.

155 of 160 agents done. Three hours and twelve minutes. 11.4 million tokens consumed. I did not babysit it. I did not feed it follow-up prompts. I wrote one carefully designed instruction, turned on ultracode, and let Claude orchestrate a small army of itself while I got on with other work. What came back was not a half-finished draft. It was a complete, internally consistent research wiki, every document in the same format, every claim checked.

So here is the honest question this raises, and the one most teams have not sat with yet: would you let your Claude session run for three hours on a single prompt? A year ago that sentence sounded reckless. In 2026, with the right harness around the model, it is simply how serious work gets done. This article explains the three ideas that make it possible — dynamic workflows, ultracode, and loops — then walks through the exact research run above so you can rebuild it yourself.

02.What Dynamic Workflows Actually Are

Dynamic workflows arrived alongside Claude Opus 4.8 on 28 May 2026 ^[1]. The idea is deceptively simple. Instead of Claude deciding what to do turn by turn inside your chat, it writes a small JavaScript orchestration script from your request and runs it in the background ^[2]. The plan moves out of the conversation and into code. Your session stays responsive, and only the final synthesised result lands back in your context window.

That last detail is the unlock. The reason you could never run hundreds of agents from a normal chat is that every intermediate result used to pile into the same context window until it overflowed. A workflow keeps all of that chatter in script variables, out of sight. The orchestrator only hands you the conclusion ^[3].

The building blocks

Every workflow script begins with a meta block and then uses a handful of primitives. agent() spawns one subagent. parallel() runs a batch and waits for all of them (a barrier). pipeline() streams items through stages without waiting, so item two can start while item one is still finishing. phase() and log() drive the progress display. Here is the shape of a real one:

export const meta = {
  name: 'audit-and-verify',
  description: 'Review every changed file, then verify each finding',
  phases: [{ title: 'Review' }, { title: 'Verify' }],
}

// Each dimension is reviewed, then its findings are
// adversarially verified the moment that review finishes.
const results = await pipeline(
  DIMENSIONS,
  d => agent(d.prompt, { phase: 'Review', schema: FINDINGS }),
  review => parallel(review.findings.map(f => () =>
    agent(`Try to refute: ${f.title}`, { phase: 'Verify', schema: VERDICT })
  ))
)
return results.flat().filter(f => f.verdict?.isReal)

Pass a JSON schema to agent() and the subagent is forced to return clean, validated data rather than prose you have to parse. That is what lets a workflow treat its own agents as reliable functions.

03.Ultracode: xhigh Effort Plus Permission

If dynamic workflows are the engine, ultracode is the ignition. In Claude Code, dynamic workflows surface as a mode called ultracode in the effort menu ^[6]. It is not a brand-new reasoning level. Ultracode is xhigh reasoning effort paired with standing permission to launch multi-agent workflows — Claude Code's shorthand for “think as hard as you can, and orchestrate freely”.

The capability that makes this possible is one of Opus 4.8's quieter additions: mid-conversation system messages. Before 4.8, a system prompt sat at the very start of a conversation and stayed fixed. Now an instruction can be injected partway through the message history, which is exactly how an orchestrator is granted permission to spin up workflows after a session has already started ^[6].

You turn it on in seconds:

/effort ultracode          # set ultracode for this session
# or open /config and toggle Dynamic Workflows to Ultracode
# or simply include the word "ultracode" in your prompt

With ultracode standing on, Claude stops waiting for you to say “use a workflow”. It decides, for each substantial task, whether to author and run one. A single request to audit a codebase might quietly become three workflows in sequence: one to understand the code, one to make changes, and one to verify them. The default posture flips from do the task to orchestrate the task, and token cost stops being treated as a constraint ^[5].

04.Why Loops Are the Whole Game in 2026

Ask around the Claude Code community right now and one word keeps coming up: loops. It is the technique most people have heard of and the one most people cannot actually do. So let us fix that, starting with the person who designed the tool.

Cherny describes his own evolution in three stages ^[9]. A year ago he wrote code by hand with autocomplete. Then he ran five to ten Claude sessions in parallel and prompted each one manually. Now he does not prompt at all: he writes the loops that prompt Claude, and a couple of hundred agents read his GitHub, Slack, and other inputs and decide what to build next. The job moved up an altitude — from writing the code, to writing the thing that writes the code.

The practical difference is compounding. A prompt gets you one output. A loop gets you a repeating operation that improves on its last result. But a loop is only as good as its stopping condition, which is why Cherny's other piece of advice is the one that actually matters:

The three ways to loop, from simplest to most powerful

Every one of these comes down to the same rhythm: act, then check ^[12]. What changed in 2026 is that a single loop can now fan out across hundreds of agents and still verify its own work. The run at the top of this article is that idea taken to its logical conclusion — so let us pull it apart and rebuild it.

05.Case Study: A Research Wiki From One Prompt

Now the run itself. My goal was a deep, well-organised research wiki on a single topic — the kind of thing that would normally take a person several focused days of reading, note-taking, and tidying. I did not want to write the wiki, and I did not even want to write the research plan. I wanted Claude to do both, and to get better at the job as it went.

The prompt was built around a single insight: do not ask for the answer, ask for the methodology first. Here is the actual instruction I gave, more or less word for word.

That one paragraph is the entire run. The shape it describes is a loop with a sharpening step at the front and two cleanup steps at the back — like this:

Because ultracode is on, you never write the JavaScript — Claude turns that prompt into the workflow. For the curious, the heart of the generated script looks like this:

export const meta = {
  name: 'research-wiki',
  description: 'Self-improving, multi-pass research wiki from one prompt',
  phases: [{ title: 'Methodology' }, { title: 'Research' },
           { title: 'Verify' }, { title: 'Standardise' }],
}

let methodology = await agent(
  'Design the methodology for researching this topic and the ' +
  'structure of the wiki. Do not research yet.',
  { phase: 'Methodology', schema: METHODOLOGY }
)

// 10 passes. Each pass sharpens the method, then researches.
for (let pass = 1; pass <= 10; pass++) {
  methodology = await agent(
    `Pass ${pass}: review the methodology and the wiki so far. ` +
    `Improve the method and list the gaps still to fill.`,
    { phase: 'Methodology', schema: METHODOLOGY }
  )

  await parallel(methodology.gaps.map(topic => () =>
    agent(`Research "${topic}" and write it into the wiki.`,
      { phase: 'Research', schema: WIKI_DOC })
  ))
  log(`Pass ${pass} complete — ${methodology.gaps.length} topics filled`)
}

// Verification loop: adversarially check every claim.
const docs = await readWiki()
const verified = await parallel(docs.map(d => () =>
  agent(`Fact-check this document. Flag unsupported claims.`,
    { phase: 'Verify', schema: VERDICT })
))

// Standardise every surviving document to one house format.
await parallel(verified.filter(v => v.isSound).map(v => () =>
  agent(`Rewrite to the standard wiki template.`,
    { phase: 'Standardise', schema: WIKI_DOC })
))

That is the whole trick. The loop is ten passes. The intelligence is in step three: by forcing the model to improve its own methodology before each round of research, the wiki gets deeper and better organised with every pass instead of just longer. The final two phases — verify, then standardise — are what turn a sprawling pile of notes into something you would actually trust and publish.

When I hit enter, all of that became the screenshot at the top of this article: 160 agents, three hours, 11.4 million tokens, and a finished wiki waiting for me.

Nothing here is specific to research, either. Swap the topic for “audit this codebase”, “map this market”, or “draft this content series” and the same shape holds — design the method first, loop it, then verify. If you want the productised version of this idea, it is essentially what our LLM wiki build and autonomous development guide have been circling all year — dynamic workflows just made it a single prompt.

06.Should You Let Claude Run for 3 Hours?

Let us address the discomfort head-on. Eleven million tokens is a real bill, and three unattended hours feels like a lot of rope to give an autonomous system. Both reactions are healthy. The answer is not to avoid long runs; it is to know when they pay for themselves.

The framing that helps: do not compare the token bill to a chat message; compare it to the human hours it removes. A three-hour run that replaces three days of skilled research is a bargain even at 11 million tokens. Opus 4.8 also shipped a cheaper fast mode, which lowers the cost of long sessions considerably ^[1], and workflows accept a token budget so you can cap a run at a hard ceiling before you start.

And the three unattended hours? They are only safe because of the verification phase. A loop with no way to check itself should not run for three minutes, let alone three hours. A loop that adversarially verifies its own output can run all night — which is exactly the bet the whole 2026 agentic-engineering movement is making.

07.What This Means for Echofold Users

The same Opus 4.8 is available to everyone, so the advantage goes to whoever designs the better loop around it. It is a good example of something we write about a lot: the harness tends to matter more than the model.

If you want to get hands-on with it, Production Vibe Coding covers the workflow for shipping production-grade software with Claude Code — hooks, MCP servers, verification gates, and the autonomous patterns this article describes. And if you want to learn this alongside other builders, our Dublin and Belfast meetups are where these techniques get shared first.

The model is the same for everyone. The real advantage is the loop you build around it — and that is a skill anyone on your team can pick up.

08.Frequently Asked Questions

09.References