> ## Documentation Index
> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Оркестрируйте множество подагентов с помощью динамических workflows

> Dynamic workflows оркестрируют множество подагентов из скрипта, который пишет Claude, и вы можете его переиспользовать. Используйте их для аудитов кодовой базы, крупных миграций и перекрёстной проверки исследований.

{/* plan-availability: feature=workflows plans=pro,max,team,enterprise providers=all */}

<Note>
  Dynamic workflows требуют Claude Code v2.1.154 или позже и доступны на всех платных планах, с доступом к Anthropic API, а также на Amazon Bedrock, Google Cloud's Agent Platform и Microsoft Foundry. На Pro включите их из строки Dynamic workflows в `/config`.
</Note>

Dynamic workflow — это JavaScript-скрипт, который оркестрирует [подагентов](/ru/sub-agents) в масштабе. Claude пишет скрипт для описанной вами задачи, а runtime выполняет его в фоне, пока ваша сессия остаётся отзывчивой.

Используйте workflow, когда задача требует больше агентов, чем может координировать одна беседа, или когда вы хотите, чтобы оркестрация была закодирована в скрипт, который вы можете прочитать и переиспользовать. Примеры включают сквозную проверку кодовой базы на ошибки, миграцию 500 файлов, исследовательский вопрос, который требует перекрёстной проверки источников друг против друга, и сложный план, стоящий того, чтобы его разработать с нескольких независимых углов перед тем, как вы примете решение.

<h2 id="when-to-use-a-workflow">
  Когда использовать workflow
</h2>

[Подагенты](/ru/sub-agents), [skills](/ru/skills), [команды агентов](/ru/agent-teams) и workflows могут все запустить многошаговую задачу. Разница в том, кто держит план:

|                                    | Подагенты                             | Skills                             | Команды агентов                             | Workflows                         |
| :--------------------------------- | :------------------------------------ | :--------------------------------- | :------------------------------------------ | :-------------------------------- |
| Что это                            | Рабочий Claude, которого вы создаёте  | Инструкции, которые следует Claude | Ведущий агент, контролирующий сеансы коллег | Скрипт, который выполняет runtime |
| Кто решает, что запустить дальше   | Claude, ход за ходом                  | Claude, следуя подсказке           | Ведущий агент, ход за ходом                 | Скрипт                            |
| Где живут промежуточные результаты | Контекстное окно Claude               | Контекстное окно Claude            | Общий список задач                          | Переменные скрипта                |
| Что повторяемо                     | Определение рабочего                  | Инструкции                         | Определение команды                         | Сама оркестрация                  |
| Масштаб                            | Несколько делегированных задач за ход | То же, что подагенты               | Несколько долгоживущих коллег               | Десятки-сотни агентов за запуск   |
| Прерывание                         | Перезапускает ход                     | Перезапускает ход                  | Товарищи по команде продолжают работать     | Возобновляемо в той же сессии     |

Workflow перемещает план в код. С подагентами, skills и командами агентов Claude является оркестратором: он решает ход за ходом, что создавать или назначать дальше, и каждый результат попадает в контекстное окно. Скрипт workflow держит цикл, ветвление и промежуточные результаты сам, поэтому контекст Claude содержит только финальный ответ.

Перемещение плана в код также позволяет workflow применить повторяемый паттерн качества, а не просто запустить больше агентов: он может иметь независимых агентов, которые противоречиво рецензируют выводы друг друга перед тем, как они будут доложены, или разработать план с нескольких углов и взвесить их друг против друга, чтобы вы получили более надёжный результат, чем один проход.

<h2 id="run-a-bundled-workflow">
  Запустить bundled workflow
</h2>

