Claude Code Ultracode: What It Is, When to Use It, and When to Leave It Off

Ultracode is the name of two different things in Claude Code, and most of the confusion around the feature comes from that one fact. Typed as a keyword in a prompt, it makes Claude structure a single task as a multi-agent workflow. Set with /effort ultracode, it does that for every substantive task in the session and raises reasoning effort to xhigh on top. Both run on Claude Opus 5, Anthropic's current flagship. For the right class of work, either one removes the need to orchestrate agents by hand or break a large task into sequential prompts. For routine work, both are an expensive way to do something simple.

This guide covers what ultracode actually does, how to enable it, what a real run cost and returned on a public codebase, and how to decide whether a given task warrants it.

What Is Claude Opus 5

Claude Opus 5 is Anthropic's current flagship model, released July 24, 2026. It matches, and on several benchmarks surpasses, Anthropic's most powerful commercially available model, Fable 5, at half the price: it leads on Frontier-Bench (43.3% vs 33.7%) and OSWorld 2.0 (70.6% vs 66.1%), and scores 1,861 on the GDPval knowledge-work benchmark against Fable 5's 1,747. It ships with a 1M-token context window, 128K max output, and a May 2026 knowledge cutoff, the most current of any Claude model.

Standard pricing is $5 per million input tokens and $25 per million output tokens, unchanged from Opus 4.8. Fast mode runs roughly 2.5 times faster at double the price ($10/$50 per million), which makes it the right pick for latency-sensitive steps. For the full breakdown of benchmarks, pricing, and how it stacks up against Opus 4.8 and Fable 5, see our Claude Opus 5 guide.

Its default effort level is high. The ultracode session setting requires xhigh reasoning, which only Opus 5 and its predecessor Opus 4.8 support. Older models, including Sonnet 4.6 and Opus 4.6, do not. If you set /effort ultracode on an unsupported model, Claude Code falls back silently to high.

Ultracode Means Two Different Things

Before anything else, get this table straight. It is the single most confusing thing about the feature, and the docs are the only place that spell it out.

	Effort	Orchestration	Scope
ultracode typed in a prompt	unchanged	this turn only	one turn
/effort ultracode	raised to xhigh	every substantive task	whole session

The docs are explicit on the keyword: "To run a single task as a workflow without changing the session's effort level, include the keyword ultracode in your prompt. The keyword only chooses how Claude structures the work." And on the setting: "Ultracode is a Claude Code setting that combines xhigh reasoning effort with automatic workflow orchestration."

So the setting bundles the keyword's behavior with an effort bump. The keyword alone is the orchestration half and nothing else.

Why the collision exists: the keyword arrived by rename. Claude Code's changelog notes that the dynamic-workflow trigger was renamed from workflow to ultracode, and that the word "workflow" no longer triggers a run. An existing trigger word was renamed onto an existing effort tier. The overlap is a product decision, not a coincidence, and it does real damage. While preparing the benchmark described below, we got this wrong twice in one session, once in each direction, with the changelog open. If you are comparing ultracode against anything, decide first which of the two you mean.

What Ultracode Actually Does

The honest claim is not "ultracode uses subagents and a normal session does not." A normal session can spawn subagents too. The claim is about who holds the plan.

With subagents, skills, or agent teams, Claude orchestrates turn by turn, and every intermediate result lands back in Claude's context window. With a workflow, a JavaScript script written by Claude holds the loop, the branching, and the intermediate results. Agents fan out in parallel where possible, each with a fresh context window, and only the final answer returns to the main context.

That distinction is the mechanism. Effort scales depth inside one context. Orchestration scales breadth across many. A solo run at maximum effort still reads everything through a single window and starts sampling when the material does not fit. In a fan-out, one agent can spend its whole window on a repository's type definitions while another spends its whole window parsing a 232-entry library catalog, and neither competes for the other's budget. Ultracode is context economics, not smarter thinking.

What it looks like in practice: you ask Claude to audit authentication across your API layer. Under the session setting, Claude may spin up one workflow to map all the routes, a second to audit each one, and a third to verify the findings adversarially before producing a report. All of that happens without you specifying the structure. A single run can spawn hundreds of agents. The technical ceiling is 1,000 per run and 16 concurrent on a typical machine. Completed work is cached and resumable within the session.

How to Enable It

There are two routes, matching the two meanings.

For one task, include the keyword in your prompt:

ultracode: audit every API route for missing authentication

For the whole session, run:

/effort ultracode

The setting is the only path to the effort bump. The CLAUDE_CODE_EFFORT_LEVEL environment variable, the --effort flag, and the effortLevel setting in configuration files accept standard effort levels only. The setting is session-scoped and resets when you start a new session. That is deliberate: choose it for specific heavy tasks, then drop back to /effort high for routine work.

