---
title: Sécuriser votre déploiement Managed Agents
url: https://platform.claude.com/docs/fr/managed-agents/secure-deployment
description: Les paramètres qui limitent ce que vos agents peuvent atteindre et faire, du plus important au moins important.
featureMetadata:
topic:
title: Managed Agents
url: https://platform.claude.com/docs/en/managed-agents/overview
status: beta
betaHeader: managed-agents-2026-04-01
---
Ce guide répertorie les paramètres qui limitent ce qu'un agent sur Claude Managed Agents peut atteindre et faire, du plus important au moins important. Chaque section renvoie à la page qui couvre le paramètre en détail.
| Section | Paramètre ou décision | Recommandé |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Choisir où l'agent s'exécute](https://platform.claude.com/docs/fr/managed-agents/secure-deployment#choose-where-the-agent-runs) | Sandbox cloud ou auto-hébergé | Cloud, sauf si les outils doivent s'exécuter sur une infrastructure que vous contrôlez |
| [Limiter le réseau](https://platform.claude.com/docs/fr/managed-agents/secure-deployment#limit-the-network) | `networking.type` de l'environnement | `limited`, avec uniquement les hôtes dont l'agent a besoin |
| [Conserver les identifiants dans des coffres](https://platform.claude.com/docs/fr/managed-agents/secure-deployment#keep-credentials-in-vaults) | `injection_location` et `networking` sur chaque identifiant de variable d'environnement | En-têtes de requête uniquement, et réseau `limited` avec uniquement les hôtes auxquels la clé est destinée |
| [Restreindre la recherche web et la récupération web](https://platform.claude.com/docs/fr/managed-agents/secure-deployment#restrict-web-search-and-web-fetch) | `allowed_domains` sur chaque outil web | Une liste d'autorisation sur chaque outil. Sur `web_fetch`, listez uniquement les sites dont l'agent a besoin. Sur `web_search`, listez les sites dont vous souhaitez obtenir des résultats |
| [Approuver les actions risquées](https://platform.claude.com/docs/fr/managed-agents/secure-deployment#approve-risky-actions) | `permission_policy` sur chaque outil | `auto` sur `bash`, `write`, `edit`, `web_fetch` et les outils MCP qui ne font que lire des données. `always_ask` à la place sur un outil si vous ne pouvez pas annuler ses modifications en dehors du sandbox, ou si le texte relayé d'un utilisateur final ne devrait pas à lui seul le faire s'exécuter |
| [Donner à l'agent le plus petit ensemble d'outils](https://platform.claude.com/docs/fr/managed-agents/secure-deployment#give-the-agent-the-smallest-tool-set) | `default_config.enabled` sur l'ensemble d'outils de l'agent | `false`, puis activez les outils dont l'agent a besoin |
| [Tenir les entrées non fiables à l'écart des outils puissants](https://platform.claude.com/docs/fr/managed-agents/secure-deployment#keep-untrusted-input-away-from-powerful-tools) | Les outils et identifiants dont dispose un agent lorsqu'il lit des entrées non fiables | Aucun agent qui lit des entrées non fiables ne dispose d'un outil en `always_allow` qui écrit des fichiers, exécute des commandes ou modifie des enregistrements |
| [Définir des limites et un moyen d'arrêter](https://platform.claude.com/docs/fr/managed-agents/secure-deployment#set-limits-and-a-way-to-stop) | `budget` sur chaque session et déploiement | Un plafond dimensionné selon le coût attendu d'une exécution |
| [Faire éventuellement lire chaque transcription par un examinateur hors ligne](https://platform.claude.com/docs/fr/managed-agents/secure-deployment-monitoring#optionally-have-an-offline-reviewer-read-every-transcript) | Une tâche d'examen hors ligne que vous exécutez et qui lit les événements de chaque session | Facultatif. Un examen planifié de chaque session passée à l'état inactif ou terminée |
| [Surveiller les sessions et examiner la conservation](https://platform.claude.com/docs/fr/managed-agents/secure-deployment-monitoring#monitor-sessions-and-review-retention) | Webhooks et suppression de sessions | Une alerte lorsqu'une session devient inactive, atteint son budget ou se termine, et une vérification de la raison pour laquelle elle est devenue inactive. Stockez les événements que vous souhaitez conserver dans vos propres journaux, et supprimez les sessions dont vous n'avez plus besoin |
[Risques de sécurité et limites du sandbox](https://platform.claude.com/docs/fr/managed-agents/secure-deployment-risks) explique pourquoi ces paramètres sont importants et contre quoi ils ne protègent pas. Pour examiner et surveiller les sessions, consultez [Examiner et surveiller les sessions d'agent](https://platform.claude.com/docs/fr/managed-agents/secure-deployment-monitoring).
## Choisir où l'agent s'exécute
L'endroit où s'exécutent les outils de l'agent détermine qui sécurise le sandbox : Anthropic, avec un environnement cloud, ou vous, avec un sandbox auto-hébergé. Pour choisir entre les deux et savoir ce qui parvient à Anthropic dans chaque cas, consultez [Choisir un environnement d'agent](https://platform.claude.com/docs/fr/managed-agents/choosing-an-environment).
Si vous utilisez un [sandbox auto-hébergé](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes), gardez ces quatre points à l'esprit :
* **Réseau :** [Limiter le réseau](https://platform.claude.com/docs/fr/managed-agents/secure-deployment#limit-the-network) s'applique aux environnements cloud. Pour un sandbox auto-hébergé, définissez les limites équivalentes sur son trafic dans votre propre pare-feu. Votre pare-feu ne limite pas les serveurs MCP qu'un agent déclare, alors examinez-les, ainsi que ceux que votre application définit pour une session.
* **Outils web :** Les outils web s'exécutent sur les serveurs d'Anthropic, votre pare-feu ne les limite donc pas. Limitez-les avec leurs listes de domaines. Consultez [Restreindre la recherche web et la récupération web](https://platform.claude.com/docs/fr/managed-agents/secure-deployment#restrict-web-search-and-web-fetch).
* **Identifiants :** Les identifiants de variables d'environnement ne sont pas encore pris en charge avec les sandboxes auto-hébergés.
* **Isolation et durcissement :** Vous êtes responsable des deux. Consultez le [Modèle de sécurité](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes-security).
Aucune des deux options ne modifie la couverture de conformité de Managed Agents ni la durée pendant laquelle il conserve l'historique des sessions. Consultez [Surveiller les sessions et examiner la conservation](https://platform.claude.com/docs/fr/managed-agents/secure-deployment-monitoring#monitor-sessions-and-review-retention).
## Limiter le réseau
Définissez `networking.type` sur `limited` et listez uniquement les hôtes dont l'agent a besoin dans `allowed_hosts`. Une requête de création d'environnement qui omet `networking` peut obtenir `unrestricted`, alors définissez `networking` dans chaque requête de création. Consultez [Risques de la mise en réseau non restreinte](https://platform.claude.com/docs/fr/managed-agents/environments#risks-of-unrestricted-networking).
Les fichiers, les magasins de mémoire et les dépôts GitHub que vous attachez restent accessibles à l'agent, quel que soit `allowed_hosts`.
Les exemples de cette page utilisent un agent de support. Il lit le ticket d'un client, recherche la commande, lit votre centre d'aide et rédige une réponse. Votre application exécute la recherche de commande, qui ne nécessite aucun hôte, donc cet environnement autorise un seul hôte, le centre d'aide, pour `web_fetch` :
```bash cURL
curl -fsS 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": "support-agent",
"config": {
"type": "cloud",
"networking": {
"type": "limited",
"allowed_hosts": ["help.example.com"]
}
}
}'
```
```bash CLI
ant apply environment.yaml
```
```yaml
# yaml-language-server: $schema=https://platform.claude.com/schemas/ant/beta/environment.json
name: support-agent
config:
type: cloud
networking:
type: limited
allowed_hosts:
- help.example.com
```
```python Python
environment = client.beta.environments.create(
name="support-agent",
config={
"type": "cloud",
"networking": {
"type": "limited",
"allowed_hosts": ["help.example.com"],
},
},
)
```
```typescript TypeScript
const environment = await client.beta.environments.create({
name: "support-agent",
config: {
type: "cloud",
networking: {
type: "limited",
allowed_hosts: ["help.example.com"]
}
}
});
```
```csharp C#
using Anthropic.Models.Beta.Environments;
var environment = await client.Beta.Environments.Create(new()
{
Name = "support-agent",
Config = new BetaCloudConfigParams
{
Networking = new BetaLimitedNetworkParams
{
AllowedHosts = ["help.example.com"],
},
},
});
```
```go Go
environment, err := client.Beta.Environments.New(ctx, anthropic.BetaEnvironmentNewParams{
Name: "support-agent",
Config: anthropic.BetaEnvironmentNewParamsConfigUnion{
OfCloud: &anthropic.BetaCloudConfigParams{
Networking: anthropic.BetaCloudConfigParamsNetworkingUnion{
OfLimited: &anthropic.BetaLimitedNetworkParams{
AllowedHosts: []string{"help.example.com"},
},
},
},
},
})
if err != nil {
panic(err)
}
_ = environment
```
```java Java
import com.anthropic.models.beta.environments.*;
import java.util.List;
var environment = client.beta().environments().create(EnvironmentCreateParams.builder()
.name("support-agent")
.config(BetaCloudConfigParams.builder()
.networking(BetaLimitedNetworkParams.builder()
.allowedHosts(List.of("help.example.com"))
.build())
.build())
.build());
```
```php PHP
$environment = $client->beta->environments->create(
name: 'support-agent',
config: [
'type' => 'cloud',
'networking' => [
'type' => 'limited',
'allowed_hosts' => ['help.example.com'],
],
],
);
```
```ruby Ruby
environment = client.beta.environments.create(
name: "support-agent",
config: {
type: "cloud",
networking: {
type: "limited",
allowed_hosts: ["help.example.com"]
}
}
)
```
Un environnement `limited` possède trois paramètres réseau :
| Paramètre | Ce qu'il ouvre au code dans le sandbox | Recommandé |
| ------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `allowed_hosts` | Les hôtes que vous listez, pour toute requête | Uniquement les hôtes dont l'agent a besoin, y compris l'hôte de chaque serveur MCP que vous exploitez ou auquel vous faites confiance |
| `allow_package_managers` | Les [hôtes des gestionnaires de paquets](https://platform.claude.com/docs/fr/managed-agents/environments#package-manager-hosts). Ils incluent chaque dépôt et chemin sur `github.com`, `gitlab.com` et `bitbucket.org`, où n'importe qui peut publier du contenu et où le code dans le sandbox peut téléverser des fichiers | `false`, sauf si le paramètre `packages` de l'environnement liste des paquets, ce qui nécessite `true`. Si l'agent installe des paquets pendant son exécution, listez plutôt uniquement les hôtes de registre dont il a besoin dans `allowed_hosts` |
| `allow_mcp_servers` | Aucun hôte. Managed Agents se connecte aux serveurs MCP depuis les serveurs d'Anthropic | `false`, avec l'hôte de chaque serveur MCP que vous exploitez ou auquel vous faites confiance listé dans `allowed_hosts` |
Les paramètres `allow_package_managers` et `allow_mcp_servers` n'ajoutent aucun hôte pour la recherche web et la récupération web.
Laissez `allow_mcp_servers` désactivé, ce qui est la valeur par défaut, et listez l'hôte de chaque serveur MCP que vous exploitez ou auquel vous faites confiance dans `allowed_hosts`. Chaque hôte que vous listez est également ouvert au code dans le sandbox. Avec `allow_mcp_servers` désactivé, une vérification lors de la création de la session rejette la requête si l'hôte d'un serveur MCP n'est pas listé. Consultez [Fournir l'authentification à la création de la session](https://platform.claude.com/docs/fr/managed-agents/mcp-connector#provide-authentication-at-session-creation). La même vérification s'exécute lorsqu'une mise à jour de session modifie `mcp_servers`.
L'accès réseau est accordé pour chaque hôte, et non pour chaque opération. Le sandbox peut envoyer n'importe quelle requête à un hôte autorisé, y compris des téléversements tels que `git push` et la publication de paquets. Il peut également utiliser n'importe quel identifiant fourni par la commande, même un identifiant que quelqu'un a dissimulé dans un texte que l'agent lit.
Lorsque vous choisissez les hôtes pour `allowed_hosts`, suivez ces deux règles :
* Listez uniquement les hôtes que vous exploitez ou auxquels vous faites confiance.
* Évitez les caractères génériques `*.` et les domaines d'hébergement partagé où n'importe qui peut publier du contenu.
Si l'agent conserve `bash`, définissez la [politique d'autorisation](https://platform.claude.com/docs/fr/managed-agents/permission-policies) de l'outil `bash` comme le décrit [Approuver les actions risquées](https://platform.claude.com/docs/fr/managed-agents/secure-deployment#approve-risky-actions).
Après avoir restreint davantage un environnement, démarrez de nouvelles sessions et arrêtez celles qui étaient déjà en cours d'exécution. Une session déjà en cours d'exécution peut conserver les anciennes limites jusqu'à sa fin. Consultez [Définir des limites et un moyen d'arrêter](https://platform.claude.com/docs/fr/managed-agents/secure-deployment#set-limits-and-a-way-to-stop).
Consultez [Configuration de l'environnement cloud](https://platform.claude.com/docs/fr/managed-agents/environments#networking) pour tous les paramètres réseau.
## Conserver les identifiants dans des coffres
Stockez chaque secret dans un coffre (vault). Pour chaque identifiant de variable d'environnement, définissez l'emplacement d'injection sur les en-têtes de requête uniquement et listez uniquement les hôtes auxquels le secret est destiné. Le code dans le sandbox voit un espace réservé au lieu du secret. Managed Agents substitue le vrai secret uniquement dans les requêtes HTTPS sortantes vers les hôtes que l'identifiant autorise. Le secret reste ainsi hors de portée directe du modèle, sauf si un service le renvoie, comme un point de terminaison qui renvoie en écho les en-têtes de requête. Si le `networking` de l'identifiant est `unrestricted`, Managed Agents substitue le vrai secret dans les requêtes vers tout hôte que l'environnement permet au sandbox d'atteindre. Pour utiliser un coffre, transmettez son ID dans `vault_ids` lorsque vous créez la session ou le déploiement.
| Paramètre | Valeur à définir | Pourquoi | Ce qu'il ne fait pas |
| ------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `injection_location` | `{"header": true, "body": false}`, après avoir vérifié que le service lit la clé depuis un en-tête | Les corps de requête sont souvent construits à partir du contenu que l'agent lit, donc une clé dans un corps est plus exposée. Nommez les deux champs : une requête de création qui omet l'objet active les deux emplacements, et une mise à jour ne modifie que les champs que vous envoyez | Le code peut toujours utiliser la clé sur chaque hôte que l'identifiant autorise. Un service qui attend la clé dans le corps reçoit l'espace réservé et rejette la requête |
| `networking` sur l'identifiant | `limited`, avec les hôtes exacts auxquels la clé est destinée | Les réponses parviennent au sandbox sans masquage, alors évitez les caractères génériques, les domaines d'hébergement partagé et les hôtes qui renvoient en écho les en-têtes de requête | Il n'ouvre pas l'hôte. L'environnement doit également l'autoriser |
| Les autorisations de la clé, auprès du service qui l'a émise | Uniquement les autorisations dont l'agent a besoin | L'agent peut faire tout ce que la clé permet | Sans objet |
| Le jeton GitHub d'un dépôt monté | Un [jeton à granularité fine](https://platform.claude.com/docs/fr/managed-agents/github#token-permissions) avec les autorisations minimales | Le code dans le sandbox peut l'utiliser pour récupérer depuis le dépôt monté et y pousser pendant toute la session. N'accordez l'accès en écriture que si l'agent doit pousser | Sans objet |
L'agent de support n'a besoin d'aucun identifiant de coffre, car votre application détient la clé API de votre API de commandes. Si votre agent détient un identifiant de coffre, consultez [Ajouter un identifiant](https://platform.claude.com/docs/fr/managed-agents/vaults#add-a-credential) pour la requête dans chaque langage.
Gardez les clés hors des invites système, des définitions d'agent et des messages. Ne donnez pas de clé API Claude à l'agent. Même lorsqu'une clé API Claude se trouve dans un coffre, le code dans le sandbox peut l'utiliser pour appeler directement l'API Claude. Il peut faire tout ce que cette clé permet, comme démarrer ou supprimer des sessions, ou utiliser la recherche web et la récupération web. Les paramètres d'outils, les approbations et le budget de l'agent ne s'appliquent pas à ces appels. Dans un environnement `limited`, le code ne peut effectuer ces appels que si `allowed_hosts` permet au sandbox d'atteindre `api.anthropic.com`.
Récupérez vous-même les jetons et stockez-les dans le coffre, car un jeton que le code dans le sandbox récupère avec un secret stocké revient sans masquage.
Conservez les coffres des charges de travail ayant des niveaux de confiance différents dans des [espaces de travail](https://platform.claude.com/docs/fr/manage-claude/workspaces) distincts, car toute clé API ayant accès à un espace de travail peut référencer ses coffres. Utilisez des clés API limitées à un seul espace de travail.
Consultez [S'authentifier avec des coffres-forts](https://platform.claude.com/docs/fr/managed-agents/vaults) pour les identifiants MCP et la rotation.
## Restreindre la recherche web et la récupération web
Définissez `allowed_domains` sur `web_fetch` avec les sites dont l'agent a besoin. Toute URL que l'agent récupère peut transporter des données vers le site vers lequel elle pointe, cette liste est donc un contrôle de sécurité. Sur `web_search`, définissez `allowed_domains` avec les sites dont vous souhaitez obtenir des résultats, afin que les résultats proviennent uniquement de sites auxquels vous faites confiance pour leur exactitude. La liste n'empêche pas la requête de recherche d'atteindre le fournisseur de recherche. Les résultats de recherche incluent du texte provenant de pages, la liste limite donc aussi les sites dont le texte parvient à l'agent. Définissez `allowed_domains` sur les deux outils pour chaque type d'environnement.
Une liste `blocked_domains` bloque les hôtes que vous listez et leurs sous-domaines, et aucun autre hôte. Le même contenu peut toujours parvenir à l'agent depuis des archives web, des caches, des miroirs ou des domaines apparentés que vous n'avez pas listés. Ne comptez pas sur `blocked_domains` pour la sécurité. Utilisez `allowed_domains` et nommez les hôtes auxquels vous faites confiance.
Dans un environnement `limited`, la liste `allowed_hosts` de [Limiter le réseau](https://platform.claude.com/docs/fr/managed-agents/secure-deployment#limit-the-network) limite également les outils web. Un environnement `unrestricted` ou un sandbox auto-hébergé ne limite pas les outils web.
| Dans un environnement `limited` | Résultat |
| ------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Une entrée `allowed_domains` sur un outil web activé est en dehors de `allowed_hosts` | La création d'une session échoue avec une erreur 400, tout comme une mise à jour de session qui ajoute une telle entrée. Une session qu'un déploiement démarre, selon sa planification ou par une exécution manuelle, est tout de même créée. L'outil ne renvoie alors rien depuis les hôtes en dehors de `allowed_hosts` |
| Un outil web n'a pas de liste propre | L'outil renvoie des pages et des résultats uniquement depuis les hôtes de `allowed_hosts`. Définissez également `allowed_domains` sur l'outil |
| `allowed_hosts` ne contient aucune entrée | Aucun des deux outils web ne renvoie de page ni de résultat de recherche |
| Vous ajoutez un hôte à `allowed_hosts` pour un outil web | L'hôte est également ouvert au code dans le sandbox |
Les deux listes font correspondre les hôtes différemment :
| Liste | Entrée | Correspond à | Ne correspond pas à |
| ------------------------------- | --------------- | ------------------------------------ | ------------------- |
| `allowed_hosts` (environnement) | `example.com` | `example.com` | `www.example.com` |
| `allowed_hosts` (environnement) | `*.example.com` | Chaque sous-domaine | `example.com` |
| `allowed_domains` (outil web) | `example.com` | `example.com` et chaque sous-domaine | Les autres domaines |
Si l'agent a besoin d'un site et de tous ses sous-domaines, listez à la fois `example.com` et `*.example.com` dans `allowed_hosts`, et sinon listez des hôtes exacts. Si un outil liste `example.com` et que `allowed_hosts` liste uniquement `*.example.com`, la session est créée. La vérification lors de la création de la session considère `example.com` comme inclus dans `*.example.com`, mais l'outil ne renvoie rien depuis `example.com` lui-même. Consultez [Définir des listes de domaines sur un agent](https://platform.claude.com/docs/fr/managed-agents/tools-web-restrictions#set-domain-lists-on-an-agent) pour savoir comment les deux listes font correspondre les hôtes.
L'outil `web_fetch` n'ouvre également que les URL qui sont déjà apparues dans la session :
| Où l'URL apparaît | `web_fetch` peut l'ouvrir |
| -------------------------------------------------------------------------------------------------------- | ---------------------------------------------------- |
| Le texte d'un message utilisateur, y compris le texte d'un utilisateur final que vous relayez | Oui |
| La description d'un événement `user.define_outcome` | Oui |
| L'adresse d'un résultat de recherche web | Oui |
| Le texte d'une page que `web_fetch` a renvoyée précédemment (pas un PDF), où l'URL complète est affichée | Oui |
| Le texte du résultat d'un outil personnalisé, lorsque Claude a appelé l'outil directement | Oui, sauf si le résultat est marqué `is_error: true` |
| L'invite système | Non |
| La configuration de l'agent, y compris les entrées `allowed_domains` | Non |
| La sortie de Claude lui-même | Non |
| La sortie de `bash` et des autres outils du sandbox | Non |
| Le résultat d'un outil MCP | Non |
| Un fichier joint à un message utilisateur | Non |
Dans une session multi-agents, `web_fetch` n'ouvre une URL provenant d'un autre agent que si elle a atteint cet agent par une source marquée Oui. Le résultat d'un outil personnalisé issu d'un appel direct compte comme une source marquée Oui. Cela reste vrai même si Claude a écrit son texte, par exemple lorsque l'outil répète son entrée. Une URL peut compter même lorsqu'elle est écrite sans `https://`, comme `example.com/docs`. L'outil `web_fetch` ne peut pas toujours ouvrir un lien qui affiche des mots au lieu de son URL, comme « Contacter le support ». Si l'agent doit récupérer une URL qui n'est pas apparue dans la session, envoyez-la dans un message utilisateur.
Cette règle réduit le risque qu'un texte injecté construise une URL transportant des données privées. Le texte des utilisateurs finaux, les résultats de recherche, les pages récupérées et les résultats d'outils personnalisés peuvent toujours ajouter des URL, alors gardez `allowed_domains` défini. L'API Messages applique une règle similaire avec une liste de sources différente. Consultez [Validation des URL](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/web-fetch-tool#url-validation).
Une liste de domaines sur `web_fetch` ne limite pas l'outil `bash`. [Limitez également le réseau](https://platform.claude.com/docs/fr/managed-agents/secure-deployment#limit-the-network). Consultez [Règles des listes de domaines](https://platform.claude.com/docs/fr/managed-agents/tools-web-restrictions#domain-list-rules).
## Approuver les actions risquées
Définissez `auto` sur `bash`, `write`, `edit` et `web_fetch`, ainsi que sur les outils MCP qui ne font que lire des données. Utilisez plutôt `always_ask` sur un outil si vous ne pouvez pas annuler ses modifications en dehors du sandbox. Utilisez-le également sur un outil qui ne devrait pas s'exécuter simplement parce que le texte d'un utilisateur final que vous relayez le demande. Une [politique d'autorisation](https://platform.claude.com/docs/fr/managed-agents/permission-policies) détermine si un appel d'outil s'exécute, attend votre approbation ou est évalué par le serveur.
| Outil | Politique recommandée | Pourquoi |
| ------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `read`, `glob`, `grep` | `always_allow` | Ils lisent des fichiers dans le sandbox et ne modifient rien |
| `bash`, `write`, `edit` | `auto`. Utilisez `always_ask` sur un outil si vous ne pouvez pas annuler ses modifications en dehors du sandbox. Utilisez `always_ask` sur `bash` si vous relayez le texte d'utilisateurs finaux | La valeur par défaut de l'ensemble d'outils de l'agent est `always_allow`, qui exécute chaque appel sans approbation |
| `web_fetch` | `auto` | Une URL que l'agent récupère peut transporter des données vers le site vers lequel elle pointe |
| `web_search` | `always_ask` si l'agent traite des données que vous ne voudriez pas voir envoyées dans une requête de recherche. Sinon `always_allow` | `allowed_domains` limite les sites dont proviennent les résultats, et non le contenu de la requête |
| Outils MCP qui ne font que lire des données | `auto`, défini pour chaque outil dans les `configs` de l'ensemble d'outils | La valeur par défaut de l'ensemble d'outils reste `always_ask`, donc un outil que le serveur MCP ajoute ultérieurement attend toujours une approbation |
| Outils MCP qui modifient des données | `always_ask` | C'est la valeur par défaut de l'ensemble d'outils MCP. Conservez-la |
| Outils personnalisés | Votre code décide si chaque appel s'exécute | Les politiques d'autorisation ne s'appliquent pas |
L'ensemble d'outils de [Donner à l'agent le plus petit ensemble d'outils](https://platform.claude.com/docs/fr/managed-agents/secure-deployment#give-the-agent-the-smallest-tool-set) applique ces politiques.
La [politique `auto`](https://platform.claude.com/docs/fr/managed-agents/permission-policies#let-the-server-evaluate-each-call-with-auto) permet au serveur d'exécuter un appel, de le refuser ou de se mettre en pause pour approbation. Une personne ne peut pas approuver chaque appel d'une longue exécution, le serveur vérifie donc chacun d'eux à sa place. Associez `auto` à un réseau limité, une clé aux autorisations restreintes, un budget et une alerte sur les sessions inactives. `auto` n'est pas un point de contrôle humain, donc si une personne doit examiner les appels d'un outil avant leur exécution, configurez `always_ask` sur cet outil.
`auto` traite le texte des événements `user.message` et la description d'un événement `user.define_outcome` comme votre instruction, y compris le texte d'utilisateurs finaux que vous relayez.
Une session en pause attend indéfiniment, donc une session sans surveillance a besoin d'un client qui répond aux appels en pause ou interrompt la session.
Examinez chaque appel en pause avant de l'autoriser. Un client qui autorise chaque appel sans le montrer à une personne équivaut à `always_allow`. Consultez [Répondre aux demandes de confirmation](https://platform.claude.com/docs/fr/managed-agents/permission-policies#respond-to-confirmation-requests) et [Voir comment chaque appel a été évalué](https://platform.claude.com/docs/fr/managed-agents/permission-policies#see-how-each-call-was-evaluated).
## Donner à l'agent le plus petit ensemble d'outils
Définissez `default_config.enabled` sur `false` et [activez uniquement les outils dont l'agent a besoin](https://platform.claude.com/docs/fr/managed-agents/tools#enabling-only-specific-tools). L'ensemble d'outils de l'agent active par défaut les huit outils intégrés.
| Outil | Ce qu'il fait |
| ------------------------- | -------------------------------------------------------------------------------------- |
| `bash` | Exécute n'importe quelle commande, y compris des requêtes vers les hôtes autorisés |
| `write`, `edit` | Modifient des fichiers dans le sandbox |
| `read`, `glob`, `grep` | Lisent des fichiers dans le sandbox |
| `web_fetch`, `web_search` | Renvoient des pages et des résultats de recherche du web, via les serveurs d'Anthropic |
L'agent de support a besoin de trois outils intégrés : `read` et `write` pour son brouillon, et `web_fetch` pour le centre d'aide. Il recherche les commandes via un [outil personnalisé](https://platform.claude.com/docs/fr/managed-agents/tools#custom-tools), `lookup_order`, que votre application exécute. Votre application détient la clé API de votre API de commandes, l'agent n'a donc besoin ni de `bash` ni d'un identifiant.
L'exemple suivant limite `web_fetch` à `help.example.com` avec `allowed_domains`. Il définit `auto` sur `write` et `web_fetch`, comme le recommande [Approuver les actions risquées](https://platform.claude.com/docs/fr/managed-agents/secure-deployment#approve-risky-actions). Si le ticket d'un client amène l'agent à utiliser ces outils, l'agent peut uniquement modifier des fichiers dans le sandbox ou ouvrir des pages du centre d'aide. C'est pourquoi aucun des deux outils n'a besoin de `always_ask`. L'exemple définit également `always_ask` dans `default_config`, de sorte qu'un outil que vous activez ultérieurement sans politique propre utilise `always_ask` :
```bash cURL
tools='[
{
"type": "agent_toolset_20260401",
"default_config": {
"enabled": false,
"permission_policy": {"type": "always_ask"}
},
"configs": [
{"name": "read", "enabled": true, "permission_policy": {"type": "always_allow"}},
{"name": "write", "enabled": true, "permission_policy": {"type": "auto"}},
{
"name": "web_fetch",
"enabled": true,
"allowed_domains": ["help.example.com"],
"permission_policy": {"type": "auto"}
}
]
},
{
"type": "custom",
"name": "lookup_order",
"description": "Look up one order by its ID. Returns the status, the items, and the delivery date.",
"input_schema": {
"type": "object",
"properties": {
"order_id": {"type": "string", "description": "The order ID from the ticket"}
},
"required": ["order_id"]
}
}
]'
```
```bash CLI
ant apply agent.md
```
```markdown
---
name: Support Agent
model: claude-opus-5-5
tools:
- type: agent_toolset_20260401
default_config:
enabled: false
permission_policy:
type: always_ask
configs:
- name: read
enabled: true
permission_policy:
type: always_allow
- name: write
enabled: true
permission_policy:
type: auto
- name: web_fetch
enabled: true
allowed_domains: [help.example.com]
permission_policy:
type: auto
- type: custom
name: lookup_order
description: Look up one order by its ID. Returns the status, the items, and the delivery date.
input_schema:
type: object
properties:
order_id:
type: string
description: The order ID from the ticket
required:
- order_id
---
```
```python Python
tools = [
{
"type": "agent_toolset_20260401",
"default_config": {
"enabled": False,
"permission_policy": {"type": "always_ask"},
},
"configs": [
{
"name": "read",
"enabled": True,
"permission_policy": {"type": "always_allow"},
},
{
"name": "write",
"enabled": True,
"permission_policy": {"type": "auto"},
},
{
"name": "web_fetch",
"enabled": True,
"allowed_domains": ["help.example.com"],
"permission_policy": {"type": "auto"},
},
],
},
{
"type": "custom",
"name": "lookup_order",
"description": "Look up one order by its ID. Returns the status, the items, and the delivery date.",
"input_schema": {
"type": "object",
"properties": {
"order_id": {
"type": "string",
"description": "The order ID from the ticket",
},
},
"required": ["order_id"],
},
},
]
```
```typescript TypeScript
const tools = [
{
type: "agent_toolset_20260401",
default_config: {
enabled: false,
permission_policy: { type: "always_ask" }
},
configs: [
{
name: "read",
enabled: true,
permission_policy: { type: "always_allow" }
},
{
name: "write",
enabled: true,
permission_policy: { type: "auto" }
},
{
name: "web_fetch",
enabled: true,
allowed_domains: ["help.example.com"],
permission_policy: { type: "auto" }
}
]
},
{
type: "custom",
name: "lookup_order",
description:
"Look up one order by its ID. Returns the status, the items, and the delivery date.",
input_schema: {
type: "object",
properties: {
order_id: { type: "string", description: "The order ID from the ticket" }
},
required: ["order_id"]
}
}
] satisfies Anthropic.Beta.AgentCreateParams["tools"];
```
```csharp C#
using System.Text.Json;
using Anthropic.Models.Beta.Agents;
using Tool = Anthropic.Models.Beta.Agents.Tool;
Tool[] tools =
[
new BetaManagedAgentsAgentToolset20260401Params
{
Type = BetaManagedAgentsAgentToolset20260401ParamsType.AgentToolset20260401,
DefaultConfig = new()
{
Enabled = false,
PermissionPolicy = new BetaManagedAgentsAlwaysAskPolicy { Type = "always_ask" },
},
Configs =
[
new BetaManagedAgentsReadToolConfigParams
{
Enabled = true,
PermissionPolicy = new BetaManagedAgentsAlwaysAllowPolicy { Type = "always_allow" },
},
new BetaManagedAgentsWriteToolConfigParams
{
Enabled = true,
PermissionPolicy = new BetaManagedAgentsAutoPolicy(),
},
new BetaManagedAgentsWebFetchToolConfigParams
{
Enabled = true,
AllowedDomains = ["help.example.com"],
PermissionPolicy = new BetaManagedAgentsAutoPolicy(),
},
],
},
new BetaManagedAgentsCustomToolParams
{
Type = "custom",
Name = "lookup_order",
Description = "Look up one order by its ID. Returns the status, the items, and the delivery date.",
InputSchema = new()
{
Properties = new Dictionary
{
["order_id"] = JsonSerializer.SerializeToElement(
new { type = "string", description = "The order ID from the ticket" }
),
},
Required = ["order_id"],
},
},
];
```
```go Go
tools := []anthropic.BetaAgentNewParamsToolUnion{{
OfAgentToolset20260401: &anthropic.BetaManagedAgentsAgentToolset20260401Params{
Type: anthropic.BetaManagedAgentsAgentToolset20260401ParamsTypeAgentToolset20260401,
DefaultConfig: anthropic.BetaManagedAgentsAgentToolsetDefaultConfigParams{
Enabled: anthropic.Bool(false),
PermissionPolicy: anthropic.BetaManagedAgentsAgentToolsetDefaultConfigParamsPermissionPolicyUnion{
OfAlwaysAsk: &anthropic.BetaManagedAgentsAlwaysAskPolicyParam{
Type: anthropic.BetaManagedAgentsAlwaysAskPolicyTypeAlwaysAsk,
},
},
},
Configs: []anthropic.BetaManagedAgentsAgentToolConfigParamsUnion{
{OfRead: &anthropic.BetaManagedAgentsReadToolConfigParams{
Enabled: anthropic.Bool(true),
PermissionPolicy: anthropic.BetaManagedAgentsReadToolConfigParamsPermissionPolicyUnion{
OfAlwaysAllow: &anthropic.BetaManagedAgentsAlwaysAllowPolicyParam{
Type: anthropic.BetaManagedAgentsAlwaysAllowPolicyTypeAlwaysAllow,
},
},
}},
{OfWrite: &anthropic.BetaManagedAgentsWriteToolConfigParams{
Enabled: anthropic.Bool(true),
PermissionPolicy: anthropic.BetaManagedAgentsWriteToolConfigParamsPermissionPolicyUnion{
OfAuto: &anthropic.BetaManagedAgentsAutoPolicyParam{},
},
}},
{OfWebFetch: &anthropic.BetaManagedAgentsWebFetchToolConfigParams{
AllowedDomains: []string{"help.example.com"},
Enabled: anthropic.Bool(true),
PermissionPolicy: anthropic.BetaManagedAgentsWebFetchToolConfigParamsPermissionPolicyUnion{
OfAuto: &anthropic.BetaManagedAgentsAutoPolicyParam{},
},
}},
},
},
}, {
OfCustom: &anthropic.BetaManagedAgentsCustomToolParams{
Type: anthropic.BetaManagedAgentsCustomToolParamsTypeCustom,
Name: "lookup_order",
Description: "Look up one order by its ID. Returns the status, the items, and the delivery date.",
InputSchema: anthropic.BetaManagedAgentsCustomToolInputSchemaParam{
Properties: map[string]any{
"order_id": map[string]any{
"type": "string",
"description": "The order ID from the ticket",
},
},
Required: []string{"order_id"},
},
},
}}
_ = tools
```
```java Java
import com.anthropic.core.JsonValue;
import com.anthropic.models.beta.agents.*;
import java.util.List;
import java.util.Map;
var tools = List.of(
AgentCreateParams.Tool.ofAgentToolset20260401(
BetaManagedAgentsAgentToolset20260401Params.builder()
.type(BetaManagedAgentsAgentToolset20260401Params.Type.AGENT_TOOLSET_20260401)
.defaultConfig(
BetaManagedAgentsAgentToolsetDefaultConfigParams.builder()
.enabled(false)
.permissionPolicy(
BetaManagedAgentsAlwaysAskPolicy.builder()
.type(BetaManagedAgentsAlwaysAskPolicy.Type.ALWAYS_ASK)
.build()
)
.build()
)
.addConfig(
BetaManagedAgentsReadToolConfigParams.builder()
.enabled(true)
.permissionPolicy(
BetaManagedAgentsAlwaysAllowPolicy.builder()
.type(BetaManagedAgentsAlwaysAllowPolicy.Type.ALWAYS_ALLOW)
.build()
)
.build()
)
.addConfig(
BetaManagedAgentsWriteToolConfigParams.builder()
.enabled(true)
.permissionPolicy(BetaManagedAgentsAutoPolicy.builder().build())
.build()
)
.addConfig(
BetaManagedAgentsWebFetchToolConfigParams.builder()
.enabled(true)
.allowedDomains(List.of("help.example.com"))
.permissionPolicy(BetaManagedAgentsAutoPolicy.builder().build())
.build()
)
.build()
),
AgentCreateParams.Tool.ofCustom(
BetaManagedAgentsCustomToolParams.builder()
.type(BetaManagedAgentsCustomToolParams.Type.CUSTOM)
.name("lookup_order")
.description("Look up one order by its ID. Returns the status, the items, and the delivery date.")
.inputSchema(
BetaManagedAgentsCustomToolInputSchema.builder()
.properties(
BetaManagedAgentsCustomToolInputSchema.Properties.builder()
.putAdditionalProperty("order_id", JsonValue.from(Map.of(
"type", "string",
"description", "The order ID from the ticket")))
.build()
)
.addRequired("order_id")
.build()
)
.build()
)
);
```
```php PHP
use Anthropic\Beta\Agents\BetaManagedAgentsAgentToolset20260401Params;
use Anthropic\Beta\Agents\BetaManagedAgentsAgentToolsetDefaultConfigParams;
use Anthropic\Beta\Agents\BetaManagedAgentsAlwaysAllowPolicy;
use Anthropic\Beta\Agents\BetaManagedAgentsAlwaysAskPolicy;
use Anthropic\Beta\Agents\BetaManagedAgentsAutoPolicy;
use Anthropic\Beta\Agents\BetaManagedAgentsCustomToolInputSchema;
use Anthropic\Beta\Agents\BetaManagedAgentsCustomToolParams;
use Anthropic\Beta\Agents\BetaManagedAgentsReadToolConfigParams;
use Anthropic\Beta\Agents\BetaManagedAgentsWebFetchToolConfigParams;
use Anthropic\Beta\Agents\BetaManagedAgentsWriteToolConfigParams;
$tools = [
BetaManagedAgentsAgentToolset20260401Params::with(
type: 'agent_toolset_20260401',
defaultConfig: BetaManagedAgentsAgentToolsetDefaultConfigParams::with(
enabled: false,
permissionPolicy: BetaManagedAgentsAlwaysAskPolicy::with(type: 'always_ask'),
),
configs: [
BetaManagedAgentsReadToolConfigParams::with(
enabled: true,
permissionPolicy: BetaManagedAgentsAlwaysAllowPolicy::with(type: 'always_allow'),
),
BetaManagedAgentsWriteToolConfigParams::with(
enabled: true,
permissionPolicy: BetaManagedAgentsAutoPolicy::with(),
),
BetaManagedAgentsWebFetchToolConfigParams::with(
allowedDomains: ['help.example.com'],
enabled: true,
permissionPolicy: BetaManagedAgentsAutoPolicy::with(),
),
],
),
BetaManagedAgentsCustomToolParams::with(
type: 'custom',
name: 'lookup_order',
description: 'Look up one order by its ID. Returns the status, the items, and the delivery date.',
inputSchema: BetaManagedAgentsCustomToolInputSchema::with(
properties: ['order_id' => ['type' => 'string', 'description' => 'The order ID from the ticket']],
required: ['order_id'],
),
),
];
```
```ruby Ruby
tools = [
{
type: "agent_toolset_20260401",
default_config: {
enabled: false,
permission_policy: {type: "always_ask"}
},
configs: [
{
name: "read",
enabled: true,
permission_policy: {type: "always_allow"}
},
{
name: "write",
enabled: true,
permission_policy: {type: "auto"}
},
{
name: "web_fetch",
enabled: true,
allowed_domains: ["help.example.com"],
permission_policy: {type: "auto"}
}
]
},
{
type: "custom",
name: "lookup_order",
description: "Look up one order by its ID. Returns the status, the items, and the delivery date.",
input_schema: {
type: "object",
properties: {order_id: {type: "string", description: "The order ID from the ticket"}},
required: ["order_id"]
}
}
]
```
Une [mise à jour d'agent](https://platform.claude.com/docs/fr/managed-agents/agent-setup#update-semantics) remplace l'intégralité du tableau `tools`, alors envoyez chaque entrée que vous souhaitez conserver.
Une mise à jour d'agent n'atteint que les nouvelles sessions, vérifiez donc également les déploiements, les agents qui listent cet agent et les sessions existantes :
* Un déploiement épingle une version d'agent, alors faites pointer chaque déploiement vers la nouvelle.
* Un agent qui liste celui-ci dans [`subagents.predefined_agents`](https://platform.claude.com/docs/fr/managed-agents/multiagent-orchestration#list-the-subagents) ou `workflows.predefined_agents` conserve la version qu'il a épinglée, alors mettez également cet agent à jour.
* Pour restreindre davantage une session qui existe déjà, [mettez à jour les outils de cette session](https://platform.claude.com/docs/fr/managed-agents/session-operations#updating-the-agent-configuration). La session doit être `idle`, et la mise à jour remplace l'intégralité du tableau `tools`. Dans une session multi-agents, les nouvelles listes `allowed_domains` et `blocked_domains` sur les outils web de l'agent que la session exécute s'appliquent également à tous les autres agents. Elles s'appliquent à partir du tour suivant de chaque agent. Les outils activés et les politiques d'autorisation de ces agents ne changent pas. Pour les modifier, mettez à jour chaque agent, puis démarrez une nouvelle session.
Limitez également les serveurs MCP et les outils personnalisés à ce dont l'agent a besoin :
* **Serveurs MCP :** Un ensemble d'outils MCP active par défaut chaque outil que le serveur expose. Définissez `default_config.enabled` sur `false` et activez des outils nommés, afin que les outils qu'un serveur ajoute ultérieurement restent désactivés. Supprimez les serveurs que l'agent n'utilise pas. Consultez [Connecteur MCP](https://platform.claude.com/docs/fr/managed-agents/mcp-connector#configure-which-mcp-tools-are-available).
* **Outils personnalisés :** Votre application les exécute, et les politiques d'autorisation ne s'appliquent pas. Validez l'entrée de chaque appel dans votre application et limitez ce que l'outil peut toucher.
## Tenir les entrées non fiables à l'écart des outils puissants
Vérifiez les outils et identifiants dont dispose un agent chaque fois qu'il lit des entrées non fiables, c'est-à-dire du texte que quelqu'un en dehors de votre équipe peut écrire. Cette section utilise deux termes :
* **Entrées non fiables :** Pages web, résultats de recherche, tickets de support, e-mails, fichiers de dépôt, téléversements, résultats de serveurs MCP et messages d'utilisateurs finaux que vous relayez.
* **Outils puissants :** `bash`, `write`, `edit`, `web_fetch`, `web_search`, les outils MCP et outils personnalisés qui écrivent ou envoient des données, et tout outil qui utilise un identifiant.
Le texte d'une entrée non fiable peut demander à l'agent d'utiliser un outil puissant dont il dispose. L'agent de support lit des tickets, il n'accède donc à votre API de commandes que via l'outil personnalisé `lookup_order`. Votre application vérifie que la commande appartient à l'expéditeur du ticket.
| Entrée que l'agent lit | Pouvoir dont il dispose également | Action à mener |
| ----------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Tickets, e-mails ou téléversements | `bash` avec un identifiant | Remplacez `bash` par un outil personnalisé qui fait une seule chose. Si l'agent doit conserver `bash`, approuvez chaque appel avec `always_ask` |
| Pages web ou résultats de recherche | Écriture de fichiers ou modification d'enregistrements | Désactivez les outils web, ou limitez-les aux sites que vous exploitez ou auxquels vous faites confiance |
| Résultats MCP ou fichiers de dépôt | Outils MCP qui écrivent | Conservez l'ensemble d'outils MCP sur `always_ask`, et activez uniquement les outils dont l'agent a besoin |
| Un dépôt GitHub monté | N'importe quel outil | Montez uniquement des dépôts auxquels vous faites confiance. Un agent disposant de `read` charge les skills du répertoire `.claude/skills` du dépôt comme instructions d'agent, sans étape de révision. Consultez [Charger des skills depuis un dépôt GitHub](https://platform.claude.com/docs/fr/managed-agents/skills#load-skills-from-a-github-repository) |
| Toute entrée non fiable | Écriture dans un [magasin de mémoire](https://platform.claude.com/docs/fr/managed-agents/memory#attach-a-memory-store-to-a-session) | Attachez le magasin en `read_only` sauf si l'agent doit écrire. La valeur par défaut est `read_write`, et les sessions ultérieures lisent le texte enregistré comme une mémoire de confiance |
Dans un environnement cloud, la lecture d'un fichier avec `read` peut également charger des fichiers `CLAUDE.md` et `AGENTS.md` comme instructions. Ils sont chargés depuis le répertoire du fichier et ses répertoires parents, jusqu'au répertoire de travail du sandbox. Les fichiers qu'ils référencent avec `@` et un chemin, comme `@docs/setup.md`, sont également chargés, jusqu'à cinq niveaux de références. Une référence peut pointer n'importe où dans le sandbox, par exemple `@/etc/hosts`. Aucun paramètre ne désactive ce comportement, hormis la désactivation de `read`, alors traitez un dépôt, un paquet ou une archive que quelqu'un en dehors de votre équipe peut écrire comme une entrée non fiable.
Lorsqu'un agent doit lire des entrées non fiables et également agir, ce guide recommande l'une de trois conceptions :
* **Séparer la lecture de l'action.** Dans une même session multi-agents, un [agent principal](https://platform.claude.com/docs/fr/managed-agents/multiagent-orchestration#list-the-subagents) confie des tâches à un récupérateur, qui lit le web, et à un rédacteur, qui modifie des fichiers ou des enregistrements.
* **Donner à l'agent un seul outil personnalisé restreint.** Votre application exécute l'outil, vérifie son entrée et détient l'identifiant. L'agent de support utilise cette conception, et non la séparation. Consultez [Répondre aux appels d'outils qui mettent la session en pause](https://platform.claude.com/docs/fr/managed-agents/events-and-streaming#answer-tool-calls-that-pause-the-session).
* **Garder une personne dans la boucle.** Utilisez `always_ask` sur l'outil puissant afin qu'une personne approuve chaque appel.
La séparation utilise trois agents :
| Agent | Lit | Détient | Transmet |
| ------------------------------------------ | ---------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------ |
| Principal (l'agent que la session exécute) | Votre message, et ce que les autres agents renvoient | Aucun outil intégré. Sa liste `subagents.predefined_agents` nomme le récupérateur et le rédacteur | Une tâche à chaque agent |
| Récupérateur | Pages web et résultats de recherche | `web_fetch` et `web_search` uniquement, chacun avec `allowed_domains` | Des résultats courts, dans un format que vous demandez dans son invite système |
| Rédacteur | La tâche de l'agent principal | Les outils qui écrivent des fichiers, exécutent des commandes ou modifient des enregistrements, en `auto` ou `always_ask`. Aucun outil web | Son résultat |
Les résultats du récupérateur sont construits à partir de pages non fiables, et l'agent principal peut transmettre leur texte au rédacteur. Conservez `auto` ou `always_ask` sur les outils du rédacteur. Le récupérateur peut toujours envoyer une partie de ce qu'il lit aux sites de sa liste `web_fetch`, et au fournisseur de recherche dans ses requêtes.
Les agents d'une même session multi-agents [partagent le sandbox](https://platform.claude.com/docs/fr/managed-agents/multiagent-orchestration#how-it-works), ses fichiers et les identifiants du coffre, donc cette séparation ne sépare que leurs outils et leurs conversations. Pour une séparation plus forte, utilisez deux sessions avec des environnements et des coffres distincts. Faites en sorte que votre application ne transmette que des champs fixes, comme un ID de commande, entre les deux sessions.
## Définir des limites et un moyen d'arrêter
Définissez un budget lorsque vous créez chaque session, et décidez à l'avance comment vous arrêtez un agent.
| Contrôle | Ce qu'il fait |
| ------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Budget de session | Un plafond de dépenses aux prix catalogue publics. Au plafond, la session et chaque [fil](https://platform.claude.com/docs/fr/managed-agents/session-threads) se mettent en pause. Les requêtes en cours peuvent se terminer et leurs appels d'outils s'exécutent toujours, donc les dépenses peuvent dépasser le plafond. Consultez [Lorsqu'une session atteint son budget](https://platform.claude.com/docs/fr/managed-agents/budgets#when-a-session-reaches-its-budget) |
| Budget de déploiement | Le même plafond, appliqué à chaque session qu'un déploiement démarre |
| [Événement `user.interrupt`](https://platform.claude.com/docs/fr/managed-agents/events-and-streaming#interrupt-the-agent) | Arrête immédiatement la réponse du modèle. Un appel d'outil en cours peut se terminer d'abord. La session passe à `idle`, sauf si une exécution de workflow la maintient en `running`, et reprend à votre prochain message. Une interruption ne met fin à aucune exécution de workflow |
| Archiver ou supprimer une session | L'archivage conserve l'historique et bloque les nouveaux événements. La suppression retire l'enregistrement, les événements et le sandbox |
| Mettre en pause ou archiver un déploiement | La mise en pause arrête les nouvelles exécutions planifiées mais autorise toujours les exécutions manuelles. L'archivage met fin définitivement à la planification. Les sessions déjà en cours continuent de s'exécuter |
| Archiver ou supprimer un coffre ou un identifiant | Retire le secret des sessions en cours sans redémarrage. Prévoyez un délai. Les sessions continuent de s'exécuter, alors interrompez-les également. Un jeton que l'agent a déjà récupéré avec le secret reste dans le sandbox |
Pour arrêter un agent en cours d'exécution, suivez ces étapes :
1. Envoyez `user.interrupt` seul.
2. Pour un agent planifié, mettez également le déploiement en pause afin qu'aucune nouvelle exécution planifiée ne démarre. Pour mettre fin définitivement à la planification, archivez le déploiement.
3. Si une clé a pu être exposée, effectuez sa rotation auprès du service qui l'a émise.
4. Si l'agent a des exécutions de workflow ouvertes, envoyez également un `user.message` lui demandant de les arrêter, car une interruption ne met fin à aucune exécution. Consultez [Interrompre une session avec des exécutions ouvertes](https://platform.claude.com/docs/fr/managed-agents/workflow-runs#interrupt-a-session-with-runs-open) pour les appels d'outils à annuler en premier.
5. Attendez que la session passe à `idle`. Une session en cours d'exécution ne peut être ni archivée ni supprimée.
6. Archivez la session pour conserver son historique. Supprimez-la lorsque vous n'avez plus besoin de l'historique.
Une interruption n'annule pas ce que l'agent a déjà fait ou envoyé. L'archivage d'un agent n'arrête pas ses sessions en cours.
Le `max_list_cost.amount` d'un budget est un nombre entier de cents américains écrit sous forme de chaîne, donc `"125"` signifie 1,25 $. Consultez [Définir un budget à la création de la session](https://platform.claude.com/docs/fr/managed-agents/budgets#set-a-budget-at-session-creation).
Vous ne pouvez pas ajouter de budget à une session créée sans budget. Pour modifier ou supprimer un plafond, consultez [Reprendre une session ayant atteint son budget](https://platform.claude.com/docs/fr/managed-agents/budgets#resume-a-session-at-its-budget). Après avoir supprimé le plafond d'une session, vous ne pouvez pas en définir un nouveau.
Un budget plafonne les dépenses, mais il ne limite pas ce que fait l'agent avant d'atteindre le plafond. Pour séparer les charges de travail ayant des niveaux de confiance différents, utilisez des [espaces de travail](https://platform.claude.com/docs/fr/manage-claude/workspaces) distincts. Donnez à chaque charge de travail une clé API limitée à un seul espace de travail, car une clé qui peut atteindre plusieurs espaces de travail peut agir dans n'importe lequel d'entre eux.
Consultez [Budgets de session](https://platform.claude.com/docs/fr/managed-agents/budgets), [Opérations sur les sessions](https://platform.claude.com/docs/fr/managed-agents/session-operations#archiving-a-session) et [Déploiements planifiés](https://platform.claude.com/docs/fr/managed-agents/scheduled-deployments#managing-deployment-lifecycle).
## Étapes suivantes
Modes réseau, hôtes autorisés et gestionnaires de paquets.
Politiques d'approbation et demandes de confirmation.
Types d'identifiants, emplacements d'injection et rotation.
Plafonds, reprise d'une session ayant atteint son budget et budgets sur les déploiements.