---
title: Развёртывание самостоятельно размещаемых воркеров
url: https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes-workers
description: Выберите, как самостоятельно размещаемые воркеры песочниц получают работу и где выполняются сеансы, а затем запустите постоянно работающий воркер или запускайте воркеры по вебхукам.
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
---

[Быстрый старт по самостоятельно размещаемым песочницам](https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes#quickstart) запускает один воркер `ant` CLI, который непрерывно опрашивает очередь и выполняет каждую сессию в одном процессе. Эта страница поможет вам выбрать шаблон развёртывания, а затем описывает постоянно работающие воркеры и воркеры, запускаемые по вебхукам.

## Выбор шаблона развёртывания

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

**Как воркер получает работу:**

* **Постоянная работа («always-on»):** долго работающий процесс непрерывно опрашивает очередь. Процесс выполняет только исходящие HTTPS-запросы, поэтому вам не нужно открывать конечную точку для Anthropic.
* **Запуск по вебхуку («webhook-triggered»):** обработчик активируется по событию `session.status_run_started` и начинает опрос. Это позволяет избежать простаивающего опрашивающего процесса, но требует конечной точки [вебхука](https://platform.claude.com/docs/ru/managed-agents/webhooks), доступной для Anthropic.

**Где выполняется каждый сеанс:**

* **В процессе:** воркер, получивший сеанс, сам выполняет его вызовы инструментов в одном общем рабочем каталоге.
* **Песочница на сеанс:** опрашивающий процесс запускает новую песочницу для каждого полученного сеанса. Выбирайте этот вариант для более сильной изоляции: новая файловая система, ограничения ресурсов или сетевые ограничения для каждого сеанса. См. раздел [Запуск отдельной песочницы для каждого сеанса](https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes-per-session), где также описан Helm-чарт для Kubernetes.

Воркеры CLI и SDK поддерживают разные комбинации:

| Возможность | CLI `ant` | SDK (Python, TypeScript, Go) |
| ----- | ----- | ----- |
| Постоянный опрос | Да | Да |
| Запуск по вебхуку | Нет | Да |
| [Песочница на сеанс](https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes-per-session) | Да | Да |
| [Хранилища памяти](https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes-memory) | Да, с настройками синхронизации по умолчанию | Да, с настраиваемой синхронизацией |
| [Пользовательские инструменты](https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes-custom-tools) | Нет | Да |

Все флаги CLI и параметры SDK описаны в [справочнике по самостоятельно размещаемым воркерам](https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes-reference).

Для большего контроля вызывайте [конечные точки Environments Work](https://platform.claude.com/docs/ru/api/beta/environments/work) напрямую и реализуйте собственный воркер. Тогда ваш воркер делает то же, что и воркеры SDK. Помимо прочего, он подтверждает каждый элемент работы, отправляет контрольные сигналы (heartbeat) и загружает навыки агента. Он выполняет только те вызовы инструментов, которые разрешает [политика разрешений](https://platform.claude.com/docs/ru/managed-agents/permission-policies#see-how-each-call-was-evaluated) сеанса. Каждый результат он возвращает в виде события `user.tool_result` или `user.custom_tool_result`. В конце он останавливает элемент. В качестве образца используйте исходный код воркера в [Python SDK](https://github.com/anthropics/anthropic-sdk-python/tree/main/src/anthropic/lib/environments), [TypeScript SDK](https://github.com/anthropics/anthropic-sdk-typescript/tree/main/src/lib/environments) или [Go SDK](https://github.com/anthropics/anthropic-sdk-go/tree/main/lib/environments).

## Запуск постоянно работающего воркера

В этих примерах в качестве рабочего каталога воркера используется `/workspace`. Каталог должен существовать до запуска воркера. На новом хосте создайте его и предоставьте пользователю воркера права на запись, как в шаге «Запустите воркер» раздела [Запуск первого сеанса](https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes#run-your-first-session).

В macOS `mkdir` не может создать `/workspace`, поскольку корневой том доступен только для чтения. Вместо этого создайте `~/workspace`, как показано в этом шаге. Вместо `/workspace` используйте полный путь, который выводит `echo ~/workspace`, поскольку SDK не раскрывает `~`.

Запустите воркер, который непрерывно опрашивает очередь. Он проходит аутентификацию с помощью [ключа среды](https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes#run-your-first-session) из краткого руководства:

<CodeGroup exclude="shell:cURL, csharp, java, php, ruby">
  <CodeGroupItem language="cURL">
    Воркер — это долго работающий процесс, а не отдельный HTTP-запрос. Вместо этого запустите воркер CLI `ant`: `ant beta:worker poll --workdir /workspace`.
  </CodeGroupItem>

  ```bash CLI
  ant beta:worker poll --workdir /workspace
  ```

  ```python Python
  import asyncio
  import contextlib
  import os
  import signal
  from anthropic import AsyncAnthropic
  from anthropic.lib.environments import EnvironmentWorker


  async def main() -> None:
      environment_key = os.environ["ANTHROPIC_ENVIRONMENT_KEY"]
      environment_id = os.environ["ANTHROPIC_ENVIRONMENT_ID"]
      async with AsyncAnthropic(auth_token=environment_key) as client:
          worker = EnvironmentWorker(
              client,
              environment_id=environment_id,
              environment_key=environment_key,
              workdir="/workspace",
          )
          task = asyncio.create_task(worker.run())
          # Отмена задачи вместо завершения процесса позволяет воркеру остановить
          # текущий элемент работы и загрузить изменённые файлы памяти перед выходом.
          loop = asyncio.get_running_loop()
          for signum in (signal.SIGINT, signal.SIGTERM):
              loop.add_signal_handler(signum, task.cancel)
          with contextlib.suppress(asyncio.CancelledError):
              await task


  asyncio.run(main())
  ```

  ```typescript TypeScript
  import Anthropic from "@anthropic-ai/sdk";
  import { EnvironmentWorker } from "@anthropic-ai/sdk/helpers/beta/environments";

  const environmentKey = process.env.ANTHROPIC_ENVIRONMENT_KEY!;
  const environmentId = process.env.ANTHROPIC_ENVIRONMENT_ID!;
  const client = new Anthropic({ authToken: environmentKey });
  const controller = new AbortController();
  // Прерывание по любому из сигналов позволяет воркеру выгрузить изменённые файлы памяти и удалить свои
  // каталоги хранилища до завершения процесса.
  process.once("SIGINT", () => controller.abort());
  process.once("SIGTERM", () => controller.abort());

  await new EnvironmentWorker({
    client,
    environmentId,
    environmentKey,
    workdir: "/workspace",
    signal: controller.signal
  }).run();
  ```

  <CodeGroupItem language="C#">
    В SDK для C# нет `EnvironmentWorker`. Вместо этого запустите воркер CLI `ant`: `ant beta:worker poll --workdir /workspace`.
  </CodeGroupItem>

  ```go Go
  package main

  import (
  	"context"
  	"log"
  	"os"
  	"os/signal"
  	"syscall"

  	"github.com/anthropics/anthropic-sdk-go/v2"
  	"github.com/anthropics/anthropic-sdk-go/v2/lib/environments"
  	"github.com/anthropics/anthropic-sdk-go/v2/option"
  )

  func main() {
  	environmentKey := os.Getenv("ANTHROPIC_ENVIRONMENT_KEY")
  	environmentID := os.Getenv("ANTHROPIC_ENVIRONMENT_ID")

  	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
  	defer stop()

  	client := anthropic.NewClient(option.WithAuthToken(environmentKey))

  	worker := environments.NewEnvironmentWorker(client, environments.EnvironmentWorkerOptions{
  		EnvironmentID:  environmentID,
  		EnvironmentKey: environmentKey,
  		Workdir:        "/workspace",
  	})
  	if err := worker.Run(ctx); err != nil {
  		log.Fatalf("worker: %v", err)
  	}
  }
  ```

  <CodeGroupItem language="Java">
    В SDK для Java нет `EnvironmentWorker`. Вместо этого запустите воркер CLI `ant`: `ant beta:worker poll --workdir /workspace`.
  </CodeGroupItem>

  <CodeGroupItem language="PHP">
    В SDK для PHP нет `EnvironmentWorker`. Вместо этого запустите воркер CLI `ant`: `ant beta:worker poll --workdir /workspace`.
  </CodeGroupItem>

  <CodeGroupItem language="Ruby">
    В SDK для Ruby нет `EnvironmentWorker`. Вместо этого запустите воркер CLI `ant`: `ant beta:worker poll --workdir /workspace`.
  </CodeGroupItem>
</CodeGroup>

## Запуск воркеров по вебхукам

<Steps>
  <Step title="Подпишитесь на вебхуки сеансов">
    В [Claude Console](https://platform.claude.com/settings/workspaces/default/webhooks) определите конечную точку вебхука, которая прослушивает события `session.status_run_started`. Подробности см. в разделе [Подписка на вебхуки](https://platform.claude.com/docs/ru/managed-agents/webhooks).
  </Step>

  <Step title="Экспортируйте ключ подписи вебхука">
    Вместе с ID среды и ключом из раздела [Запуск первого сеанса](https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes#run-your-first-session) экспортируйте ключ подписи вебхука на хосте обработчика. Обработчик использует его для проверки входящих полезных данных.

    ```bash
    export ANTHROPIC_WEBHOOK_SIGNING_KEY="whsec_..."
    ```
  </Step>

  <Step title="Реализуйте обработчик вебхука">
    Запускайте воркер при срабатывании `session.status_run_started`. Обработчик опустошает очередь и передаёт каждый забранный элемент работы в `handle_item()` (typescript: `handleItem()`; go: `HandleItem()`) (в SDK для Python, TypeScript и Go). Этот метод загружает навыки, выполняет вызовы инструментов, отправляет результаты обратно и завершается.

    В примерах в качестве рабочего каталога используется `/workspace`. Перед запуском обработчика создайте этот каталог на хосте обработчика. Убедитесь, что пользователь обработчика может записывать в него, как в шаге «Запустите воркер» раздела [Запуск первого сеанса](https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes#run-your-first-session).

    <CodeGroup exclude="shell, csharp, java, php, ruby">
      <CodeGroupItem language="cURL">
        Этому обработчику нужно больше логики, чем одна команда оболочки. Для его запуска используйте SDK для Python, TypeScript или Go.
      </CodeGroupItem>

      <CodeGroupItem language="CLI">
        Этому обработчику нужно больше логики, чем одна команда оболочки. Для его запуска используйте SDK для Python, TypeScript или Go.
      </CodeGroupItem>

      <CodeGroupItem>
        Чтобы проверять подписи вебхуков, установите дополнительный пакет webhooks: `pip install "anthropic[webhooks]"`.

        ```python Python
        import asyncio
        import os
        import anthropic
        import standardwebhooks  # installed by the anthropic[webhooks] extra

        environment_key = os.environ["ANTHROPIC_ENVIRONMENT_KEY"]
        environment_id = os.environ["ANTHROPIC_ENVIRONMENT_ID"]
        client = anthropic.AsyncAnthropic(
            auth_token=environment_key,
        )
        # Отменяется через shutdown(), чтобы выполняемый элемент работы мог выгрузить изменённые файлы памяти и
        # удалить свои каталоги хранилища до завершения процесса.
        inflight: set[asyncio.Task[None]] = set()


        # Ожидайте это в хуке завершения работы хоста, например в завершении lifespan ASGI (код после
        # `yield` в lifespan FastAPI), который uvicorn запускает по SIGTERM. uvicorn даёт открытым запросам
        # завершиться до запуска этого хука, поэтому задайте --timeout-graceful-shutdown, чтобы ограничить ожидание.
        async def shutdown() -> None:
            for task in inflight:
                task.cancel()
            await asyncio.gather(*inflight, return_exceptions=True)


        async def handle(raw: bytes, headers: dict[str, str]) -> tuple[dict[str, str], int]:
            try:
                event = client.beta.webhooks.unwrap(raw.decode(), headers=headers)
            except standardwebhooks.WebhookVerificationError:
                return {"error": "signature verification failed"}, 401
            if event.data.type != "session.status_run_started":
                return {"status": "ignored"}, 200
            task = asyncio.create_task(run_queued_work())
            inflight.add(task)
            task.add_done_callback(inflight.discard)
            try:
                # Защищено: разорванная или просроченная доставка не должна отменять элемент; это делает shutdown().
                await asyncio.shield(task)
            except asyncio.CancelledError:
                return {"status": "shutting down"}, 503
            return {"status": "ok"}, 200


        async def run_queued_work() -> None:
            async for work in client.beta.environments.work.poller(
                environment_id=environment_id,
                environment_key=environment_key,
                block_ms=None,
                reclaim_older_than_ms=2000,
                drain=True,
                auto_stop=False,
            ):
                await client.beta.environments.work.worker(workdir="/workspace").handle_item(
                    work_id=work.id,
                    environment_id=environment_id,
                    session_id=work.data.id,
                    environment_key=environment_key,
                    # Секрет сеанса позволяет воркеру монтировать хранилища памяти сеанса.
                    work_secret=work.secret,
                )
        ```
      </CodeGroupItem>

      ```typescript TypeScript
      import Anthropic from "@anthropic-ai/sdk";

      const environmentKey = process.env.ANTHROPIC_ENVIRONMENT_KEY!;
      const environmentId = process.env.ANTHROPIC_ENVIRONMENT_ID!;
      const client = new Anthropic({
        authToken: environmentKey
      });
      // Вызовите shutdown.abort() из обработчика SIGTERM/SIGINT хоста, одновременно с закрытием сервера,
      // затем дождитесь выполняющихся вызовов handle() перед выходом: abort позволяет работающему элементу
      // сначала выгрузить изменённые файлы памяти и удалить свои каталоги хранилищ.
      export const shutdown = new AbortController();

      export async function handle(req: Request): Promise<Response> {
        // Никогда не подтверждайте доставку, работа которой здесь не будет выполнена; 503 заставит отправителя повторить попытку.
        if (shutdown.signal.aborted) {
          return Response.json({ status: "shutting down" }, { status: 503 });
        }
        const body = await req.text();
        let event;
        try {
          event = client.beta.webhooks.unwrap(body, { headers: Object.fromEntries(req.headers) });
        } catch {
          return new Response("signature verification failed", { status: 401 });
        }
        if (event.data.type !== "session.status_run_started") {
          return Response.json({ status: "ignored" });
        }

        for await (const work of client.beta.environments.work.poller({
          environmentId,
          environmentKey,
          blockMs: null,
          reclaimOlderThanMs: 2000,
          drain: true,
          autoStop: false,
          signal: shutdown.signal
        })) {
          await client.beta.environments.work.worker({ workdir: "/workspace" }).handleItem({
            workId: work.id,
            environmentId,
            sessionId: work.data.id,
            environmentKey,
            // Именно секрет сессии позволяет воркеру монтировать хранилища памяти этой сессии.
            workSecret: work.secret ?? undefined,
            signal: shutdown.signal
          });
        }
        // Поллер и handleItem тихо завершаются при abort, поэтому прерванный досрочно drain попадает сюда.
        if (shutdown.signal.aborted) {
          return Response.json({ status: "shutting down" }, { status: 503 });
        }
        return Response.json({ status: "ok" });
      }
      ```

      <CodeGroupItem language="C#">
        В SDK для C# нет `EnvironmentWorker`. Чтобы обрабатывать элементы работы из собственного кода, реализуйте собственный воркер, как описано в разделе [Выбор шаблона развёртывания](https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes-workers#choose-a-deployment-pattern).
      </CodeGroupItem>

      ```go Go
      package main

      import (
      	"context"
      	"encoding/json"
      	"errors"
      	"io"
      	"log/slog"
      	"net/http"
      	"os"
      	"os/signal"
      	"syscall"

      	"github.com/anthropics/anthropic-sdk-go/v2"
      	"github.com/anthropics/anthropic-sdk-go/v2/lib/environments"
      	"github.com/anthropics/anthropic-sdk-go/v2/option"
      	"github.com/anthropics/anthropic-sdk-go/v2/packages/param"
      )

      var (
      	environmentKey = os.Getenv("ANTHROPIC_ENVIRONMENT_KEY")
      	environmentID  = os.Getenv("ANTHROPIC_ENVIRONMENT_ID")
      	client         = anthropic.NewClient(
      		option.WithAuthToken(environmentKey),
      		option.WithWebhookKey(os.Getenv("ANTHROPIC_WEBHOOK_SIGNING_KEY")),
      	)
      	worker = environments.NewEnvironmentWorker(client, environments.EnvironmentWorkerOptions{
      		Workdir: "/workspace",
      	})
      	// Отменяется по SIGINT или SIGTERM (задаётся в main), чтобы выполняемый элемент работы мог
      	// загрузить изменённые файлы памяти и удалить каталоги хранилища перед выходом.
      	shutdown context.Context
      )

      func handle(w http.ResponseWriter, r *http.Request) {
      	body, err := io.ReadAll(r.Body)
      	if err != nil {
      		http.Error(w, "bad request", http.StatusBadRequest)
      		return
      	}
      	event, err := client.Beta.Webhooks.Unwrap(body, r.Header)
      	if err != nil {
      		http.Error(w, "signature verification failed", http.StatusUnauthorized)
      		return
      	}
      	if event.Data.Type != "session.status_run_started" {
      		json.NewEncoder(w).Encode(map[string]string{"status": "ignored"})
      		return
      	}

      	// Go SDK не предоставляет удобного RunOne: выбирайте ожидающие элементы
      	// с помощью WorkPoller и запускайте каждый через HandleItem.
      	// Отвязываемся от r.Context(): сеанс может пережить тайм-аут доставки webhook.
      	// Общий для процесса контекст завершения всё равно корректно завершает элемент по SIGTERM.
      	ctx := shutdown
      	poller := environments.NewWorkPoller(ctx, client, environments.WorkPollerOptions{
      		EnvironmentID:      environmentID,
      		EnvironmentKey:     environmentKey,
      		BlockMs:            param.Null[int64](),
      		ReclaimOlderThanMs: param.NewOpt[int64](2000),
      		Drain:              true,
      		AutoStop:           param.NewOpt(false),
      	})
      	defer poller.Close()
      	for poller.Next() {
      		item := poller.Current()
      		if err := worker.HandleItem(ctx, environments.HandleItemOptions{
      			WorkID:         item.ID,
      			EnvironmentID:  item.EnvironmentID,
      			SessionID:      item.Data.ID,
      			EnvironmentKey: environmentKey,
      			// Секрет сеанса позволяет воркеру монтировать хранилища памяти сеанса.
      			WorkSecret: item.Secret,
      		}); err != nil {
      			slog.Error("handle work item", "work_id", item.ID, "err", err)
      			http.Error(w, "internal error", http.StatusInternalServerError)
      			return
      		}
      	}
      	if err := poller.Err(); err != nil {
      		slog.Error("poll work queue", "err", err)
      		http.Error(w, "internal error", http.StatusInternalServerError)
      		return
      	}
      	json.NewEncoder(w).Encode(map[string]string{"status": "ok"})
      }

      func main() {
      	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
      	defer stop()
      	shutdown = ctx

      	server := &http.Server{Addr: ":8080"}
      	http.HandleFunc("POST /webhook", handle)
      	go func() {
      		if err := server.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
      			slog.Error("http server", "err", err)
      			os.Exit(1)
      		}
      	}()
      	// По сигналу прекращаем приём доставок и возвращаемся только после того, как активные
      	// обработчики, а значит, и очистка памяти их элементов работы, завершатся.
      	<-ctx.Done()
      	if err := server.Shutdown(context.Background()); err != nil {
      		slog.Error("http shutdown", "err", err)
      	}
      }
      ```

      <CodeGroupItem language="Java">
        В SDK для Java нет `EnvironmentWorker`. Чтобы обрабатывать элементы работы из собственного кода, реализуйте собственный воркер, как описано в разделе [Выбор шаблона развёртывания](https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes-workers#choose-a-deployment-pattern).
      </CodeGroupItem>

      <CodeGroupItem language="PHP">
        В SDK для PHP нет `EnvironmentWorker`. Чтобы обрабатывать элементы работы из собственного кода, реализуйте собственный воркер, как описано в разделе [Выбор шаблона развёртывания](https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes-workers#choose-a-deployment-pattern).
      </CodeGroupItem>

      <CodeGroupItem language="Ruby">
        В SDK для Ruby нет `EnvironmentWorker`. Чтобы обрабатывать элементы работы из собственного кода, реализуйте собственный воркер, как описано в разделе [Выбор шаблона развёртывания](https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes-workers#choose-a-deployment-pattern).
      </CodeGroupItem>
    </CodeGroup>

    В SDK для Python, TypeScript и Go методу `handle_item()` (typescript: `handleItem()`; go: `HandleItem()`) нужен секрет элемента работы для монтирования хранилищ памяти. У воркера, который опрашивает очередь с помощью `run()` (go: `Run()`), секрет уже есть. Этот обработчик сам забирает каждый элемент, поэтому передаёт секрет в аргументе `work_secret` (typescript: `workSecret`; go: `WorkSecret`). См. раздел [Передача секрета элемента работы](https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes-per-session#forward-the-work-items-secret).
  </Step>
</Steps>

Этот обработчик выполняет каждый полученный элемент в одном процессе и одновременно выполняет элементы из разных доставок вебхуков. Эти сеансы используют одну общую файловую систему, включая `/workspace` и `/mnt/memory`. Если ваши сеансы подключают одно и то же хранилище памяти, см. раздел [Изоляция сеансов, использующих общее хранилище](https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes-memory#isolate-sessions-that-share-a-store).

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

<CardGroup cols={2}>
  <Card title="Запуск отдельной песочницы для каждого сеанса" icon="cube" href="https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes-per-session">
    Запускайте песочницы с помощью Helm-чарта в Kubernetes, скрипта запуска или опрашивающего процесса SDK.
  </Card>

  <Card title="Мониторинг и устранение неполадок самостоятельно размещаемых воркеров" icon="lightning" href="https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes-operations">
    Отслеживайте глубину очереди, корректно останавливайте сеансы и воркеры и устраняйте распространённые сбои.
  </Card>

  <Card title="Модель безопасности" icon="lock" href="https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes-security">
    Модель разделённой ответственности для самостоятельно размещаемых сред песочниц.
  </Card>
</CardGroup>

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

Готовые самостоятельно размещаемые воркеры находятся в бета-версии для всех моделей.

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

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

* Доступность: Доступно

| Статус | Облачные платформы |
| ----- | ----- |
| Бета | Claude API, [Claude Platform on AWS](https://platform.claude.com/docs/ru/build-with-claude/claude-platform-on-aws) |

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

[Обзор бета-заголовков](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`
