---
title: Политики разрешений
url: https://platform.claude.com/docs/ru/managed-agents/permission-policies
description: Управляйте тем, когда запускаются инструменты агента и MCP.
featureMetadata:
  topic:
    title: Managed Agents
    url: https://platform.claude.com/docs/en/managed-agents/overview
  status: beta
  betaHeader: managed-agents-2026-04-01
  zdr:
    eligibility: not-eligible
    note: Не подпадает под ZDR, за исключением самостоятельно размещаемых Managed Agents. Сессии — это ресурсы с состоянием; их расшифровки хранятся, пока вы их не удалите.
  supportedModels:
    - claude-fable-5-2
    - claude-mythos-5-2
    - claude-fable-5-1
    - claude-mythos-5-1
    - claude-fable-5
    - claude-mythos-5
    - claude-mythos-preview
    - claude-opus-5-5
    - claude-opus-5
    - claude-sonnet-5-5
    - claude-sonnet-5
    - claude-haiku-5-5
    - claude-haiku-4-5-20251001
    - claude-opus-4-8
    - claude-opus-4-7
    - claude-opus-4-6
    - claude-sonnet-4-6
    - claude-opus-4-5-20251101
    - claude-sonnet-4-5-20250929
  supportedPlatforms:
    Claude API: beta
    Claude Platform on AWS: beta
    Claude Models on Google Cloud (Anthropic managed): beta
---

Политики разрешений (permission policies) применяются к инструментам, выполняемым на сервере: к готовому набору инструментов агента и к наборам инструментов MCP. Политика определяет, будут ли вызовы инструмента запускаться автоматически, ожидать вашего одобрения или передаваться серверу, который оценивает каждый вызов. Пользовательские инструменты запускаются в вашем приложении и находятся под вашим контролем, поэтому политики разрешений на пользовательские инструменты не распространяются.

## Типы политик разрешений

