Ultracode & Effort Levels: Turning Claude Code Up to Eleven

For most of Claude Code’s history, you had one big dial: which model to use. In the Fable 5 era there’s a second one, and it might matter more day-to-day. /effort controls how hard the model reasons about each step, independent of which model you picked. And at the very top of that dial sits ultracode — a mode where Claude Code stops optimizing for speed or cost entirely and starts orchestrating multi-agent workflows on every substantive task.

This guide covers the four effort levels, what ultracode actually changes, the token budget directives that keep big runs from running away, and — just as important — when to leave all of it switched off.

---

What Effort Actually Controls

/effort sets the reasoning effort for your session. It doesn’t change which model answers you — that’s /model — it changes how much thinking that model spends per step before acting.

The trade is straightforward:

more effort  →  deeper reasoning per step
             →  more tokens, more latency
             →  better answers on hard problems

less effort  →  faster, cheaper turns
             →  perfectly fine for mechanical work

Both /model and /effort can be switched mid-session, and both persist as defaults when you choose to save them. So the workflow is: set a sensible default, then reach for the dial when a specific task deserves more (or less) than your default.

If you’re also deciding which model to run, read this alongside our model selection guide — model tier and effort level are two separate dials, and the interesting configurations mix them.

The Four Levels

/effort offers four session levels: low, medium, high, and xhigh.

There’s no official per-level spec sheet, and you don’t need one. The useful mental model comes from how effort is used inside multi-agent workflows: cheap, mechanical stages get low effort; hard verification and judgment stages get the high tiers. Apply the same logic to your sessions:

Level	Reach for it when
low	Mechanical work: renames, formatting, boilerplate, “read this file and tell me X”
medium	Everyday coding: routine features, straightforward fixes
high	Genuinely hard problems: tricky debugging, multi-file refactors, design questions
xhigh	The hardest judgment work: architecture decisions, adversarial verification, “this must be right”

The key shift: quality-versus-cost used to be a property of the model you picked. Now it’s a dial you hold, adjustable per session and — as you’ll see below — per individual subagent.

Ultracode: xhigh Plus Standing Orchestration

Above xhigh sits a special top setting: ultracode = xhigh effort + dynamic workflow orchestration.

That second half is what makes it different in kind, not just degree. With ultracode on, Claude Code is instructed to:

• optimize for the most exhaustive, correct answer — not the fastest or cheapest one
• use multi-agent Workflow orchestration on every substantive task, not just when you ask for it
• treat token cost as explicitly not a constraint

In practice that means a task like “review this diff” stops being one agent reading files and becomes a scripted Workflow: parallel finders fanning out across the change, skeptic agents trying to refute each finding, a synthesis stage assembling what survives. Workflows can spawn dozens of agents and consume large token volumes — which is exactly why ultracode is opt-in. The harness requires you to explicitly request that scale; it will never silently burn a workflow-sized token bill on your behalf.

How to Opt In

Ultracode itself has two activation paths:

1. The keyword. Include “ultracode” in a prompt for a one-off opt-in:

   ultracode: audit the payments module for correctness bugs

   That single turn runs at full scale. The next turn is back to normal.

2. The session toggle. Choose ultracode via /effort for a standing opt-in — every substantive task in the session gets the treatment until you dial back down.

Zoom out one level and workflow orchestration more broadly has a third door: workflows also run when you explicitly ask for one (“use a workflow to…”) or when a skill you’ve invoked instructs it. Without one of those opt-ins — ultracode, an explicit request, or a skill — Claude Code defaults to individual subagents or working solo. Orchestration at scale is always something you asked for.

Token Budgets: “+500k” and the Hard Ceiling

“Token cost is not a constraint” sounds alarming until you meet the counterweight: token budget directives. Write a target directly in your prompt:

ultracode +500k: find every place our API contract and the
OpenAPI spec disagree

That +500k gives the turn a token target, and it’s not a suggestion. Inside workflow scripts it surfaces as a budget object:

• budget.total — the target (a number, or null when no directive was given)
• budget.spent() — tokens consumed so far
• budget.remaining() — what’s left

Two properties matter:

The pool is shared. One budget covers the main loop and all workflows in the turn. You can’t overspend by splitting work across nested workflows — everything draws from the same account.

The ceiling is hard. Once spent() reaches total, further agent() calls throw. A well-written workflow checks the budget and degrades gracefully; a naive one dies mid-run. Which brings us to the code.

Per-Agent Effort: Spend Where Judgment Lives

Inside workflow scripts, reasoning effort is set per subagent: effort: 'low' | 'medium' | 'high' | 'xhigh' | 'max'. This is where the economics of big runs actually get decided. The pattern:

