---
title: Защита развёртывания Managed Agents
url: https://platform.claude.com/docs/ru/managed-agents/secure-deployment
description: Настройки, которые ограничивают, к чему ваши агенты могут получить доступ и что они могут делать, — в порядке важности.
featureMetadata:
topic:
title: Managed Agents
url: https://platform.claude.com/docs/en/managed-agents/overview
status: beta
betaHeader: managed-agents-2026-04-01
---
В этом руководстве перечислены настройки, которые ограничивают, к чему агент в Claude Managed Agents может получить доступ и что он может делать, — начиная с самых важных. Каждый раздел содержит ссылку на страницу, где настройка описана полностью.
| Раздел | Настройка или решение | Рекомендуется |
| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Выберите, где работает агент](https://platform.claude.com/docs/ru/managed-agents/secure-deployment#choose-where-the-agent-runs) | Облачная или самостоятельно размещаемая песочница («sandbox») | Облачная, если только инструменты не должны работать в инфраструктуре, которую вы контролируете |
| [Ограничьте сеть](https://platform.claude.com/docs/ru/managed-agents/secure-deployment#limit-the-network) | `networking.type` среды | `limited`, только с теми хостами, которые нужны агенту |
| [Храните учётные данные в хранилищах](https://platform.claude.com/docs/ru/managed-agents/secure-deployment#keep-credentials-in-vaults) | `injection_location` и `networking` для каждой записи учётных данных в виде переменной окружения | Только заголовки запросов и сеть `limited` только с теми хостами, для которых предназначен ключ |
| [Ограничьте веб-поиск и веб-загрузку](https://platform.claude.com/docs/ru/managed-agents/secure-deployment#restrict-web-search-and-web-fetch) | `allowed_domains` для каждого веб-инструмента | «Allowlist» (список разрешённых) для каждого инструмента. Для `web_fetch` укажите только сайты, которые нужны агенту. Для `web_search` укажите сайты, из которых вы хотите получать результаты |
| [Одобряйте рискованные действия](https://platform.claude.com/docs/ru/managed-agents/secure-deployment#approve-risky-actions) | `permission_policy` для каждого инструмента | `auto` для `bash`, `write`, `edit`, `web_fetch` и инструментов MCP, которые только читают данные. Вместо этого `always_ask` для инструмента, если вы не можете отменить его изменения за пределами песочницы или если одного лишь пересланного текста конечного пользователя не должно быть достаточно для его запуска |
| [Дайте агенту минимальный набор инструментов](https://platform.claude.com/docs/ru/managed-agents/secure-deployment#give-the-agent-the-smallest-tool-set) | `default_config.enabled` в наборе инструментов агента | `false`, затем включите инструменты, которые нужны агенту |
| [Держите недоверенные входные данные подальше от мощных инструментов](https://platform.claude.com/docs/ru/managed-agents/secure-deployment#keep-untrusted-input-away-from-powerful-tools) | Какие инструменты и учётные данные есть у агента, когда он читает недоверенные входные данные | Ни у одного агента, читающего недоверенные входные данные, нет инструмента с `always_allow`, который записывает файлы, выполняет команды или изменяет записи |
| [Установите лимиты и способ остановки](https://platform.claude.com/docs/ru/managed-agents/secure-deployment#set-limits-and-a-way-to-stop) | `budget` для каждой сессии и развёртывания | Лимит, соответствующий ожидаемой стоимости запуска |
| [При необходимости поручите офлайн-проверяющему читать каждую стенограмму](https://platform.claude.com/docs/ru/managed-agents/secure-deployment-monitoring#optionally-have-an-offline-reviewer-read-every-transcript) | Запускаемое вами задание офлайн-проверки, которое читает события каждой сессии | Необязательно. Проверка по расписанию каждой сессии, которая перешла в режим ожидания или завершилась |
| [Мониторинг сессий и проверка сроков хранения](https://platform.claude.com/docs/ru/managed-agents/secure-deployment-monitoring#monitor-sessions-and-review-retention) | «Webhooks» (вебхуки) и удаление сессий | Оповещение, когда сессия переходит в режим ожидания, достигает бюджета или завершается, и проверка причины перехода в режим ожидания. Сохраняйте нужные события в собственных журналах и удаляйте сессии, которые вам больше не нужны |
В разделе [Риски безопасности и границы песочницы](https://platform.claude.com/docs/ru/managed-agents/secure-deployment-risks) объясняется, почему эти настройки важны и от чего они не защищают. Чтобы проверять и отслеживать сессии, см. [Проверка и мониторинг сессий агентов](https://platform.claude.com/docs/ru/managed-agents/secure-deployment-monitoring).
## Выберите, где работает агент
От того, где работают инструменты агента, зависит, кто обеспечивает безопасность песочницы: Anthropic — в случае облачной среды, или вы — в случае самостоятельно размещаемой песочницы. Чтобы выбрать между ними и узнать, что передаётся в Anthropic в каждом случае, см. [Выбор среды для агента](https://platform.claude.com/docs/ru/managed-agents/choosing-an-environment).
Если вы используете [самостоятельно размещаемую песочницу](https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes), учитывайте следующие четыре момента:
* **Сеть:** раздел [Ограничьте сеть](https://platform.claude.com/docs/ru/managed-agents/secure-deployment#limit-the-network) относится к облачным средам. Для самостоятельно размещаемой песочницы установите эквивалентные ограничения на её трафик в собственном брандмауэре. Ваш брандмауэр не ограничивает серверы MCP, которые объявляет агент, поэтому проверяйте их, а также те, которые ваше приложение задаёт для сессии.
* **Веб-инструменты:** веб-инструменты работают на серверах Anthropic, поэтому ваш брандмауэр их не ограничивает. Ограничивайте их с помощью списков доменов. См. [Ограничьте веб-поиск и веб-загрузку](https://platform.claude.com/docs/ru/managed-agents/secure-deployment#restrict-web-search-and-web-fetch).
* **Учётные данные:** учётные данные в виде переменных окружения пока не поддерживаются в самостоятельно размещаемых песочницах.
* **Изоляция и усиление защиты:** вы отвечаете и за то, и за другое. См. [Модель безопасности](https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes-security).
Ни один из вариантов не меняет охват соответствия требованиям Managed Agents или срок хранения истории сессий. См. [Мониторинг сессий и проверка сроков хранения](https://platform.claude.com/docs/ru/managed-agents/secure-deployment-monitoring#monitor-sessions-and-review-retention).
## Ограничьте сеть
Установите `networking.type` в значение `limited` и укажите в `allowed_hosts` только те хосты, которые нужны агенту. Запрос на создание среды без `networking` может получить `unrestricted`, поэтому задавайте `networking` в каждом запросе на создание. См. [Риски неограниченного сетевого доступа](https://platform.claude.com/docs/ru/managed-agents/environments#risks-of-unrestricted-networking).
Подключённые вами файлы, хранилища памяти и репозитории GitHub остаются доступными агенту независимо от `allowed_hosts`.
В примерах на этой странице используется агент поддержки. Он читает обращение клиента, находит заказ, читает ваш справочный центр и составляет черновик ответа. Поиск заказа выполняет ваше приложение, и ему не нужен хост, поэтому эта среда разрешает один хост — справочный центр — для `web_fetch`:
```bash cURL
curl -fsS https://api.anthropic.com/v1/environments \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: managed-agents-2026-04-01" \
-H "content-type: application/json" \
-d '{
"name": "support-agent",
"config": {
"type": "cloud",
"networking": {
"type": "limited",
"allowed_hosts": ["help.example.com"]
}
}
}'
```
```bash CLI
ant apply environment.yaml
```
```yaml
# yaml-language-server: $schema=https://platform.claude.com/schemas/ant/beta/environment.json
name: support-agent
config:
type: cloud
networking:
type: limited
allowed_hosts:
- help.example.com
```
```python Python
environment = client.beta.environments.create(
name="support-agent",
config={
"type": "cloud",
"networking": {
"type": "limited",
"allowed_hosts": ["help.example.com"],
},
},
)
```
```typescript TypeScript
const environment = await client.beta.environments.create({
name: "support-agent",
config: {
type: "cloud",
networking: {
type: "limited",
allowed_hosts: ["help.example.com"]
}
}
});
```
```csharp C#
using Anthropic.Models.Beta.Environments;
var environment = await client.Beta.Environments.Create(new()
{
Name = "support-agent",
Config = new BetaCloudConfigParams
{
Networking = new BetaLimitedNetworkParams
{
AllowedHosts = ["help.example.com"],
},
},
});
```
```go Go
environment, err := client.Beta.Environments.New(ctx, anthropic.BetaEnvironmentNewParams{
Name: "support-agent",
Config: anthropic.BetaEnvironmentNewParamsConfigUnion{
OfCloud: &anthropic.BetaCloudConfigParams{
Networking: anthropic.BetaCloudConfigParamsNetworkingUnion{
OfLimited: &anthropic.BetaLimitedNetworkParams{
AllowedHosts: []string{"help.example.com"},
},
},
},
},
})
if err != nil {
panic(err)
}
_ = environment
```
```java Java
import com.anthropic.models.beta.environments.*;
import java.util.List;
var environment = client.beta().environments().create(EnvironmentCreateParams.builder()
.name("support-agent")
.config(BetaCloudConfigParams.builder()
.networking(BetaLimitedNetworkParams.builder()
.allowedHosts(List.of("help.example.com"))
.build())
.build())
.build());
```
```php PHP
$environment = $client->beta->environments->create(
name: 'support-agent',
config: [
'type' => 'cloud',
'networking' => [
'type' => 'limited',
'allowed_hosts' => ['help.example.com'],
],
],
);
```
```ruby Ruby
environment = client.beta.environments.create(
name: "support-agent",
config: {
type: "cloud",
networking: {
type: "limited",
allowed_hosts: ["help.example.com"]
}
}
)
```
У среды `limited` есть три сетевые настройки:
| Настройка | Что она открывает для кода в песочнице | Рекомендуется |
| ------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `allowed_hosts` | Указанные вами хосты, для любых запросов | Только хосты, которые нужны агенту, включая хост каждого сервера MCP, которым вы управляете или которому доверяете |
| `allow_package_managers` | [Хосты менеджеров пакетов](https://platform.claude.com/docs/ru/managed-agents/environments#package-manager-hosts). Они включают все репозитории и пути на `github.com`, `gitlab.com` и `bitbucket.org`, где кто угодно может публиковать контент и куда код в песочнице может загружать файлы | `false`, если только настройка `packages` среды не содержит пакеты, что требует `true`. Если агент устанавливает пакеты во время работы, вместо этого укажите в `allowed_hosts` только нужные ему хосты реестров |
| `allow_mcp_servers` | Никаких хостов. Managed Agents подключается к серверам MCP с серверов Anthropic | `false`, при этом хост каждого сервера MCP, которым вы управляете или которому доверяете, указан в `allowed_hosts` |
Настройки `allow_package_managers` и `allow_mcp_servers` не добавляют хостов для веб-поиска и веб-загрузки.
Оставьте `allow_mcp_servers` выключенной (это значение по умолчанию) и укажите в `allowed_hosts` хост каждого сервера MCP, которым вы управляете или которому доверяете. Каждый указанный хост также открыт для кода в песочнице. Когда `allow_mcp_servers` выключена, проверка при создании сессии отклоняет запрос, если хост сервера MCP не указан. См. [Предоставление аутентификации при создании сессии](https://platform.claude.com/docs/ru/managed-agents/mcp-connector#provide-authentication-at-session-creation). Та же проверка выполняется, когда обновление сессии изменяет `mcp_servers`.
Сетевой доступ предоставляется для каждого хоста, а не для каждой операции. Песочница может отправить любой запрос на разрешённый хост, включая загрузки, такие как `git push` и публикация пакетов. Она также может использовать любые учётные данные, которые передаёт команда, даже если кто-то спрятал их в тексте, который читает агент.
Выбирая хосты для `allowed_hosts`, следуйте двум правилам:
* Указывайте только хосты, которыми вы управляете или которым доверяете.
* Избегайте подстановочных знаков `*.` и доменов общего хостинга, где кто угодно может публиковать контент.
Если у агента остаётся `bash`, настройте [политику разрешений](https://platform.claude.com/docs/ru/managed-agents/permission-policies) инструмента `bash`, как описано в разделе [Одобряйте рискованные действия](https://platform.claude.com/docs/ru/managed-agents/secure-deployment#approve-risky-actions).
После ужесточения настроек среды запустите новые сессии и остановите уже работающие. Уже работающая сессия может сохранять старые ограничения до своего завершения. См. [Установите лимиты и способ остановки](https://platform.claude.com/docs/ru/managed-agents/secure-deployment#set-limits-and-a-way-to-stop).
Все сетевые настройки описаны в разделе [Настройка облачной среды](https://platform.claude.com/docs/ru/managed-agents/environments#networking).
## Храните учётные данные в хранилищах
Храните каждый секрет в «vault» (хранилище). Для каждой записи учётных данных в виде переменной окружения задайте местом внедрения только заголовки запросов и укажите только те хосты, для которых предназначен секрет. Код в песочнице видит заполнитель вместо секрета. Managed Agents подставляет настоящий секрет только в исходящие HTTPS-запросы к хостам, разрешённым для этих учётных данных. Поэтому секрет остаётся вне прямой досягаемости модели, если только сервис не отправит его обратно, например конечная точка, которая возвращает заголовки запроса. Если `networking` учётных данных имеет значение `unrestricted`, Managed Agents подставляет настоящий секрет в запросы к любому хосту, к которому среда разрешает доступ песочнице. Чтобы использовать хранилище, передайте его ID в `vault_ids` при создании сессии или развёртывания.
| Настройка | Значение | Почему | Чего она не делает |
| --------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `injection_location` | `{"header": true, "body": false}`, после того как вы проверите, что сервис читает ключ из заголовка | Тела запросов часто формируются из контента, который читает агент, поэтому ключ в теле более уязвим. Укажите оба поля: запрос на создание без этого объекта включает оба места, а обновление изменяет только отправленные вами поля | Код по-прежнему может использовать ключ на каждом хосте, который разрешают учётные данные. Сервис, ожидающий ключ в теле, получит заполнитель и отклонит запрос |
| `networking` учётных данных | `limited`, с точными хостами, для которых предназначен ключ | Ответы попадают в песочницу в открытом виде, поэтому избегайте подстановочных знаков, доменов общего хостинга и хостов, которые возвращают заголовки запроса | Она не открывает хост. Среда также должна его разрешать |
| Разрешения ключа в сервисе, который его выдал | Только разрешения, которые нужны агенту | Агент может делать всё, что разрешает ключ | Неприменимо |
| Токен GitHub смонтированного репозитория | [Детализированный токен](https://platform.claude.com/docs/ru/managed-agents/github#token-permissions) с минимальными разрешениями | Код в песочнице может с его помощью получать данные из смонтированного репозитория и отправлять в него изменения в течение всей сессии. Предоставляйте доступ на запись, только если агент должен отправлять изменения | Неприменимо |
Агенту поддержки не нужны учётные данные в хранилище, потому что ключ API для вашего API заказов хранит ваше приложение. Если у вашего агента есть учётные данные в хранилище, см. [Добавление учётных данных](https://platform.claude.com/docs/ru/managed-agents/vaults#add-a-credential), где приведён запрос на всех языках.
Не помещайте ключи в системные подсказки, определения агентов и сообщения. Не давайте агенту ключ API Claude. Даже если ключ API Claude находится в хранилище, код в песочнице может использовать его для прямых вызовов Claude API. Он может делать всё, что разрешает этот ключ, например запускать или удалять сессии либо использовать веб-поиск и веб-загрузку. Настройки инструментов агента, одобрения и бюджет к этим вызовам не применяются. В среде `limited` код может выполнять такие вызовы, только если `allowed_hosts` разрешает песочнице доступ к `api.anthropic.com`.
Получайте токены самостоятельно и сохраняйте их в хранилище, потому что токен, который код в песочнице получает с помощью сохранённого секрета, возвращается в открытом виде.
Храните хранилища для рабочих нагрузок с разными уровнями доверия в отдельных [рабочих пространствах](https://platform.claude.com/docs/ru/manage-claude/workspaces), потому что любой ключ API с доступом к рабочему пространству может ссылаться на его хранилища. Используйте ключи API, ограниченные одним рабочим пространством.
Учётные данные MCP и ротация описаны в разделе [Аутентификация с помощью хранилищ](https://platform.claude.com/docs/ru/managed-agents/vaults).
## Ограничьте веб-поиск и веб-загрузку
Задайте в `allowed_domains` для `web_fetch` сайты, которые нужны агенту. Любой URL, который загружает агент, может передать данные сайту, на который он указывает, поэтому этот список является средством защиты. Для `web_search` задайте в `allowed_domains` сайты, из которых вы хотите получать результаты, чтобы результаты поступали только с сайтов, в точности которых вы уверены. Список не мешает поисковому запросу попасть к поставщику поиска. Результаты поиска содержат текст со страниц, поэтому список также ограничивает, текст каких сайтов попадает к агенту. Задавайте `allowed_domains` для обоих инструментов в средах любого типа.
Список `blocked_domains` блокирует указанные хосты и их поддомены и никакие другие хосты. Тот же контент всё равно может попасть к агенту из веб-архивов, кэшей, зеркал или связанных доменов, которые вы не указали. Не полагайтесь на `blocked_domains` для обеспечения безопасности. Используйте `allowed_domains` и указывайте хосты, которым доверяете.
В среде `limited` список `allowed_hosts` из раздела [Ограничьте сеть](https://platform.claude.com/docs/ru/managed-agents/secure-deployment#limit-the-network) также ограничивает веб-инструменты. Среда `unrestricted` или самостоятельно размещаемая песочница веб-инструменты не ограничивают.
| В среде `limited` | Результат |
| ------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Запись `allowed_domains` включённого веб-инструмента находится за пределами `allowed_hosts` | Создание сессии завершается ошибкой 400, как и обновление сессии, добавляющее такую запись. Сессия, которую запускает развёртывание — по расписанию или вручную, — всё равно создаётся. Затем инструмент ничего не возвращает с хостов за пределами `allowed_hosts` |
| У веб-инструмента нет собственного списка | Инструмент возвращает страницы и результаты только с хостов из `allowed_hosts`. Задайте также `allowed_domains` для инструмента |
| В `allowed_hosts` нет записей | Ни один веб-инструмент не возвращает ни страниц, ни результатов поиска |
| Вы добавляете хост в `allowed_hosts` для веб-инструмента | Хост также открывается для кода в песочнице |
Два списка сопоставляют хосты по-разному:
| Список | Запись | Соответствует | Не соответствует |
| ---------------------------------- | --------------- | ------------------------------ | ----------------- |
| `allowed_hosts` (среда) | `example.com` | `example.com` | `www.example.com` |
| `allowed_hosts` (среда) | `*.example.com` | Любой поддомен | `example.com` |
| `allowed_domains` (веб-инструмент) | `example.com` | `example.com` и любой поддомен | Другие домены |
Если агенту нужен сайт и все его поддомены, укажите в `allowed_hosts` и `example.com`, и `*.example.com`, а в остальных случаях указывайте точные хосты. Если инструмент указывает `example.com`, а `allowed_hosts` — только `*.example.com`, сессия создаётся. Проверка при создании сессии считает `example.com` входящим в `*.example.com`, но инструмент ничего не возвращает с самого `example.com`. О том, как сопоставляются два списка, см. [Задание списков доменов для агента](https://platform.claude.com/docs/ru/managed-agents/tools-web-restrictions#set-domain-lists-on-an-agent).
Инструмент `web_fetch` также открывает только те URL, которые уже появлялись в сессии:
| Где появляется URL | Может ли `web_fetch` его открыть |
| ----------------------------------------------------------------------------------------- | ----------------------------------------------------- |
| Текст пользовательского сообщения, включая пересылаемый вами текст конечного пользователя | Да |
| Описание события `user.define_outcome` | Да |
| Адрес результата веб-поиска | Да |
| Текст страницы, которую ранее вернул `web_fetch` (не PDF), где показан полный URL | Да |
| Текст результата пользовательского инструмента, когда Claude вызвал инструмент напрямую | Да, если только результат не помечен `is_error: true` |
| Системная подсказка | Нет |
| Конфигурация агента, включая записи `allowed_domains` | Нет |
| Собственный вывод Claude | Нет |
| Вывод `bash` и других инструментов песочницы | Нет |
| Результат инструмента MCP | Нет |
| Файл, прикреплённый к пользовательскому сообщению | Нет |
В мультиагентной сессии `web_fetch` открывает URL от другого агента, только если он попал к этому агенту через источник, помеченный «Да». Результат пользовательского инструмента при прямом вызове считается источником, помеченным «Да». Это верно, даже если его текст написал Claude, например когда инструмент повторяет свои входные данные. URL может учитываться, даже если он записан без `https://`, например `example.com/docs`. Инструмент `web_fetch` не всегда может открыть ссылку, которая показывает слова вместо своего URL, например «Связаться с поддержкой». Если агент должен загрузить URL, который не появлялся в сессии, отправьте его в пользовательском сообщении.
Это правило снижает вероятность того, что внедрённый текст сформирует URL, передающий конфиденциальные данные. Текст конечного пользователя, результаты поиска, загруженные страницы и результаты пользовательских инструментов всё равно могут добавлять URL, поэтому не отключайте `allowed_domains`. Messages API применяет похожее правило с другим списком источников. См. [Проверка URL-адресов](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/web-fetch-tool#url-validation).
Список доменов для `web_fetch` не ограничивает инструмент `bash`. Также [ограничьте сеть](https://platform.claude.com/docs/ru/managed-agents/secure-deployment#limit-the-network). См. [Правила списков доменов](https://platform.claude.com/docs/ru/managed-agents/tools-web-restrictions#domain-list-rules).
## Одобряйте рискованные действия
Установите `auto` для `bash`, `write`, `edit` и `web_fetch`, а также для инструментов MCP, которые только читают данные. Вместо этого используйте `always_ask` для инструмента, если вы не можете отменить его изменения за пределами песочницы. Также используйте его для инструмента, который не должен запускаться только потому, что об этом просит пересылаемый вами текст конечного пользователя. [Политика разрешений](https://platform.claude.com/docs/ru/managed-agents/permission-policies) определяет, выполняется ли вызов инструмента, ожидает ли он вашего одобрения или оценивается сервером.
| Инструмент | Рекомендуемая политика | Почему |
| --------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `read`, `glob`, `grep` | `always_allow` | Они читают файлы в песочнице и ничего не изменяют |
| `bash`, `write`, `edit` | `auto`. Используйте `always_ask` для инструмента, если вы не можете отменить его изменения за пределами песочницы. Используйте `always_ask` для `bash`, если вы пересылаете текст конечного пользователя | Значение по умолчанию для набора инструментов агента — `always_allow`, при котором каждый вызов выполняется без одобрения |
| `web_fetch` | `auto` | URL, который загружает агент, может передать данные сайту, на который он указывает |
| `web_search` | `always_ask`, если агент обрабатывает данные, которые вы не хотели бы отправлять в поисковом запросе. В противном случае `always_allow` | `allowed_domains` ограничивает, с каких сайтов поступают результаты, а не содержимое запроса |
| Инструменты MCP, которые только читают данные | `auto`, задаётся для каждого инструмента в `configs` набора инструментов | Значение по умолчанию для набора инструментов остаётся `always_ask`, поэтому инструмент, который сервер MCP добавит позже, по-прежнему будет ожидать одобрения |
| Инструменты MCP, которые изменяют данные | `always_ask` | Это значение по умолчанию для набора инструментов MCP. Сохраните его |
| Пользовательские инструменты | Ваш код решает, выполняется ли каждый вызов | Политики разрешений не применяются |
Набор инструментов в разделе [Дайте агенту минимальный набор инструментов](https://platform.claude.com/docs/ru/managed-agents/secure-deployment#give-the-agent-the-smallest-tool-set) применяет эти политики.
[Политика `auto`](https://platform.claude.com/docs/ru/managed-agents/permission-policies#let-the-server-evaluate-each-call-with-auto) позволяет серверу выполнить вызов, отклонить его или приостановить для одобрения. Человек не может одобрить каждый вызов в длительном запуске, поэтому вместо этого каждый вызов проверяет сервер. Сочетайте `auto` с ограниченной сетью, ключом с узкими разрешениями, бюджетом и оповещением о сессиях в режиме ожидания. `auto` не является контрольной точкой с участием человека, поэтому если человек должен проверять вызовы инструмента до их выполнения, настройте для этого инструмента `always_ask`.
`auto` рассматривает текст в событиях `user.message` и описание в событии `user.define_outcome` как ваши инструкции, включая пересылаемый вами текст конечного пользователя.
Приостановленная сессия ожидает бесконечно, поэтому сессии без присмотра нужен клиент, который отвечает на приостановленные вызовы или прерывает сессию.
Проверяйте каждый приостановленный вызов, прежде чем разрешить его. Клиент, который разрешает каждый вызов, не показывая его человеку, равнозначен `always_allow`. См. [Ответ на запросы подтверждения](https://platform.claude.com/docs/ru/managed-agents/permission-policies#respond-to-confirmation-requests) и [Просмотр результатов оценки каждого вызова](https://platform.claude.com/docs/ru/managed-agents/permission-policies#see-how-each-call-was-evaluated).
## Дайте агенту минимальный набор инструментов
Установите `default_config.enabled` в значение `false` и [включите только те инструменты, которые нужны агенту](https://platform.claude.com/docs/ru/managed-agents/tools#enabling-only-specific-tools). Набор инструментов агента по умолчанию включает все восемь встроенных инструментов.
| Инструмент | Что он делает |
| ------------------------- | ---------------------------------------------------------------------------- |
| `bash` | Выполняет любые команды, включая запросы к разрешённым хостам |
| `write`, `edit` | Изменяют файлы в песочнице |
| `read`, `glob`, `grep` | Читают файлы в песочнице |
| `web_fetch`, `web_search` | Возвращают страницы и результаты поиска из интернета через серверы Anthropic |
Агенту поддержки нужны три встроенных инструмента: `read` и `write` для черновика и `web_fetch` для справочного центра. Он ищет заказы через [пользовательский инструмент](https://platform.claude.com/docs/ru/managed-agents/tools#custom-tools) `lookup_order`, который выполняет ваше приложение. Ключ API для вашего API заказов хранит ваше приложение, поэтому агенту не нужны ни `bash`, ни учётные данные.
Следующий пример ограничивает `web_fetch` хостом `help.example.com` с помощью `allowed_domains`. Он устанавливает `auto` для `write` и `web_fetch`, как рекомендует раздел [Одобряйте рискованные действия](https://platform.claude.com/docs/ru/managed-agents/secure-deployment#approve-risky-actions). Если обращение клиента побудит агента использовать эти инструменты, агент сможет только изменять файлы в песочнице или открывать страницы справочного центра. Поэтому ни одному из инструментов не нужен `always_ask`. Пример также устанавливает `always_ask` в `default_config`, поэтому инструмент, который вы включите позже без собственной политики, будет использовать `always_ask`:
```bash cURL
tools='[
{
"type": "agent_toolset_20260401",
"default_config": {
"enabled": false,
"permission_policy": {"type": "always_ask"}
},
"configs": [
{"name": "read", "enabled": true, "permission_policy": {"type": "always_allow"}},
{"name": "write", "enabled": true, "permission_policy": {"type": "auto"}},
{
"name": "web_fetch",
"enabled": true,
"allowed_domains": ["help.example.com"],
"permission_policy": {"type": "auto"}
}
]
},
{
"type": "custom",
"name": "lookup_order",
"description": "Look up one order by its ID. Returns the status, the items, and the delivery date.",
"input_schema": {
"type": "object",
"properties": {
"order_id": {"type": "string", "description": "The order ID from the ticket"}
},
"required": ["order_id"]
}
}
]'
```
```bash CLI
ant apply agent.md
```
```markdown
---
name: Support Agent
model: claude-opus-5-5
tools:
- type: agent_toolset_20260401
default_config:
enabled: false
permission_policy:
type: always_ask
configs:
- name: read
enabled: true
permission_policy:
type: always_allow
- name: write
enabled: true
permission_policy:
type: auto
- name: web_fetch
enabled: true
allowed_domains: [help.example.com]
permission_policy:
type: auto
- type: custom
name: lookup_order
description: Look up one order by its ID. Returns the status, the items, and the delivery date.
input_schema:
type: object
properties:
order_id:
type: string
description: The order ID from the ticket
required:
- order_id
---
```
```python Python
tools = [
{
"type": "agent_toolset_20260401",
"default_config": {
"enabled": False,
"permission_policy": {"type": "always_ask"},
},
"configs": [
{
"name": "read",
"enabled": True,
"permission_policy": {"type": "always_allow"},
},
{
"name": "write",
"enabled": True,
"permission_policy": {"type": "auto"},
},
{
"name": "web_fetch",
"enabled": True,
"allowed_domains": ["help.example.com"],
"permission_policy": {"type": "auto"},
},
],
},
{
"type": "custom",
"name": "lookup_order",
"description": "Look up one order by its ID. Returns the status, the items, and the delivery date.",
"input_schema": {
"type": "object",
"properties": {
"order_id": {
"type": "string",
"description": "The order ID from the ticket",
},
},
"required": ["order_id"],
},
},
]
```
```typescript TypeScript
const tools = [
{
type: "agent_toolset_20260401",
default_config: {
enabled: false,
permission_policy: { type: "always_ask" }
},
configs: [
{
name: "read",
enabled: true,
permission_policy: { type: "always_allow" }
},
{
name: "write",
enabled: true,
permission_policy: { type: "auto" }
},
{
name: "web_fetch",
enabled: true,
allowed_domains: ["help.example.com"],
permission_policy: { type: "auto" }
}
]
},
{
type: "custom",
name: "lookup_order",
description:
"Look up one order by its ID. Returns the status, the items, and the delivery date.",
input_schema: {
type: "object",
properties: {
order_id: { type: "string", description: "The order ID from the ticket" }
},
required: ["order_id"]
}
}
] satisfies Anthropic.Beta.AgentCreateParams["tools"];
```
```csharp C#
using System.Text.Json;
using Anthropic.Models.Beta.Agents;
using Tool = Anthropic.Models.Beta.Agents.Tool;
Tool[] tools =
[
new BetaManagedAgentsAgentToolset20260401Params
{
Type = BetaManagedAgentsAgentToolset20260401ParamsType.AgentToolset20260401,
DefaultConfig = new()
{
Enabled = false,
PermissionPolicy = new BetaManagedAgentsAlwaysAskPolicy { Type = "always_ask" },
},
Configs =
[
new BetaManagedAgentsReadToolConfigParams
{
Enabled = true,
PermissionPolicy = new BetaManagedAgentsAlwaysAllowPolicy { Type = "always_allow" },
},
new BetaManagedAgentsWriteToolConfigParams
{
Enabled = true,
PermissionPolicy = new BetaManagedAgentsAutoPolicy(),
},
new BetaManagedAgentsWebFetchToolConfigParams
{
Enabled = true,
AllowedDomains = ["help.example.com"],
PermissionPolicy = new BetaManagedAgentsAutoPolicy(),
},
],
},
new BetaManagedAgentsCustomToolParams
{
Type = "custom",
Name = "lookup_order",
Description = "Look up one order by its ID. Returns the status, the items, and the delivery date.",
InputSchema = new()
{
Properties = new Dictionary
{
["order_id"] = JsonSerializer.SerializeToElement(
new { type = "string", description = "The order ID from the ticket" }
),
},
Required = ["order_id"],
},
},
];
```
```go Go
tools := []anthropic.BetaAgentNewParamsToolUnion{{
OfAgentToolset20260401: &anthropic.BetaManagedAgentsAgentToolset20260401Params{
Type: anthropic.BetaManagedAgentsAgentToolset20260401ParamsTypeAgentToolset20260401,
DefaultConfig: anthropic.BetaManagedAgentsAgentToolsetDefaultConfigParams{
Enabled: anthropic.Bool(false),
PermissionPolicy: anthropic.BetaManagedAgentsAgentToolsetDefaultConfigParamsPermissionPolicyUnion{
OfAlwaysAsk: &anthropic.BetaManagedAgentsAlwaysAskPolicyParam{
Type: anthropic.BetaManagedAgentsAlwaysAskPolicyTypeAlwaysAsk,
},
},
},
Configs: []anthropic.BetaManagedAgentsAgentToolConfigParamsUnion{
{OfRead: &anthropic.BetaManagedAgentsReadToolConfigParams{
Enabled: anthropic.Bool(true),
PermissionPolicy: anthropic.BetaManagedAgentsReadToolConfigParamsPermissionPolicyUnion{
OfAlwaysAllow: &anthropic.BetaManagedAgentsAlwaysAllowPolicyParam{
Type: anthropic.BetaManagedAgentsAlwaysAllowPolicyTypeAlwaysAllow,
},
},
}},
{OfWrite: &anthropic.BetaManagedAgentsWriteToolConfigParams{
Enabled: anthropic.Bool(true),
PermissionPolicy: anthropic.BetaManagedAgentsWriteToolConfigParamsPermissionPolicyUnion{
OfAuto: &anthropic.BetaManagedAgentsAutoPolicyParam{},
},
}},
{OfWebFetch: &anthropic.BetaManagedAgentsWebFetchToolConfigParams{
AllowedDomains: []string{"help.example.com"},
Enabled: anthropic.Bool(true),
PermissionPolicy: anthropic.BetaManagedAgentsWebFetchToolConfigParamsPermissionPolicyUnion{
OfAuto: &anthropic.BetaManagedAgentsAutoPolicyParam{},
},
}},
},
},
}, {
OfCustom: &anthropic.BetaManagedAgentsCustomToolParams{
Type: anthropic.BetaManagedAgentsCustomToolParamsTypeCustom,
Name: "lookup_order",
Description: "Look up one order by its ID. Returns the status, the items, and the delivery date.",
InputSchema: anthropic.BetaManagedAgentsCustomToolInputSchemaParam{
Properties: map[string]any{
"order_id": map[string]any{
"type": "string",
"description": "The order ID from the ticket",
},
},
Required: []string{"order_id"},
},
},
}}
_ = tools
```
```java Java
import com.anthropic.core.JsonValue;
import com.anthropic.models.beta.agents.*;
import java.util.List;
import java.util.Map;
var tools = List.of(
AgentCreateParams.Tool.ofAgentToolset20260401(
BetaManagedAgentsAgentToolset20260401Params.builder()
.type(BetaManagedAgentsAgentToolset20260401Params.Type.AGENT_TOOLSET_20260401)
.defaultConfig(
BetaManagedAgentsAgentToolsetDefaultConfigParams.builder()
.enabled(false)
.permissionPolicy(
BetaManagedAgentsAlwaysAskPolicy.builder()
.type(BetaManagedAgentsAlwaysAskPolicy.Type.ALWAYS_ASK)
.build()
)
.build()
)
.addConfig(
BetaManagedAgentsReadToolConfigParams.builder()
.enabled(true)
.permissionPolicy(
BetaManagedAgentsAlwaysAllowPolicy.builder()
.type(BetaManagedAgentsAlwaysAllowPolicy.Type.ALWAYS_ALLOW)
.build()
)
.build()
)
.addConfig(
BetaManagedAgentsWriteToolConfigParams.builder()
.enabled(true)
.permissionPolicy(BetaManagedAgentsAutoPolicy.builder().build())
.build()
)
.addConfig(
BetaManagedAgentsWebFetchToolConfigParams.builder()
.enabled(true)
.allowedDomains(List.of("help.example.com"))
.permissionPolicy(BetaManagedAgentsAutoPolicy.builder().build())
.build()
)
.build()
),
AgentCreateParams.Tool.ofCustom(
BetaManagedAgentsCustomToolParams.builder()
.type(BetaManagedAgentsCustomToolParams.Type.CUSTOM)
.name("lookup_order")
.description("Look up one order by its ID. Returns the status, the items, and the delivery date.")
.inputSchema(
BetaManagedAgentsCustomToolInputSchema.builder()
.properties(
BetaManagedAgentsCustomToolInputSchema.Properties.builder()
.putAdditionalProperty("order_id", JsonValue.from(Map.of(
"type", "string",
"description", "The order ID from the ticket")))
.build()
)
.addRequired("order_id")
.build()
)
.build()
)
);
```
```php PHP
use Anthropic\Beta\Agents\BetaManagedAgentsAgentToolset20260401Params;
use Anthropic\Beta\Agents\BetaManagedAgentsAgentToolsetDefaultConfigParams;
use Anthropic\Beta\Agents\BetaManagedAgentsAlwaysAllowPolicy;
use Anthropic\Beta\Agents\BetaManagedAgentsAlwaysAskPolicy;
use Anthropic\Beta\Agents\BetaManagedAgentsAutoPolicy;
use Anthropic\Beta\Agents\BetaManagedAgentsCustomToolInputSchema;
use Anthropic\Beta\Agents\BetaManagedAgentsCustomToolParams;
use Anthropic\Beta\Agents\BetaManagedAgentsReadToolConfigParams;
use Anthropic\Beta\Agents\BetaManagedAgentsWebFetchToolConfigParams;
use Anthropic\Beta\Agents\BetaManagedAgentsWriteToolConfigParams;
$tools = [
BetaManagedAgentsAgentToolset20260401Params::with(
type: 'agent_toolset_20260401',
defaultConfig: BetaManagedAgentsAgentToolsetDefaultConfigParams::with(
enabled: false,
permissionPolicy: BetaManagedAgentsAlwaysAskPolicy::with(type: 'always_ask'),
),
configs: [
BetaManagedAgentsReadToolConfigParams::with(
enabled: true,
permissionPolicy: BetaManagedAgentsAlwaysAllowPolicy::with(type: 'always_allow'),
),
BetaManagedAgentsWriteToolConfigParams::with(
enabled: true,
permissionPolicy: BetaManagedAgentsAutoPolicy::with(),
),
BetaManagedAgentsWebFetchToolConfigParams::with(
allowedDomains: ['help.example.com'],
enabled: true,
permissionPolicy: BetaManagedAgentsAutoPolicy::with(),
),
],
),
BetaManagedAgentsCustomToolParams::with(
type: 'custom',
name: 'lookup_order',
description: 'Look up one order by its ID. Returns the status, the items, and the delivery date.',
inputSchema: BetaManagedAgentsCustomToolInputSchema::with(
properties: ['order_id' => ['type' => 'string', 'description' => 'The order ID from the ticket']],
required: ['order_id'],
),
),
];
```
```ruby Ruby
tools = [
{
type: "agent_toolset_20260401",
default_config: {
enabled: false,
permission_policy: {type: "always_ask"}
},
configs: [
{
name: "read",
enabled: true,
permission_policy: {type: "always_allow"}
},
{
name: "write",
enabled: true,
permission_policy: {type: "auto"}
},
{
name: "web_fetch",
enabled: true,
allowed_domains: ["help.example.com"],
permission_policy: {type: "auto"}
}
]
},
{
type: "custom",
name: "lookup_order",
description: "Look up one order by its ID. Returns the status, the items, and the delivery date.",
input_schema: {
type: "object",
properties: {order_id: {type: "string", description: "The order ID from the ticket"}},
required: ["order_id"]
}
}
]
```
[Обновление агента](https://platform.claude.com/docs/ru/managed-agents/agent-setup#update-semantics) заменяет весь массив `tools`, поэтому отправляйте все записи, которые хотите сохранить.
Обновление агента затрагивает только новые сессии, поэтому также проверьте развёртывания, агентов, которые ссылаются на этого агента, и существующие сессии:
* Развёртывание закрепляет версию агента, поэтому направьте каждое развёртывание на новую версию.
* Агент, который указывает этого агента в [`subagents.predefined_agents`](https://platform.claude.com/docs/ru/managed-agents/multiagent-orchestration#list-the-subagents) или `workflows.predefined_agents`, сохраняет закреплённую им версию, поэтому обновите и этого агента.
* Чтобы ужесточить уже существующую сессию, [обновите инструменты этой сессии](https://platform.claude.com/docs/ru/managed-agents/session-operations#updating-the-agent-configuration). Сессия должна находиться в состоянии `idle`, а обновление заменяет весь массив `tools`. В мультиагентной сессии новые списки `allowed_domains` и `blocked_domains` для веб-инструментов агента, которого запускает сессия, применяются и ко всем остальным агентам. Они вступают в силу со следующего хода каждого агента. Включённые инструменты и политики разрешений этих агентов не меняются. Чтобы изменить их, обновите каждого агента, а затем запустите новую сессию.
Также ограничьте серверы MCP и пользовательские инструменты тем, что нужно агенту:
* **Серверы MCP:** набор инструментов MCP по умолчанию включает все инструменты, которые предоставляет сервер. Установите `default_config.enabled` в значение `false` и включите инструменты по имени, чтобы инструменты, которые сервер добавит позже, оставались выключенными. Удалите серверы, которые агент не использует. См. [Коннектор MCP](https://platform.claude.com/docs/ru/managed-agents/mcp-connector#configure-which-mcp-tools-are-available).
* **Пользовательские инструменты:** их выполняет ваше приложение, и политики разрешений к ним не применяются. Проверяйте входные данные каждого вызова в своём приложении и ограничивайте то, к чему может обращаться инструмент.
## Держите недоверенные входные данные подальше от мощных инструментов
Проверяйте, какие инструменты и учётные данные есть у агента, всякий раз, когда он читает недоверенные входные данные, то есть текст, который может написать кто-то за пределами вашей команды. В этом разделе используются два термина:
* **Недоверенные входные данные:** веб-страницы, результаты поиска, обращения в поддержку, электронные письма, файлы репозиториев, загрузки, результаты серверов MCP и пересылаемые вами сообщения конечных пользователей.
* **Мощные инструменты:** `bash`, `write`, `edit`, `web_fetch`, `web_search`, инструменты MCP и пользовательские инструменты, которые записывают или отправляют данные, а также любой инструмент, использующий учётные данные.
Текст в недоверенных входных данных может указать агенту использовать имеющийся у него мощный инструмент. Агент поддержки читает обращения, поэтому он обращается к вашему API заказов только через пользовательский инструмент `lookup_order`. Ваше приложение проверяет, что заказ принадлежит отправителю обращения.
| Входные данные, которые читает агент | Какие ещё возможности у него есть | Что делать |
| ------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Обращения, электронные письма или загрузки | `bash` с учётными данными | Замените `bash` пользовательским инструментом, который делает что-то одно. Если агент должен сохранить `bash`, одобряйте каждый вызов с помощью `always_ask` |
| Веб-страницы или результаты поиска | Запись файлов или изменение записей | Отключите веб-инструменты или ограничьте их сайтами, которыми вы управляете или которым доверяете |
| Результаты MCP или файлы репозиториев | Инструменты MCP, которые записывают данные | Оставьте для набора инструментов MCP `always_ask` и включите только те инструменты, которые нужны агенту |
| Смонтированный репозиторий GitHub | Любой инструмент | Монтируйте только репозитории, которым доверяете. Агент с `read` загружает навыки из каталога `.claude/skills` репозитория как инструкции агента без этапа проверки. См. [Загрузка навыков из репозитория GitHub](https://platform.claude.com/docs/ru/managed-agents/skills#load-skills-from-a-github-repository) |
| Любые недоверенные входные данные | Запись в [хранилище памяти](https://platform.claude.com/docs/ru/managed-agents/memory#attach-a-memory-store-to-a-session) | Подключайте хранилище как `read_only`, если только агент не должен в него записывать. Значение по умолчанию — `read_write`, и последующие сессии читают сохранённый текст как доверенную память |
В облачной среде чтение файла с помощью `read` также может загрузить файлы `CLAUDE.md` и `AGENTS.md` как инструкции. Они загружаются из каталога файла и его родительских каталогов вплоть до рабочего каталога песочницы. Файлы, на которые они ссылаются с помощью `@` и пути, например `@docs/setup.md`, также загружаются — до пяти уровней ссылок в глубину. Ссылка может указывать на любое место в песочнице, например `@/etc/hosts`. Никакая настройка не отключает это, кроме отключения `read`, поэтому рассматривайте репозиторий, пакет или архив, в который может записывать кто-то за пределами вашей команды, как недоверенные входные данные.
Когда агент должен читать недоверенные входные данные и при этом действовать, это руководство рекомендует один из трёх вариантов архитектуры:
* **Разделите чтение и действия.** В одной мультиагентной сессии [ведущий агент](https://platform.claude.com/docs/ru/managed-agents/multiagent-orchestration#list-the-subagents) даёт задачи сборщику, который читает веб, и исполнителю, который изменяет файлы или записи.
* **Дайте агенту один узкий пользовательский инструмент.** Ваше приложение выполняет инструмент, проверяет его входные данные и хранит учётные данные. Агент поддержки использует этот вариант, а не разделение. См. [Ответ на вызовы инструментов, приостанавливающие сеанс](https://platform.claude.com/docs/ru/managed-agents/events-and-streaming#answer-tool-calls-that-pause-the-session).
* **Оставьте человека в контуре.** Используйте `always_ask` для мощного инструмента, чтобы человек одобрял каждый вызов.
Разделение использует трёх агентов:
| Агент | Читает | Имеет | Передаёт дальше |
| ------------------------------------------ | ------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------- |
| Ведущий (агент, которого запускает сессия) | Ваше сообщение и то, что возвращают другие агенты | Никаких встроенных инструментов. Его список `subagents.predefined_agents` указывает сборщика и исполнителя | Задачу каждому агенту |
| Сборщик | Веб-страницы и результаты поиска | Только `web_fetch` и `web_search`, каждый с `allowed_domains` | Краткие результаты в формате, который вы запрашиваете в его системной подсказке |
| Исполнитель | Задачу от ведущего | Инструменты, которые записывают файлы, выполняют команды или изменяют записи, с `auto` или `always_ask`. Никаких веб-инструментов | Свой результат |
Результаты сборщика формируются из недоверенных страниц, и ведущий может передать их текст исполнителю. Сохраняйте `auto` или `always_ask` для инструментов исполнителя. Сборщик всё равно может отправить часть прочитанного на сайты из своего списка `web_fetch` и поставщику поиска в своих запросах.
Агенты в одной мультиагентной сессии [совместно используют песочницу](https://platform.claude.com/docs/ru/managed-agents/multiagent-orchestration#how-it-works), её файлы и учётные данные хранилища, поэтому такое разделение разграничивает только их инструменты и диалоги. Для более строгого разделения используйте две сессии с отдельными средами и хранилищами. Пусть ваше приложение передаёт между двумя сессиями только фиксированные поля, например ID заказа.
## Установите лимиты и способ остановки
Задавайте бюджет при создании каждой сессии и заранее решите, как вы будете останавливать агента.
| Средство управления | Что оно делает |
| ----------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Бюджет сессии | Лимит расходов по публичным прейскурантным ценам. При достижении лимита сессия и каждый [поток](https://platform.claude.com/docs/ru/managed-agents/session-threads) приостанавливаются. Выполняющиеся запросы могут завершиться, а их вызовы инструментов всё равно выполняются, поэтому расходы могут превысить лимит. См. [Когда сессия достигает бюджета](https://platform.claude.com/docs/ru/managed-agents/budgets#when-a-session-reaches-its-budget) |
| Бюджет развёртывания | Тот же лимит, применяемый к каждой сессии, которую запускает развёртывание |
| [Событие `user.interrupt`](https://platform.claude.com/docs/ru/managed-agents/events-and-streaming#interrupt-the-agent) | Немедленно останавливает ответ модели. Выполняющийся вызов инструмента может сначала завершиться. Сессия переходит в состояние `idle`, если только запуск рабочего процесса не удерживает её в состоянии `running`, и возобновляется при вашем следующем сообщении. Прерывание не завершает ни один запуск рабочего процесса |
| Архивирование или удаление сессии | Архивирование сохраняет историю и блокирует новые события. Удаление удаляет запись, события и песочницу |
| Приостановка или архивирование развёртывания | Приостановка останавливает новые запуски по расписанию, но по-прежнему разрешает ручные запуски. Архивирование окончательно завершает расписание. Уже работающие сессии продолжают работать |
| Архивирование или удаление хранилища или учётных данных | Удаляет секрет из работающих сессий без перезапуска. Учитывайте задержку. Сессии продолжают работать, поэтому также прервите их. Токен, который агент уже получил с помощью секрета, остаётся в песочнице |
Чтобы остановить работающего агента, выполните следующие шаги:
1. Отправьте `user.interrupt` отдельно.
2. Для агента, работающего по расписанию, также приостановите развёртывание, чтобы не начинались новые запуски по расписанию. Чтобы окончательно завершить расписание, заархивируйте развёртывание.
3. Если ключ мог быть раскрыт, выполните его ротацию в сервисе, который его выдал.
4. Если у агента есть открытые запуски рабочих процессов, также отправьте `user.message` с просьбой остановить их, потому что прерывание не завершает ни один запуск. О том, какие вызовы инструментов нужно сначала отменить, см. [Прерывание сессии с открытыми запусками](https://platform.claude.com/docs/ru/managed-agents/workflow-runs#interrupt-a-session-with-runs-open).
5. Дождитесь перехода сессии в состояние `idle`. Работающую сессию нельзя заархивировать или удалить.
6. Заархивируйте сессию, чтобы сохранить её историю. Удалите её, когда история вам больше не понадобится.
Прерывание не отменяет того, что агент уже сделал или отправил. Архивирование агента не останавливает его работающие сессии.
Значение `max_list_cost.amount` бюджета — это целое число центов США, записанное в виде строки, поэтому `"125"` означает $1,25. См. [Задание бюджета при создании сессии](https://platform.claude.com/docs/ru/managed-agents/budgets#set-a-budget-at-session-creation).
Нельзя добавить бюджет к сессии, созданной без него. Чтобы изменить или удалить лимит, см. [Возобновление сессии, достигшей бюджета](https://platform.claude.com/docs/ru/managed-agents/budgets#resume-a-session-at-its-budget). После удаления лимита сессии установить новый нельзя.
Бюджет ограничивает расходы, но не ограничивает то, что агент делает до достижения лимита. Чтобы разделить рабочие нагрузки с разными уровнями доверия, используйте отдельные [рабочие пространства](https://platform.claude.com/docs/ru/manage-claude/workspaces). Дайте каждой рабочей нагрузке ключ API, ограниченный одним рабочим пространством, потому что ключ с доступом к нескольким рабочим пространствам может действовать в любом из них.
См. [Бюджеты сессий](https://platform.claude.com/docs/ru/managed-agents/budgets), [Операции с сессиями](https://platform.claude.com/docs/ru/managed-agents/session-operations#archiving-a-session) и [Развёртывания по расписанию](https://platform.claude.com/docs/ru/managed-agents/scheduled-deployments#managing-deployment-lifecycle).
## Следующие шаги
Сетевые режимы, разрешённые хосты и менеджеры пакетов.
Политики одобрения и запросы подтверждения.
Типы учётных данных, места внедрения и ротация.
Лимиты, возобновление при достижении бюджета и бюджеты развёртываний.