---
title: Déployer des workers auto-hébergés
url: https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes-workers
description: Choisissez comment les workers de sandbox auto-hébergés réclament le travail et où les sessions s'exécutent, puis exécutez un worker toujours actif ou déclenchez des workers à partir de webhooks.
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: Non éligible à la ZDR, sauf pour Managed Agents auto-hébergé. Les sessions sont des ressources avec état ; les transcriptions persistent jusqu’à ce que vous les supprimiez.
  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
---

Le [démarrage rapide des sandboxes auto-hébergées](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes#quickstart) exécute un worker de la CLI `ant` qui interroge la file en continu et exécute chaque session dans un seul processus. Cette page vous aide à choisir un modèle de déploiement, puis présente les workers toujours actifs et les workers déclenchés par webhook.

## Choisir un modèle de déploiement

Lors du déploiement de workers, vous devez faire deux choix : comment le worker réclame le travail, et où chaque session s’exécute.

**Comment le worker réclame le travail :**

* **Toujours actif :** Un processus de longue durée interroge la file en continu. Le processus n’effectue que des requêtes HTTPS sortantes, vous n’exposez donc aucun point de terminaison à Anthropic.
* **Déclenché par webhook :** Un gestionnaire se réveille sur `session.status_run_started` et commence à interroger la file. Cela évite un « poller » (processus d’interrogation) inactif, mais nécessite un point de terminaison de [webhook](https://platform.claude.com/docs/fr/managed-agents/webhooks) accessible par Anthropic.

**Où chaque session s’exécute :**

* **Dans le processus :** Le worker qui réclame une session exécute également ses appels d’outils, dans un répertoire de travail partagé unique.
* **Une sandbox par session :** Un poller lance une nouvelle sandbox pour chaque session réclamée. Choisissez cette option pour une isolation plus forte : un système de fichiers neuf, des limites de ressources ou des contrôles réseau par session. Consultez [Exécuter une sandbox par session](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes-per-session), qui couvre également le chart Helm pour Kubernetes.

Les workers CLI et SDK prennent en charge différentes combinaisons :

| Capacité | CLI `ant` | SDK (Python, TypeScript, Go) |
| ----- | ----- | ----- |
| Interrogation permanente | Oui | Oui |
| Déclenché par webhook | Non | Oui |
| [Une sandbox par session](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes-per-session) | Oui | Oui |
| [Magasins de mémoire](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes-memory) | Oui, avec les paramètres de synchronisation par défaut | Oui, avec une synchronisation configurable |
| [Outils personnalisés](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes-custom-tools) | Non | Oui |

Consultez la [référence des workers auto-hébergés](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes-reference) pour chaque option de la CLI et du SDK.

Pour plus de contrôle, appelez directement les [points de terminaison de travail d’environnement](https://platform.claude.com/docs/fr/api/beta/environments/work) et implémentez votre propre worker. Votre worker fait alors ce que font les workers du SDK. Entre autres, il acquitte chaque élément de travail, envoie des heartbeats et télécharge les skills de l’agent. Il n’exécute que les appels d’outils autorisés par la [politique d’autorisation](https://platform.claude.com/docs/fr/managed-agents/permission-policies#see-how-each-call-was-evaluated) de la session. Il renvoie chaque résultat sous forme d’événement `user.tool_result` ou `user.custom_tool_result`. À la fin, il arrête l’élément. Utilisez comme référence le code source du worker dans le [SDK Python](https://github.com/anthropics/anthropic-sdk-python/tree/main/src/anthropic/lib/environments), le [SDK TypeScript](https://github.com/anthropics/anthropic-sdk-typescript/tree/main/src/lib/environments) ou le [SDK Go](https://github.com/anthropics/anthropic-sdk-go/tree/main/lib/environments).

## Exécuter un worker toujours actif

Ces exemples utilisent `/workspace` comme répertoire de travail du worker. Le répertoire doit exister avant le démarrage du worker. Sur un nouvel hôte, créez-le et accordez à l’utilisateur du worker un accès en écriture, comme dans l’étape « Démarrer le worker » de [Exécuter votre première session](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes#run-your-first-session).

Sur macOS, `mkdir` ne peut pas créer `/workspace`, car le volume racine est en lecture seule. Créez plutôt `~/workspace`, comme le montre cette étape. À la place de `/workspace`, utilisez le chemin complet affiché par `echo ~/workspace`, car le SDK ne développe pas `~`.

Démarrez un worker qui interroge la file en continu. Il s’authentifie avec la [clé d’environnement](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes#run-your-first-session) du démarrage rapide :

<CodeGroup exclude="shell:cURL, csharp, java, php, ruby">
  <CodeGroupItem language="cURL">
    Un worker est un processus de longue durée, et non une simple requête HTTP. Exécutez plutôt le worker de la 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())
          # Annuler la tâche, plutôt que tuer le processus, permet au worker d'arrêter son
          # élément de travail en cours et de téléverser les fichiers mémoire modifiés avant de quitter.
          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();
  // L'abandon sur l'un ou l'autre signal permet au worker de téléverser les fichiers mémoire modifiés et de supprimer ses
  // répertoires de stockage avant la fin du processus.
  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#">
    Le SDK C# ne dispose pas de `EnvironmentWorker`. Exécutez plutôt le worker de la 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">
    Le SDK Java ne dispose pas de `EnvironmentWorker`. Exécutez plutôt le worker de la CLI `ant` : `ant beta:worker poll --workdir /workspace`.
  </CodeGroupItem>

  <CodeGroupItem language="PHP">
    Le SDK PHP ne dispose pas de `EnvironmentWorker`. Exécutez plutôt le worker de la CLI `ant` : `ant beta:worker poll --workdir /workspace`.
  </CodeGroupItem>

  <CodeGroupItem language="Ruby">
    Le SDK Ruby ne dispose pas de `EnvironmentWorker`. Exécutez plutôt le worker de la CLI `ant` : `ant beta:worker poll --workdir /workspace`.
  </CodeGroupItem>
</CodeGroup>

## Déclencher des workers à partir de webhooks

<Steps>
  <Step title="S’abonner aux webhooks de session">
    Dans la [Claude Console](https://platform.claude.com/settings/workspaces/default/webhooks), définissez un point de terminaison de webhook qui écoute les événements `session.status_run_started`. Consultez [S’abonner aux webhooks](https://platform.claude.com/docs/fr/managed-agents/webhooks) pour plus de détails.
  </Step>

  <Step title="Exporter la clé de signature du webhook">
    En plus de l’ID et de la clé d’environnement de [Exécuter votre première session](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes#run-your-first-session), exportez la clé de signature du webhook sur l’hôte de votre gestionnaire. Le gestionnaire l’utilise pour vérifier les charges utiles entrantes.

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

  <Step title="Implémenter le gestionnaire de webhook">
    Démarrez le worker lorsque `session.status_run_started` se déclenche. Le gestionnaire vide la file et transmet chaque élément de travail récupéré à `handle_item()` (typescript: `handleItem()`; go: `HandleItem()`) (dans les SDK Python, TypeScript et Go). Cette méthode télécharge les skills, exécute les appels d’outils, renvoie les résultats, puis se termine.

    Les exemples utilisent `/workspace` comme répertoire de travail. Avant de démarrer le gestionnaire, créez ce répertoire sur l’hôte du gestionnaire. Assurez-vous que l’utilisateur du gestionnaire peut y écrire, comme dans l’étape « Démarrer le worker » de [Exécuter votre première session](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes#run-your-first-session).

    <CodeGroup exclude="shell, csharp, java, php, ruby">
      <CodeGroupItem language="cURL">
        Ce gestionnaire nécessite plus de logique qu’une simple commande shell. Utilisez le SDK Python, TypeScript ou Go pour l’exécuter.
      </CodeGroupItem>

      <CodeGroupItem language="CLI">
        Ce gestionnaire nécessite plus de logique qu’une simple commande shell. Utilisez le SDK Python, TypeScript ou Go pour l’exécuter.
      </CodeGroupItem>

      <CodeGroupItem>
        Pour vérifier les signatures des webhooks, installez l’extra 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,
        )
        # Annulé par shutdown() afin qu'un élément de travail en cours puisse téléverser les fichiers mémoire modifiés et
        # supprimer ses répertoires de magasin avant la fin du processus.
        inflight: set[asyncio.Task[None]] = set()


        # Attendez ceci depuis le hook d'arrêt de l'hôte, tel qu'un arrêt de lifespan ASGI (le code après
        # `yield` dans un lifespan FastAPI), qu'uvicorn exécute sur SIGTERM. uvicorn laisse les requêtes ouvertes
        # se terminer avant ce hook ; définissez donc --timeout-graceful-shutdown pour borner l'attente.
        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:
                # Protégé : une livraison abandonnée ou expirée ne doit pas annuler l'élément ; c'est shutdown() qui le fait.
                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,
                    # Le secret par session est ce qui permet au worker de monter les magasins de mémoire de la session.
                    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
      });
      // Appelez shutdown.abort() depuis le gestionnaire SIGTERM/SIGINT de l'hôte, en plus de fermer le serveur,
      // puis attendez les appels handle() en cours avant de quitter : l'abort permet à un élément de travail en cours
      // de téléverser les fichiers mémoire modifiés et de supprimer d'abord ses répertoires de magasin.
      export const shutdown = new AbortController();

      export async function handle(req: Request): Promise<Response> {
        // N'accusez jamais réception d'une livraison dont le travail ne s'exécutera pas ici ; un 503 fait réessayer l'expéditeur.
        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,
            // Le secret par session est ce qui permet au worker de monter les magasins de mémoire de la session.
            workSecret: work.secret ?? undefined,
            signal: shutdown.signal
          });
        }
        // Le poller et handleItem retournent silencieusement en cas d'abort, donc un drainage interrompu aboutit ici.
        if (shutdown.signal.aborted) {
          return Response.json({ status: "shutting down" }, { status: 503 });
        }
        return Response.json({ status: "ok" });
      }
      ```

      <CodeGroupItem language="C#">
        Le SDK C# ne dispose pas de `EnvironmentWorker`. Pour traiter des éléments de travail depuis votre propre code, implémentez votre propre worker, comme le décrit [Choisir un modèle de déploiement](https://platform.claude.com/docs/fr/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",
      	})
      	// Annulé sur SIGINT ou SIGTERM (défini dans main) afin qu'un élément de travail en cours puisse
      	// téléverser les fichiers de mémoire modifiés et supprimer ses répertoires de magasin avant de quitter.
      	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
      	}

      	// Le SDK Go ne fournit pas de raccourci RunOne : videz les éléments en attente
      	// avec WorkPoller et exécutez chacun avec HandleItem.
      	// Se détacher de r.Context() : la session peut durer plus longtemps que le délai de livraison du webhook.
      	// Le contexte d'arrêt global au processus termine tout de même l'élément proprement sur 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,
      			// Le secret par session permet au worker de monter les magasins de mémoire de la session.
      			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)
      		}
      	}()
      	// Sur un signal, cesser d'accepter les livraisons et ne retourner qu'une fois que les gestionnaires
      	// en cours, et donc le nettoyage mémoire de leurs éléments de travail, sont terminés.
      	<-ctx.Done()
      	if err := server.Shutdown(context.Background()); err != nil {
      		slog.Error("http shutdown", "err", err)
      	}
      }
      ```

      <CodeGroupItem language="Java">
        Le SDK Java ne dispose pas de `EnvironmentWorker`. Pour traiter des éléments de travail depuis votre propre code, implémentez votre propre worker, comme le décrit [Choisir un modèle de déploiement](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes-workers#choose-a-deployment-pattern).
      </CodeGroupItem>

      <CodeGroupItem language="PHP">
        Le SDK PHP ne dispose pas de `EnvironmentWorker`. Pour traiter des éléments de travail depuis votre propre code, implémentez votre propre worker, comme le décrit [Choisir un modèle de déploiement](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes-workers#choose-a-deployment-pattern).
      </CodeGroupItem>

      <CodeGroupItem language="Ruby">
        Le SDK Ruby ne dispose pas de `EnvironmentWorker`. Pour traiter des éléments de travail depuis votre propre code, implémentez votre propre worker, comme le décrit [Choisir un modèle de déploiement](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes-workers#choose-a-deployment-pattern).
      </CodeGroupItem>
    </CodeGroup>

    Dans les SDK Python, TypeScript et Go, `handle_item()` (typescript: `handleItem()`; go: `HandleItem()`) a besoin du secret de l’élément de travail pour monter les magasins de mémoire. Un worker qui interroge la file avec `run()` (go: `Run()`) dispose déjà du secret. Ce gestionnaire réclame lui-même chaque élément ; il transmet donc le secret dans l’argument `work_secret` (typescript: `workSecret`; go: `WorkSecret`). Consultez [Transmettre le secret de l’élément de travail](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes-per-session#forward-the-work-items-secret).
  </Step>
</Steps>

Ce gestionnaire exécute chaque élément réclamé dans un seul processus, et il exécute simultanément les éléments issus de livraisons de webhook distinctes. Ces sessions partagent un même système de fichiers, y compris `/workspace` et `/mnt/memory`. Si vos sessions attachent le même magasin de mémoire, consultez [Isoler les sessions qui partagent un magasin](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes-memory#isolate-sessions-that-share-a-store).

## Étapes suivantes

<CardGroup cols={2}>
  <Card title="Exécuter une sandbox par session" icon="cube" href="https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes-per-session">
    Lancez des sandboxes avec le chart Helm sur Kubernetes, un script de lancement ou le poller du SDK.
  </Card>

  <Card title="Surveiller et dépanner les workers auto-hébergés" icon="lightning" href="https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes-operations">
    Consultez la profondeur de la file, arrêtez proprement les sessions et les workers, et corrigez les défaillances courantes.
  </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 sandbox auto-hébergés.
  </Card>
</CardGroup>

## Disponibilité

Workers auto-hébergés préconstruits sont en bêta sur tous les modèles.

### Prise en charge de l’API

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

* Disponibilité : Disponible

| Statut | Plateformes cloud |
| ----- | ----- |
| Bêta | Claude API, [Claude Platform on AWS](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws) |

### En-têtes bêta requis

[Présentation des en-têtes bêta](https://platform.claude.com/docs/fr/api/beta-headers)

Les en-têtes bêta vous permettent d’accéder à des fonctionnalités expérimentales et à de nouvelles capacités des modèles avant qu’elles ne fassent partie de l’API standard.

* `managed-agents-2026-04-01`

### Traitement des données

[Présentation du traitement des données](https://platform.claude.com/docs/fr/manage-claude/api-and-data-retention#feature-eligibility)

| Élément | Zéro conservation des données | HIPAA |
| ----- | ----- | ----- |
| Statut | Non éligible | Non éligible |
| Détails | Non éligible à la ZDR, sauf pour Managed Agents auto-hébergé. Les sessions sont des ressources avec état ; les transcriptions persistent jusqu’à ce que vous les supprimiez. [En savoir plus](https://platform.claude.com/docs/fr/managed-agents/self-hosted-data-and-access#how-long-data-is-kept) | Non éligible à HIPAA. S’applique à toutes les sous-fonctionnalités de Managed Agents. |

Points de terminaison concernés :

* `/v1/agents`
* `/v1/sessions`
* `/v1/environments`
