# Ultracode in Claude Code 2026: how to enable it with one command > Ultracode in Claude Code: a mode where Claude launches a team of agents itself. How it differs from /effort xhigh, how to enable it, and how quickly it burns through tokens. Source: https://ailoot.ai/blog/en/ultracode-claude-code/ Canonical: https://ailoot.ai/blog/en/ultracode-claude-code/ Language: en Publisher: Ailoot (https://ailoot.ai/) Translation: guide-227 Revision: sha256-3e46039241cd499ef739e2b4155584fc64f04801bc567889188b3325cf3819f8
Key takeaway Ultracode is a mode in Claude Code where Claude decides for itself that a task is worth running as a workflow with dozens of parallel agents instead of answering with a single prompt. Enable it with `/effort ultracode` for the whole session or with the word `ultracode` at the beginning of a single task. Under the hood, it combines xhigh effort (like Opus 4.8 at its maximum) with an automatic orchestrator. It is useful for large code audits, migrations spanning hundreds of files, and in-depth research. It burns through tokens several times faster than normal mode, so it is better to keep `/effort high` for routine work.
For information about working with the service, see the [Ailoot documentation](https://ailoot.ai/docs/). ## What ultracode is and who needs it
Key takeaway Ultracode is a session-level setting in Claude Code that combines the maximum reasoning level (xhigh) with automatic orchestration of dynamic workflows. It appeared on May 28, 2026, in v2.1.154, alongside the release of Opus 4.8. It is intended for large tasks that one prompt cannot handle: auditing an entire project, migrating 500 files, or researching a complex question across 20 sources.
Until May 28, 2026, Claude Code had only the `/effort` parameter, with low / medium / high / xhigh levels. This is the model's level of “thinking”: the higher it is, the more tokens are spent on reasoning, the more accurate the result, and the longer Claude takes to respond. Ultracode does not fit on the `/effort low → xhigh` scale. It sits alongside it. When enabled, Claude automatically looks at your task and decides: “This one is better split into 30 parallel agents so I can assemble the result.” Before, you had to do that manually by writing your own workflow or assembling a subagent command. Now Claude decides for itself when it makes sense. The main audience is people who have hit the ceiling of a single prompt. If you: - ran `/code-review` on a repo with 200 files and the session fell over at file 50 - asked “find all the places where we use the deprecated API,” and Claude listed three while forgetting another fifteen - want Claude to check its own hypothesis from three angles before giving you an answer the ultracode is for you. If you are writing one function and need one solution, you do not need it: ordinary `/effort high` will do the job with three times fewer tokens. ## How ultracode differs from the regular low/medium/high/xhigh effort levels
Key takeaway Regular effort changes the depth of reasoning in a single response. Ultracode adds an automatic choice: launch a workflow with parallel agents or solve the task in one pass. The reasoning depth remains at the xhigh maximum, with an additional layer on top: orchestration.
A comparison of the essentials: | Parameter | `/effort low` | `/effort medium` | `/effort high` | `/effort xhigh` | `/effort ultracode` | |----|----|----|----|----|----| | Reasoning depth | minimum | medium | deep | maximum | maximum (xhigh) | | Tokens for reasoning | few | medium | many | very many | very many + orchestration | | Who decides to split up the task | you | you | you | you | Claude automatically | | When a workflow starts | at your command | at your command | at your command | at your command | on every substantial task | | Reset between sessions | no | no | no | no | yes - you have to enable it again | | Available on models | all | all | all | only models with xhigh | only models with xhigh (Opus 4.8) | The main difference in one line: `/effort xhigh` means “think longer”; ultracode means “think longer AND decide for yourself when you can handle it with one prompt and when you need a team of 30 agents.” So, in essence, ultracode adds another layer on top of xhigh: automatic orchestration. Anthropic states this explicitly in its [official documentation](https://code.claude.com/docs/en/workflows#let-claude-decide-with-ultracode):

With ultracode on, Claude decides when a task warrants a workflow. A single request can turn into several workflows in a row: one to understand the code, one to make the change, and one to verify it.

— Anthropic Docs, code.claude.com/docs/en/workflows
That means one request from you can unfold into three workflows in a row: understand the code, make the changes, and verify them. Each one can launch 10–30 parallel agents. ## Which versions and models support ultracode
Key takeaway You need Claude Code v2.1.154 or newer and a model that supports xhigh effort. As of June 2026, Anthropic effectively ties the xhigh release to Opus 4.8 (no other models with xhigh are confirmed in the changelog). It is available with Pro / Max / Team / Enterprise + API. On Pro, you have to enable it manually in `/config`; on the other plans, it works out of the box. Bedrock, Vertex AI, and Microsoft Foundry support it.
Check your version: ```bash claude --version ``` If it is older than `2.1.154`, update it: ```bash npm install -g @anthropic-ai/claude-code ``` Next, look at the list of effort levels: ```bash claude /effort ``` If you see `ultracode` in the dropdown, you are all set. If it is not there, it is most likely because: - your current model is not Opus 4.8 (for example, Sonnet 4.7 does not have xhigh) - you are on Pro and the mode is disabled in `/config` (enable the “Dynamic workflows” option) - your organization administrator has disabled workflows in managed settings Check the model: ```bash claude /model ``` If the default there is not Opus 4.8, switch: select Opus 4.8 in the model menu or set it as the default with the `d` key. ## How to enable ultracode: two methods
Key takeaway Method one is for the whole session, using `/effort ultracode`. Every subsequent task in that session will go through automatic workflow selection. Method two is for one task: put the word `ultracode` at the beginning of your prompt; it will be highlighted, and only that task will start as a workflow. The session effort level does not change.
**Method 1. Enable it for the whole session.** In a Claude Code session: ```bash /effort ultracode ``` From that point on, Claude will decide for itself whether to launch a workflow for every substantial task. The session lasts until you close it. When you close Claude Code and open it again, ultracode will reset. This is intentional: you should enable this mode deliberately, not have it on “by default.” **Method 2. For one task only.** Put `ultracode` at the beginning of the prompt (before v2.1.160, the keyword was `workflow`; after the release, Anthropic renamed the trigger to avoid confusion with ordinary runs): ``` ultracode: go through all /api/* endpoints in src/routes/ and find where authorization checks are missing ``` Claude Code will highlight the word `ultracode` and launch this task as a workflow. The session effort level stays the same (high or medium, depending on what you have set). Anthropic [writes](https://code.claude.com/docs/en/workflows#ask-for-a-workflow-in-your-prompt) that the same thing also works in natural language:

Asking in your own words, for example "use a workflow" or "run a workflow", also works: Claude treats a direct request as the same opt-in.

— Anthropic Docs, code.claude.com/docs/en/workflows
If you accidentally typed `ultracode` and did not mean to launch a workflow, press `Option+W` (macOS) or `Alt+W` (Windows/Linux) while the cursor is directly after the highlighted word. The highlight will disappear, and the task will proceed normally. ## What changes in Claude's work after you enable it
Key takeaway Claude stops responding “turn by turn” — one prompt from you, one response from Claude. Instead, it writes a JavaScript script that the runtime runs in the background. The script can launch 10–30 parallel agents, each with its own context, and assemble their results. Your session stays responsive, so you can assign new tasks while the workflow runs in the background.
Before ultracode: you write a prompt, Claude thinks for 30 seconds, and responds. If the task is large, its context fills up with intermediate results, and by the end of the session everything starts to “drift.” With ultracode: you write a prompt, Claude sees the scale and writes a script. The script runs in isolation: intermediate results are held in script variables, not in the session context. Only the final answer comes back to you. In practice, this has three effects: 1. **The session context does not fill up.** You can work longer without `/compact`. 2. **You can parallelize.** One run can launch up to 16 agents working at the same time (fewer on machines with little CPU). The limit for the entire run is 1000 agents. 3. **The result is checked automatically.** Claude can ask one agent to write a solution and another to critically review it. This reduces hallucinations on complex tasks. You can watch a run live: ```bash /workflows ``` A list of running and completed workflows will open. Use the arrow keys to select one and Enter to open its phase details. You can see the agents, each one's token usage, and execution time. Press `p` to pause, `x` to stop, or `r` to restart an agent. ## When to enable ultracode and when not to
Key takeaway Enable it for tasks that one prompt can no longer handle: auditing an entire project, migrating hundreds of files, or in-depth research that cross-checks sources. Do not enable it for routine work — fixing one bug, writing one function, or correcting a typo. Every task in ultracode mode costs several times more tokens, so using it for small jobs simply wastes your budget. ⚠️ Since June 15, 2026, Anthropic has split the subscription: programmatic workloads (including workflows) use a separate $20–$200/month credit. When the credit runs out, workflow requests simply stop, with no fallback to the subscription. This changes ultracode's economics considerably on Pro — see the section on tokens below.
Three situations where ultracode is justified: **1. Auditing a large codebase.** For example: “find all the places in the project where we commit passwords to logs.” One prompt will only work on a small repo. In a 500-file repo, one Claude will forget half of them, while a workflow will launch 20 agents in parallel, each handling 25 files. **2. A migration that touches many files.** Replacing a deprecated API, switching from one library to another, or refactoring a pattern throughout the project. A workflow can process files in batches of 10, checking itself after each batch. **3. Research that requires comparing sources with each other.** Anthropic has packaged this as the `/deep-research` workflow: it breaks a question down into angles, finds sources, cross-checks facts, and filters out anything that could not be confirmed. I ran it to gather data for the AI coding market and got a report better than an hour of my manual work. Three situations where ultracode wastes tokens: **1. Fixing one bug in one function.** A single `/effort high` prompt can do it for one tenth of the cost. Do not launch a workflow for this. **2. Writing one new function or component.** Same thing: use `/effort high` or even `medium`. Complexity does not increase with the number of agents; it increases with the depth of reasoning, which `xhigh` provides on its own without orchestration. **3. You want a quick answer.** A workflow is slower than a regular prompt by definition: even with parallel agents, coordination takes time. If you need it “right now, within the same minute,” do not enable it. The strategy in the example described here: default to `/effort high` for routine edits. I enable ultracode selectively for a specific task, using the word in the prompt, not for the whole session. That is because forgetting to turn it off means continuing routine work after the task in ultracode and burning tokens for no reason. ## How many tokens and how much money it costs
Key takeaway Each workflow uses tokens equal to the sum used by all its agents. A workflow with 30 agents means 30 contexts, each with a system prompt, tools, and its own reasoning. The token hit is several times greater than with a single prompt. On Pro, one large workflow can eat up half the daily limit. It is easier on Max and Team, but you still need to keep an eye on it.
Let's estimate roughly. One regular prompt on Opus 4.8 with `effort high` uses around 5,000–15,000 tokens for reasoning plus the model's response. A good, substantial task uses 50,000–100,000 tokens in total. One workflow with 20 agents means 20 parallel prompts, each with its own system-prompt context (~5–10K), its own reasoning (xhigh — 10–30K), and its own response. A rough estimate is 600,000–1.5 million tokens for one run. That is 10–30 times more expensive than one “normal” prompt. What that means in terms of money: - **Pro ($20/month):** In February 2026, Anthropic clarified its ban on programmatic access from third-party software, and on June 15, 2026 separated workflow credit from the chat subscription. Pro gets $20 in credit for programmatic workloads. One large workflow will consume half that amount. Once the credit runs out, workflows will stop launching until you enable overage charges. - **Max 5x ($100/month):** $100 in credit. That is enough for 5–10 large workflows a month. - **Max 20x ($200/month):** $200 in credit. - **Team ($30/$150 per member):** The credit mirrors each seat's subscription plan. - **API:** You simply pay the token rate. Anthropic itself [recommends](https://code.claude.com/docs/en/workflows#cost) estimating the cost before running a workflow:

To gauge the spend before committing to a large task, run the workflow on a small slice first: one directory instead of the whole repo, or a narrow question instead of a broad one.

— Anthropic Docs, code.claude.com/docs/en/workflows#cost
That is, run the workflow on one folder first, check `/workflows` to see how much it cost, and then decide whether to run it across the whole repo. A run has a limit of 1000 agents in total, but even 100 on a large repo already means hundreds of thousands of tokens. If your goal is to “reduce usage,” you can explicitly route secondary stages to a smaller model in the workflow script. In the prompt: “use Sonnet 4.7 for the file classification stage, and Opus 4.8 only for the final analysis.” Anthropic supports this. ## What happens inside: workflows, /workflows, and limits
Key takeaway A workflow is a JavaScript script Claude writes for your task and the runtime executes in an isolated environment. The script itself handles loops, branching, and intermediate results. It does not clutter your context. You can read the script, edit it, and save it as a command. Runtime limits: 16 parallel agents, 1000 agents per run in total.
Each run writes its own script to a file under `~/.claude/projects/`. Claude gets the script path when the run starts. This means you can: - ask Claude, “show me the script for this workflow” - open it in an editor and inspect its logic - diff it against the previous run - edit it and ask Claude to rerun the edited version The runtime sets limits: | Limit | Why | |----|----| | No user input in the middle of a run | To keep the run from waiting indefinitely — make each stage a separate workflow if you need confirmation between stages | | The script has no direct access to files or shell | Agents do that; the script only coordinates them | | Up to 16 parallel agents at once | To avoid bringing the local CPU to its knees | | 1000 agents per run in total | To stop a broken script from entering an infinite loop | A permission mode is applied to each run. By default, Claude Code asks for permission each time. You can choose “Yes, and don't ask again for `` in ``”; then that particular workflow in that project will no longer ask. In Auto mode, it asks only on the first run, then saves your approval in user settings. In `claude -p` and the Agent SDK, it does not ask because there is no one to answer. One important detail: subagents in workflows always run in `acceptEdits` mode and inherit your tool allowlist, regardless of your current permission mode. File edits are automatically approved. Keep this in mind if you are working on something critical. ## How to save a working workflow as a command
Key takeaway If you have run a workflow, liked how it worked, and know you will reuse it, save it as a `/command` using `/workflows` and the `s` key. It then works like a regular slash command: `/workflow_name arguments`. It is saved either in the project's `.claude/workflows/` (for the team) or in `~/.claude/workflows/` (for you alone).
Scenario: I ran `/code-review` through ultracode on a new branch. The workflow did three runs: the first was a quick review of the entire diff, the second was an in-depth check of security functions, and the third ran tests on the changed functions. The results converged well, and it caught two problems. Now I want to run this on every branch before merging. I open: ```bash /workflows ``` I select my completed run and press `s`. In the dialog, I choose where to save it — `.claude/workflows/` (in the project, in git, available to the team) or `~/.claude/workflows/` (personal, on any project). I give it a name, for example `pre-merge-review`. I press Enter. Now, in any future session: ```bash /pre-merge-review ``` And the workflow starts with the same script I debugged. If the workflow expects arguments, describe this in the prompt when saving it; then the script receives `args` as a global variable. You can pass a list of paths, issue numbers, file IDs, or anything else. Anthropic [notes](https://code.claude.com/docs/en/workflows#pass-input-to-a-saved-workflow) that arguments arrive as structured data:

Claude passes the list as structured data, so the script can call array and object methods on args directly without parsing it first.

— Anthropic Docs, code.claude.com/docs/en/workflows#pass-input-to-a-saved-workflow
That means you can use `args.map(...)` directly in the script, without parsing a string. This is useful for mass tasks: a list of tickets, folders, or endpoints. ## How to disable ultracode and why you might do it
Key takeaway Disable it with `/effort high` (or another level you need) and the session returns to normal mode. If you want to disable workflows permanently, use the “Dynamic workflows” toggle in `/config` or set the `CLAUDE_CODE_DISABLE_WORKFLOWS=1` environment variable. In organizations, you can do this through managed settings.
The main reason to disable it is to go back to routine work. If you switched to ultracode for one large task and have finished, switch back right away: ```bash /effort high ``` Otherwise, your next small edit will run as a workflow and burn through tokens without any benefit. For keyword-only use, leave Dynamic workflows enabled and keep an ordinary session effort such as `/effort high`; add `ultracode` only to the selected task. Do not apply the global disable below for that purpose: it also disables the keyword. If you instead want to prohibit both session-level and keyword-triggered workflows, use one of these global options: ```bash # in the client settings # /config → Dynamic workflows → off # or # ~/.claude/settings.json { "disableWorkflows": true } # or via an environment variable export CLAUDE_CODE_DISABLE_WORKFLOWS=1 ``` After that, the `ultracode` keyword in a prompt will no longer trigger a workflow, and the `ultracode` option itself will disappear from the `/effort` menu. This is useful if you work on a team that wants one shared rule: “no automatic workflows.” In that case, configure it in the organization's managed settings. I keep `/effort high` as my default and enable ultracode selectively. It is a compromise between “do it well when needed” and “do not burn the budget for no reason.” For routine edits in the project described here, regular high is enough. When I need to run a large security audit or gather research from 20 sources, I use `/effort ultracode` or put the word at the beginning of the prompt. ## What to do next If you are using Claude Code right now and have checked that you have `v2.1.154+` and the Opus 4.8 model, give it a try now. Not for the whole session, just for one specific task: ``` ultracode: go through all the files in src/components/ui/ and find where the same button is styled differently ``` Check `/workflows` to see how many agents launched and how many tokens were used. This will give you a more realistic sense of the cost and benefit than any text can. ## Sources
### Sources - [Orchestrate subagents at scale with dynamic workflows - Claude Code Docs](https://code.claude.com/docs/en/workflows) - [Claude Code changelog](https://code.claude.com/docs/en/changelog)
See also: - [Dynamic workflows in Claude Code: how to orchestrate hundreds of parallel agents](https://ailoot.ai/blog/en/claude-code-dynamic-workflows/) - [Multi-agent in Claude Code: how to parallelize subagents](https://ailoot.ai/blog/en/claude-code-parallel-worktree-agents/) - [Routines in Claude Code: automate with a schedule instead of cron](https://ailoot.ai/blog/en/claude-code-routines/) - [Sonnet or Opus in Claude Code: which model to use for which task](https://ailoot.ai/blog/en/claude-code-model-effort-sonnet-opus/) - [Goal mode in Claude Code and Codex: set a goal and work toward it](https://ailoot.ai/blog/en/goal-mode-claude-code-codex/) Get to know [Ailoot](https://ailoot.ai/). ## Questions about Ultracode in Claude Code 2026: how to enable it with one command ### How do I keep workflows available only when I deliberately use the keyword? Leave Dynamic workflows enabled and keep the ordinary session effort, such as /effort high. Add ultracode only to the specific task you want to run as a workflow; a global workflow disable also disables that keyword route. ### How do I stop a session from automatically selecting workflows? Return from /effort ultracode to an ordinary effort level. If you want to prohibit both session and keyword workflows, use the global disable described in the article and check that the keyword no longer starts one. ## Ailoot · The company and its project portfolio Ailoot combines established operating experience, a large client base, stable service and ongoing KPI control. The company and its project portfolio: millions of customers; monthly sales in the billions. Ailoot brings that operating experience to API access for AI features in customer products, agents, applications and automations.