---
title: Sandboxes auto-hébergés
url: https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes
description: Exécutez les sessions Claude Managed Agents dans des sandboxes auto-hébergés, en conservant l'exécution des outils, les fichiers et le trafic réseau sortant dans votre propre infrastructure.
featureMetadata:
  topic:
    title: Managed Agents
    url: https://platform.claude.com/docs/en/managed-agents/overview
  status: beta
  betaHeader: managed-agents-2026-04-01
---

Les sandboxes auto-hébergés déplacent l'exécution des outils de l'agent depuis les sandboxes cloud gérés par Anthropic vers une infrastructure que vous contrôlez, tandis qu'Anthropic continue d'exécuter l'agent. Pour comprendre ce que cela implique et décider si cela convient à votre agent, consultez [Choisir un environnement d'agent](https://platform.claude.com/docs/fr/managed-agents/choosing-an-environment).

## Fonctionnement

Un environnement `self_hosted` agit comme une file de travail. Vous exécutez un **environment worker** (worker d'environnement), un processus sur votre propre infrastructure qui dessert cette file :

1. Vous créez une [session](https://platform.claude.com/docs/fr/managed-agents/sessions) qui cible l'environnement. Anthropic place la session dans la file en tant qu'élément de travail.
2. Votre worker réclame l'élément de travail et télécharge les [skills](https://platform.claude.com/docs/fr/managed-agents/skills) de l'agent ainsi que les [memory stores](https://platform.claude.com/docs/fr/managed-agents/memory) de la session.
3. Claude s'exécute du côté d'Anthropic et demande des appels d'outils. Votre worker exécute chaque appel localement et renvoie le résultat.

Les entrées et sorties des outils transitent toujours par le plan de contrôle d'Anthropic, afin que le modèle puisse voir les résultats et déterminer la suite. Anthropic stocke les skills et les memory stores. Votre sandbox en conserve une copie pour la session. Consultez [Modèle de sécurité](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes-security) pour connaître la frontière complète des flux de données.

Les sandboxes auto-hébergés prennent en charge tous les modèles Claude disponibles dans Managed Agents. Le modèle est configuré sur l'agent, et non sur l'environnement.

La CLI `ant` et les SDK Python, TypeScript et Go fournissent des workers préconstruits. Des fournisseurs de sandboxes tels que Cloudflare, Daytona et Modal publient également leurs propres [guides de plateforme](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes#platform-guides).

## Démarrage rapide

Ce démarrage rapide exécute un worker toujours actif avec la CLI `ant`, lui envoie une session et confirme que les appels d'outils de l'agent se sont exécutés sur votre hôte.

### Prérequis

* **Un agent :** si vous n'en avez pas, suivez d'abord [Premiers pas avec Claude Managed Agents](https://platform.claude.com/docs/fr/managed-agents/quickstart) et notez l'ID de l'agent.
* **Un hôte Linux :** l'hôte doit disposer de `/bin/bash` à ce chemin exact. Le worker n'a besoin que de HTTPS sortant.
* **Une clé API Claude :** vous l'utilisez depuis votre propre machine pour créer des sessions et lire les statistiques de la file. Ne la placez pas sur l'hôte du worker, où les appels d'outils de l'agent pourraient la lire.
* **La CLI `ant` ou le SDK sur votre propre machine :** les étapes de statistiques et de session de ce démarrage rapide s'exécutent là, et non sur l'hôte du worker. Installez la CLI de la même manière que l'[étape d'installation](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes#run-your-first-session) le fait pour le worker, ou installez le [SDK](https://platform.claude.com/docs/fr/cli-sdks-libraries/overview).

<Note>
  Sur [Claude Platform on AWS](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws), le worker s'authentifie avec AWS IAM (SigV4) ou une [clé API générée dans la console AWS](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#api-key-authentication), et non avec une clé d'environnement. Attachez la politique gérée [`AnthropicSelfHostedEnvironmentAccess`](https://platform.claude.com/docs/fr/api/claude-platform-on-aws-iam-actions#managed-policies) au principal IAM sous lequel votre worker s'exécute. Les clés d'environnement générées dans la Claude Console ne fonctionnent pas avec le point de terminaison Claude Platform on AWS.
</Note>

### Exécuter votre première session

<Steps>
  <Step title="Créer un environnement auto-hébergé">
    Dans la Claude Console, accédez à la page [Environments](https://platform.claude.com/environments) (`platform.claude.com/environments`), cliquez sur **Create environment**, puis sous **Hosting**, sélectionnez **Self-hosted**.

    Ou via l'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="Générer une clé d'environnement">
    Dans la Console, ouvrez l'environnement et cliquez sur **Generate environment key**. La clé d'environnement authentifie le worker auprès de sa file. Vous ne pouvez en générer une que dans la Console, même pour un environnement créé via l'API.

    Exportez l'ID et la clé de l'environnement sur l'hôte du worker :

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

  <Step title="Installer la CLI ant">
    Exécutez ceci sur l'hôte du worker.

    <Tabs>
      <Tab title="curl (Linux/WSL)">
        Pour les environnements Linux, téléchargez directement le binaire de la version.

        ```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
        ```

        Vous trouverez toutes les versions sur la [page des versions GitHub](https://github.com/anthropics/anthropic-cli/releases).
      </Tab>

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

  <Step title="Démarrer le worker">
    Créez le répertoire de travail, puis démarrez le worker. `--workdir` utilise par défaut le répertoire courant ; passez donc `/workspace` pour correspondre à la valeur par défaut du système.

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

    Le worker lit les deux variables que vous avez exportées et interroge la file jusqu'à ce que vous l'arrêtiez.
  </Step>

  <Step title="Vérifier que le worker est connecté">
    Sur votre propre machine, définissez `ANTHROPIC_API_KEY` sur votre clé API Claude (et non sur la clé d'environnement) et `ANTHROPIC_ENVIRONMENT_ID` (python, ruby: `environment_id`; typescript, java, csharp: `environmentId`; go: `environmentID`; php: `$environmentId`) sur l'ID de l'environnement. Vérifiez que `workers_polling` (java, php: `workersPolling`; csharp, go: `WorkersPolling`) vaut au moins 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>

    Si `workers_polling` (java, php: `workersPolling`; csharp, go: `WorkersPolling`) reste à 0, consultez [Dépannage](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes-operations#troubleshooting).
  </Step>

  <Step title="Démarrer une session">
    Définissez `AGENT_ID` (python, ruby: `agent_id`; typescript, java, csharp: `agentId`; go: `agentID`; php: `$agentId`) sur l'ID de votre agent. Créez une session qui cible l'environnement, puis envoyez-lui une tâche :

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

    La session attend dans la file de l'environnement jusqu'à ce qu'un worker la réclame. Si aucun worker n'est connecté, la session reste en file d'attente au lieu d'échouer.
  </Step>

  <Step title="Confirmer que les outils se sont exécutés sur votre hôte">
    Sur l'hôte du worker, lisez le fichier écrit par l'agent :

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

    Le fichier décrit le noyau de votre propre hôte ; les appels d'outils de l'agent s'y sont donc bien exécutés. Pour suivre le travail de l'agent en temps réel, consultez [Flux d'événements de session](https://platform.claude.com/docs/fr/managed-agents/events-and-streaming).
  </Step>
</Steps>

## Ressources de session

Les sandboxes auto-hébergés prennent en charge uniquement les ressources `memory_store`. Une session sur un environnement auto-hébergé qui inclut une ressource `file` ou `github_repository` est rejetée avec une erreur 400 :

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

Les [déploiements](https://platform.claude.com/docs/fr/managed-agents/scheduled-deployments) qui ciblent un environnement auto-hébergé suivent la même règle. Pour fournir à une session ses propres fichiers d'entrée, consultez [Préparer des fichiers pour une session](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes-workers#stage-files-for-a-session).

## Sandboxes auto-hébergés et tunnels MCP

L'auto-hébergement contrôle *l'endroit où le code de l'agent s'exécute*. Les [tunnels MCP](https://platform.claude.com/docs/fr/agents-and-tools/mcp-tunnels/overview) contrôlent *la manière dont Anthropic atteint les serveurs MCP de votre réseau*. Les deux sont indépendants :

* Une session dans les sandboxes cloud d'Anthropic peut atteindre des serveurs MCP privés via un tunnel. Par exemple, un serveur MCP privé peut se trouver devant une base de données ou une API interne derrière votre pare-feu.
* Une session auto-hébergée peut utiliser des serveurs MCP tunnelisés ou publics.

Utilisez les deux lorsque vous souhaitez que l'exécution et l'accès aux outils restent à l'intérieur de votre périmètre. Pour vous passer du tunnel, [encapsulez le serveur MCP sous forme d'outils personnalisés](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes-custom-tools#wrap-an-mcp-server-as-custom-tools) que votre worker dessert.

## Guides de plateforme

Ces pages décrivent comment construire un worker sur n'importe quelle plateforme de sandboxing. Des guides spécifiques à certaines plateformes sont également disponibles :

* [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)

## Étapes suivantes

<CardGroup cols={2}>
  <Card title="Déployer des workers" icon="play" href="https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes-workers">
    Exécutez le worker du SDK, déclenchez des workers à partir de webhooks ou attribuez à chaque session son propre sandbox.
  </Card>

  <Card title="Memory stores" icon="brain" href="https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes-memory">
    Préparez l'hôte, configurez la synchronisation et gérez les stores en lecture seule et les conflits.
  </Card>

  <Card title="Outils personnalisés et serveurs MCP" icon="tool" href="https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes-custom-tools">
    Servez vos propres outils depuis le worker, y compris des outils provenant d'un serveur MCP à l'intérieur de votre réseau.
  </Card>

  <Card title="Surveiller et dépanner" icon="lightning" href="https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes-operations">
    Lisez la profondeur de la file, arrêtez proprement les sessions et les workers, et corrigez les défaillances courantes.
  </Card>

  <Card title="Référence du worker" icon="book" href="https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes-reference">
    Options de la CLI, variables d'environnement, chemins du système de fichiers et options des helpers du SDK.
  </Card>

  <Card title="Modèle de sécurité" icon="lock" href="https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes-security">
    Modèle de responsabilité partagée pour les environnements de sandboxes auto-hébergés.
  </Card>
</CardGroup>