| Политика | Поведение |
| ----- | ----- |
| `always_allow` | Инструмент выполняется автоматически без подтверждения. |
| `always_ask` | Сессия приостанавливается и ожидает вашего одобрения перед выполнением. Описание потока событий см. в разделе [Ответ на запросы подтверждения](https://platform.claude.com/docs/ru/managed-agents/permission-policies#respond-to-confirmation-requests). |
| `auto` | Сервер оценивает каждый вызов и выполняет его, отклоняет или приостанавливает сессию до вашего одобрения. См. [Оценка каждого вызова сервером с помощью `auto`](https://platform.claude.com/docs/ru/managed-agents/permission-policies#let-the-server-evaluate-each-call-with-auto). |

У каждого вида набора инструментов своё значение по умолчанию: для набора инструментов агента по умолчанию используется `always_allow`, а для наборов инструментов MCP — `always_ask`.

Политика разрешений определяет, когда запускается включённый инструмент. Чтобы полностью убрать инструмент у агента, отключите его. См. раздел [Отключение отдельных инструментов](https://platform.claude.com/docs/ru/managed-agents/tools#disabling-specific-tools).

## Установка политики для набора инструментов

Политики разрешений задаются в конфигурации `tools` (csharp, go: `Tools`) агента при его создании, а изменить их позже можно, [обновив агента](https://platform.claude.com/docs/ru/managed-agents/agent-setup#update-an-agent). Запущенные сессии сохраняют конфигурацию набора инструментов, с которой они были созданы. Обновления применяются к сессиям, созданным после них.

### Разрешения набора инструментов агента

При создании агента вы можете применить политику ко всем инструментам в `agent_toolset_20260401` с помощью `default_config.permission_policy` (java, php: `defaultConfig.permissionPolicy`; csharp, go: `DefaultConfig.PermissionPolicy`):

<CodeGroup defaultLanguage="CLI">
  ```bash cURL
  curl -fsSL https://api.anthropic.com/v1/agents \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "anthropic-beta: managed-agents-2026-04-01" \
    -H "content-type: application/json" \
    -d '{
      "name": "Coding Assistant",
      "model": "claude-opus-5-5",
      "tools": [
        {
          "type": "agent_toolset_20260401",
          "default_config": {
            "permission_policy": {"type": "always_ask"}
          }
        }
      ]
    }'
  ```

  <CodeGroupItem>
    ```bash CLI
    ant apply agent.md
    ```

    <File filename="agent.md">
      ```markdown
      ---
      name: Coding Assistant
      model: claude-opus-5-5
      tools:
        - type: agent_toolset_20260401
          default_config:
            permission_policy:
              type: always_ask
      ---
      ```
    </File>
  </CodeGroupItem>

  ```python Python
  agent = client.beta.agents.create(
      name="Coding Assistant",
      model="claude-opus-5-5",
      tools=[
          {
              "type": "agent_toolset_20260401",
              "default_config": {
                  "permission_policy": {"type": "always_ask"},
              },
          },
      ],
  )
  ```

  ```typescript TypeScript
  const agent = await client.beta.agents.create({
    name: "Coding Assistant",
    model: "claude-opus-5-5",
    tools: [
      {
        type: "agent_toolset_20260401",
        default_config: {
          permission_policy: { type: "always_ask" }
        }
      }
    ]
  });
  ```

  ```csharp C#
  using Anthropic.Models.Beta.Agents;

  var agent = await client.Beta.Agents.Create(new()
  {
      Name = "Coding Assistant",
      Model = BetaManagedAgentsModel.ClaudeOpus5_5,
      Tools =
      [
          new BetaManagedAgentsAgentToolset20260401Params
          {
              DefaultConfig = new()
              {
                  PermissionPolicy = new BetaManagedAgentsAlwaysAskPolicy(),
              },
          },
      ],
  });
  ```

  ```go Go
  agent, err := client.Beta.Agents.New(ctx, anthropic.BetaAgentNewParams{
  	Name: "Coding Assistant",
  	Model: anthropic.BetaManagedAgentsModelConfigParams{
  		ID: anthropic.BetaManagedAgentsModelClaudeOpus5_5,
  	},
  	Tools: []anthropic.BetaAgentNewParamsToolUnion{{
  		OfAgentToolset20260401: &anthropic.BetaManagedAgentsAgentToolset20260401Params{
  			DefaultConfig: anthropic.BetaManagedAgentsAgentToolsetDefaultConfigParams{
  				PermissionPolicy: anthropic.BetaManagedAgentsAgentToolsetDefaultConfigParamsPermissionPolicyUnion{
  					OfAlwaysAsk: &anthropic.BetaManagedAgentsAlwaysAskPolicyParam{},
  				},
  			},
  		},
  	}},
  })
  if err != nil {
  	panic(err)
  }
  ```

  ```java Java
  import com.anthropic.models.beta.agents.*;

  var agent = client.beta().agents().create(
      AgentCreateParams.builder()
          .name("Coding Assistant")
          .model(BetaManagedAgentsModel.CLAUDE_OPUS_5_5)
          .addTool(
              BetaManagedAgentsAgentToolset20260401Params.builder()
                  .defaultConfig(
                      BetaManagedAgentsAgentToolsetDefaultConfigParams.builder()
                          .permissionPolicy(BetaManagedAgentsAlwaysAskPolicy.builder().build())
                          .build()
                  )
                  .build()
          )
          .build()
  );
  ```

  ```php PHP
  use Anthropic\Beta\Agents\BetaManagedAgentsAgentToolset20260401Params;
  use Anthropic\Beta\Agents\BetaManagedAgentsAgentToolsetDefaultConfigParams;
  use Anthropic\Beta\Agents\BetaManagedAgentsAlwaysAskPolicy;

  $agent = $client->beta->agents->create(
      name: 'Coding Assistant',
      model: 'claude-opus-5-5',
      tools: [
          BetaManagedAgentsAgentToolset20260401Params::with(
              defaultConfig: BetaManagedAgentsAgentToolsetDefaultConfigParams::with(
                  permissionPolicy: BetaManagedAgentsAlwaysAskPolicy::with(),
              ),
          ),
      ],
  );
  ```

  ```ruby Ruby
  agent = client.beta.agents.create(
    name: "Coding Assistant",
    model: "claude-opus-5-5",
    tools: [
      {
        type: "agent_toolset_20260401",
        default_config: {
          permission_policy: {type: "always_ask"}
        }
      }
    ]
  )
  ```
</CodeGroup>

`default_config` (java, php: `defaultConfig`; csharp, go: `DefaultConfig`) — необязательный параметр. Если его опустить, набор инструментов агента включается с политикой разрешений по умолчанию — `always_allow`.

### Разрешения набора инструментов MCP

Для наборов инструментов MCP по умолчанию используется `always_ask`. Это гарантирует, что новые инструменты, добавленные на MCP-сервер, не будут запускаться в вашем приложении без одобрения. Чтобы автоматически одобрять инструменты доверенного MCP-сервера, задайте `default_config.permission_policy` (java, php: `defaultConfig.permissionPolicy`; csharp, go: `DefaultConfig.PermissionPolicy`) в записи `mcp_toolset`.

Значение `mcp_server_name` (java, php: `mcpServerName`; csharp: `McpServerName`; go: `MCPServerName`) должно совпадать с `name` (csharp, go: `Name`) одного из серверов в массиве `mcp_servers` (java, php: `mcpServers`; csharp: `McpServers`; go: `MCPServers`).

В этом примере подключается сервер MCP GitHub, и его инструментам разрешается выполняться без подтверждения:

<CodeGroup defaultLanguage="CLI">
  ```bash cURL
  curl -fsSL https://api.anthropic.com/v1/agents \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "anthropic-beta: managed-agents-2026-04-01" \
    -H "content-type: application/json" \
    -d '{
      "name": "Dev Assistant",
      "model": "claude-opus-5-5",
      "mcp_servers": [
        {"type": "url", "name": "github", "url": "https://mcp.example.com/github"}
      ],
      "tools": [
        {"type": "agent_toolset_20260401"},
        {
          "type": "mcp_toolset",
          "mcp_server_name": "github",
          "default_config": {
            "permission_policy": {"type": "always_allow"}
          }
        }
      ]
    }'
  ```

  <CodeGroupItem>
    ```bash CLI
    ant apply agent.md
    ```

    <File filename="agent.md">
      ```markdown
      ---
      name: Dev Assistant
      model: claude-opus-5-5
      mcp_servers:
        - type: url
          name: github
          url: https://mcp.example.com/github
      tools:
        - type: agent_toolset_20260401
        - type: mcp_toolset
          mcp_server_name: github
          default_config:
            permission_policy:
              type: always_allow
      ---
      ```
    </File>
  </CodeGroupItem>

  ```python Python
  agent = client.beta.agents.create(
      name="Dev Assistant",
      model="claude-opus-5-5",
      mcp_servers=[
          {"type": "url", "name": "github", "url": "https://mcp.example.com/github"},
      ],
      tools=[
          {"type": "agent_toolset_20260401"},
          {
              "type": "mcp_toolset",
              "mcp_server_name": "github",
              "default_config": {
                  "permission_policy": {"type": "always_allow"},
              },
          },
      ],
  )
  ```

  ```typescript TypeScript
  const agent = await client.beta.agents.create({
    name: "Dev Assistant",
    model: "claude-opus-5-5",
    mcp_servers: [{ type: "url", name: "github", url: "https://mcp.example.com/github" }],
    tools: [
      { type: "agent_toolset_20260401" },
      {
        type: "mcp_toolset",
        mcp_server_name: "github",
        default_config: {
          permission_policy: { type: "always_allow" }
        }
      }
    ]
  });
  ```

  ```csharp C#
  using Anthropic.Models.Beta.Agents;

  var agent = await client.Beta.Agents.Create(new()
  {
      Name = "Dev Assistant",
      Model = BetaManagedAgentsModel.ClaudeOpus5_5,
      McpServers =
      [
          new()
          {
              Name = "github",
              Url = "https://mcp.example.com/github",
          },
      ],
      Tools =
      [
          new BetaManagedAgentsAgentToolset20260401Params(),
          new BetaManagedAgentsMcpToolsetParams
          {
              McpServerName = "github",
              DefaultConfig = new()
              {
                  PermissionPolicy = new BetaManagedAgentsAlwaysAllowPolicy(),
              },
          },
      ],
  });
  ```

  ```go Go
  agent, err := client.Beta.Agents.New(ctx, anthropic.BetaAgentNewParams{
  	Name: "Dev Assistant",
  	Model: anthropic.BetaManagedAgentsModelConfigParams{
  		ID: anthropic.BetaManagedAgentsModelClaudeOpus5_5,
  	},
  	MCPServers: []anthropic.BetaManagedAgentsURLMCPServerParams{{
  		Name: "github",
  		URL:  "https://mcp.example.com/github",
  	}},
  	Tools: []anthropic.BetaAgentNewParamsToolUnion{
  		{
  			OfAgentToolset20260401: &anthropic.BetaManagedAgentsAgentToolset20260401Params{},
  		},
  		{
  			OfMCPToolset: &anthropic.BetaManagedAgentsMCPToolsetParams{
  				MCPServerName: "github",
  				DefaultConfig: anthropic.BetaManagedAgentsMCPToolsetDefaultConfigParams{
  					PermissionPolicy: anthropic.BetaManagedAgentsMCPToolsetDefaultConfigParamsPermissionPolicyUnion{
  						OfAlwaysAllow: &anthropic.BetaManagedAgentsAlwaysAllowPolicyParam{},
  					},
  				},
  			},
  		},
  	},
  })
  if err != nil {
  	panic(err)
  }
  ```

  ```java Java
  import com.anthropic.models.beta.agents.*;

  var agent = client.beta().agents().create(
      AgentCreateParams.builder()
          .name("Dev Assistant")
          .model(BetaManagedAgentsModel.CLAUDE_OPUS_5_5)
          .addMcpServer(
              BetaManagedAgentsUrlMcpServerParams.builder()
                  .name("github")
                  .url("https://mcp.example.com/github")
                  .build()
          )
          .addTool(BetaManagedAgentsAgentToolset20260401Params.builder().build())
          .addTool(
              BetaManagedAgentsMcpToolsetParams.builder()
                  .mcpServerName("github")
                  .defaultConfig(
                      BetaManagedAgentsMcpToolsetDefaultConfigParams.builder()
                          .permissionPolicy(BetaManagedAgentsAlwaysAllowPolicy.builder().build())
                          .build()
                  )
                  .build()
          )
          .build()
  );
  ```

  ```php PHP
  use Anthropic\Beta\Agents\BetaManagedAgentsAgentToolset20260401Params;
  use Anthropic\Beta\Agents\BetaManagedAgentsAlwaysAllowPolicy;
  use Anthropic\Beta\Agents\BetaManagedAgentsMCPToolsetDefaultConfigParams;
  use Anthropic\Beta\Agents\BetaManagedAgentsMCPToolsetParams;
  use Anthropic\Beta\Agents\BetaManagedAgentsURLMCPServerParams;

  $agent = $client->beta->agents->create(
      name: 'Dev Assistant',
      model: 'claude-opus-5-5',
      mcpServers: [
          BetaManagedAgentsURLMCPServerParams::with(
              name: 'github',
              url: 'https://mcp.example.com/github',
          ),
      ],
      tools: [
          BetaManagedAgentsAgentToolset20260401Params::with(),
          BetaManagedAgentsMCPToolsetParams::with(
              mcpServerName: 'github',
              defaultConfig: BetaManagedAgentsMCPToolsetDefaultConfigParams::with(
                  permissionPolicy: BetaManagedAgentsAlwaysAllowPolicy::with(),
              ),
          ),
      ],
  );
  ```

  ```ruby Ruby
  agent = client.beta.agents.create(
    name: "Dev Assistant",
    model: "claude-opus-5-5",
    mcp_servers: [
      {type: "url", name: "github", url: "https://mcp.example.com/github"}
    ],
    tools: [
      {type: "agent_toolset_20260401"},
      {
        type: "mcp_toolset",
        mcp_server_name: "github",
        default_config: {
          permission_policy: {type: "always_allow"}
        }
      }
    ]
  )
  ```
</CodeGroup>

## Переопределение политики отдельного инструмента

Используйте массив `configs` (csharp, go: `Configs`), чтобы переопределить значение по умолчанию для отдельных инструментов. Значения `name` (csharp, go: `Name`) для набора инструментов агента перечислены в разделе [Доступные инструменты](https://platform.claude.com/docs/ru/managed-agents/tools#available-tools). В этом примере по умолчанию разрешён весь набор инструментов агента, но перед выполнением любой команды bash требуется подтверждение:

<CodeGroup defaultLanguage="CLI">
  ```bash cURL
  curl -fsSL https://api.anthropic.com/v1/agents \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "anthropic-beta: managed-agents-2026-04-01" \
    -H "content-type: application/json" \
    -d '{
      "name": "Coding Assistant",
      "model": "claude-opus-5-5",
      "tools": [
        {
          "type": "agent_toolset_20260401",
          "default_config": {
            "permission_policy": {"type": "always_allow"}
          },
          "configs": [
            {
              "name": "bash",
              "permission_policy": {"type": "always_ask"}
            }
          ]
        }
      ]
    }'
  ```

  <CodeGroupItem>
    ```bash CLI
    ant apply agent.md
    ```

    <File filename="agent.md">
      ```markdown
      ---
      name: Coding Assistant
      model: claude-opus-5-5
      tools:
        - type: agent_toolset_20260401
          default_config:
            permission_policy:
              type: always_allow
          configs:
            - name: bash
              permission_policy:
                type: always_ask
      ---
      ```
    </File>
  </CodeGroupItem>

  ```python Python
  tools = [
      {
          "type": "agent_toolset_20260401",
          "default_config": {
              "permission_policy": {"type": "always_allow"},
          },
          "configs": [
              {
                  "name": "bash",
                  "permission_policy": {"type": "always_ask"},
              },
          ],
      },
  ]
  ```

  ```typescript TypeScript
  const tools = [
    {
      type: "agent_toolset_20260401",
      default_config: {
        permission_policy: { type: "always_allow" }
      },
      configs: [
        {
          name: "bash",
          permission_policy: { type: "always_ask" }
        }
      ]
    }
  ] satisfies Anthropic.Beta.AgentCreateParams["tools"];
  ```

  ```csharp C#
  using Anthropic.Models.Beta.Agents;
  using Tool = Anthropic.Models.Beta.Agents.Tool;

  Tool[] tools =
  [
      new BetaManagedAgentsAgentToolset20260401Params
      {
          DefaultConfig = new()
          {
              PermissionPolicy = new BetaManagedAgentsAlwaysAllowPolicy(),
          },
          Configs =
          [
              new BetaManagedAgentsBashToolConfigParams
              {
                  PermissionPolicy = new BetaManagedAgentsAlwaysAskPolicy(),
              },
          ],
      },
  ];
  ```

  ```go Go
  tools := []anthropic.BetaAgentNewParamsToolUnion{{
  	OfAgentToolset20260401: &anthropic.BetaManagedAgentsAgentToolset20260401Params{
  		DefaultConfig: anthropic.BetaManagedAgentsAgentToolsetDefaultConfigParams{
  			PermissionPolicy: anthropic.BetaManagedAgentsAgentToolsetDefaultConfigParamsPermissionPolicyUnion{
  				OfAlwaysAllow: &anthropic.BetaManagedAgentsAlwaysAllowPolicyParam{},
  			},
  		},
  		Configs: []anthropic.BetaManagedAgentsAgentToolConfigParamsUnion{{
  			OfBash: &anthropic.BetaManagedAgentsBashToolConfigParams{
  				PermissionPolicy: anthropic.BetaManagedAgentsBashToolConfigParamsPermissionPolicyUnion{
  					OfAlwaysAsk: &anthropic.BetaManagedAgentsAlwaysAskPolicyParam{},
  				},
  			},
  		}},
  	},
  }}
  ```

  ```java Java
  import com.anthropic.models.beta.agents.*;
  import java.util.List;

  var tools = List.of(
      AgentCreateParams.Tool.ofAgentToolset20260401(
          BetaManagedAgentsAgentToolset20260401Params.builder()
              .defaultConfig(
                  BetaManagedAgentsAgentToolsetDefaultConfigParams.builder()
                      .permissionPolicy(BetaManagedAgentsAlwaysAllowPolicy.builder().build())
                      .build()
              )
              .addConfig(
                  BetaManagedAgentsBashToolConfigParams.builder()
                      .permissionPolicy(BetaManagedAgentsAlwaysAskPolicy.builder().build())
                      .build()
              )
              .build()
      )
  );
  ```

  ```php PHP
  use Anthropic\Beta\Agents\BetaManagedAgentsBashToolConfigParams;
  use Anthropic\Beta\Agents\BetaManagedAgentsAgentToolset20260401Params;
  use Anthropic\Beta\Agents\BetaManagedAgentsAgentToolsetDefaultConfigParams;
  use Anthropic\Beta\Agents\BetaManagedAgentsAlwaysAllowPolicy;
  use Anthropic\Beta\Agents\BetaManagedAgentsAlwaysAskPolicy;

  $tools = [
      BetaManagedAgentsAgentToolset20260401Params::with(
          defaultConfig: BetaManagedAgentsAgentToolsetDefaultConfigParams::with(
              permissionPolicy: BetaManagedAgentsAlwaysAllowPolicy::with(),
          ),
          configs: [
              BetaManagedAgentsBashToolConfigParams::with(
                  permissionPolicy: BetaManagedAgentsAlwaysAskPolicy::with(),
              ),
          ],
      ),
  ];
  ```

  ```ruby Ruby
  tools = [
    {
      type: "agent_toolset_20260401",
      default_config: {
        permission_policy: {type: "always_allow"}
      },
      configs: [
        {
          name: "bash",
          permission_policy: {type: "always_ask"}
        }
      ]
    }
  ]
  ```
</CodeGroup>

Передайте эту конфигурацию `tools` (csharp, go: `Tools`) при создании агента. Наборы инструментов MCP поддерживают такие же переопределения для отдельных инструментов, где `name` (csharp, go: `Name`) задаётся как имя инструмента, сообщаемое сервером MCP. См. [Настройка доступных инструментов MCP](https://platform.claude.com/docs/ru/managed-agents/mcp-connector#configure-which-mcp-tools-are-available).

## Оценка каждого вызова сервером с помощью `auto`

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

* **Вызов выполняется.** Если сервер определяет, что вызов безопасен, инструмент запускается так же, как при `always_allow`.
* **Вызов отклоняется.** Если сервер оценивает вызов как высокорисковый, инструмент не запускается. Агент получает результат инструмента с ошибкой, содержащий `Permission to use {tool_name} has been denied.` и `is_error: true`. Сессия продолжает работу, и ваш клиент не может отменить это отклонение.
* **Вызов приостанавливается до вашего одобрения.** Если сервер не приходит к определённому решению, сессия приостанавливается так же, как при `always_ask`. См. [Ответ на запросы подтверждения](https://platform.claude.com/docs/ru/managed-agents/permission-policies#respond-to-confirmation-requests).

Чтобы включить `auto`, задайте для `permission_policy` (java, php: `permissionPolicy`; csharp, go: `PermissionPolicy`) значение `{"type": "auto"}`. Оно указывается в тех же двух местах, что и другие политики: в [`default_config` (java, php: `defaultConfig`; csharp, go: `DefaultConfig`)](https://platform.claude.com/docs/ru/managed-agents/permission-policies#set-a-policy-for-a-toolset) набора инструментов — для всего набора, или в [записи `configs` (csharp, go: `Configs`)](https://platform.claude.com/docs/ru/managed-agents/permission-policies#override-an-individual-tool-policy) — для одного инструмента. Его принимают как набор инструментов агента, так и наборы инструментов MCP. Ни один набор инструментов не использует `auto` по умолчанию.

В следующем примере `auto` задаётся по умолчанию для набора инструментов агента и для набора инструментов MCP `github`, а для `bash` переопределяется на `always_ask`:

<CodeGroup defaultLanguage="CLI">
  ```bash cURL
  curl -fsSL https://api.anthropic.com/v1/agents \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "anthropic-beta: managed-agents-2026-04-01" \
    -H "content-type: application/json" \
    -d '{
      "name": "Ops Agent",
      "model": "claude-opus-5-5",
      "mcp_servers": [
        {"type": "url", "name": "github", "url": "https://mcp.example.com/github"}
      ],
      "tools": [
        {
          "type": "agent_toolset_20260401",
          "default_config": {
            "permission_policy": {"type": "auto"}
          },
          "configs": [
            {"name": "bash", "permission_policy": {"type": "always_ask"}}
          ]
        },
        {
          "type": "mcp_toolset",
          "mcp_server_name": "github",
          "default_config": {
            "permission_policy": {"type": "auto"}
          }
        }
      ]
    }'
  ```

  <CodeGroupItem>
    ```bash CLI
    ant apply agent.md
    ```

    <File filename="agent.md">
      ```markdown
      ---
      name: Ops Agent
      model: claude-opus-5-5
      mcp_servers:
        - type: url
          name: github
          url: https://mcp.example.com/github
      tools:
        - type: agent_toolset_20260401
          default_config:
            permission_policy:
              type: auto
          configs:
            - name: bash
              permission_policy:
                type: always_ask
        - type: mcp_toolset
          mcp_server_name: github
          default_config:
            permission_policy:
              type: auto
      ---
      ```
    </File>
  </CodeGroupItem>

  ```python Python
  agent = client.beta.agents.create(
      name="Ops Agent",
      model="claude-opus-5-5",
      mcp_servers=[
          {"type": "url", "name": "github", "url": "https://mcp.example.com/github"},
      ],
      tools=[
          {
              "type": "agent_toolset_20260401",
              "default_config": {
                  "permission_policy": {"type": "auto"},
              },
              "configs": [
                  {"name": "bash", "permission_policy": {"type": "always_ask"}},
              ],
          },
          {
              "type": "mcp_toolset",
              "mcp_server_name": "github",
              "default_config": {
                  "permission_policy": {"type": "auto"},
              },
          },
      ],
  )
  ```

  ```typescript TypeScript
  const agent = await client.beta.agents.create({
    name: "Ops Agent",
    model: "claude-opus-5-5",
    mcp_servers: [{ type: "url", name: "github", url: "https://mcp.example.com/github" }],
    tools: [
      {
        type: "agent_toolset_20260401",
        default_config: {
          permission_policy: { type: "auto" }
        },
        configs: [{ name: "bash", permission_policy: { type: "always_ask" } }]
      },
      {
        type: "mcp_toolset",
        mcp_server_name: "github",
        default_config: {
          permission_policy: { type: "auto" }
        }
      }
    ]
  });
  ```

  ```csharp C#
  using Anthropic.Models.Beta.Agents;

  var agent = await client.Beta.Agents.Create(new()
  {
      Name = "Ops Agent",
      Model = BetaManagedAgentsModel.ClaudeOpus5_5,
      McpServers =
      [
          new()
          {
              Name = "github",
              Url = "https://mcp.example.com/github",
          },
      ],
      Tools =
      [
          new BetaManagedAgentsAgentToolset20260401Params
          {
              DefaultConfig = new()
              {
                  PermissionPolicy = new BetaManagedAgentsAutoPolicy(),
              },
              Configs =
              [
                  new BetaManagedAgentsBashToolConfigParams
                  {
                      PermissionPolicy = new BetaManagedAgentsAlwaysAskPolicy(),
                  },
              ],
          },
          new BetaManagedAgentsMcpToolsetParams
          {
              McpServerName = "github",
              DefaultConfig = new()
              {
                  PermissionPolicy = new BetaManagedAgentsAutoPolicy(),
              },
          },
      ],
  });
  ```

  ```go Go
  agent, err := client.Beta.Agents.New(ctx, anthropic.BetaAgentNewParams{
  	Name: "Ops Agent",
  	Model: anthropic.BetaManagedAgentsModelConfigParams{
  		ID: anthropic.BetaManagedAgentsModelClaudeOpus5_5,
  	},
  	MCPServers: []anthropic.BetaManagedAgentsURLMCPServerParams{{
  		Name: "github",
  		URL:  "https://mcp.example.com/github",
  	}},
  	Tools: []anthropic.BetaAgentNewParamsToolUnion{
  		{
  			OfAgentToolset20260401: &anthropic.BetaManagedAgentsAgentToolset20260401Params{
  				DefaultConfig: anthropic.BetaManagedAgentsAgentToolsetDefaultConfigParams{
  					PermissionPolicy: anthropic.BetaManagedAgentsAgentToolsetDefaultConfigParamsPermissionPolicyUnion{
  						OfAuto: &anthropic.BetaManagedAgentsAutoPolicyParam{},
  					},
  				},
  				Configs: []anthropic.BetaManagedAgentsAgentToolConfigParamsUnion{{
  					OfBash: &anthropic.BetaManagedAgentsBashToolConfigParams{
  						PermissionPolicy: anthropic.BetaManagedAgentsBashToolConfigParamsPermissionPolicyUnion{
  							OfAlwaysAsk: &anthropic.BetaManagedAgentsAlwaysAskPolicyParam{},
  						},
  					},
  				}},
  			},
  		},
  		{
  			OfMCPToolset: &anthropic.BetaManagedAgentsMCPToolsetParams{
  				MCPServerName: "github",
  				DefaultConfig: anthropic.BetaManagedAgentsMCPToolsetDefaultConfigParams{
  					PermissionPolicy: anthropic.BetaManagedAgentsMCPToolsetDefaultConfigParamsPermissionPolicyUnion{
  						OfAuto: &anthropic.BetaManagedAgentsAutoPolicyParam{},
  					},
  				},
  			},
  		},
  	},
  })
  if err != nil {
  	panic(err)
  }
  ```

  ```java Java
  import com.anthropic.models.beta.agents.*;

  var agent = client.beta().agents().create(
      AgentCreateParams.builder()
          .name("Ops Agent")
          .model(BetaManagedAgentsModel.CLAUDE_OPUS_5_5)
          .addMcpServer(
              BetaManagedAgentsUrlMcpServerParams.builder()
                  .name("github")
                  .url("https://mcp.example.com/github")
                  .build()
          )
          .addTool(
              BetaManagedAgentsAgentToolset20260401Params.builder()
                  .defaultConfig(
                      BetaManagedAgentsAgentToolsetDefaultConfigParams.builder()
                          .permissionPolicy(BetaManagedAgentsAutoPolicy.builder().build())
                          .build()
                  )
                  .addConfig(
                      BetaManagedAgentsBashToolConfigParams.builder()
                          .permissionPolicy(BetaManagedAgentsAlwaysAskPolicy.builder().build())
                          .build()
                  )
                  .build()
          )
          .addTool(
              BetaManagedAgentsMcpToolsetParams.builder()
                  .mcpServerName("github")
                  .defaultConfig(
                      BetaManagedAgentsMcpToolsetDefaultConfigParams.builder()
                          .permissionPolicy(BetaManagedAgentsAutoPolicy.builder().build())
                          .build()
                  )
                  .build()
          )
          .build()
  );
  ```

  ```php PHP
  use Anthropic\Beta\Agents\BetaManagedAgentsAgentToolset20260401Params;
  use Anthropic\Beta\Agents\BetaManagedAgentsAgentToolsetDefaultConfigParams;
  use Anthropic\Beta\Agents\BetaManagedAgentsAlwaysAskPolicy;
  use Anthropic\Beta\Agents\BetaManagedAgentsAutoPolicy;
  use Anthropic\Beta\Agents\BetaManagedAgentsBashToolConfigParams;
  use Anthropic\Beta\Agents\BetaManagedAgentsMCPToolsetDefaultConfigParams;
  use Anthropic\Beta\Agents\BetaManagedAgentsMCPToolsetParams;
  use Anthropic\Beta\Agents\BetaManagedAgentsURLMCPServerParams;

  $agent = $client->beta->agents->create(
      name: 'Ops Agent',
      model: 'claude-opus-5-5',
      mcpServers: [
          BetaManagedAgentsURLMCPServerParams::with(
              name: 'github',
              url: 'https://mcp.example.com/github',
          ),
      ],
      tools: [
          BetaManagedAgentsAgentToolset20260401Params::with(
              defaultConfig: BetaManagedAgentsAgentToolsetDefaultConfigParams::with(
                  permissionPolicy: BetaManagedAgentsAutoPolicy::with(),
              ),
              configs: [
                  BetaManagedAgentsBashToolConfigParams::with(
                      permissionPolicy: BetaManagedAgentsAlwaysAskPolicy::with(),
                  ),
              ],
          ),
          BetaManagedAgentsMCPToolsetParams::with(
              mcpServerName: 'github',
              defaultConfig: BetaManagedAgentsMCPToolsetDefaultConfigParams::with(
                  permissionPolicy: BetaManagedAgentsAutoPolicy::with(),
              ),
          ),
      ],
  );
  ```

  ```ruby Ruby
  agent = client.beta.agents.create(
    name: "Ops Agent",
    model: "claude-opus-5-5",
    mcp_servers: [
      {type: "url", name: "github", url: "https://mcp.example.com/github"}
    ],
    tools: [
      {
        type: "agent_toolset_20260401",
        default_config: {
          permission_policy: {type: "auto"}
        },
        configs: [
          {name: "bash", permission_policy: {type: "always_ask"}}
        ]
      },
      {
        type: "mcp_toolset",
        mcp_server_name: "github",
        default_config: {
          permission_policy: {type: "auto"}
        }
      }
    ]
  )
  ```
</CodeGroup>

То, что вы отправляете в событиях `user.message`, считается вашим намерением и может привести к тому, что сервер разрешит вызов, который в противном случае отклонил бы. Сервер не считывает намерение из результата инструмента, загруженной веб-страницы, ответа сервера MCP или сообщения между [потоками сессии](https://platform.claude.com/docs/ru/managed-agents/session-threads#tool-permissions-and-custom-tools). Он оценивает это содержимое, но не принимает из него инструкций. Некоторые вызовы сервер оценивает как высокорисковые независимо от того, кто о них просит. Если вы передаёте недоверенный ввод конечного пользователя в событиях `user.message`, сервер также воспринимает этот ввод как ваше намерение, и это может привести к разрешению вызова. Настройте `always_ask` для инструментов, которые вы не позволили бы этому конечному пользователю запускать без проверки.

<Warning>
  `auto` — это не контрольная точка с участием человека. Если сервер определяет, что вызов безопасен, вызов выполняется до того, как его кто-либо увидит, и его последствия могут быть необратимыми. Если человек должен проверять вызовы инструмента до их выполнения, настройте для этого инструмента `always_ask`.
</Warning>

## Просмотр результатов оценки каждого вызова

При любой политике разрешений каждое событие `agent.tool_use` и `agent.mcp_tool_use` содержит `evaluated_permission` — результат проверки разрешений для вызова: `"allow"`, `"ask"` или `"deny"`. Большинство событий также содержат объект `evaluation`, поле `type` которого указывает политику, давшую этот результат. При `auto` объект также фиксирует решение сервера, а если результат — `ask` или `deny`, то и `reason_code`.

Например, если для `bash` задана политика `auto` и сервер оценивает вызов как высокорисковый, отклонённый вызов появляется в потоке событий следующим образом:

```json
{
  "type": "agent.tool_use",
  "id": "sevt_01pqr...",
  "name": "bash",
  "input": {
    "command": "rm -rf /workspace/reports"
  },
  "evaluated_permission": "deny",
  "evaluation": {
    "type": "auto",
    "evaluated_permission": {
      "type": "deny",
      "reason_code": "high_risk"
    }
  },
  "processed_at": "2026-03-25T14:05:12Z"
}
```

Объект `evaluation` принимает одну из форм, приведённых в следующей таблице.

| `evaluation` | `evaluated_permission` верхнего уровня | Значение |
| ----- | ----- | ----- |
| `{"type": "always_allow"}` | `"allow"` | Итоговая политика — `always_allow`, поэтому вызов был выполнен. |
| `{"type": "always_ask"}` | `"ask"` | Итоговая политика — `always_ask`, поэтому вызов был приостановлен до вашего одобрения. |
| `{"type": "auto", "evaluated_permission": {"type": "allow"}}` | `"allow"` | При `auto` сервер определил, что вызов безопасен, и он был выполнен. |
| `{"type": "auto", "evaluated_permission": {"type": "ask", "reason_code": "indeterminate"}}` | `"ask"` | При `auto` сервер не пришёл к определённому решению, поэтому вызов был приостановлен до вашего одобрения. |
| `{"type": "auto", "evaluated_permission": {"type": "deny", "reason_code": "high_risk"}}` | `"deny"` | При `auto` сервер оценил вызов как высокорисковый и отклонил его. |

Когда `evaluation.type` равно `"auto"`, вложенное поле `evaluated_permission.type` повторяет `evaluated_permission` верхнего уровня события, поэтому результат можно прочитать из любого из этих полей. `reason_code` — это значение, по которому ваш клиент может выбирать ветку логики и которое стоит сохранять в журналах аудита, а не текст для показа конечным пользователям.

`evaluation` отсутствует в двух случаях. Если агент указывает инструмент, не включённый в сессии, сервер отклоняет вызов без оценки политики: событие содержит `evaluated_permission: "deny"` и не содержит `evaluation`. События, записанные до появления `evaluation`, также не содержат его: интерпретируйте их как `always_allow`, если `evaluated_permission` равно `"allow"`, и как `always_ask`, если оно равно `"ask"`.

Пишите клиент так, чтобы он корректно обрабатывал нераспознанные значения `evaluation.type` или `reason_code`. События `agent.custom_tool_use` не содержат ни одного из этих полей, поскольку политики разрешений не распространяются на [пользовательские инструменты](https://platform.claude.com/docs/ru/managed-agents/permission-policies#custom-tools).

## Ответ на запросы подтверждения

Вызов инструмента получает результат `ask` при политике `always_ask` или при `auto`, когда сервер не приходит ни к какому решению. В этом случае:

1. Сессия генерирует событие `agent.tool_use` или `agent.mcp_tool_use`.
2. Сессия приостанавливается с событием `session.status_idle`, у которого `stop_reason.type` равно `requires_action`. Идентификаторы блокирующих событий находятся в массиве `stop_reason.event_ids`. Сессия ожидает ответа неограниченно долго. Вызов из потока [запуска рабочего процесса](https://platform.claude.com/docs/ru/managed-agents/workflow-runs#while-a-run-is-open) поступает вашему клиенту в основном потоке событий. Пока в сессии работает что-либо ещё, сессия может оставаться в состоянии `running` и не отправлять `session.status_idle`, поэтому отвечайте на само событие использования инструмента. Вызов ожидает только до тех пор, пока запуск не завершит работу с этим потоком или пока запуск не закончится. Прерывание может оставить его в ожидании, поэтому разрешите или отклоните его самостоятельно.
3. Отправьте событие `user.tool_confirmation` для каждого блокирующего события, передав идентификатор события в параметре `tool_use_id` (java: `toolUseId`; php: `toolUseID`; csharp, go: `ToolUseID`). Задайте для `result` (csharp, go: `Result`) значение `"allow"` или `"deny"`. Используйте `deny_message` (java, php: `denyMessage`; csharp, go: `DenyMessage`), чтобы объяснить отклонение. В одном запросе `events` можно отправить несколько подтверждений.
4. После разрешения всех блокирующих событий сессия снова переходит в состояние `running`. Разрешённые инструменты запускаются. Отклонённые инструменты не запускаются, и агент получает результат инструмента о том, что вызов был отклонён, включая ваше `deny_message` (java, php: `denyMessage`; csharp, go: `DenyMessage`).

Например, вызов `bash`, приостановленный при политике `always_ask`, появляется в потоке следующим образом:

```json
{
  "type": "agent.tool_use",
  "id": "sevt_01def...",
  "name": "bash",
  "input": {
    "command": "pip install -r requirements.txt"
  },
  "evaluated_permission": "ask",
  "evaluation": {
    "type": "always_ask"
  },
  "processed_at": "2026-03-25T14:01:45Z"
}
```

Если вы отправите `user.tool_confirmation` для события, у которого `evaluated_permission` (java, php: `evaluatedPermission`; csharp, go: `EvaluatedPermission`) не равно `ask`, API отклонит его с ошибкой 400. Это касается и вызовов, отклонённых сервером при `auto`: ваш клиент не может их переопределить.

Чтобы отвечать в интерактивном режиме, используйте `ant beta:sessions connect` — эта команда показывает ожидающий вызов и отправляет это событие, когда вы разрешаете или отклоняете его. См. [Подключение к сессии Managed Agents из терминала](https://platform.claude.com/docs/ru/cli-sdks-libraries/cli/sessions-connect#follow-and-steer-the-session).

В следующих примерах идентификаторы событий использования инструментов берутся из массива `stop_reason.event_ids` события `session.status_idle`. Подробнее о [получении событий](https://platform.claude.com/docs/ru/managed-agents/events-and-streaming#stream-events) читайте в руководстве по потоку событий сессии или [подпишитесь на вебхуки](https://platform.claude.com/docs/ru/managed-agents/webhooks), чтобы получать уведомления, когда сессия приостанавливается в ожидании ввода.

<CodeGroup>
  ```bash cURL
  # Разрешить выполнение инструмента
  curl -fsSL https://api.anthropic.com/v1/sessions/sesn_011CZkZAtmR3yMPDzynEDxu7/events \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "anthropic-beta: managed-agents-2026-04-01" \
    -H "content-type: application/json" \
    -d '{
      "events": [
        {
          "type": "user.tool_confirmation",
          "tool_use_id": "sevt_011CZkZbMpR8aS3Wtv5Yq2Ln",
          "result": "allow"
        }
      ]
    }'

  # Отклонить другой вызов с пояснением
  curl -fsSL https://api.anthropic.com/v1/sessions/sesn_011CZkZAtmR3yMPDzynEDxu7/events \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "anthropic-beta: managed-agents-2026-04-01" \
    -H "content-type: application/json" \
    -d '{
      "events": [
        {
          "type": "user.tool_confirmation",
          "tool_use_id": "sevt_011CZkZcNqT9bT4Xuw6Zr3Mo",
          "result": "deny",
          "deny_message": "Do not create issues in the production project. Use the staging project."
        }
      ]
    }'
  ```

  ```bash CLI
  # Разрешить запуск инструмента
  ant beta:sessions:events send \
    --session-id sesn_011CZkZAtmR3yMPDzynEDxu7 \
    --event '{type: user.tool_confirmation, tool_use_id: sevt_011CZkZbMpR8aS3Wtv5Yq2Ln, result: allow}'

  # Отклонить другой вызов с пояснением
  ant beta:sessions:events send \
    --session-id sesn_011CZkZAtmR3yMPDzynEDxu7 \
    --event '{type: user.tool_confirmation, tool_use_id: sevt_011CZkZcNqT9bT4Xuw6Zr3Mo, result: deny, deny_message: "Do not create issues in the production project. Use the staging project."}'
  ```

  ```python Python
  # Разрешить запуск инструмента
  client.beta.sessions.events.send(
      "sesn_011CZkZAtmR3yMPDzynEDxu7",
      events=[
          {
              "type": "user.tool_confirmation",
              "tool_use_id": "sevt_011CZkZbMpR8aS3Wtv5Yq2Ln",
              "result": "allow",
          },
      ],
  )

  # Отклонить другой вызов с пояснением
  client.beta.sessions.events.send(
      "sesn_011CZkZAtmR3yMPDzynEDxu7",
      events=[
          {
              "type": "user.tool_confirmation",
              "tool_use_id": "sevt_011CZkZcNqT9bT4Xuw6Zr3Mo",
              "result": "deny",
              "deny_message": "Do not create issues in the production project. Use the staging project.",
          },
      ],
  )
  ```

  ```typescript TypeScript
  // Разрешить запуск инструмента
  await client.beta.sessions.events.send("sesn_011CZkZAtmR3yMPDzynEDxu7", {
    events: [
      {
        type: "user.tool_confirmation",
        tool_use_id: "sevt_011CZkZbMpR8aS3Wtv5Yq2Ln",
        result: "allow"
      }
    ]
  });

  // Отклонить другой вызов с пояснением
  await client.beta.sessions.events.send("sesn_011CZkZAtmR3yMPDzynEDxu7", {
    events: [
      {
        type: "user.tool_confirmation",
        tool_use_id: "sevt_011CZkZcNqT9bT4Xuw6Zr3Mo",
        result: "deny",
        deny_message: "Do not create issues in the production project. Use the staging project."
      }
    ]
  });
  ```

  ```csharp C#
  using Anthropic.Models.Beta.Sessions.Events;

  // Разрешить запуск инструмента
  await client.Beta.Sessions.Events.Send("sesn_011CZkZAtmR3yMPDzynEDxu7", new()
  {
      Events =
      [
          new BetaManagedAgentsUserToolConfirmationEventParams
          {
              ToolUseID = "sevt_011CZkZbMpR8aS3Wtv5Yq2Ln",
              Result = "allow",
          },
      ],
  });

  // Отклонить ещё один вызов с пояснением
  await client.Beta.Sessions.Events.Send("sesn_011CZkZAtmR3yMPDzynEDxu7", new()
  {
      Events =
      [
          new BetaManagedAgentsUserToolConfirmationEventParams
          {
              ToolUseID = "sevt_011CZkZcNqT9bT4Xuw6Zr3Mo",
              Result = "deny",
              DenyMessage = "Do not create issues in the production project. Use the staging project.",
          },
      ],
  });
  ```

  ```go Go
  // Разрешить запуск инструмента
  _, err := client.Beta.Sessions.Events.Send(ctx, "sesn_011CZkZAtmR3yMPDzynEDxu7", anthropic.BetaSessionEventSendParams{
  	Events: []anthropic.BetaManagedAgentsEventParamsUnion{{
  		OfUserToolConfirmation: &anthropic.BetaManagedAgentsUserToolConfirmationEventParams{
  			ToolUseID: "sevt_011CZkZbMpR8aS3Wtv5Yq2Ln",
  			Result:    anthropic.BetaManagedAgentsUserToolConfirmationEventParamsResultAllow,
  		},
  	}},
  })
  if err != nil {
  	panic(err)
  }

  // Отклонить другой вызов с объяснением
  _, err = client.Beta.Sessions.Events.Send(ctx, "sesn_011CZkZAtmR3yMPDzynEDxu7", anthropic.BetaSessionEventSendParams{
  	Events: []anthropic.BetaManagedAgentsEventParamsUnion{{
  		OfUserToolConfirmation: &anthropic.BetaManagedAgentsUserToolConfirmationEventParams{
  			ToolUseID:   "sevt_011CZkZcNqT9bT4Xuw6Zr3Mo",
  			Result:      anthropic.BetaManagedAgentsUserToolConfirmationEventParamsResultDeny,
  			DenyMessage: anthropic.String("Do not create issues in the production project. Use the staging project."),
  		},
  	}},
  })
  if err != nil {
  	panic(err)
  }
  ```

  ```java Java
  import com.anthropic.models.beta.sessions.events.BetaManagedAgentsUserToolConfirmationEventParams;
  import com.anthropic.models.beta.sessions.events.EventSendParams;

  // Разрешить запуск инструмента
  client.beta().sessions().events().send(
      "sesn_011CZkZAtmR3yMPDzynEDxu7",
      EventSendParams.builder()
          .addEvent(
              BetaManagedAgentsUserToolConfirmationEventParams.builder()
                  .toolUseId("sevt_011CZkZbMpR8aS3Wtv5Yq2Ln")
                  .result(BetaManagedAgentsUserToolConfirmationEventParams.Result.ALLOW)
                  .build()
          )
          .build()
  );

  // Отклонить другой вызов с пояснением
  client.beta().sessions().events().send(
      "sesn_011CZkZAtmR3yMPDzynEDxu7",
      EventSendParams.builder()
          .addEvent(
              BetaManagedAgentsUserToolConfirmationEventParams.builder()
                  .toolUseId("sevt_011CZkZcNqT9bT4Xuw6Zr3Mo")
                  .result(BetaManagedAgentsUserToolConfirmationEventParams.Result.DENY)
                  .denyMessage("Do not create issues in the production project. Use the staging project.")
                  .build()
          )
          .build()
  );
  ```

  ```php PHP
  use Anthropic\Beta\Sessions\Events\ManagedAgentsUserToolConfirmationEventParams;

  // Разрешить запуск инструмента
  $client->beta->sessions->events->send(
      'sesn_011CZkZAtmR3yMPDzynEDxu7',
      events: [
          ManagedAgentsUserToolConfirmationEventParams::with(
              toolUseID: 'sevt_011CZkZbMpR8aS3Wtv5Yq2Ln',
              result: 'allow',
          ),
      ],
  );

  // Отклонить ещё один вызов с пояснением
  $client->beta->sessions->events->send(
      'sesn_011CZkZAtmR3yMPDzynEDxu7',
      events: [
          ManagedAgentsUserToolConfirmationEventParams::with(
              toolUseID: 'sevt_011CZkZcNqT9bT4Xuw6Zr3Mo',
              result: 'deny',
              denyMessage: 'Do not create issues in the production project. Use the staging project.',
          ),
      ],
  );
  ```

  ```ruby Ruby
  # Разрешить выполнение инструмента
  client.beta.sessions.events.send_(
    "sesn_011CZkZAtmR3yMPDzynEDxu7",
    events: [
      {
        type: "user.tool_confirmation",
        tool_use_id: "sevt_011CZkZbMpR8aS3Wtv5Yq2Ln",
        result: "allow"
      }
    ]
  )

  # Отклонить другой вызов с объяснением
  client.beta.sessions.events.send_(
    "sesn_011CZkZAtmR3yMPDzynEDxu7",
    events: [
      {
        type: "user.tool_confirmation",
        tool_use_id: "sevt_011CZkZcNqT9bT4Xuw6Zr3Mo",
        result: "deny",
        deny_message: "Do not create issues in the production project. Use the staging project."
      }
    ]
  )
  ```
</CodeGroup>

## Пользовательские инструменты

Политики разрешений не применяются к пользовательским инструментам. Когда агент вызывает пользовательский инструмент, ваше приложение получает событие `agent.custom_tool_use` и само решает, запускать ли его, прежде чем отправить обратно `user.custom_tool_result`. Полное описание процесса см. в разделе [Ответ на вызовы инструментов, приостанавливающие сессию](https://platform.claude.com/docs/ru/managed-agents/events-and-streaming#answer-tool-calls-that-pause-the-session).

## Следующие шаги

<CardGroup cols={2}>
  <Card title="Навыки" icon="books" href="https://platform.claude.com/docs/ru/managed-agents/skills">
    Подключите к вашему агенту многократно используемую экспертизу на основе файловой системы для предметно-ориентированных рабочих процессов.
  </Card>

  <Card title="Поток событий сессии" icon="lightning" href="https://platform.claude.com/docs/ru/managed-agents/events-and-streaming">
    Отправляйте события, получайте ответы в режиме потоковой передачи, а также прерывайте или перенаправляйте сессию во время её работы.
  </Card>
</CardGroup>

## Доступность

Политики разрешений находятся в бета-версии для всех моделей.

### Поддержка API

#### [Managed Agents](https://platform.claude.com/docs/ru/managed-agents/overview)

* Доступность: Всегда включено

| Статус | Облачные платформы |
| ----- | ----- |
| Бета | Все поддерживаемые платформы |

### Обязательные бета-заголовки

[Обзор бета-заголовков](https://platform.claude.com/docs/ru/api/beta-headers)

Бета-заголовки позволяют получить доступ к экспериментальным функциям и новым возможностям моделей до того, как они станут частью стандартного API.

* `managed-agents-2026-04-01`

### Обработка данных

[Обзор обработки данных](https://platform.claude.com/docs/ru/manage-claude/api-and-data-retention#feature-eligibility)

| Элемент | Нулевое хранение данных | HIPAA |
| ----- | ----- | ----- |
| Статус | Не допускается | Не допускается |
| Подробности | Не подпадает под ZDR, за исключением самостоятельно размещаемых Managed Agents. Сессии — это ресурсы с состоянием; их расшифровки хранятся, пока вы их не удалите. [Подробнее](https://platform.claude.com/docs/ru/managed-agents/self-hosted-data-and-access#how-long-data-is-kept) | Не подпадает под HIPAA. Относится ко всем подфункциям Managed Agents. |

Применимые конечные точки:

* `/v1/agents`
* `/v1/sessions`
* `/v1/environments`