One gotcha that will silently ruin any scripted comparison: the keyword does not fire from non-human input. The docs list where it is inert: a prompt passed with -p, an Agent SDK prompt not stamped as human input, a scheduled task prompt, and a webhook payload or pull request comment relayed into the conversation. If you script a benchmark non-interactively, you will measure a plain run and not be told.

This shift toward delegation is already well underway. As Anthropic CEO Dario Amodei observed, "some of the strongest engineers I've ever met are now handing over almost all their coding to AI." Ultracode is built for exactly that kind of hand-off: tasks that benefit from parallel agents and adversarial verification before anything is committed.

What a Fan-Out Actually Buys: A Real Run

Abstract arguments about verification are easy to make. Here is what one run returned on a public codebase.

The setup: we are preparing a demo on the Excalidraw monorepo around a four-year-old feature request for native tables (325 reactions, 147 comments). Before building anything, we needed a yes-or-no answer to one narrow question: does any table feature already exist in Excalidraw, in the core element types or the public library? That preliminary check was run as an ultracode fan-out.

Metric	Value
Agents	5 (4 parallel searchers, 1 adjudicator)
Tokens	471,480
Wall clock	264 seconds
Tool calls	84

State that plainly: nearly half a million tokens and four and a half minutes for a pre-check, not the main task. Now what came back, beyond the "no" that was asked for.

It refuted the source material's own technical proposal. The GitHub thread contains a contributor's 2023 proposal to implement tables as "a subtype of the frame element." The audit found that Excalidraw elements have no subtype mechanism at all. The one type that looks like one is derived at runtime from geometry and never persisted, and the element that looks like a frame variant is its own top-level type. A single-context run reading the thread would very likely have repeated the proposal as the implementation path.

It caught a defect in its own inputs. The checkout was a shallow clone with exactly one commit of history, which makes any git log question unanswerable. The agent said so explicitly instead of returning an empty result that would have read as "nothing found," then went to the GitHub API instead.

It found a better precedent than the one it was pointed at. A commit adding an entirely new element type had landed upstream two days earlier and was absent from the local checkout. That commit is a far better template for the work than the older examples the prompt named.

The verification layer corrected the searchers. The adjudicator noticed that one auditor's dissenting verdict was not a disagreement at all, since it was answering a different question. It flagged that a second auditor's claim was already stale because it came only from the behind-by-two local checkout. And it surfaced a consequence none of the four were asked about: the scene restore code is an exhaustive switch with a deliberate no-default policy, so any client predating a new element type silently drops those elements rather than degrading them.

That last finding is the argument for the pattern. The value was not four searches. It was a layer whose only job was to disbelieve the searches.

Use Cases Where Ultracode Makes Sense

The right question is not "could ultracode help here?" but "does the cost of getting this wrong exceed the cost of extra compute?" When the answer is yes, ultracode earns its token spend.

Codebase-wide audits. Checking 200 API routes for missing authentication, or scanning a repository for SQL injection exposure. A single-agent pass will miss things. Ultracode fans out parallel auditors, then runs a verification pass that adversarially reviews each finding before surfacing it.

Large-scale migrations. Renaming a pattern across 500 files, migrating from one ORM to another, or updating all usages of a deprecated API. Parallel agents working across file groups beat sequential single-agent work on both speed and consistency, and the verification layer catches the 10 files where the pattern was missed.

Multi-source research requiring cross-checking. The built-in /deep-research workflow is the model: fan out searches, fetch sources in parallel, then have separate agents check each other's conclusions before synthesis. For any research task where factual accuracy matters, the adversarial step is what changes the quality of the output.

Complex refactors where the architecture needs several angles. Redesigning a service boundary or extracting a shared module from tightly coupled code. One agent drafts the approach while another identifies the dependency implications before you commit to a plan.

Security reviews. Missing a single finding can cost far more than the compute for a thorough one. The verification step catches cases where the primary auditor made a plausible-but-wrong assumption, which is exactly what happened with the frame-subtype proposal above.

When Not to Use Ultracode

Ultracode is genuinely overkill for most daily work, and the token cost is real. The pre-check above spent 471k tokens on a yes-or-no question. A full audit under the session setting can consume more of your plan's weekly rate limit than a full day of normal Claude Code usage.

Routine single-file edits do not benefit from orchestration. Fixing a bug in one function, renaming a variable, explaining a block of code, writing a unit test for a known interface: none of these have the surface area that parallel agents improve. Quick questions are similarly poor fits; ten agents to answer what one search answers.

Any task where you need to interact mid-way is also a poor fit. Dynamic workflows cannot pause for user input once running. If you expect to redirect Claude partway through, a regular high-effort session where you guide the conversation turn by turn is the better tool.

Two more things to know before turning the session setting on.

The cost tripwire is off exactly when you need it. Claude Code normally warns when a run schedules more than 25 agents or projects past 1.5 million tokens. Per the docs, sessions with ultracode on do not show that warning, because turning it on already opts you into large runs.