Самый быстрый способ увидеть workflow в действии — запустить `/deep-research`, [встроенный workflow](#bundled-workflows), который Claude Code включает для исследования вопроса по множеству источников. Вы увидите, как агенты работают через набор фаз в фоне, пока ваша сессия остаётся свободной, и получите один отчёт в конце вместо пошагового транскрипта.

<Steps>
  <Step title="Запустить workflow">
    Запустите `/deep-research` с вопросом, который вы хотите исследовать. Он распределяет веб-поиски по нескольким углам, получает и перекрёстно проверяет найденные источники и синтезирует цитируемый отчёт.

    ```text theme={null}
    /deep-research What changed in the Node.js permission model between v20 and v22?
    ```
  </Step>

  <Step title="Разрешить workflows">
    Claude Code спрашивает, разрешить ли workflow. Выберите **Yes** для продолжения. Точная подсказка зависит от вашего режима разрешений. Смотрите [Одобрить план перед его запуском](#approve-the-plan-before-it-runs) для опций для каждого режима.
  </Step>

  <Step title="Смотреть прогресс">
    Запуск начинается в фоне. Запустите `/workflows`, используйте клавиши со стрелками для выбора запуска и нажмите Enter для открытия его представления прогресса:

    ```text theme={null}
    /workflows
    ```

    Представление показывает каждую фазу с количеством агентов, общим количеством токенов и прошедшим временем. Углубитесь в любую фазу, чтобы увидеть её агентов и то, что каждый из них нашёл. Смотрите [Смотреть запуск](#watch-the-run) для полного набора элементов управления.

    Вы также можете смотреть из панели задач ниже поля ввода: там появляется однострочное резюме прогресса во время выполнения запуска. Нажмите стрелку вниз для фокусировки, затем Enter для расширения.
  </Step>

  <Step title="Прочитать отчёт">
    Когда запуск завершится, отчёт попадает в вашу сессию. Он цитирует источники, из которых каждое утверждение пришло, с утверждениями, которые не пережили перекрёстную проверку, уже отфильтрованными.

    {/* min-version: 2.1.196 */}Начиная с версии 2.1.196, когда агенты-верификаторы не могут проверить утверждение, например после ограничения скорости или ошибки API, отчёт указывает это утверждение как непроверенное вместо того, чтобы считать его опровергнутым.
  </Step>
</Steps>

Чтобы запустить workflow для вашей собственной задачи, [попросите Claude написать один](#have-claude-write-a-workflow), и как только запуск сделает то, что вы хотели, вы можете [сохранить его](#save-the-workflow-for-reuse) как команду вашу собственную.

<h3 id="bundled-workflows">
  Bundled workflows
</h3>

Claude Code включает `/deep-research` как встроенный workflow:

| Команда                     | Что она делает                                                                                                                                                                                                                                                                                                                                            |
| :-------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `/deep-research <question>` | Распределяет веб-поиски по вопросу по нескольким углам, получает и перекрёстно проверяет найденные источники, голосует по каждому утверждению и возвращает цитируемый отчёт с утверждениями, которые не пережили перекрёстную проверку, отфильтрованными. Требует, чтобы инструмент [WebSearch](/ru/tools-reference#websearch-tool-behavior) был доступен |

[Workflows, которые вы сохраняете](#save-the-workflow-for-reuse) сами, становятся командами таким же образом и появляются в автодополнении `/` рядом с встроенными.

<h3 id="watch-the-run">
  Смотреть запуск
</h3>

Workflows работают в фоне, поэтому сессия остаётся отзывчивой, пока агенты работают. Запустите `/workflows` в любое время для списка работающих и завершённых workflows, затем выберите один для открытия его представления прогресса.

```text theme={null}
/workflows
```

Представление прогресса показывает каждую фазу с количеством агентов, общим количеством токенов и прошедшим временем. Нижний колонтитул перечисляет ключ для каждого действия:

| Ключ            | Действие                                                                                                           |
| :-------------- | :----------------------------------------------------------------------------------------------------------------- |
| `↑` / `↓`       | Выбрать фазу или агента                                                                                            |
| `Enter` или `→` | Углубиться в выбранную фазу, затем в агента для чтения его подсказки, недавних вызовов инструментов и результата   |
| `Esc`           | Вернуться на один уровень назад                                                                                    |
| `j` / `k`       | Прокручивать в деталях агента, когда это переполняется                                                             |
| `f`             | {/* min-version: 2.1.186 */}Фильтровать список агентов в выбранной фазе по статусу. Нажмите снова для циклирования |
| `p`             | Приостановить или возобновить запуск                                                                               |
| `x`             | Остановить выбранного агента или остановить весь workflow, когда фокус находится на запуске                        |
| `r`             | Перезапустить выбранного работающего агента                                                                        |
| `s`             | [Сохранить](#save-the-workflow-for-reuse) скрипт запуска как команду                                               |

<h2 id="have-claude-write-a-workflow">
  Попросить Claude написать workflow
</h2>

Вы можете попросить Claude написать workflow для вашей задачи двумя способами:

* [Попросить workflow в вашей подсказке](#ask-for-a-workflow-in-your-prompt) в ваших собственных словах или включив ключевое слово `ultracode`, и Claude напишет один для задачи.
* [Позволить Claude решить с ultracode](#let-claude-decide-with-ultracode): установите `/effort ultracode` и Claude спланирует workflow для каждой существенной задачи в сессии.

Вы также можете запустить команду workflow, которая уже существует: [bundled workflow](#bundled-workflows) как `/deep-research`, или один, который вы [сохранили](#save-the-workflow-for-reuse).

<h3 id="ask-for-a-workflow-in-your-prompt">
  Попросить workflow в вашей подсказке
</h3>

Чтобы запустить одну задачу как workflow без изменения уровня усилий сессии, включите ключевое слово `ultracode` в вашу подсказку. Просьба в ваших собственных словах, например "использовать workflow" или "запустить workflow", также работает: Claude рассматривает прямой запрос как то же самое согласие. До версии 2.1.160 буквальное ключевое слово было `workflow`; запросы на естественном языке работают в обеих версиях.

```text theme={null}
ultracode: audit every API endpoint under src/routes/ for missing auth checks
```

Claude Code выделяет ключевое слово в вашем вводе и Claude пишет скрипт workflow для задачи вместо того, чтобы работать через него ход за ходом. Если вы не имели в виду запустить workflow, нажмите `Option+W` на macOS или `Alt+W` на Windows и Linux, чтобы отменить выделение для этой подсказки, или нажмите backspace, пока курсор находится прямо после выделенного ключевого слова. Чтобы остановить ключевое слово от срабатывания вообще, отключите Ultracode keyword trigger в `/config`.

Если запуск делает то, что вы хотели, вы можете [сохранить его как команду](#save-the-workflow-for-reuse) после этого.

Если у вас уже есть оркестратор, построенный другим способом, например папка подсказок подагентов или навык, который распределяет работу, вы можете указать Claude на него и попросить workflow, который делает то же самое.

<h3 id="let-claude-decide-with-ultracode">
  Позволить Claude решить с ultracode
</h3>

Ultracode — это параметр Claude Code, который объединяет `xhigh` [усилие рассуждения](/ru/model-config#adjust-effort-level) с автоматической оркестрацией workflow. С ним включённым, Claude планирует workflow для каждой существенной задачи вместо того, чтобы ждать, пока вы попросите.

```text theme={null}
/effort ultracode
```

Чтобы начать сессию с уже включённым ultracode, запустите с `claude --effort ultracode`. Требуется Claude Code версии 2.1.203 или позже.

С ultracode включённым, Claude решает, когда задача требует workflow. Один запрос может превратиться в несколько workflows подряд: один для понимания кода, один для внесения изменения и один для его проверки. Это применяется к каждой задаче в сессии, поэтому каждый запрос использует больше токенов и занимает больше времени, чем на более низких уровнях усилий.

Ultracode длится для текущей сессии и сбрасывается, когда вы начинаете новую. Вернитесь с `/effort high`, когда вы вернётесь к рутинной работе. Это доступно на моделях, которые поддерживают `xhigh` [усилие](/ru/model-config#adjust-effort-level); на других моделях меню `/effort` не предлагает это.

<h3 id="approve-the-plan-before-it-runs">
  Одобрить план перед его запуском
</h3>

В CLI подсказка для каждого запуска показывает запланированные фазы и эти опции:

* **Yes, run it**: начать запуск
* **Yes, and don't ask again for `<name>` in `<path>`**: начать и пропустить эту подсказку для этого workflow в этом проекте с этого момента
* **View raw script**: прочитать скрипт перед решением
* **No**: отменить

`Ctrl+G` открывает скрипт в вашем редакторе. `Tab` позволяет вам отрегулировать подсказку перед запуском.

Видите ли вы эту подсказку, зависит от вашего [режима разрешений](/ru/permission-modes):

| Режим разрешений                           | Когда вас спрашивают                                                                                                                                                                      |
| :----------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Default, accept edits                      | Каждый запуск, если вы не выбрали **Yes, and don't ask again** для этого workflow в этом проекте                                                                                          |
| Auto                                       | Только первый запуск. Любой **Yes** записывает согласие в ваши пользовательские параметры, и более поздние запуски начинаются без подсказки. Полностью пропущено, когда ultracode включён |
| Bypass permissions, `claude -p`, Agent SDK | Никогда. Запуск начинается немедленно                                                                                                                                                     |

В приложении Desktop карточка одобрения показывает имя workflow, список фаз и предупреждение об использовании токенов, с действиями **Once**, **Always** и **Deny**. Представление прогресса появляется в боковой панели Background tasks.

Ваш режим разрешений контролирует только подсказку запуска выше. Подагенты, которые создаёт workflow, всегда работают в режиме `acceptEdits` и наследуют ваш [список разрешённых инструментов](/ru/settings#permission-settings), независимо от режима вашей сессии. Редактирования файлов автоматически одобрены.

Команды shell, веб-выборки и MCP-инструменты, которые не в вашем списке разрешённых, всё ещё могут вас спросить во время запуска. Чтобы избежать этого на длительном запуске, добавьте команды, которые нужны агентам, в ваш список разрешённых перед запуском.

В `claude -p` и Agent SDK нет никого, кого спрашивать, поэтому вызовы инструментов следуют вашим настроенным правилам разрешений без интерактивного подтверждения.

<h3 id="save-the-workflow-for-reuse">
  Сохранить workflow для переиспользования
</h3>

Когда Claude пишет workflow для задачи, которую вы будете повторять, вы можете сохранить скрипт этого запуска как команду. Процесс, как проверка, которую вы запускаете на каждой ветке, затем запускает ту же оркестрацию каждый раз.

Запустите `/workflows`, выберите запуск, который вы хотите сохранить, и нажмите `s`. В диалоге сохранения Tab переключается между двумя местами сохранения:

* `.claude/workflows/` в вашем проекте: общее с каждым, кто клонирует репо
* `~/.claude/workflows/` в вашем домашнем каталоге: доступно в каждом проекте, видимо только вам

Нажмите Enter для сохранения. Workflow запускается как `/<name>` в будущих сессиях из любого места.

{/* min-version: 2.1.178 */}В монорепо с несколькими каталогами `.claude/` вы можете хранить workflows рядом с пакетом, к которому они применяются. Начиная с версии 2.1.178, сохранение в местоположение проекта записывает в ближайший каталог `.claude/workflows/`, который уже существует между вашей рабочей директорией и корнем репозитория, или в корень репозитория, если ни один ещё не существует. Workflows проекта также загружаются из каждого `.claude/workflows/` вдоль этого пути, и когда более одного определяет одно имя, Claude Code запускает тот, который ближе всего к рабочей директории.

Если project workflow и personal workflow имеют одно имя, запускается project.

<h3 id="pass-input-to-a-saved-workflow">
  Передать входные данные в сохранённый workflow
</h3>

Сохранённый workflow может принимать входные данные через параметр `args`. Скрипт читает его как глобальную переменную с именем `args`. Используйте это для предоставления исследовательского вопроса, списка целевых путей или объекта конфигурации во время вызова вместо редактирования скрипта для каждого запуска.

Следующая подсказка запускает сохранённый workflow со списком номеров проблем:

```text theme={null}
> Run /triage-issues on issues 1024, 1025, and 1030
```

Claude передаёт список как структурированные данные, поэтому скрипт может вызывать методы массива и объекта на `args` напрямую без предварительного анализа. Если `args` опущен, глобальная переменная имеет значение `undefined` внутри скрипта.

<h2 id="example-workflow-prompts">
  Примеры подсказок workflow
</h2>

Workflow подходит лучше всего, когда задача больше, чем один агент может держать в контексте, или когда один и тот же шаг нужно запустить по множеству элементов. Подсказки ниже показывают общие формы. Каждая просит Claude написать и запустить workflow для этой задачи; вы не пишете скрипт сами.

<h3 id="audit-many-files-for-the-same-issue">
  Аудит множества файлов на одну и ту же проблему
</h3>

Распределите одного агента на файл, затем соберите и проверьте выводы.

```text theme={null}
> use a workflow to audit every route handler under src/routes/ for missing authentication checks, and adversarially verify each finding before reporting it
```

<h3 id="keep-fixing-until-a-check-passes">
  Продолжайте исправлять, пока проверка не пройдёт
</h3>

Запустите проверку, исправьте то, что не прошло, и повторяйте, пока это не пройдёт или не перестанет делать прогресс.

```text theme={null}
> use a workflow to run npx tsc --noEmit and keep fixing the reported errors until the type check passes or two rounds in a row make no progress
```

<h3 id="migrate-many-files-in-parallel">
  Мигрировать множество файлов параллельно
</h3>

Обнаружьте файлы для миграции, преобразуйте каждый в изолированную копию, чтобы редактирования не конфликтовали, и проверьте каждый результат.

```text theme={null}
> use a workflow to migrate every component under src/components/ from styled-components to Tailwind, working on each file in its own isolated copy
```

<h3 id="review-every-changed-file-and-write-one-summary">
  Проверить каждый изменённый файл и написать одно резюме
</h3>

Запустите рецензента на файл, затем передайте все выводы одному агенту, который ранжирует и дедублирует их.

```text theme={null}
> use a workflow to review every file changed in this PR for correctness issues, then merge the per-file findings into one ranked summary
```

<h3 id="research-a-topic-across-many-sources">
  Исследовать тему по множеству источников
</h3>

Распределите читателей по changelogs, issues и docs, затем синтезируйте. Встроенный workflow `/deep-research` делает это; вы также можете описать более узкую версию.

```text theme={null}
> use a workflow to research how our three competitors handle rate limiting: read their public docs and recent changelog entries in parallel, then compare the approaches
```

<h3 id="find-issues-until-the-list-stops-growing">
  Найти проблемы, пока список не перестанет расти
</h3>

Продолжайте искать в раундах и остановитесь, когда новые раунды не найдут ничего нового.

```text theme={null}
> use a workflow to find flaky tests in this repo: run the suite repeatedly, record which tests fail intermittently, and stop once two rounds in a row find nothing new
```

<h3 id="what-the-saved-script-looks-like">
  Как выглядит сохранённый скрипт
</h3>

Когда вы [сохраняете workflow](#save-the-workflow-for-reuse), файл в `.claude/workflows/` содержит блок `meta`, за которым следует тело скрипта, который оркестрирует подагентов. Обычно вам не нужно его редактировать, но вот форма маленького, чтобы вы могли узнать, что Claude сгенерировал:

```javascript theme={null}
export const meta = {
  name: 'audit-routes',
  description: 'Audit every route handler for missing auth checks',
}

const found = await agent('List every .ts file under src/routes/.', {
  schema: { type: 'object', required: ['files'], properties: { files: { type: 'array', items: { type: 'string' } } } },
})

const audits = await pipeline(found.files, file =>
  agent(`Audit ${file} for missing authentication checks.`, { label: file }),
)

return audits.filter(Boolean)
```

Тело — это простой JavaScript с top-level `await`. `agent()` создаёт один подагент и `pipeline()` запускает один на элемент в списке. Если вы хотите отредактировать скрипт вручную, попросите Claude провести вас через изменение, или смотрите запись инструмента Workflow в [справочнике Agent SDK](/ru/agent-sdk/typescript) для полного набора опций.

<h2 id="how-a-workflow-runs">
  Как работает workflow
</h2>

Runtime workflow выполняет скрипт в изолированной среде, отдельно от вашей беседы. Промежуточные результаты остаются в переменных скрипта вместо того, чтобы попадать в контекст Claude.

Каждый запуск записывает свой скрипт в файл в директорию вашей сессии в `~/.claude/projects/`. Claude получает путь при запуске, поэтому вы можете попросить его. Вы можете открыть этот файл, чтобы прочитать оркестровку, которую написал Claude, сравнить его с скриптом предыдущего запуска или отредактировать его и попросить Claude перезапустить с отредактированной версии.

Runtime отслеживает результат каждого агента по мере прогресса запуска, что делает запуск [возобновляемым](#resume-after-a-pause) в той же сессии.

<h3 id="behavior-and-limits">
  Поведение и ограничения
</h3>

Runtime применяет следующие ограничения:

| Ограничение                                                               | Почему                                                                                                                                          |
| :------------------------------------------------------------------------ | :---------------------------------------------------------------------------------------------------------------------------------------------- |
| Нет пользовательского ввода во время запуска                              | Только подсказки разрешений агентов могут приостановить запуск. Для одобрения между этапами запустите каждый этап как свой собственный workflow |
| Нет прямого доступа к файловой системе или shell из самого workflow       | Агенты читают, пишут и запускают команды. Скрипт координирует агентов                                                                           |
| До 16 одновременных агентов, меньше на машинах с ограниченными ядрами CPU | Ограничивает локальное использование ресурсов                                                                                                   |
| 1000 агентов всего за запуск                                              | Предотвращает бесконечные циклы                                                                                                                 |

<h2 id="manage-runs">
  Управление запусками
</h2>

Как только запуск начинается, вы управляете им из представления `/workflows`, или расширяя его строку прогресса в панели задач ниже поля ввода.

<h3 id="resume-after-a-pause">
  Возобновить после паузы
</h3>

Если вы остановите запуск, вы можете возобновить его: агенты, которые уже завершились, возвращают свои кэшированные результаты, а остальные работают в реальном времени. Возобновите приостановленный запуск из `/workflows`, выбрав его и нажав `p`, или попросите Claude перезапустить workflow с тем же скриптом.

Возобновление работает в той же сессии Claude Code. Если вы выйдете из Claude Code, пока workflow работает, следующая сессия запустит workflow заново.

<h3 id="cost">
  Стоимость
</h3>

Workflow создаёт множество агентов, поэтому один запуск может использовать значительно больше токенов, чем работа через ту же задачу в беседе. Запуски считаются в сторону использования вашего плана и ограничений скорости, как и любая другая сессия.

Чтобы оценить расходы перед выполнением крупной задачи, сначала запустите workflow на небольшом срезе: один каталог вместо всего репозитория или узкий вопрос вместо широкого. Представление `/workflows` показывает использование токенов каждым агентом по мере выполнения запуска, и вы можете остановить запуск там в любое время без потери завершённой работы. [Ограничения агентов](#behavior-and-limits) среды выполнения ограничивают количество агентов, которых может создать один запуск, что ограничивает стоимость неконтролируемого скрипта. Чтобы по умолчанию сохранять каждый запуск меньшего размера, [установите рекомендацию по размеру](#set-a-size-guideline) в `/config`.

Claude Code также отмечает запуск, который растёт необычно быстро. Когда workflow планирует более 25 агентов, или его прогнозируемый общий объём токенов превышает 1,5 миллиона, его строка прогресса в панели задач ниже поля ввода показывает предупреждение `Large workflow`. Предупреждение указывает вам на [`/workflows`](#watch-the-run), где вы можете остановить запуск. Требуется Claude Code v2.1.203 или позже.

Предупреждение носит рекомендательный характер: оно не приостанавливает и не ограничивает запуск. Два параметра изменяются, когда вы его видите:

* Если вы [установите рекомендацию по размеру](#set-a-size-guideline), количество агентов рекомендации заменяет порог в 25 агентов.
* Сессии с включённым [ultracode](#let-claude-decide-with-ultracode) не показывают предупреждение, потому что включение ultracode уже означает согласие на крупные запуски.

Каждый агент в workflow использует модель вашей сессии, если скрипт не маршрутизирует этап на другую. Чтобы контролировать стоимость модели:

* Проверьте `/model` перед крупным запуском, если вы обычно переключаетесь на меньшую модель для рутинной работы
* Попросите Claude использовать меньшую модель для этапов, которые не требуют самой сильной, когда вы описываете задачу

<h3 id="set-a-size-guideline">
  Установить рекомендацию по размеру
</h3>

Параметр Dynamic workflow size в `/config` сохраняет workflows, которые пишет Claude, в меньшем масштабе по умолчанию. Claude Code отправляет параметр Claude в качестве рекомендации, поэтому подсказка, которая требует другого масштаба, всё ещё переопределяет его. Требуется Claude Code v2.1.202 или позже.

Каждое значение устанавливает количество агентов, на которое Claude нацелен в написанных им скриптах.

| Значение       | Рекомендация, отправленная Claude            |
| :------------- | :------------------------------------------- |
| `unrestricted` | Нет рекомендации. Это значение по умолчанию. |
| `small`        | Нацеливайтесь на менее 5 агентов.            |
| `medium`       | Нацеливайтесь на менее 15 агентов.           |
| `large`        | Нацеливайтесь на менее 50 агентов.           |

Изменения вступают в силу при следующем запросе. [Ограничения агентов среды выполнения](#behavior-and-limits) по-прежнему применяются независимо от параметра.

<h3 id="turn-workflows-off">
  Отключить workflows
</h3>

Workflows доступны в CLI, приложении Desktop, расширениях IDE, [неинтерактивном режиме](/ru/headless) с `claude -p` и [Agent SDK](/ru/agent-sdk/overview). Те же параметры отключения применяются на каждой поверхности.

Чтобы отключить workflows для себя:

* Переключите Dynamic workflows в `/config`. Сохраняется между сессиями.
* Установите `"disableWorkflows": true` в `~/.claude/settings.json`. Сохраняется между сессиями.
* Установите `CLAUDE_CODE_DISABLE_WORKFLOWS=1`. Читается при запуске, поэтому применяется везде, где вы это установите.

Чтобы отключить workflows для всей вашей организации, установите `"disableWorkflows": true` в [управляемые параметры](/ru/server-managed-settings), или используйте переключатель на странице [параметров администратора Claude Code](https://claude.ai/admin-settings/claude-code).

Когда workflows отключены, встроенные команды workflow недоступны, ключевое слово `ultracode` больше не запускает запуск, и `ultracode` удаляется из меню `/effort`.

<h2 id="related-resources">
  Связанные ресурсы
</h2>

* [Запустить агентов параллельно](/ru/agents): сравнить подагентов, представление агента, команды агентов и workflows
* [Создать пользовательские подагенты](/ru/sub-agents): примитив рабочего, который оркестрируют workflows
* [Управлять затратами](/ru/costs): как многоагентные запуски считаются в сторону ограничений использования