> ## 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.

# Claude Code

> Exécutez Claude Code dans un sandbox CoreWeave et interagissez avec lui depuis votre terminal, les applications Claude ou claude.ai.

Run Claude Code in a CoreWeave sandbox and choose how you interact with it. With the terminal user interface (TUI), you use your local terminal to control Claude Code inside the sandbox. With Remote Control, you use the Claude mobile app, Claude Desktop, or [claude.ai/code](https://claude.ai/code). In both cases, the agent process, tools, and workspace run in the sandbox. Model requests go to your configured model provider.

| Interface | Where you interact | Claude authentication |
| - | - | - |
| Terminal (TUI) | Your local terminal, attached to the sandbox | A Claude account or supported API credentials |
| Remote Control | The Claude mobile app, Claude Desktop, or claude.ai/code | A Claude subscription signed in through `/login` |

For an integration where Anthropic manages the agent loop and a sandbox executes tools, see [Claude Managed Agents](claude-managed-agents).

## Prerequisites

Before you begin, you need the following:

* Une [clé API W\&B](https://forge.coreweave.com/settings#apikeys). Ces exemples utilisent l’authentification W\&B.
* Pour l’interface en terminal, un compte Claude ou des identifiants d’authentification API pris en charge par Claude Code. Pour Remote Control, un abonnement Claude Pro, Max, Team ou Enterprise. Les clés API et les jetons générés par `claude setup-token` ne permettent pas de s’authentifier auprès de Remote Control.
* Une URL de dépôt que le sandbox peut cloner. Les exemples utilisent un dépôt public. Les dépôts privés nécessitent des identifiants d’authentification Git dans le sandbox.

Exportez votre clé API W\&B dans le terminal depuis lequel vous suivez ce guide. Supprimez toute variable de jeton CoreWeave afin que `cws-agent` sélectionne l’authentification W\&B :

```bash theme={"system"}
export WANDB_API_KEY="[WANDB-API-KEY]"
unset CWSANDBOX_API_KEY
```

For Remote Control, Team and Enterprise accounts need an Owner to enable the feature. Your organization must also permit its transcript storage. Organizations with Zero Data Retention requirements can't enable it. Review Anthropic's [Remote Control requirements](https://code.claude.com/docs/en/remote-control#requirements).

Connections use outbound HTTPS and don't require a public sandbox endpoint or inbound port.

Both setup paths use an 8-hour sandbox lifetime for a working day. The lifetime starts at creation, includes setup and idle time, and can't be extended. When it expires, the sandbox stops even if Claude is working, ending the session. [Save your results and stop the sandbox](#keep-results-and-stop) when you're finished, before the lifetime expires.

For overnight work, choose 24 hours at creation. With `cws-agent`, use `--lifetime 24h`. In the software development kit (SDK) examples, set Python's `max_lifetime_seconds` or TypeScript's `maxLifetimeSeconds` to `24 * 3600`.

## Quick start with cws-agent

Choose this setup path to create the sandbox with `cws-agent`. To create it directly with a client library, skip to [Set up with the Sandbox SDK](#set-up-with-the-sandbox-sdk). Both paths support either interface.

Suivez les [instructions d’installation de `cws-agent`](https://github.com/coreweave/cws-agent#install). L’outil configure un volume d’instantanés pour enregistrer et restaurer votre espace de travail à l’aide d’[instantanés du système de fichiers](/products/sandboxes/serverless/file-system-snapshots#start-a-sandbox-with-a-snapshot-mount).

Before Claude opens, `cws-agent` may show a preview of local skills and Model Context Protocol (MCP) servers to import. For this guide, press **Enter** at the import prompt to skip it. You can configure imports later using the [agent tools guidance](.#use-tools-efficiently).

Choose one of the following interfaces. Replace `[SANDBOX-NAME]` with a `cws-agent` session name and `[REPOSITORY-URL]` with a public repository URL. Use 1 to 40 lowercase letters, digits, or hyphens for the session name, starting with a letter or digit.

### Use the terminal interface

To use an Anthropic API key, load it into `ANTHROPIC_API_KEY` in your local terminal before launching or restoring the sandbox. `cws-agent` passes this variable into the sandbox. API-key authentication doesn't require browser sign-in. See [Claude Code authentication](https://code.claude.com/docs/en/authentication).

Launch Claude Code and connect your local terminal:

```bash theme={"system"}
cws-agent launch [SANDBOX-NAME] --repo-url [REPOSITORY-URL] --lifetime 8h --permission-mode native
```

Claude Code opens in the sandbox's project directory. Follow any workspace trust prompts. For API-key authentication, approve the key when prompted. If you need account authentication, exit Claude and run `cws-agent login [SANDBOX-NAME]`, then complete `/login` there.

The `--permission-mode native` option uses Claude's own approval settings. Without it, `cws-agent` defaults to bypassing those approval prompts. See [permission modes](https://github.com/coreweave/cws-agent/blob/main/docs/permissions.md).

If Claude reports `Not logged in` despite a configured API key and never offers to approve it, exit with `/exit`, then reconnect with onboarding enabled:

```bash theme={"system"}
cws-agent connect [SANDBOX-NAME] --cmd 'unset IS_DEMO; exec claude'
```

This command uses Claude's own approval settings. Accept the workspace trust and API-key prompts before continuing.

Continue to [Check the session](#check-the-session) to send a prompt and verify the result.

### Use Remote Control

Create a detached sandbox, then connect your terminal for subscription sign-in:

```bash theme={"system"}
cws-agent launch [SANDBOX-NAME] --repo-url [REPOSITORY-URL] --lifetime 8h --detach
cws-agent connect [SANDBOX-NAME] --cmd 'unset IS_DEMO CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC CLAUDE_CODE_OAUTH_TOKEN ANTHROPIC_API_KEY; exec claude'
```

The connection command clears settings that would prevent subscription sign-in or Remote Control feature checks. It also unsets `IS_DEMO` to enable onboarding. See [Claude Code environment variables](https://code.claude.com/docs/en/env-vars).

Inside Claude, complete `/login` with your Claude subscription account and accept the project trust prompt. Run `/remote-control` and accept its first-use confirmation, then exit Claude with `/exit`. Complete this step interactively to answer the confirmation before you start the detached server.

From your local terminal, start Remote Control with Claude's own approval settings:

```bash theme={"system"}
cws-agent rc [SANDBOX-NAME] --permission-mode native
```

Open the session URL when it appears. A message that a process started isn't sufficient to confirm the connection. Send a prompt from the web, mobile, or desktop client and verify its result as described in [Check the session](#check-the-session).

If no URL appears, inspect the remote log:

```bash theme={"system"}
cws-agent exec [SANDBOX-NAME] 'cat /workspace/home/remote-control.log'
```

Resolve any sign-in or eligibility error before retrying. If the server is waiting for an interactive prompt, restart it in an attached `tmux` session in the same sandbox. The `cws-agent rc` command redirects output to the log, so attaching to its existing session doesn't display the prompts.

From your local terminal, stop the waiting server and open a replacement session:

```bash theme={"system"}
cws-agent exec [SANDBOX-NAME] 'tmux kill-session -t cws-remote-control'
cws-agent connect [SANDBOX-NAME] --cmd 'tmux new-session -s cws-remote-control'
```

Inside `tmux`, start Remote Control so its sessions use the project directory:

```bash theme={"system"}
unset IS_DEMO CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC CLAUDE_CODE_OAUTH_TOKEN ANTHROPIC_API_KEY
cd /workspace/project
claude remote-control --spawn same-dir
```

Answer any prompts and open the displayed Claude Code URL. After the connection works, detach with **Ctrl-b**, then **d**, to leave the server running. The replacement session displays output in `tmux` instead of updating the log. To return, run `cws-agent connect [SANDBOX-NAME] --cmd 'tmux attach -t cws-remote-control'`.

## Set up with the Sandbox SDK

Use this alternative to create a sandbox for either interface with the Sandbox SDK. It doesn't depend on `cws-agent` or configure snapshots.

Run Python snippets in the virtual environment created in this guide. Save TypeScript snippets as `.mts` files in the project where you install the client, then run them with `npx tsx [FILENAME].mts`.

### Create the sandbox

Choose a client and install it locally:

<Tabs>
  <Tab title="Python">
    Utilisez Python 3.11 ou une version ultérieure, ainsi que `uv` :

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

  <Tab title="TypeScript">
    Utilisez Node.js 22 ou une version ultérieure. Installez le client et le runner TypeScript dans votre projet :

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

Save the script for your language using the filename shown. It installs Claude Code and `tmux`, then clones the repository you pass on the command line.

Both scripts require the container to run as root to install packages with `apt-get` and use `/root/.local/bin/claude`. Your runner's policy must allow that user.

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

    from cwsandbox import AuthStrategy, Sandbox

    bootstrap = """
    set -o pipefail
    apt-get update -qq
    DEBIAN_FRONTEND=noninteractive apt-get install -y -qq tmux >/dev/null
    curl -fsSL https://claude.ai/install.sh | bash
    mkdir -p /workspace
    """

    sandbox = Sandbox.run(
        auth=AuthStrategy.WANDB,
        container_image="node:22-bookworm",
        resources={"cpu": "2", "memory": "4Gi"},
        max_lifetime_seconds=8 * 3600,
        tags=["claude-code"],
    )
    try:
        sandbox.wait()
        commands = [
            ["bash", "-ec", bootstrap],
            ["git", "clone", "--", sys.argv[1], "/workspace/project"],
        ]
        for command in commands:
            result = sandbox.exec(command, timeout_seconds=900).result()
            if result.returncode != 0:
                raise RuntimeError(result.stderr or result.stdout)
    except BaseException:
        sandbox.stop().result()
        raise

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

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

    const repository = process.argv[2];
    if (!repository) throw new Error("Pass a repository URL.");

    const bootstrap = `
    set -o pipefail
    apt-get update -qq
    DEBIAN_FRONTEND=noninteractive apt-get install -y -qq tmux >/dev/null
    curl -fsSL https://claude.ai/install.sh | bash
    mkdir -p /workspace
    `;

    const client = createSandboxClientFromEnv();
    const sandbox = await client.create({
      containerImage: "node:22-bookworm",
      resources: { cpu: "2", memory: "4Gi" },
      maxLifetimeSeconds: 8 * 3600,
      waitUntilRunning: false,
      tags: ["claude-code"],
    });
    try {
      await sandbox.wait();
      const commands = [
        ["bash", "-ec", bootstrap],
        ["git", "clone", "--", repository, "/workspace/project"],
      ];
      for (const command of commands) {
        await sandbox.commands.run(command, { timeoutMs: 900_000, check: true });
      }
    } catch (error) {
      await sandbox.stop();
      throw error;
    }
    console.log(`Sandbox ID: ${sandbox.sandboxId}`);
    ```
  </Tab>
</Tabs>

Replace `[REPOSITORY-URL]` with your public repository URL:

<Tabs>
  <Tab title="Python">
    ```bash theme={"system"}
    python create_claude_sandbox.py [REPOSITORY-URL]
    ```
  </Tab>

  <Tab title="TypeScript">
    ```bash theme={"system"}
    npx tsx create_claude_sandbox.mts [REPOSITORY-URL]
    ```
  </Tab>
</Tabs>

Keep the printed sandbox ID. These standalone examples leave the sandbox running after the script exits. The sandbox runs until you stop it or its 8-hour lifetime expires. In Python, wrapping the sandbox in a `Session` or context manager changes that cleanup behavior.

### Attach your terminal

Utilisez le SDK pour connecter votre terminal local au sandbox avec l’authentification W\&B. Le script transmet vos frappes au shell du sandbox et rétablit votre terminal à la fermeture du shell.

<Tabs>
  <Tab title="Python">
    Sous macOS ou Linux, enregistrez ce script sous le nom `attach_sandbox.py` :

    ```python title="attach_sandbox.py" theme={"system"}
    import os
    import shutil
    import sys
    import termios
    import threading
    import tty

    from cwsandbox import AuthStrategy, Sandbox

    if not sys.stdin.isatty() or not sys.stdout.isatty():
        raise SystemExit("Run this script in an interactive terminal.")

    sandbox = Sandbox.from_id(sys.argv[1], auth=AuthStrategy.WANDB).result()
    size = shutil.get_terminal_size()
    terminal = sandbox.shell(["/bin/bash"], width=size.columns, height=size.lines)
    fd = sys.stdin.fileno()
    saved = termios.tcgetattr(fd)


    def forward_input():
        while data := os.read(fd, 1024):
            terminal.stdin.write(data).result()
        terminal.stdin.close().result()


    try:
        tty.setraw(fd)
        threading.Thread(target=forward_input, daemon=True).start()
        for chunk in terminal.output:
            sys.stdout.buffer.write(chunk)
            sys.stdout.buffer.flush()
        result = terminal.result()
    finally:
        termios.tcsetattr(fd, termios.TCSADRAIN, saved)
        terminal.stdin.close().result()

    raise SystemExit(result.returncode)
    ```
  </Tab>

  <Tab title="TypeScript">
    Enregistrez ce script sous le nom `attach_sandbox.mts` :

    ```typescript title="attach_sandbox.mts" theme={"system"}
    import { createSandboxClientFromEnv } from "@coreweave/cwsandbox/wandb";

    if (!process.stdin.isTTY || !process.stdout.isTTY) {
      throw new Error("Run this script in an interactive terminal.");
    }
    const sandboxId = process.argv[2];
    if (!sandboxId) throw new Error("Pass a sandbox ID.");
    const client = createSandboxClientFromEnv();
    const sandbox = await client.fromId(sandboxId);
    const terminal = await sandbox.shell({
      command: ["/bin/bash"],
      cols: process.stdout.columns || 80,
      rows: process.stdout.rows || 24,
    });
    const wasRaw = process.stdin.isRaw;
    const forwardInput = (chunk: Buffer) => {
      void terminal.stdin.write(chunk).catch((error) => {
        console.error(error);
        void terminal.cancel();
      });
    };

    try {
      process.stdin.setRawMode(true);
      process.stdin.on("data", forwardInput);
      process.stdin.resume();
      for await (const chunk of terminal.output) {
        process.stdout.write(chunk);
      }
      const result = await terminal.wait();
      process.exitCode = result.exitCode;
    } finally {
      process.stdin.off("data", forwardInput);
      process.stdin.setRawMode(wasRaw);
      process.stdin.pause();
      await terminal.stdin.close();
    }
    ```
  </Tab>
</Tabs>

Replace `[SANDBOX-ID]` with the printed ID, then run:

<Tabs>
  <Tab title="Python">
    ```bash theme={"system"}
    python attach_sandbox.py [SANDBOX-ID]
    ```
  </Tab>

  <Tab title="TypeScript">
    ```bash theme={"system"}
    npx tsx attach_sandbox.mts [SANDBOX-ID]
    ```
  </Tab>
</Tabs>

Your terminal is now attached to a shell inside the sandbox. Choose one of the following interfaces to start Claude Code.

### Start the terminal interface

For API-key authentication, enter the key in the sandbox's Bash shell before starting Claude. The input is hidden and isn't included in the command history:

```bash theme={"system"}
read -r -s -p 'Anthropic API key: ' ANTHROPIC_API_KEY
export ANTHROPIC_API_KEY
printf '\n'
```

Inside the sandbox, start Claude from the cloned repository:

```bash theme={"system"}
cd /workspace/project
/root/.local/bin/claude
```

If you use an API key, approve it. Otherwise, complete account sign-in. Then accept the workspace trust prompts and continue to [Check the session](#check-the-session).

### Start Remote Control

Use Claude subscription sign-in for this interface. If you previously used an API key in this sandbox, remove it from the shell and any Claude settings before signing in:

```bash theme={"system"}
unset ANTHROPIC_API_KEY CLAUDE_CODE_OAUTH_TOKEN
```

Inside the sandbox, open a named `tmux` session in your project:

```bash theme={"system"}
cd /workspace/project
tmux new-session -s claude-remote
```

In `tmux`, start Claude:

```bash theme={"system"}
/root/.local/bin/claude
```

Complete subscription sign-in and accept the workspace trust prompt. Exit Claude with `/exit`, then start the Remote Control server in the same directory:

```bash theme={"system"}
/root/.local/bin/claude remote-control --name "CoreWeave sandbox" --spawn same-dir
```

The `--spawn same-dir` option uses the project directory for remote sessions. If prompted, accept the first-use confirmation. Open the displayed Claude Code URL in a browser signed in to the same Claude account.

After the connection works, detach from `tmux` with **Ctrl-b**, then **d**, and exit the sandbox shell. The `tmux` session keeps the server running. To return, rerun the attachment script and run `tmux attach -t claude-remote`.

## Check the session

For the terminal interface, send the prompt in the attached Claude Code TUI. For Remote Control, open the session at claude.ai/code in your browser, or in the Claude mobile or Desktop app, using the same account.

Choose a unique, non-secret test value and replace `[PROOF-VALUE]` in this prompt:

```text theme={"system"}
Write the exact text [PROOF-VALUE] to /workspace/project/sandbox-proof.txt, then read it back.
```

If asked, approve the file write. If you used the terminal interface, exit Claude with `/exit` and, for the SDK setup, exit the sandbox shell with `exit`. From your local terminal, verify the result using the command for your setup:

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

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

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

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

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

Matching the value confirms that Claude wrote to the sandbox you created.

## Return to a running sandbox

Exiting Claude or closing your terminal leaves the sandbox running. To return from another terminal or machine, install the same client and authenticate with credentials that can access the sandbox.

For `cws-agent`, find the session by name and open a new Claude terminal:

```bash theme={"system"}
cws-agent list
cws-agent status [SANDBOX-NAME]
cws-agent connect [SANDBOX-NAME] --permission-mode native
```

The `connect` command uses the existing sandbox and files. It doesn't resume a previous conversation. To continue a saved conversation, first exit its original Claude process. Then list the history and replace `[CONVERSATION-ID]` with the ID to resume:

```bash theme={"system"}
cws-agent session history [SANDBOX-NAME]
cws-agent session resume [SANDBOX-NAME] [CONVERSATION-ID] --permission-mode native
```

For the SDK path, rerun the [terminal attachment script](#attach-your-terminal) with the same sandbox ID, then start Claude again. A single SDK shell session ends after 24 hours, even when the sandbox's lifetime is longer. The sandbox keeps running, so rerun the script to reconnect. For Remote Control, reopen the session URL while its server is still running.

A sandbox connection and an agent process have separate lifetimes. If a terminal agent must keep working after you disconnect, use `tmux` or the `cws-agent` worktree sessions.

Reconnecting doesn't reset the sandbox's lifetime. If the sandbox has stopped, restore a saved workspace instead.

## Keep results and stop

Save progress during a long session instead of waiting until the lifetime is nearly over. With `cws-agent`, wait for Claude to finish writing and pause other workspace writers, then capture the `/workspace` directory without stopping the sandbox:

```bash theme={"system"}
cws-agent snapshot [SANDBOX-NAME]
```

Wait for the command to report a `READY` snapshot. A snapshot captures files at that point in time. Later edits need another snapshot. For capture behavior and saved credentials, see the [snapshot guidance](https://github.com/coreweave/cws-agent/blob/main/docs/usage.md#snapshots). Don't rely on lifetime expiry to save your latest changes.

In your local terminal, copy the verified text result to your machine:

```bash theme={"system"}
cws-agent exec [SANDBOX-NAME] 'cat /workspace/project/sandbox-proof.txt' > sandbox-proof.txt
```

For code changes, see [Get changes back](https://github.com/coreweave/cws-agent/blob/main/docs/usage.md#get-changes-back). A snapshot preserves the remote workspace. It doesn't copy files to your machine.

When you finish, wait for active tasks and workspace writes to complete, then save the workspace and stop compute:

```bash theme={"system"}
cws-agent down [SANDBOX-NAME]
```

The `down` command confirms a snapshot before stopping. If snapshot creation fails, it leaves the sandbox running. Check `cws-agent status [SANDBOX-NAME]` and resolve the failure before retrying. To stop without saving current changes, use `cws-agent down [SANDBOX-NAME] --no-snapshot`.

Si vous utilisez directement le SDK, cet exemple ne comporte aucun montage persistant. Pour disposer d’un espace de travail restaurable, configurez des [instantanés du système de fichiers](/products/sandboxes/serverless/file-system-snapshots) dès la création. Récupérez les résultats à l’aide des [opérations sur les fichiers](/fr/products/sandboxes/serverless/client/guides/file-operations), puis arrêtez la sandbox :

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

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

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

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

Exiting Claude alone leaves the sandbox running. Stopping the sandbox ends its agent processes, including Remote Control. Restoring files from a snapshot doesn't restore that process. Sign in as needed and start Remote Control again.

To return to a workspace saved by `cws-agent`, restore it into a new sandbox. If the skills/MCP import prompt appears, press **Enter** to skip it:

```bash theme={"system"}
cws-agent restore [SANDBOX-NAME] --lifetime 8h --connect --permission-mode native
```

For Remote Control, exit the restored Claude TUI with `/exit`, then repeat the [sign-in and server startup steps](#use-remote-control), starting with `cws-agent connect`. Skip the launch command because restore has already created the sandbox. For saved conversations and parallel worktrees, see the [`cws-agent` sessions guide](https://github.com/coreweave/cws-agent/blob/main/docs/sessions.md).

## Troubleshoot

Use these checks to resolve common issues:

* Si la création du sandbox échoue, vérifiez votre clé API W\&B et vos paramètres d’authentification.
* Si l’installation, le clonage ou les requêtes vers le modèle échouent, vérifiez la connectivité sortante et les identifiants d’authentification du fournisseur concerné.
* Si le terminal se déconnecte, rattachez-vous au sandbox tant qu’il est en cours d’exécution. Pour qu’un processus survive aux déconnexions du terminal, exécutez-le dans un multiplexeur de terminal tel que `tmux`.
* Si Remote Control refuse l’authentification, connectez-vous avec un abonnement Claude. Supprimez les identifiants de clé API en conflit dans l’environnement distant ou dans les paramètres de Claude.
* Si Remote Control n’est pas disponible, consultez les [conseils de dépannage d’Anthropic](https://code.claude.com/docs/en/remote-control#troubleshooting) concernant les paramètres d’organisation, les points de terminaison d’API personnalisés et les variables d’environnement qui désactivent des vérifications de fonctionnalités requises.
* Si le sandbox expire, créez-en un nouveau. Sa durée de vie ne peut pas être prolongée après sa création, et cet exemple de SDK n’enregistre pas automatiquement son système de fichiers.

## Data handling

Commands execute in the sandbox, while model requests go to your configured provider. Remote Control sends prompts, tool activity, and conversation content to Anthropic and stores a transcript to synchronize connected devices. See [Remote Control security](https://code.claude.com/docs/en/remote-control#connection-and-security) and [Claude Code data usage](https://code.claude.com/docs/en/data-usage).

## Next steps

For more information, see these guides:

* [Interactive shells and TTY](../client/guides/interactive-shells) covers terminal access from the SDK.
* [Sandbox lifecycle](../client/guides/sandbox-lifecycle) covers waiting, reconnecting, and stopping.
* [Claude Code documentation](https://code.claude.com/docs/en/overview) covers agent configuration and authentication.