One request can become several workflows in a row. Under /effort ultracode, the docs describe one workflow to understand the code, one to make the change, one to verify. So the session setting is not one fan-out, it is a chain of them. That, not the effort bump, is where the cost lives.

Ultracode and Dynamic Workflows

Both routes lead to the same underlying system: dynamic workflows.

Mechanism	How	Effort	Scope	Claude decides?
ultracode keyword in prompt	Include the word in your prompt	unchanged	Per-prompt	No, always triggers
/effort ultracode	Session setting	xhigh	Whole session	Yes, Claude decides per task

The keyword gives you more control; the setting gives you more automation and a chain of workflows per request.

The number of agents Claude aims for is governed by a size guideline. The default is medium, which targets under 15 agents. small targets under 5, large under 50. This is a guideline rather than a hard cap, and it can be changed in /config. If you are comparing runs, hold it fixed, because changing it mid-comparison silently changes the fleet size.

Workflows you find useful can be saved to .claude/workflows/ for project-scoped reuse or ~/.claude/workflows/ for personal cross-project use. Saved workflows become slash commands. The /workflows command opens a TUI view of running workflows, where you can pause, restart individual agents, or stop a run entirely. Stopping mid-run halts token accumulation and preserves completed work.

How to Benchmark It Honestly

If you want to test ultracode against a plain session rather than take our word for it, three design mistakes will invalidate the result before you start.

Decide which ultracode you are testing. Keyword and setting change different variables. Three runs give two clean single-variable comparisons:

Run	Effort	Orchestration
A	medium	none requested
B	medium	keyword, one turn
C	xhigh	automatic, whole session

A against B isolates orchestration. B against C isolates effort. Neither answers the skeptic who says the orchestrated run simply spent more tokens. That needs a fourth arm at xhigh with no keyword: high spend, no structure. If the orchestrated run still wins, the claim is about structure rather than spend.

Do not let the naive run inherit the research. A session that already did the fan-out holds the findings the plain run is supposed to fail to discover. Every arm needs a fresh session.

Report the token counts for both arms. Part of any orchestrated run's advantage is that it spends more. A write-up that hides this is easy to knock down. State both numbers and let the reader weigh them.

Ultracode for Product Managers

Everything above applies outside engineering work. Ultracode does not care whether the task is code. It cares whether the task is big enough to justify parallel agents and adversarial verification, and a specific shape of PM work qualifies. It is the shape most PMs hit maybe once a week, not daily. The test: does answering this require reading across more sources than one context can hold, or is being wrong expensive? If neither, skip it.

Feedback synthesis at scale. 200 support tickets, 40 interview transcripts, six months of call notes. Ultracode fans out parallel readers by source, dedupes the pain points centrally, then runs a second pass that asks "what theme did we miss?" before ranking themes by frequency and severity, with quotes attached. This is the workload where a single context simply cannot hold the inputs.

Competitive teardowns. One agent per competitor per dimension (pricing, onboarding, positioning, changelog velocity), then a synthesis pass. Far better than sequentially reading eight sites and losing the first four by the time you reach the last. A verification agent re-checks every claim against the sources before the comparison reaches you.

Audits with a checklist. Every page against a rubric, every flow against a heuristic set, every event in the tracking plan against what actually fires in production. Rubric-times-inventory work is exactly what parallel agents plus a verification pass do better than one long session.

Decisions where you want to be confident, not fast. Generate four independent approaches to a problem from different angles (risk-first, MVP-first, user-first), score them with independent judges, then synthesize the winner. This beats one plan iterated three times, because the failure mode of solo reasoning is committing early to a frame.

Feature requests with a long thread behind them. The Excalidraw case above is a PM task. A 147-comment thread splits into two camps who want different products, contains a maintainer's stated position, and carries a technical proposal that turned out to be wrong. One context reads the title and writes a tidy generic spec. A fan-out reads all of it and tells you which proposal to distrust.

Where ultracode is waste for PM work: the writing itself. A PRD, a strategy memo, or a launch recap needs one coherent voice, not fifteen agents merging. Use the fan-out for the research beneath the document, then write the document in one pass. Same for anything where the bottleneck is your judgment rather than information volume.

One honest caveat. The failure mode is a PM who runs ultracode on everything and gets confident-sounding synthesis over shallow inputs. The value comes from the verification structure, agents actively trying to refute each finding, not from the parallelism itself. Learn the "when not to" half as hard as the "when to" half. None of this requires writing code: you describe the outcome, ultracode decides the orchestration.

Closing Thoughts

Ultracode is not a setting to leave on. It is a mode you reach for when missing something is more expensive than the compute required to be thorough: large audits, complex migrations, adversarial research, security reviews, and any question whose inputs do not fit in one context.

Know which ultracode you are using. The keyword buys structure for one task at your current effort. The setting buys structure for every task plus deeper reasoning, and chains workflows per request. For everything else, high effort on Opus 5 delivers strong results at a fraction of the cost. The discipline of switching intentionally is what makes ultracode useful rather than just expensive.