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

# Use Sandboxes with Claude Managed Agents

> Connect a self-hosted sandbox worker to Claude Managed Agents and verify tool execution on CoreWeave.

[Claude Managed Agents](https://platform.claude.com/docs/en/managed-agents/overview) を CoreWeave サンドボックスで実行中のワーカーに接続します。Anthropic がエージェントのループと会話を管理します。ワーカーはツールを実行し、その結果を Anthropic に返します。このインテグレーションはセルフホスト環境を使用し、Claude Code CLI および Remote Control とは別です。

Claude Managed Agents もベータ版です。その API には `managed-agents-2026-04-01` ベータヘッダーが必要です。このガイドで使用する Anthropic SDK は自動的にそれを追加します。[Anthropic beta access](https://platform.claude.com/docs/en/managed-agents/overview#beta-access) を参照してください。

<h2 id="prerequisites">
  前提条件
</h2>

始める前に、以下が必要です：

* `SANDBOX_USER` action を持つ [CoreWeave API アクセストークン](/ja/products/sandboxes/placement#choose-and-get-credentials)。
* Anthropic ワークスペースでの Claude Managed Agents アクセスと、セッションを作成するクライアント用の Console APIキー。
* `agent_toolset_20260401` で設定された既存のエージェント。Anthropic の [Managed Agents クイックスタート](https://platform.claude.com/docs/en/managed-agents/quickstart) に従って作成し、その ID を記録してください。
* SDK の例では、[`uv`](https://docs.astral.sh/uv/) を使用した Python 3.11 以降、または Node.js 22 以降のいずれか。

CoreWeave API アクセストークンを、このガイドを実行するターミナルでエクスポートします：

```bash theme={"system"}
export CWSANDBOX_API_KEY="[API-ACCESS-TOKEN]"
```

<h2 id="create-an-environment">
  環境を作成する
</h2>

[Claude Console](https://platform.claude.com/environments) で **セルフホスト** 環境を作成します。環境を開いて環境キーを生成してください。環境 ID を記録し、キーを安全に保管します。Anthropic の [環境の設定](https://platform.claude.com/docs/en/managed-agents/self-hosted-sandboxes#create-a-self-hosted-environment) を参照してください。

環境キーはワーカーをこの環境に対して認証します。Console APIキーはクライアントからセッションを作成します。2 つの認証情報は分けて管理してください。

検証タスクでは、このガイドで作成したワーカーのみが所属する環境を使用してください。これにより、別のワーカーがテストセッションを引き受けるのを防げます。

環境が準備完了したら、`cws-agent` または Sandboxes SDK のいずれかを選択してワーカーを起動し、検証タスクを実行してください。

<h2 id="quick-start-with-cws-agent">
  cws-agent のクイックスタート
</h2>

[`cws-agent` のインストール手順](https://github.com/coreweave/cws-agent#install)に従ってください。このツールは、[ファイルシステムスナップショット](/ja/products/sandboxes/file-system-snapshots#start-a-sandbox-with-a-snapshot-mount)でワークスペースを保存およびリストアするためのスナップショットボリュームを設定します。

`[ENVIRONMENT-KEY]`、`[ENVIRONMENT-ID]`、`[SANDBOX-NAME]` を、それぞれ環境キー、環境 ID、サンドボックスの `cws-agent` セッション名に置き換えてください。セッション名には、先頭を英字または数字とし、1～40 文字の小文字の英字、数字、ハイフンを使用してください:

```bash theme={"system"}
export ANTHROPIC_ENVIRONMENT_KEY="[ENVIRONMENT-KEY]"
cws-agent launch [SANDBOX-NAME] --claude-env [ENVIRONMENT-ID]
```

Launch は `/workspace/claude/0` でワーカーを 1 つ起動し、シェルに戻ります。ツールは環境キーをサンドボックスに渡します。

ワーカーのターミナルを表示するには、次を実行します。

```bash theme={"system"}
cws-agent connect [SANDBOX-NAME] --cmd 'tmux attach -t claude-0'
```

**Ctrl-b**、続いて **d** を押してデタッチします。[タスクを実行して確認する](#run-and-verify-a-task)に進みます。Managed Agents API を通じてタスクを送信します。`cws-agent run` コマンドは Managed Agents の会話を実行しません。

<h2 id="set-up-with-the-sandbox-sdk">
  Sandboxes SDK で設定する
</h2>

この代替方法では、Anthropic の `ant` ワーカーをサンドボックスのメインプロセスとして起動します。`cws-agent` やスナップショットの設定は必要ありません。

このガイドで作成した仮想環境で Python スニペットを実行します。TypeScript スニペットは、クライアントをインストールした project に `.mts` ファイルとして保存し、`npx tsx [FILENAME].mts` で実行します。

<h3 id="configure-credentials-and-install-the-client">
  認証情報を設定してクライアントをインストールする
</h3>

Console で取得した環境キーと ID を、スクリプトを実行するターミナルでエクスポートします：

```bash theme={"system"}
export ANTHROPIC_ENVIRONMENT_KEY="[ENVIRONMENT-KEY]"
export ANTHROPIC_ENVIRONMENT_ID="[ENVIRONMENT-ID]"
```

<Tabs>
  <Tab title="Python">
    Python 3.11 以降と `uv` を使用します：

    ```bash theme={"system"}
    uv venv --python 3.11
    source .venv/bin/activate
    uv pip install 'cwsandbox>=1.14.2'
    ```
  </Tab>

  <Tab title="TypeScript">
    Node.js 22 以降を使用します。クライアントと TypeScript ランナーを project にインストールします：

    ```bash theme={"system"}
    npm install @coreweave/cwsandbox@0.5.0-beta.0 tsx
    ```
  </Tab>
</Tabs>

<h3 id="start-the-worker">
  ワーカーを開始する
</h3>

言語に応じたスクリプトを表示されているファイル名で保存してください。このスクリプトは、Bash を備えた Linux イメージに `ant` CLI をインストールし、1 つのワーカーを開始して、サンドボックス ID を出力します。クライアントはローカルの環境から `ANTHROPIC_ENVIRONMENT_KEY` を読み取り、その値をサンドボックスリクエストに渡して、ワーカーの環境変数を設定します。

<Tabs>
  <Tab title="Python">
    ```python title="start_claude_worker.py" theme={"system"}
    import os

    from cwsandbox import Sandbox

    worker = """
    set -o pipefail
    case "$(uname -m)" in
        x86_64) arch=amd64 ;;
        aarch64) arch=arm64 ;;
        *) echo "Unsupported architecture" >&2; exit 1 ;;
    esac
    version=1.33.0
    curl -fsSL "https://github.com/anthropics/anthropic-cli/releases/download/v${version}/ant_${version}_linux_${arch}.tar.gz" \
        | tar -xz -C /usr/local/bin ant
    mkdir -p /workspace
    exec ant beta:worker poll --workdir /workspace
    """

    sandbox = Sandbox.run(
        "bash", "-ec", worker,
        container_image="python:3.12-bookworm",
        environment_variables={
            "ANTHROPIC_ENVIRONMENT_KEY": os.environ["ANTHROPIC_ENVIRONMENT_KEY"],
            "ANTHROPIC_ENVIRONMENT_ID": os.environ["ANTHROPIC_ENVIRONMENT_ID"],
        },
        resources={"cpu": "2", "memory": "4Gi"},
        max_lifetime_seconds=8 * 3600,
        tags=["claude-managed-agents-worker"],
    )
    try:
        sandbox.wait()
    except BaseException:
        sandbox.stop().result()
        raise

    print(f"Worker sandbox ID: {sandbox.sandbox_id}")
    ```
  </Tab>

  <Tab title="TypeScript">
    ```typescript title="start_claude_worker.mts" theme={"system"}
    import { createSandboxClientFromEnv } from "@coreweave/cwsandbox/node";

    const token = process.env.ANTHROPIC_ENVIRONMENT_KEY;
    if (!token) throw new Error("Set ANTHROPIC_ENVIRONMENT_KEY.");
    const environmentId = process.env.ANTHROPIC_ENVIRONMENT_ID;
    if (!environmentId) throw new Error("Set ANTHROPIC_ENVIRONMENT_ID.");

    const worker = `
    set -o pipefail
    case "$(uname -m)" in
        x86_64) arch=amd64 ;;
        aarch64) arch=arm64 ;;
        *) echo "Unsupported architecture" >&2; exit 1 ;;
    esac
    version=1.33.0
    curl -fsSL "https://github.com/anthropics/anthropic-cli/releases/download/v\${version}/ant_\${version}_linux_\${arch}.tar.gz" \\
        | tar -xz -C /usr/local/bin ant
    mkdir -p /workspace
    exec ant beta:worker poll --workdir /workspace
    `;

    const client = createSandboxClientFromEnv();
    const sandbox = await client.run(["bash", "-ec", worker], {
      containerImage: "python:3.12-bookworm",
      environmentVariables: {
        ANTHROPIC_ENVIRONMENT_KEY: token,
        ANTHROPIC_ENVIRONMENT_ID: environmentId,
      },
      resources: { cpu: "2", memory: "4Gi" },
      maxLifetimeSeconds: 8 * 3600,
      waitUntilRunning: false,
      tags: ["claude-managed-agents-worker"],
    });
    try {
      await sandbox.wait();
    } catch (error) {
      await sandbox.stop();
      throw error;
    }
    console.log(`Worker sandbox ID: ${sandbox.sandboxId}`);
    ```
  </Tab>
</Tabs>

スクリプトを実行します:

<Tabs>
  <Tab title="Python">
    ```bash theme={"system"}
    python start_claude_worker.py
    ```
  </Tab>

  <Tab title="TypeScript">
    ```bash theme={"system"}
    npx tsx start_claude_worker.mts
    ```
  </Tab>
</Tabs>

スクリプトは起動を待機します。Python では、`wait()` はメインプロセスがすでに完了している場合にも返ることがあります。出力されたサンドボックス ID は、ワーカーが認証済みまたはポーリング中であることを確認するものではありません。タスクを開始する前に、そのステータスと最近のログを確認してください。`[SANDBOX-ID]` を出力された ID に置き換えてください:

<Tabs>
  <Tab title="Python">
    ```python theme={"system"}
    from cwsandbox import Sandbox

    sandbox = Sandbox.from_id("[SANDBOX-ID]").result()
    print("Sandbox status:", sandbox.get_status())
    for container in sandbox.container_statuses:
        print(container.name, container.state, container.exit_code, container.restart_count)
    for line in sandbox.stream_logs(tail_lines=100):
        print(line, end="")
    ```
  </Tab>

  <Tab title="TypeScript">
    ```typescript theme={"system"}
    import { createSandboxClientFromEnv } from "@coreweave/cwsandbox/node";

    const client = createSandboxClientFromEnv();
    const sandbox = await client.fromId("[SANDBOX-ID]");
    console.log("Sandbox status:", sandbox.status, "Exit code:", sandbox.exitCode);
    for (const line of await sandbox.logs.read({ tailLines: 100 })) {
      process.stdout.write(line);
    }
    ```
  </Tab>
</Tabs>

Python クライアントでは、コンテナーごとの状態、終了コード、再起動回数も取得できます。TypeScript クライアントでは、これらの情報はまだ取得できません。最新のログを取得するには、この確認を再実行してください。

このワーカーは、外向きの HTTPS 接続を介してポーリングします。外部から接続を受け付けるサービスは必要ありません。すべてのセッションで同じサンドボックスのファイルシステムを使用するため、この例ではセッションごとに新しいサンドボックスは用意されません。セッションごとに新しいサンドボックスを用意するアーキテクチャについては、Anthropic の[セルフホストのサンドボックスに関するインテグレーションガイド](https://platform.claude.com/docs/en/managed-agents/self-hosted-sandboxes)を参照してください。

<h3 id="optional-use-a-secret-store">
  オプション: シークレットストアを使用する
</h3>

環境キーの値の代わりに [Forge シークレット参照](/ja/products/sandboxes/secrets) を渡すことができます。このオプションを使用するには、Forge 認証とサーバーレス配置が必要です。環境キーを Forge チームの Secret Manager に保存してから、そのチームの認証情報をエクスポートしてください:

```bash theme={"system"}
export FORGE_API_KEY="[FORGE-API-KEY]"
export FORGE_TEAM="[FORGE-TEAM]"
```

これらの認証情報を使用して、SDK を明示的に設定してください。`FORGE_API_KEY` と `FORGE_TEAM` は説明用の環境変数名であるため、SDK はこれらを自動的には検出しません。

<Tabs>
  <Tab title="Python">
    サンドボックスを作成する前に、`AuthHeaders` をインポートして `auth` を定義します:

    ```python theme={"system"}
    import os

    from cwsandbox import AuthHeaders

    auth = AuthHeaders(
        headers={
            "x-wandb-api-key": os.environ["FORGE_API_KEY"],
            "x-entity-id": os.environ["FORGE_TEAM"],
        },
        strategy="wandb_api_key",
    )
    ```

    `Sandbox.run()` に `auth=auth` を渡します。以降の Python の例でもこの設定を含め、すべての `Sandbox.from_id()` 呼び出しにも `auth=auth` を渡してください。
  </Tab>

  <Tab title="TypeScript">
    クライアントのインポートと初期化を次のコードに置き換えます。以降の TypeScript の例でも、このクライアント設定を使用してください:

    ```typescript theme={"system"}
    import { createSandboxClient } from "@coreweave/cwsandbox/wandb";

    const client = createSandboxClient({
      apiKey: process.env.FORGE_API_KEY,
      entity: process.env.FORGE_TEAM,
    });
    ```
  </Tab>
</Tabs>

`[SECRET-NAME]` をチームシークレットの名前に置き換えてください:

<Tabs>
  <Tab title="Python">
    `cwsandbox` から `Secret` をインポートし、`environment_variables` から `ANTHROPIC_ENVIRONMENT_KEY` を削除して、`secrets=[Secret(store="wandb", name="[SECRET-NAME]", env_var="ANTHROPIC_ENVIRONMENT_KEY")]` を `Sandbox.run()` に追加します。
  </Tab>

  <Tab title="TypeScript">
    `const token` の宣言とその `if (!token)` チェックを削除します。`environmentVariables` から `ANTHROPIC_ENVIRONMENT_KEY` を削除し、`secrets: [{ store: "wandb", name: "[SECRET-NAME]", envVar: "ANTHROPIC_ENVIRONMENT_KEY" }]` を `client.run()` に渡すオプションに追加します。
  </Tab>
</Tabs>

プラットフォームが参照を解決し、ワーカーの環境変数を設定します。

<h2 id="run-and-verify-a-task">
  タスクを実行して確認する
</h2>

どちらのセットアップ方法でも、ご自身のマシンでセッションクライアントを実行します。使用する言語に対応した Anthropic SDK をインストールしてください:

<Tabs>
  <Tab title="Python">
    ```bash theme={"system"}
    uv venv --python 3.11 .claude-client
    source .claude-client/bin/activate
    uv pip install 'anthropic>=1.6.0'
    ```
  </Tab>

  <Tab title="TypeScript">
    ```bash theme={"system"}
    npm install @anthropic-ai/sdk@0.126.0 tsx
    ```
  </Tab>
</Tabs>

`[ANTHROPIC-API-KEY]` を Console の API キーに、`[AGENT-ID]` を既存のエージェント ID に、`[ENVIRONMENT-ID]` をワーカーに接続された環境に置き換えてください:

```bash theme={"system"}
export ANTHROPIC_API_KEY="[ANTHROPIC-API-KEY]"
export ANTHROPIC_AGENT_ID="[AGENT-ID]"
export ANTHROPIC_ENVIRONMENT_ID="[ENVIRONMENT-ID]"
```

使用する言語の検証スクリプトを、表示されているファイル名で保存します。このスクリプトは、エージェントに作業ディレクトリ内へ一意のシークレットではない値を書き込むよう求めます。セルフホストのツール実行では、ワーカーが許可された Call を処理している間、一時的なアイドルイベントが発生します。スクリプトはこれらのイベントの間は待機し、ターンが終了するか、別の action が必要になると停止します。ファイルを取得する前に、出力された停止理由を確認してください。

<Tabs>
  <Tab title="Python">
    ```python title="verify_claude_worker.py" theme={"system"}
    import os
    import uuid

    from anthropic import Anthropic

    client = Anthropic()
    proof = uuid.uuid4().hex
    session = client.beta.sessions.create(
        agent=os.environ["ANTHROPIC_AGENT_ID"],
        environment_id=os.environ["ANTHROPIC_ENVIRONMENT_ID"],
        title="CoreWeave worker verification",
    )
    print(f"Session ID: {session.id}")
    print(f"Expected file contents: {proof}")
    events_by_id = {}

    with client.beta.sessions.events.stream(session.id) as events:
        client.beta.sessions.events.send(
            session.id,
            events=[{
                "type": "user.message",
                "content": [{
                    "type": "text",
                    "text": f"Write exactly {proof} to managed-agent-proof.txt in your working directory and read it back.",
                }],
            }],
        )
        for event in events:
            print(event.model_dump_json())
            events_by_id[event.id] = event
            if event.type == "session.status_idle":
                reason = event.stop_reason
                if reason and reason.type == "requires_action":
                    pending = [events_by_id.get(event_id) for event_id in reason.event_ids]
                    if pending and all(
                        getattr(tool, "evaluated_permission", None) == "allow"
                        for tool in pending
                    ):
                        continue
                break
    ```
  </Tab>

  <Tab title="TypeScript">
    ```typescript title="verify_claude_worker.mts" theme={"system"}
    import { randomUUID } from "node:crypto";
    import Anthropic from "@anthropic-ai/sdk";

    const agent = process.env.ANTHROPIC_AGENT_ID;
    const environmentId = process.env.ANTHROPIC_ENVIRONMENT_ID;
    if (!agent || !environmentId) {
      throw new Error("Set ANTHROPIC_AGENT_ID and ANTHROPIC_ENVIRONMENT_ID.");
    }
    const client = new Anthropic();
    const proof = randomUUID().replaceAll("-", "");
    const session = await client.beta.sessions.create({
      agent,
      environment_id: environmentId,
      title: "CoreWeave worker verification",
    });
    console.log(`Session ID: ${session.id}`);
    console.log(`Expected file contents: ${proof}`);
    const allowedEvents = new Map<string, boolean>();

    await client.beta.sessions.events.send(session.id, {
      events: [{
        type: "user.message",
        content: [{
          type: "text",
          text: `Write exactly ${proof} to managed-agent-proof.txt in your working directory and read it back.`,
        }],
      }],
    });

    const events = await client.beta.sessions.events.stream(session.id);
    try {
      for await (const event of events) {
        console.log(JSON.stringify(event));
        if ("id" in event) {
          allowedEvents.set(event.id,
            "evaluated_permission" in event && event.evaluated_permission === "allow");
        }
        if (event.type === "session.status_idle") {
          const reason = event.stop_reason;
          if (reason?.type === "requires_action" && reason.event_ids.length > 0 &&
              reason.event_ids.every((id) => allowedEvents.get(id) === true)) {
            continue;
          }
          break;
        }
      }
    } finally {
      events.controller.abort();
    }
    ```
  </Tab>
</Tabs>

実行してイベントを確認します:

<Tabs>
  <Tab title="Python">
    ```bash theme={"system"}
    python verify_claude_worker.py
    ```
  </Tab>

  <Tab title="TypeScript">
    ```bash theme={"system"}
    npx tsx verify_claude_worker.mts
    ```
  </Tab>
</Tabs>

スクリプトが `requires_action` で停止した場合、参照されているツールイベントを調査します。`evaluated_permission: "ask"` のある Call は、Anthropic の [ツール確認ワークフロー](https://platform.claude.com/docs/en/managed-agents/events-and-streaming#tool-confirmation) が必要です。ワーカーは許可された Call を処理します。停止した場合は、そのログを調査します。別のセッションを作成するのではなく、そのセッションを継続するためにセッション ID を保持してください。

タスクが完了したら、セットアップに適したコマンドでサンドボックスからファイルを読み取ります。`[SANDBOX-NAME]` または `[SANDBOX-ID]` をワークスペース名または出力されたサンドボックス ID に置き換えてください。

<Tabs>
  <Tab title="cws-agent">
    ```bash theme={"system"}
    cws-agent exec [SANDBOX-NAME] 'cat /workspace/claude/0/managed-agent-proof.txt'
    ```
  </Tab>

  <Tab title="Sandboxes SDK">
    <Tabs>
      <Tab title="Python">
        ```python theme={"system"}
        from cwsandbox import Sandbox

        sandbox = Sandbox.from_id("[SANDBOX-ID]").result()
        result = sandbox.exec(["cat", "/workspace/managed-agent-proof.txt"], check=True).result()
        print(result.stdout, end="")
        ```
      </Tab>

      <Tab title="TypeScript">
        ```typescript theme={"system"}
        import { createSandboxClientFromEnv } from "@coreweave/cwsandbox/node";

        const client = createSandboxClientFromEnv();
        const sandbox = await client.fromId("[SANDBOX-ID]");
        const result = await sandbox.commands.run(["cat", "/workspace/managed-agent-proof.txt"], { check: true });
        process.stdout.write(result.stdout);
        ```
      </Tab>
    </Tabs>
  </Tab>
</Tabs>

Python の場合、必要に応じて `cwsandbox` をインストールした仮想環境を再有効化してください。TypeScript の場合、SDK スニペットを `.mts` ファイルとして保存し、`npx tsx` で実行してください。

ファイルの内容はクライアントが出力した値と一致する必要があります。これにより、エージェントのツール実行が特定の CoreWeave サンドボックスに紐づけられます。

<h2 id="keep-results-and-stop">
  結果を保持して停止する
</h2>

実行中のタスクが終了するのを待ち、必要な結果をサンドボックスからコピーします。その後、セットアップに合ったコマンドを使用して停止します：

<Tabs>
  <Tab title="cws-agent">
    ```bash theme={"system"}
    cws-agent down [SANDBOX-NAME]
    ```

    `down` は停止前にワークスペースのスナップショットを取得します。取得に失敗した場合は、`cws-agent status [SANDBOX-NAME]` を確認し、失敗を解決してから再試行してください。保存されていない変更を破棄できる場合は、`down --no-snapshot` を使用します。
  </Tab>

  <Tab title="Sandboxes SDK">
    <Tabs>
      <Tab title="Python">
        ```python theme={"system"}
        from cwsandbox import Sandbox

        sandbox = Sandbox.from_id("[SANDBOX-ID]").result()
        sandbox.stop().result()
        ```
      </Tab>

      <Tab title="TypeScript">
        ```typescript theme={"system"}
        import { createSandboxClientFromEnv } from "@coreweave/cwsandbox/node";

        const client = createSandboxClientFromEnv();
        const sandbox = await client.fromId("[SANDBOX-ID]");
        await sandbox.stop();
        ```
      </Tab>
    </Tabs>

    この例では永続ストレージを設定していません。停止する前にファイルをコピーしてください。
  </Tab>
</Tabs>

サンドボックスの有効期間は進行中のタスクを終了させる可能性があります。Managed Agents セッションを終了しても、この常時稼働ワーカーは停止しません。サンドボックスを停止またはリストアしても、Anthropic の会話履歴は削除またはリストアされません。

<h2 id="troubleshoot">
  トラブルシューティング
</h2>

これらのチェックを使用してよくある問題を解決します:

* セッションがワーカーを待機している場合、環境 ID、ワーカーログ、および別のタスクがすでにワーカーを占有していないかを確認します。
* ワーカーが認証できない場合、その環境キーを確認します。セッションクライアントが使用する Console APIキーは異なる認証情報です。
* ツールが不足している場合、必要な依存関係を含むイメージをビルドします。例では Python イメージを使用しており、プロジェクト固有のツールチェーンをインストールしていません。

ツールの入力と出力は、実行が CoreWeave 上で行われていても Anthropic に流れます。Managed Agents は Zero Data Retention または HIPAA Business Associate Agreement の対象外です。[Anthropic のデータ保持の対象資格](https://platform.claude.com/docs/en/managed-agents/overview#beta-access) を参照してください。データ処理とワーカーの権限については、[セルフホスト環境のセキュリティモデル](https://platform.claude.com/docs/en/managed-agents/self-hosted-sandboxes-security) を確認してください。
