---
title: セルフホスト型サンドボックス
url: https://platform.claude.com/docs/ja/managed-agents/self-hosted-sandboxes
description: Claude Managed Agentsのセッションをセルフホスト型サンドボックスで実行し、ツールの実行、ファイル、ネットワークのエグレスを自社のインフラストラクチャ内に保持します。
featureMetadata:
  topic:
    title: Managed Agents
    url: https://platform.claude.com/docs/en/managed-agents/overview
  status: beta
  betaHeader: managed-agents-2026-04-01
---

セルフホスト型サンドボックスは、エージェントのツール実行をAnthropicが管理するクラウドサンドボックスから、お客様が管理するインフラストラクチャへと移します。エージェント自体の実行は引き続きAnthropicが担います。これが何を意味するのかを理解し、お使いのエージェントに適しているかどうかを判断するには、[エージェント環境の選択](https://platform.claude.com/docs/ja/managed-agents/choosing-an-environment)を参照してください。

## 仕組み

`self_hosted`環境はワークキューとして機能します。お客様は、そのキューを処理する自社インフラストラクチャ上のプロセスである「environment worker」（環境ワーカー）を実行します。

1. 環境を対象とする[セッション](https://platform.claude.com/docs/ja/managed-agents/sessions)を作成します。Anthropicはそのセッションをワークアイテムとしてキューに追加します。
2. ワーカーがワークアイテムを取得し、エージェントの[スキル](https://platform.claude.com/docs/ja/managed-agents/skills)とセッションの[メモリストア](https://platform.claude.com/docs/ja/managed-agents/memory)をダウンロードします。
3. ClaudeはAnthropic側で実行され、ツール呼び出しをリクエストします。ワーカーは各呼び出しをローカルで実行し、結果を送り返します。

ツールの入力と出力は引き続きAnthropicのコントロールプレーンに送られるため、モデルは結果を確認して次に何をすべきかを判断できます。スキルとメモリストアはAnthropicが保存します。サンドボックスはセッション用のコピーを保持します。データフローの境界の全体像については、[セキュリティモデル](https://platform.claude.com/docs/ja/managed-agents/self-hosted-sandboxes-security)を参照してください。

セルフホスト型サンドボックスは、Managed Agentsで利用可能なすべてのClaudeモデルをサポートしています。モデルは環境ではなくエージェントで設定します。

`ant` CLIと、Python、TypeScript、GoのSDKには、ビルド済みのワーカーが付属しています。Cloudflare、Daytona、Modalなどのサンドボックスプロバイダーも、独自の[プラットフォームガイド](https://platform.claude.com/docs/ja/managed-agents/self-hosted-sandboxes#platform-guides)を公開しています。

## クイックスタート

このクイックスタートでは、`ant` CLIで常時稼働のワーカーを1つ実行し、そこにセッションを送信して、エージェントのツール呼び出しがお客様のホスト上で実行されたことを確認します。

### 前提条件

* **エージェント：** まだお持ちでない場合は、先に[Claude Managed Agentsを始める](https://platform.claude.com/docs/ja/managed-agents/quickstart)を完了し、エージェントIDを控えておいてください。
* **Linuxホスト：** ホストには、まさにそのパスに`/bin/bash`が必要です。ワーカーに必要なのはアウトバウンドのHTTPSのみです。
* **Claude APIキー：** セッションの作成とキュー統計の読み取りのために、お客様自身のマシンから使用します。エージェントのツール呼び出しから読み取られる可能性があるため、ワーカーホストには置かないでください。
* **お客様自身のマシン上の`ant` CLIまたはSDK：** このクイックスタートの統計とセッションの手順は、ワーカーホストではなくそこで実行します。ワーカー用の[インストール手順](https://platform.claude.com/docs/ja/managed-agents/self-hosted-sandboxes#run-your-first-session)と同じ方法でCLIをインストールするか、[SDK](https://platform.claude.com/docs/ja/cli-sdks-libraries/overview)をインストールしてください。

<Note>
  [Claude Platform on AWS](https://platform.claude.com/docs/ja/build-with-claude/claude-platform-on-aws)では、ワーカーは環境キーではなく、AWS IAM（SigV4）または[AWS Consoleで生成したAPIキー](https://platform.claude.com/docs/ja/build-with-claude/claude-platform-on-aws#api-key-authentication)で認証します。ワーカーが実行されるIAMプリンシパルに、[`AnthropicSelfHostedEnvironmentAccess`](https://platform.claude.com/docs/ja/api/claude-platform-on-aws-iam-actions#managed-policies)マネージドポリシーをアタッチしてください。Claude Consoleで生成した環境キーは、Claude Platform on AWSのエンドポイントでは機能しません。
</Note>

### 最初のセッションを実行する

<Steps>
  <Step title="セルフホスト型環境を作成する">
    Claude Consoleで[Environments](https://platform.claude.com/environments)ページ（`platform.claude.com/environments`）に移動し、**Create environment**をクリックして、**Hosting**で**Self-hosted**を選択します。

    またはAPIを使用します：

    <CodeGroup defaultLanguage="CLI">
      ```bash cURL
      curl -sS --fail-with-body 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": "self-hosted",
          "config": {"type": "self_hosted"}
        }'
      ```

      <CodeGroupItem>
        ```bash CLI
        ant apply environment.yaml
        ```

        <File filename="environment.yaml">
          ```yaml
          # yaml-language-server: $schema=https://platform.claude.com/schemas/ant/beta/environment.json
          name: self-hosted
          config:
            type: self_hosted
          ```
        </File>
      </CodeGroupItem>

      ```python Python
      client = anthropic.Anthropic()

      environment = client.beta.environments.create(
          name="self-hosted", config={"type": "self_hosted"}
      )
      print(environment.id)
      ```

      ```typescript TypeScript
      const client = new Anthropic();

      const environment = await client.beta.environments.create({
        name: "self-hosted",
        config: { type: "self_hosted" }
      });
      console.log(environment.id);
      ```

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

      var client = new AnthropicClient();

      var environment = await client.Beta.Environments.Create(
          new EnvironmentCreateParams
          {
              Name = "self-hosted",
              Config = new BetaSelfHostedConfigParams(),
          }
      );
      Console.WriteLine(environment.ID);
      ```

      ```go Go
      client := anthropic.NewClient()

      environment, err := client.Beta.Environments.New(context.Background(), anthropic.BetaEnvironmentNewParams{
      	Name: "self-hosted",
      	Config: anthropic.BetaEnvironmentNewParamsConfigUnion{
      		OfSelfHosted: &anthropic.BetaSelfHostedConfigParams{},
      	},
      })
      if err != nil {
      	panic(err)
      }
      fmt.Println(environment.ID)
      ```

      ```java Java
      import com.anthropic.models.beta.environments.BetaSelfHostedConfigParams;
      import com.anthropic.models.beta.environments.EnvironmentCreateParams;

      void main() {
          var client = AnthropicOkHttpClient.fromEnv();

          var environment = client.beta().environments().create(
              EnvironmentCreateParams.builder()
                  .name("self-hosted")
                  .config(BetaSelfHostedConfigParams.builder().build())
                  .build()
          );
          IO.println(environment.id());
      }
      ```

      ```php PHP
      $client = new \Anthropic\Client();

      $environment = $client->beta->environments->create(
          name: 'self-hosted',
          config: ['type' => 'self_hosted'],
      );
      echo $environment->id, PHP_EOL;
      ```

      ```ruby Ruby
      client = Anthropic::Client.new

      environment = client.beta.environments.create(
        name: "self-hosted",
        config: {type: :self_hosted}
      )
      puts environment.id
      ```
    </CodeGroup>
  </Step>

  <Step title="環境キーを生成する">
    Consoleで環境を開き、**Generate environment key**をクリックします。環境キーは、ワーカーをそのキューに対して認証します。APIで作成した環境であっても、環境キーはConsoleでのみ生成できます。

    ワーカーホストで環境IDとキーをエクスポートします：

    ```bash
    export ANTHROPIC_ENVIRONMENT_KEY="sk-ant-oat01-..."
    export ANTHROPIC_ENVIRONMENT_ID="env_..."
    ```
  </Step>

  <Step title="ant CLIをインストールする">
    これをワーカーホストで実行します。

    <Tabs>
      <Tab title="curl (Linux/WSL)">
        Linux環境では、リリースバイナリを直接ダウンロードします。

        ```bash
        VERSION=1.42.0
        OS=$(uname -s | tr '[:upper:]' '[:lower:]')
        case $(uname -m) in
          x86_64) ARCH=amd64 ;;
          aarch64) ARCH=arm64 ;;
        esac
        curl -fsSL "https://github.com/anthropics/anthropic-cli/releases/download/v${VERSION}/ant_${VERSION}_${OS}_${ARCH}.tar.gz" \
          | sudo tar -xz -C /usr/local/bin ant
        ```

        すべてのリリースは[GitHubのリリースページ](https://github.com/anthropics/anthropic-cli/releases)で確認できます。
      </Tab>

      <Tab title="Homebrew (macOS)">
        ```bash
        brew install anthropics/tap/ant
        ```
      </Tab>
    </Tabs>
  </Step>

  <Step title="ワーカーを起動する">
    作業ディレクトリを作成してから、ワーカーを起動します。`--workdir`のデフォルトは現在のディレクトリなので、システムのデフォルトに合わせて`/workspace`を渡してください。

    ```bash
    sudo mkdir -p /workspace && sudo chown "$USER" /workspace
    ant beta:worker poll --workdir /workspace
    ```

    ワーカーはエクスポートした2つの変数を読み取り、停止するまでポーリングを続けます。
  </Step>

  <Step title="ワーカーが接続されていることを確認する">
    お客様自身のマシンで、`ANTHROPIC_API_KEY`にClaude APIキー（環境キーではありません）を、`ANTHROPIC_ENVIRONMENT_ID` (python, ruby: `environment_id`; typescript, java, csharp: `environmentId`; go: `environmentID`; php: `$environmentId`)に環境IDを設定します。`workers_polling` (java, php: `workersPolling`; csharp, go: `WorkersPolling`)が1以上であることを確認してください：

    <CodeGroup>
      ```bash cURL
      curl -sS --fail-with-body "https://api.anthropic.com/v1/environments/$ANTHROPIC_ENVIRONMENT_ID/work/stats" \
        -H "x-api-key: $ANTHROPIC_API_KEY" \
        -H "anthropic-version: 2023-06-01" \
        -H "anthropic-beta: managed-agents-2026-04-01"
      ```

      ```bash CLI
      ant beta:environments:work stats --environment-id "$ANTHROPIC_ENVIRONMENT_ID"
      ```

      ```python Python
      client = anthropic.Anthropic()

      stats = client.beta.environments.work.stats(environment_id)
      print(f"workers_polling={stats.workers_polling}")
      ```

      ```typescript TypeScript
      const client = new Anthropic();

      const stats = await client.beta.environments.work.stats(environmentId);

      console.log(`workers_polling=${stats.workers_polling}`);
      ```

      ```csharp C#
      var client = new AnthropicClient();

      var stats = await client.Beta.Environments.Work.Stats(environmentId);

      Console.WriteLine($"workers_polling={stats.WorkersPolling}");
      ```

      ```go Go
      client := anthropic.NewClient()

      stats, err := client.Beta.Environments.Work.Stats(
      	context.Background(),
      	environmentID,
      	anthropic.BetaEnvironmentWorkStatsParams{},
      )
      if err != nil {
      	panic(err)
      }

      fmt.Printf("workers_polling=%d\n", stats.WorkersPolling)
      ```

      ```java Java
      var client = AnthropicOkHttpClient.fromEnv();

      var stats = client.beta().environments().work().stats(environmentId);

      IO.println("workers_polling=" + stats.workersPolling().orElse(null));
      ```

      ```php PHP
      $client = new Client();

      $stats = $client->beta->environments->work->stats($environmentId);

      printf("workers_polling=%d\n", $stats->workersPolling);
      ```

      ```ruby Ruby
      client = Anthropic::Client.new

      stats = client.beta.environments.work.stats(environment_id)

      puts "workers_polling=#{stats.workers_polling}"
      ```
    </CodeGroup>

    `workers_polling` (java, php: `workersPolling`; csharp, go: `WorkersPolling`)が0のままの場合は、[トラブルシューティング](https://platform.claude.com/docs/ja/managed-agents/self-hosted-sandboxes-operations#troubleshooting)を参照してください。
  </Step>

  <Step title="セッションを開始する">
    `AGENT_ID` (python, ruby: `agent_id`; typescript, java, csharp: `agentId`; go: `agentID`; php: `$agentId`)にエージェントのIDを設定します。環境を対象とするセッションを作成し、タスクを送信します：

    <CodeGroup>
      ```bash cURL
      SESSION_ID=$(curl -sS --fail-with-body https://api.anthropic.com/v1/sessions \
        -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 '{
          "agent": "'"$AGENT_ID"'",
          "environment_id": "'"$ANTHROPIC_ENVIRONMENT_ID"'"
        }' | jq -er '.id'
      )

      curl -sS --fail-with-body "https://api.anthropic.com/v1/sessions/$SESSION_ID/events" \
        -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 '{
          "events": [
            {
              "type": "user.message",
              "content": [
                {
                  "type": "text",
                  "text": "Write the output of \"uname -a\" to hello.txt in your working directory."
                }
              ]
            }
          ]
        }'
      ```

      ```bash CLI
      SESSION_ID=$(ant beta:sessions create \
        --agent "$AGENT_ID" \
        --environment-id "$ANTHROPIC_ENVIRONMENT_ID" \
        --transform id --raw-output)

      ant beta:sessions:events send --session-id "$SESSION_ID" <<'YAML'
      events:
        - type: user.message
          content:
            - type: text
              text: Write the output of "uname -a" to hello.txt in your working directory.
      YAML
      ```

      ```python Python
      session = client.beta.sessions.create(
          agent=agent_id,
          environment_id=environment_id,
      )

      client.beta.sessions.events.send(
          session.id,
          events=[
              {
                  "type": "user.message",
                  "content": [
                      {
                          "type": "text",
                          "text": 'Write the output of "uname -a" to hello.txt in your working directory.',
                      },
                  ],
              },
          ],
      )
      ```

      ```typescript TypeScript
      const session = await client.beta.sessions.create({
        agent: agentId,
        environment_id: environmentId
      });

      await client.beta.sessions.events.send(session.id, {
        events: [
          {
            type: "user.message",
            content: [
              {
                type: "text",
                text: 'Write the output of "uname -a" to hello.txt in your working directory.'
              }
            ]
          }
        ]
      });
      ```

      ```csharp C#
      var session = await client.Beta.Sessions.Create(new()
      {
          Agent = agentId,
          EnvironmentID = environmentId,
      });

      await client.Beta.Sessions.Events.Send(session.ID, new()
      {
          Events =
          [
              new BetaManagedAgentsUserMessageEventParams
              {
                  Type = BetaManagedAgentsUserMessageEventParamsType.UserMessage,
                  Content =
                  [
                      new BetaManagedAgentsTextBlock
                      {
                          Type = BetaManagedAgentsTextBlockType.Text,
                          Text = "Write the output of \"uname -a\" to hello.txt in your working directory.",
                      },
                  ],
              },
          ],
      });
      ```

      ```go Go
      session, err := client.Beta.Sessions.New(context.Background(), anthropic.BetaSessionNewParams{
      	Agent:         anthropic.BetaSessionNewParamsAgentUnion{OfString: anthropic.String(agentID)},
      	EnvironmentID: environmentID,
      })
      if err != nil {
      	panic(err)
      }

      _, err = client.Beta.Sessions.Events.Send(context.Background(), session.ID, anthropic.BetaSessionEventSendParams{
      	Events: []anthropic.BetaManagedAgentsEventParamsUnion{{
      		OfUserMessage: &anthropic.BetaManagedAgentsUserMessageEventParams{
      			Type: anthropic.BetaManagedAgentsUserMessageEventParamsTypeUserMessage,
      			Content: []anthropic.BetaManagedAgentsUserMessageEventParamsContentUnion{{
      				OfText: &anthropic.BetaManagedAgentsTextBlockParam{
      					Type: anthropic.BetaManagedAgentsTextBlockTypeText,
      					Text: "Write the output of \"uname -a\" to hello.txt in your working directory.",
      				},
      			}},
      		},
      	}},
      })
      if err != nil {
      	panic(err)
      }
      ```

      ```java Java
      var session = client.beta().sessions().create(SessionCreateParams.builder()
          .agent(agentId)
          .environmentId(environmentId)
          .build());

      client.beta().sessions().events().send(
          session.id(),
          EventSendParams.builder()
              .addEvent(BetaManagedAgentsUserMessageEventParams.builder()
                  .type(BetaManagedAgentsUserMessageEventParams.Type.USER_MESSAGE)
                  .addTextContent("Write the output of \"uname -a\" to hello.txt in your working directory.")
                  .build())
              .build());
      ```

      ```php PHP
      $session = $client->beta->sessions->create(
          agent: $agentId,
          environmentID: $environmentId,
      );

      $client->beta->sessions->events->send(
          $session->id,
          events: [
              [
                  'type' => 'user.message',
                  'content' => [['type' => 'text', 'text' => 'Write the output of "uname -a" to hello.txt in your working directory.']],
              ],
          ],
      );
      ```

      ```ruby Ruby
      session = client.beta.sessions.create(
        agent: agent_id,
        environment_id: environment_id
      )

      client.beta.sessions.events.send_(
        session.id,
        events: [
          {
            type: :"user.message",
            content: [{type: :text, text: 'Write the output of "uname -a" to hello.txt in your working directory.'}]
          }
        ]
      )
      ```
    </CodeGroup>

    セッションは、ワーカーが取得するまで環境のキューで待機します。ワーカーが接続されていない場合、セッションは失敗せずにキューに入ったままになります。
  </Step>

  <Step title="ツールがホスト上で実行されたことを確認する">
    ワーカーホストで、エージェントが書き込んだファイルを読み取ります：

    ```bash
    cat /workspace/hello.txt
    ```

    このファイルにはお客様自身のホストのカーネルが記述されているため、エージェントのツール呼び出しがそこで実行されたことがわかります。エージェントの作業をリアルタイムで追跡するには、[セッションイベントストリーム](https://platform.claude.com/docs/ja/managed-agents/events-and-streaming)を参照してください。
  </Step>
</Steps>

## セッションリソース

セルフホスト型サンドボックスは`memory_store`リソースのみをサポートします。`file`または`github_repository`リソースを含むセルフホスト型環境上のセッションは、400エラーで拒否されます：

```text wrap
Environment env_... is a self-hosted environment. `resources` are not supported with self-hosted environments.
```

セルフホスト型環境を対象とする[デプロイメント](https://platform.claude.com/docs/ja/managed-agents/scheduled-deployments)にも同じルールが適用されます。セッションに独自の入力ファイルを渡すには、[セッション用にファイルをステージングする](https://platform.claude.com/docs/ja/managed-agents/self-hosted-sandboxes-workers#stage-files-for-a-session)を参照してください。

## セルフホスト型サンドボックスとMCPトンネル

セルフホスティングは*エージェントのコードがどこで実行されるか*を制御します。[MCPトンネル](https://platform.claude.com/docs/ja/agents-and-tools/mcp-tunnels/overview)は*Anthropicがお客様のネットワーク内のMCPサーバーにどのように到達するか*を制御します。この2つは独立しています：

* Anthropicのクラウドサンドボックス内のセッションは、トンネルを介してプライベートなMCPサーバーに到達できます。たとえば、プライベートなMCPサーバーが、ファイアウォールの内側にあるデータベースや内部APIの前段に配置されている場合があります。
* セルフホスト型のセッションは、トンネル経由のMCPサーバーとパブリックなMCPサーバーのどちらも使用できます。

実行とツールアクセスの両方を境界内にとどめたい場合は、両方を使用してください。トンネルを使わない場合は、ワーカーが提供する[カスタムツールとしてMCPサーバーをラップ](https://platform.claude.com/docs/ja/managed-agents/self-hosted-sandboxes-custom-tools#wrap-an-mcp-server-as-custom-tools)します。

## プラットフォームガイド

これらのページでは、任意のサンドボックスプラットフォーム上でワーカーを構築する方法を説明しています。プラットフォーム固有のガイドも利用できます：

* [AWS Lambda MicroVMs](https://docs.aws.amazon.com/lambda/latest/dg/microvms-integrations-claude-managed-agents.html)
* [Blaxel](https://docs.blaxel.ai/Tutorials/Claude-Managed-Agents)
* [Cloudflare](https://developers.cloudflare.com/sandbox/claude-managed-agents/)
* [Daytona](https://www.daytona.io/docs/en/guides/claude/claude-managed-agents)
* [E2B](https://e2b.dev/docs/agents/claude-managed-agents)
* [Fly.io](https://docs.sprites.dev/integrations/claude-managed-agents/)
* [GKE Agent Sandbox](https://github.com/GoogleCloudPlatform/kubernetes-engine-samples/tree/main/ai-ml/anthropic-agent-sandbox)
* [Modal](https://github.com/modal-labs/claude-managed-agents-modal-sandbox)
* [Namespace](https://namespace.so/docs/integrations/claude)
* [Superserve](https://docs.superserve.ai/integrations/managed-agents/claude-managed-agents)
* [Vercel](https://vercel.com/kb/guide/run-claude-managed-agent-tools-with-vercel-sandbox)

## 次のステップ

<CardGroup cols={2}>
  <Card title="ワーカーをデプロイする" icon="play" href="https://platform.claude.com/docs/ja/managed-agents/self-hosted-sandboxes-workers">
    SDKワーカーを実行する、Webhookからワーカーをトリガーする、または各セッションに専用のサンドボックスを割り当てます。
  </Card>

  <Card title="メモリストア" icon="brain" href="https://platform.claude.com/docs/ja/managed-agents/self-hosted-sandboxes-memory">
    ホストを準備し、同期を設定し、読み取り専用ストアと競合を処理します。
  </Card>

  <Card title="カスタムツールとMCPサーバー" icon="tool" href="https://platform.claude.com/docs/ja/managed-agents/self-hosted-sandboxes-custom-tools">
    ネットワーク内のMCPサーバーのツールを含め、独自のツールをワーカーから提供します。
  </Card>

  <Card title="監視とトラブルシューティング" icon="lightning" href="https://platform.claude.com/docs/ja/managed-agents/self-hosted-sandboxes-operations">
    キューの深さを読み取り、セッションとワーカーを正常に停止し、一般的な障害を修正します。
  </Card>

  <Card title="ワーカーリファレンス" icon="book" href="https://platform.claude.com/docs/ja/managed-agents/self-hosted-sandboxes-reference">
    CLIフラグ、環境変数、ファイルシステムのパス、SDKヘルパーのオプション。
  </Card>

  <Card title="セキュリティモデル" icon="lock" href="https://platform.claude.com/docs/ja/managed-agents/self-hosted-sandboxes-security">
    セルフホスト型サンドボックス環境の責任共有モデル。
  </Card>
</CardGroup>