The Ultracode Field Guide: When 1,000 Agents Beat One Genius

First, the thing people get wrong: ultracode isn't a new product or a smarter model. Anthropic's docs are clear — it's xhigh reasoning effort bolted to automatic dynamic-workflow orchestration, both living under one /effort setting. The orchestration plan runs as a JavaScript script the runtime executes outside Claude's context window. Intermediate results land in script variables, not the conversation, which is the whole reason a long run doesn't lose the plot halfway through. You turn it on two ways. Type 'ultracode' in a prompt and you get one orchestrated turn. Set /effort ultracode and Claude decides for itself whether to orchestrate, for the rest of the session — that one resets when you start a new session.

• xhigh effort + auto orchestration in one /effort setting — not a new model
• Plan runs as code outside the context window, so it won't drift on long jobs
• One-off keyword 'ultracode' in a prompt = single turn
• /effort ultracode = Claude auto-decides for the whole session (resets next session)

A single reasoning pass can be confidently, expensively wrong. Ultracode's trick is to fan out into many independent agents and then make them fight. Each one tries to knock holes in the others' findings, the run votes on every claim, and anything that doesn't survive the cross-check never reaches you. That's what you're actually buying — not more words, but answers that already took a beating and held up. The honest numbers: the runtime caps at 16 agents running at once (fewer on a low-core machine) and 1,000 total per run. Anthropic puts the realistic range at dozens to hundreds.

• Many independent agents, not one chain of thought
• Each agent tries to refute the others' claims
• The run votes; unsurvived claims are filtered out before you see the report
• Caps: 16 concurrent agents, 1,000 total per run (typically dozens-to-hundreds)

Spawning a swarm of agents costs tokens — often a lot more than running the same task in a normal chat. So only reach for it when the job actually rewards fanning out and cross-checking: breadth, verification, parallel work. For anything narrow, fast, or strictly one-step-after-another, go back to /effort high. One strong serial pass does the job, and you skip the orchestration tax that buys you nothing on a task like that.

1. USE ultracode for: codebase-wide bug sweeps
2. USE ultracode for: large migrations (e.g. a 500-file refactor)
3. USE ultracode for: cross-checked research where being wrong is expensive
4. USE ultracode for: drafting a hard plan from several independent angles
5. USE /effort high instead for: single-file edits and quick tasks
6. USE /effort high instead for: strict serial A->B->C work where each step needs the last

The token bill is the one real downside, and it's entirely on you to prevent. Set these three guards before you hit go and you're steering the spend instead of apologizing for it afterward.

1. 1. Scope it to a slice. Run on a small slice first — one directory or one narrow question — to gauge spend before you point it at the whole repo.
2. 2. Prefer the bundled /deep-research workflow. It's a real, ready-to-run workflow on any paid plan (needs Claude Code v2.1.154+ and the WebSearch tool) — the lowest-risk way to feel ultracode-style orchestration without flipping the whole session to xhigh.
3. 3. Watch the run with /workflows. The phase view shows live agent count, total tokens, and elapsed time; you can pause, stop, or resume (within the same session). Stop it the moment the token total outpaces the value.

Run this gate before you type 'ultracode.' Answer no to the first question and /effort high is almost certainly the cheaper call for the same quality.

1. Is the task broad OR does being wrong cost real money/time? If no -> use /effort high.
2. Does it benefit from many angles or cross-checking (bug sweep, migration, research, hard plan)? If no -> use /effort high.
3. Want a low-risk taste first? -> run /deep-research instead of the full session flip.
4. Going for it? -> scope to one slice, open /workflows, watch tokens, and pause if value/spend tips the wrong way.