• cheap mechanical stages (searching, reading, formatting) → low effort, often on a cheap model
• hard verify/judge stages → the high tiers

Here’s a budget-guarded discovery loop that puts both ideas together — cheap finders that keep hunting until the well runs dry or the budget guard trips, then expensive skeptics on whatever was found. (Workflow scripts open with an export const meta = { ... } literal declaring name, description, and phases; the fragment below is the body.)

phase('Discover');

let dryRounds = 0;
const seen = [];

while (dryRounds < 2) {
  // budget is a HARD ceiling: once spent() reaches total,
  // further agent() calls throw. Leave headroom for the
  // verify phase instead of running into the wall.
  if (budget.total && budget.remaining() < budget.total * 0.2) {
    log(`Budget guard: ${budget.spent()} of ${budget.total} spent — moving on`);
    break;
  }

  const round = await parallel([
    () => agent(
      `Hunt for correctness bugs in the payments module.
       Already seen: ${seen.join('; ') || 'none'}.
       Report only NEW findings, or the word NONE.`,
      { label: 'hunt-correctness', model: 'haiku', effort: 'low' }
    ),
    () => agent(
      `Hunt for error-handling gaps in the payments module.
       Already seen: ${seen.join('; ') || 'none'}.
       Report only NEW findings, or the word NONE.`,
      { label: 'hunt-errors', model: 'haiku', effort: 'low' }
    ),
  ]);

  const fresh = round.filter(Boolean).filter(r => !r.trim().startsWith('NONE'));
  if (fresh.length === 0) dryRounds += 1;
  else { dryRounds = 0; seen.push(...fresh); }
}

phase('Verify');

const verdicts = await parallel(
  seen.map(finding => () => agent(
    `Try to REFUTE this finding. Confirm only if you cannot:
     ${finding}`,
    { label: 'skeptic', effort: 'xhigh' }
  ))
);

Notice the shape of the spending: the loop that might run many rounds uses Haiku at low effort, while xhigh is reserved for the verification stage where a wrong call actually costs you. The finders are told what’s already been seen so they don’t resell old findings, and the loop only stops after two consecutive empty rounds — the “loop-until-dry” pattern covered in depth in the effort and ultracode tutorial and its companion on quality patterns.

When NOT to Use Ultracode

The failure mode of a powerful dial is leaving it turned up. Skip ultracode for:

• Trivial edits. A rename, a typo fix, a config tweak needs one agent and low effort. Spawning an orchestrated workflow for it is pure waste.
• Conversational turns. “What does this function do?” or “which approach do you prefer?” are answered from context. There is nothing to fan out.
• Single-fact lookups. If you know which file holds the answer, a direct read beats any delegation.
• Anything where you want fast iteration. Ultracode optimizes for exhaustive and correct, which is the opposite of a quick feedback loop while you’re still sketching.

Rule of thumb: ultracode is for tasks where missing something is expensive and the search space is bigger than one agent’s context. Everything else runs better — and dramatically cheaper — at normal effort. For the broader cost picture, see the cost optimization tutorial.

Three Recipes

The audit. ultracode +500k: audit the auth module for security issues. This is ultracode’s home turf: unknown-size discovery where completeness is the whole point. Expect the loop-until-dry shape from the snippet above, adversarial verification of every finding, and — because well-built workflows log what was dropped whenever coverage is bounded — an honest account of anything the budget guard cut off.

The migration. ultracode: migrate every deprecated API call in src/ to the new client. Agents that mutate files in parallel need isolation: 'worktree' on their agent() calls — each gets a fresh git worktree so they can’t trample each other, auto-removed if unchanged. Worktrees cost real setup time and disk per agent, which is exactly the kind of scale you’re consenting to when you type the keyword.

The research sweep. ultracode: map every place we handle currency rounding, and how. A multi-modal sweep — parallel agents each searching a different way (by file location, by content, by entity, by time) — followed by a completeness critic asking “what’s missing?” whose answers seed the next round. Cheap models at low effort do the sweeping; the final synthesis gets the expensive treatment.

The Takeaway

Effort levels turned answer quality into something you control per task instead of something baked into a model. Ultracode is the top of that dial: xhigh reasoning plus standing workflow orchestration, gated behind explicit opt-in because it spends like it means it, and bounded by budget directives that are enforced as a hard ceiling rather than politely noted.

The skill worth building isn’t “always use ultracode” — it’s knowing which of your tasks are dial-worth-turning tasks. Audits, migrations, and research sweeps, yes. The typo you’re about to fix, no.

---

Want to go deeper? The Effort Levels & Ultracode tutorial works through the budget-guarded loop hands-on, and What Is a Workflow? explains the orchestration layer ultracode is built on.