--- title: Politiques d'autorisation url: https://platform.claude.com/docs/fr/managed-agents/permission-policies description: Contrôlez quand les outils d'agent et MCP s'exécutent. featureMetadata: topic: title: Managed Agents url: https://platform.claude.com/docs/en/managed-agents/overview status: beta betaHeader: managed-agents-2026-04-01 --- Les « permission policies » (politiques d'autorisation) déterminent si les outils exécutés par le serveur s'exécutent automatiquement, attendent votre approbation ou voient chaque appel évalué par le serveur. Ces outils sont le « toolset » (ensemble d'outils) d'agent prédéfini et l'ensemble d'outils MCP (« Model Context Protocol », ou MCP). Les « custom tools » (outils personnalisés) sont exécutés par votre application et contrôlés par vous. Ils ne sont donc pas régis par les politiques d'autorisation. ## Types de politiques d'autorisation | Politique | Comportement | | -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `always_allow` | L'outil s'exécute automatiquement, sans confirmation. | | `always_ask` | La session se met en pause et attend votre approbation avant l'exécution. Consultez [Répondre aux demandes de confirmation](https://platform.claude.com/docs/fr/managed-agents/permission-policies#respond-to-confirmation-requests) pour le flux d'événements. | | `auto` | Le serveur évalue chaque appel, puis l'exécute, le refuse ou se met en pause pour obtenir votre approbation. Consultez [Laisser le serveur évaluer chaque appel avec `auto`](https://platform.claude.com/docs/fr/managed-agents/permission-policies#let-the-server-evaluate-each-call-with-auto). | Chaque type d'ensemble d'outils possède sa propre valeur par défaut : l'ensemble d'outils d'agent utilise par défaut `always_allow`, et les ensembles d'outils MCP utilisent par défaut `always_ask`. Une politique d'autorisation contrôle quand un outil activé s'exécute. Pour retirer entièrement un outil de l'agent, désactivez-le plutôt. Consultez [Désactiver des outils spécifiques](https://platform.claude.com/docs/fr/managed-agents/tools#disabling-specific-tools). ## Définir une politique pour un ensemble d'outils Vous définissez les politiques d'autorisation dans la configuration `tools` (csharp, go: `Tools`) de l'agent lors de sa création, et vous pouvez les modifier ultérieurement en [mettant à jour l'agent](https://platform.claude.com/docs/fr/managed-agents/agent-setup#update-an-agent). Les sessions en cours conservent la configuration d'ensemble d'outils avec laquelle elles ont été créées. Les mises à jour s'appliquent aux sessions créées par la suite. ### Autorisations de l'ensemble d'outils d'agent Lors de la création d'un agent, vous pouvez appliquer une politique à chaque outil de `agent_toolset_20260401` à l'aide de `default_config.permission_policy` (java, php: `defaultConfig.permissionPolicy`; csharp, go: `DefaultConfig.PermissionPolicy`) : ```bash cURL agent=$(curl -fsSL https://api.anthropic.com/v1/agents \ -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": "Coding Assistant", "model": "claude-opus-5-5", "tools": [ { "type": "agent_toolset_20260401", "default_config": { "permission_policy": {"type": "always_ask"} } } ] }') ``` ```bash CLI ant apply agent.md ``` ```markdown --- name: Coding Assistant model: claude-opus-5-5 tools: - type: agent_toolset_20260401 default_config: permission_policy: type: always_ask --- ``` ```python Python agent = client.beta.agents.create( name="Coding Assistant", model="claude-opus-5-5", tools=[ { "type": "agent_toolset_20260401", "default_config": { "permission_policy": {"type": "always_ask"}, }, }, ], ) ``` ```typescript TypeScript const agent = await client.beta.agents.create({ name: "Coding Assistant", model: "claude-opus-5-5", tools: [ { type: "agent_toolset_20260401", default_config: { permission_policy: { type: "always_ask" } } } ] }); ``` ```csharp C# using Anthropic.Models.Beta.Agents; var agent = await client.Beta.Agents.Create(new() { Name = "Coding Assistant", Model = BetaManagedAgentsModel.ClaudeOpus5_5, Tools = [ new BetaManagedAgentsAgentToolset20260401Params { Type = BetaManagedAgentsAgentToolset20260401ParamsType.AgentToolset20260401, DefaultConfig = new() { PermissionPolicy = new BetaManagedAgentsAlwaysAskPolicy { Type = "always_ask" }, }, }, ], }); ``` ```go Go agent, err := client.Beta.Agents.New(ctx, anthropic.BetaAgentNewParams{ Name: "Coding Assistant", Model: anthropic.BetaManagedAgentsModelConfigParams{ ID: anthropic.BetaManagedAgentsModelClaudeOpus5_5, }, Tools: []anthropic.BetaAgentNewParamsToolUnion{{ OfAgentToolset20260401: &anthropic.BetaManagedAgentsAgentToolset20260401Params{ Type: anthropic.BetaManagedAgentsAgentToolset20260401ParamsTypeAgentToolset20260401, DefaultConfig: anthropic.BetaManagedAgentsAgentToolsetDefaultConfigParams{ PermissionPolicy: anthropic.BetaManagedAgentsAgentToolsetDefaultConfigParamsPermissionPolicyUnion{ OfAlwaysAsk: &anthropic.BetaManagedAgentsAlwaysAskPolicyParam{ Type: anthropic.BetaManagedAgentsAlwaysAskPolicyTypeAlwaysAsk, }, }, }, }, }}, }) if err != nil { panic(err) } _ = agent ``` ```java Java import com.anthropic.models.beta.agents.*; var agent = client.beta().agents().create( AgentCreateParams.builder() .name("Coding Assistant") .model(BetaManagedAgentsModel.CLAUDE_OPUS_5_5) .addTool( BetaManagedAgentsAgentToolset20260401Params.builder() .type(BetaManagedAgentsAgentToolset20260401Params.Type.AGENT_TOOLSET_20260401) .defaultConfig( BetaManagedAgentsAgentToolsetDefaultConfigParams.builder() .permissionPolicy( BetaManagedAgentsAlwaysAskPolicy.builder() .type(BetaManagedAgentsAlwaysAskPolicy.Type.ALWAYS_ASK) .build() ) .build() ) .build() ) .build() ); ``` ```php PHP use Anthropic\Beta\Agents\BetaManagedAgentsAgentToolset20260401Params; use Anthropic\Beta\Agents\BetaManagedAgentsAgentToolsetDefaultConfigParams; use Anthropic\Beta\Agents\BetaManagedAgentsAlwaysAskPolicy; $agent = $client->beta->agents->create( name: 'Coding Assistant', model: 'claude-opus-5-5', tools: [ BetaManagedAgentsAgentToolset20260401Params::with( type: 'agent_toolset_20260401', defaultConfig: BetaManagedAgentsAgentToolsetDefaultConfigParams::with( permissionPolicy: BetaManagedAgentsAlwaysAskPolicy::with(type: 'always_ask'), ), ), ], ); ``` ```ruby Ruby agent = client.beta.agents.create( name: "Coding Assistant", model: "claude-opus-5-5", tools: [ { type: "agent_toolset_20260401", default_config: { permission_policy: {type: "always_ask"} } } ] ) ``` `default_config` (java, php: `defaultConfig`; csharp, go: `DefaultConfig`) est facultatif. Si vous l'omettez, l'ensemble d'outils d'agent est activé avec la politique d'autorisation par défaut, `always_allow`. ### Autorisations des ensembles d'outils MCP Les ensembles d'outils MCP utilisent par défaut `always_ask`. Cela garantit que les nouveaux outils ajoutés à un serveur MCP ne s'exécutent pas dans votre application sans approbation. Pour approuver automatiquement les outils d'un serveur MCP de confiance, définissez `default_config.permission_policy` (java, php: `defaultConfig.permissionPolicy`; csharp, go: `DefaultConfig.PermissionPolicy`) sur l'entrée `mcp_toolset`. Le `mcp_server_name` (java, php: `mcpServerName`; csharp: `McpServerName`; go: `MCPServerName`) doit correspondre au `name` (csharp, go: `Name`) d'un serveur du tableau `mcp_servers` (java, php: `mcpServers`; csharp: `McpServers`; go: `MCPServers`). Cet exemple connecte un serveur MCP GitHub et permet à ses outils de s'exécuter sans confirmation : ```bash cURL agent=$(curl -fsSL https://api.anthropic.com/v1/agents \ -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": "Dev Assistant", "model": "claude-opus-5-5", "mcp_servers": [ {"type": "url", "name": "github", "url": "https://mcp.example.com/github"} ], "tools": [ {"type": "agent_toolset_20260401"}, { "type": "mcp_toolset", "mcp_server_name": "github", "default_config": { "permission_policy": {"type": "always_allow"} } } ] }') ``` ```bash CLI ant apply agent.md ``` ```markdown --- name: Dev Assistant model: claude-opus-5-5 mcp_servers: - type: url name: github url: https://mcp.example.com/github tools: - type: agent_toolset_20260401 - type: mcp_toolset mcp_server_name: github default_config: permission_policy: type: always_allow --- ``` ```python Python agent = client.beta.agents.create( name="Dev Assistant", model="claude-opus-5-5", mcp_servers=[ {"type": "url", "name": "github", "url": "https://mcp.example.com/github"}, ], tools=[ {"type": "agent_toolset_20260401"}, { "type": "mcp_toolset", "mcp_server_name": "github", "default_config": { "permission_policy": {"type": "always_allow"}, }, }, ], ) ``` ```typescript TypeScript const agent = await client.beta.agents.create({ name: "Dev Assistant", model: "claude-opus-5-5", mcp_servers: [{ type: "url", name: "github", url: "https://mcp.example.com/github" }], tools: [ { type: "agent_toolset_20260401" }, { type: "mcp_toolset", mcp_server_name: "github", default_config: { permission_policy: { type: "always_allow" } } } ] }); ``` ```csharp C# using Anthropic.Models.Beta.Agents; var agent = await client.Beta.Agents.Create(new() { Name = "Dev Assistant", Model = BetaManagedAgentsModel.ClaudeOpus5_5, McpServers = [ new() { Type = BetaManagedAgentsUrlMcpServerParamsType.Url, Name = "github", Url = "https://mcp.example.com/github", }, ], Tools = [ new BetaManagedAgentsAgentToolset20260401Params { Type = BetaManagedAgentsAgentToolset20260401ParamsType.AgentToolset20260401, }, new BetaManagedAgentsMcpToolsetParams { Type = BetaManagedAgentsMcpToolsetParamsType.McpToolset, McpServerName = "github", DefaultConfig = new() { PermissionPolicy = new BetaManagedAgentsAlwaysAllowPolicy { Type = "always_allow" }, }, }, ], }); ``` ```go Go agent, err := client.Beta.Agents.New(ctx, anthropic.BetaAgentNewParams{ Name: "Dev Assistant", Model: anthropic.BetaManagedAgentsModelConfigParams{ ID: anthropic.BetaManagedAgentsModelClaudeOpus5_5, }, MCPServers: []anthropic.BetaManagedAgentsURLMCPServerParams{{ Type: anthropic.BetaManagedAgentsURLMCPServerParamsTypeURL, Name: "github", URL: "https://mcp.example.com/github", }}, Tools: []anthropic.BetaAgentNewParamsToolUnion{ { OfAgentToolset20260401: &anthropic.BetaManagedAgentsAgentToolset20260401Params{ Type: anthropic.BetaManagedAgentsAgentToolset20260401ParamsTypeAgentToolset20260401, }, }, { OfMCPToolset: &anthropic.BetaManagedAgentsMCPToolsetParams{ Type: anthropic.BetaManagedAgentsMCPToolsetParamsTypeMCPToolset, MCPServerName: "github", DefaultConfig: anthropic.BetaManagedAgentsMCPToolsetDefaultConfigParams{ PermissionPolicy: anthropic.BetaManagedAgentsMCPToolsetDefaultConfigParamsPermissionPolicyUnion{ OfAlwaysAllow: &anthropic.BetaManagedAgentsAlwaysAllowPolicyParam{ Type: anthropic.BetaManagedAgentsAlwaysAllowPolicyTypeAlwaysAllow, }, }, }, }, }, }, }) if err != nil { panic(err) } _ = agent ``` ```java Java import com.anthropic.models.beta.agents.*; var agent = client.beta().agents().create( AgentCreateParams.builder() .name("Dev Assistant") .model(BetaManagedAgentsModel.CLAUDE_OPUS_5_5) .addMcpServer( BetaManagedAgentsUrlMcpServerParams.builder() .type(BetaManagedAgentsUrlMcpServerParams.Type.URL) .name("github") .url("https://mcp.example.com/github") .build() ) .addTool( BetaManagedAgentsAgentToolset20260401Params.builder() .type(BetaManagedAgentsAgentToolset20260401Params.Type.AGENT_TOOLSET_20260401) .build() ) .addTool( BetaManagedAgentsMcpToolsetParams.builder() .type(BetaManagedAgentsMcpToolsetParams.Type.MCP_TOOLSET) .mcpServerName("github") .defaultConfig( BetaManagedAgentsMcpToolsetDefaultConfigParams.builder() .permissionPolicy( BetaManagedAgentsAlwaysAllowPolicy.builder() .type(BetaManagedAgentsAlwaysAllowPolicy.Type.ALWAYS_ALLOW) .build() ) .build() ) .build() ) .build() ); ``` ```php PHP use Anthropic\Beta\Agents\BetaManagedAgentsAgentToolset20260401Params; use Anthropic\Beta\Agents\BetaManagedAgentsAlwaysAllowPolicy; use Anthropic\Beta\Agents\BetaManagedAgentsMCPToolsetDefaultConfigParams; use Anthropic\Beta\Agents\BetaManagedAgentsMCPToolsetParams; use Anthropic\Beta\Agents\BetaManagedAgentsURLMCPServerParams; $agent = $client->beta->agents->create( name: 'Dev Assistant', model: 'claude-opus-5-5', mcpServers: [ BetaManagedAgentsURLMCPServerParams::with( type: 'url', name: 'github', url: 'https://mcp.example.com/github', ), ], tools: [ BetaManagedAgentsAgentToolset20260401Params::with( type: 'agent_toolset_20260401', ), BetaManagedAgentsMCPToolsetParams::with( type: 'mcp_toolset', mcpServerName: 'github', defaultConfig: BetaManagedAgentsMCPToolsetDefaultConfigParams::with( permissionPolicy: BetaManagedAgentsAlwaysAllowPolicy::with(type: 'always_allow'), ), ), ], ); ``` ```ruby Ruby agent = client.beta.agents.create( name: "Dev Assistant", model: "claude-opus-5-5", mcp_servers: [ {type: "url", name: "github", url: "https://mcp.example.com/github"} ], tools: [ {type: "agent_toolset_20260401"}, { type: "mcp_toolset", mcp_server_name: "github", default_config: { permission_policy: {type: "always_allow"} } } ] ) ``` ## Remplacer la politique d'un outil individuel Utilisez le tableau `configs` (csharp, go: `Configs`) pour remplacer la valeur par défaut pour des outils individuels. Les valeurs `name` (csharp, go: `Name`) de l'ensemble d'outils d'agent sont répertoriées dans [Outils disponibles](https://platform.claude.com/docs/fr/managed-agents/tools#available-tools). Cet exemple autorise par défaut l'ensemble complet d'outils d'agent, mais exige une confirmation avant l'exécution de toute commande bash : ```bash cURL tools='[ { "type": "agent_toolset_20260401", "default_config": { "permission_policy": {"type": "always_allow"} }, "configs": [ { "name": "bash", "permission_policy": {"type": "always_ask"} } ] } ]' ``` ```bash CLI ant apply agent.md ``` ```markdown --- name: Coding Assistant model: claude-opus-5-5 tools: - type: agent_toolset_20260401 default_config: permission_policy: type: always_allow configs: - name: bash permission_policy: type: always_ask --- ``` ```python Python tools = [ { "type": "agent_toolset_20260401", "default_config": { "permission_policy": {"type": "always_allow"}, }, "configs": [ { "name": "bash", "permission_policy": {"type": "always_ask"}, }, ], }, ] ``` ```typescript TypeScript const tools = [ { type: "agent_toolset_20260401", default_config: { permission_policy: { type: "always_allow" } }, configs: [ { name: "bash", permission_policy: { type: "always_ask" } } ] } ] satisfies Anthropic.Beta.AgentCreateParams["tools"]; ``` ```csharp C# using Anthropic.Models.Beta.Agents; using Tool = Anthropic.Models.Beta.Agents.Tool; Tool[] tools = [ new BetaManagedAgentsAgentToolset20260401Params { Type = BetaManagedAgentsAgentToolset20260401ParamsType.AgentToolset20260401, DefaultConfig = new() { PermissionPolicy = new BetaManagedAgentsAlwaysAllowPolicy { Type = "always_allow" }, }, Configs = [ new BetaManagedAgentsBashToolConfigParams { PermissionPolicy = new BetaManagedAgentsAlwaysAskPolicy { Type = "always_ask" }, }, ], }, ]; ``` ```go Go tools := []anthropic.BetaAgentNewParamsToolUnion{{ OfAgentToolset20260401: &anthropic.BetaManagedAgentsAgentToolset20260401Params{ Type: anthropic.BetaManagedAgentsAgentToolset20260401ParamsTypeAgentToolset20260401, DefaultConfig: anthropic.BetaManagedAgentsAgentToolsetDefaultConfigParams{ PermissionPolicy: anthropic.BetaManagedAgentsAgentToolsetDefaultConfigParamsPermissionPolicyUnion{ OfAlwaysAllow: &anthropic.BetaManagedAgentsAlwaysAllowPolicyParam{ Type: anthropic.BetaManagedAgentsAlwaysAllowPolicyTypeAlwaysAllow, }, }, }, Configs: []anthropic.BetaManagedAgentsAgentToolConfigParamsUnion{{ OfBash: &anthropic.BetaManagedAgentsBashToolConfigParams{ PermissionPolicy: anthropic.BetaManagedAgentsBashToolConfigParamsPermissionPolicyUnion{ OfAlwaysAsk: &anthropic.BetaManagedAgentsAlwaysAskPolicyParam{ Type: anthropic.BetaManagedAgentsAlwaysAskPolicyTypeAlwaysAsk, }, }, }, }}, }, }} _ = tools ``` ```java Java import com.anthropic.models.beta.agents.*; import java.util.List; var tools = List.of( AgentCreateParams.Tool.ofAgentToolset20260401( BetaManagedAgentsAgentToolset20260401Params.builder() .type(BetaManagedAgentsAgentToolset20260401Params.Type.AGENT_TOOLSET_20260401) .defaultConfig( BetaManagedAgentsAgentToolsetDefaultConfigParams.builder() .permissionPolicy( BetaManagedAgentsAlwaysAllowPolicy.builder() .type(BetaManagedAgentsAlwaysAllowPolicy.Type.ALWAYS_ALLOW) .build() ) .build() ) .addConfig( BetaManagedAgentsBashToolConfigParams.builder() .permissionPolicy( BetaManagedAgentsAlwaysAskPolicy.builder() .type(BetaManagedAgentsAlwaysAskPolicy.Type.ALWAYS_ASK) .build() ) .build() ) .build() ) ); ``` ```php PHP use Anthropic\Beta\Agents\BetaManagedAgentsBashToolConfigParams; use Anthropic\Beta\Agents\BetaManagedAgentsAgentToolset20260401Params; use Anthropic\Beta\Agents\BetaManagedAgentsAgentToolsetDefaultConfigParams; use Anthropic\Beta\Agents\BetaManagedAgentsAlwaysAllowPolicy; use Anthropic\Beta\Agents\BetaManagedAgentsAlwaysAskPolicy; $tools = [ BetaManagedAgentsAgentToolset20260401Params::with( type: 'agent_toolset_20260401', defaultConfig: BetaManagedAgentsAgentToolsetDefaultConfigParams::with( permissionPolicy: BetaManagedAgentsAlwaysAllowPolicy::with(type: 'always_allow'), ), configs: [ BetaManagedAgentsBashToolConfigParams::with( permissionPolicy: BetaManagedAgentsAlwaysAskPolicy::with(type: 'always_ask'), ), ], ), ]; ``` ```ruby Ruby tools = [ { type: "agent_toolset_20260401", default_config: { permission_policy: {type: "always_allow"} }, configs: [ { name: "bash", permission_policy: {type: "always_ask"} } ] } ] ``` Transmettez cette configuration `tools` (csharp, go: `Tools`) dans la requête de création de l'agent (l'onglet CLI montre la commande complète). Les ensembles d'outils MCP prennent en charge les mêmes remplacements par outil, avec `name` (csharp, go: `Name`) défini sur le nom de l'outil indiqué par le serveur MCP. Consultez [Configurer les outils MCP disponibles](https://platform.claude.com/docs/fr/managed-agents/mcp-connector#configure-which-mcp-tools-are-available). ## Laisser le serveur évaluer chaque appel avec `auto` Avec la politique d'autorisation `auto`, le serveur évalue chaque appel avant son exécution. Comme l'évaluation prend en compte l'outil, l'entrée de l'appel et le contenu de la session jusqu'à ce point, le serveur peut traiter différemment deux appels au même outil. Chaque appel a l'un des trois résultats suivants : * **L'appel s'exécute.** Lorsque le serveur détermine que l'appel est sûr, l'outil s'exécute comme il le ferait sous `always_allow`. * **L'appel est refusé.** Lorsque le serveur évalue l'appel comme présentant un risque élevé, l'outil ne s'exécute pas. L'agent reçoit un résultat d'outil en erreur avec le contenu `Permission to use {tool_name} has been denied.` et `is_error: true`. La session continue de s'exécuter, et votre client ne peut pas annuler le refus. * **L'appel se met en pause pour attendre votre approbation.** Lorsque le serveur ne parvient à aucune conclusion, la session se met en pause comme sous `always_ask`. Consultez [Répondre aux demandes de confirmation](https://platform.claude.com/docs/fr/managed-agents/permission-policies#respond-to-confirmation-requests). Pour activer `auto`, définissez `permission_policy` sur `{"type": "auto"}`. Elle se place aux deux mêmes endroits que les autres politiques : le [`default_config` (java, php: `defaultConfig`; csharp, go: `DefaultConfig`)](https://platform.claude.com/docs/fr/managed-agents/permission-policies#set-a-policy-for-a-toolset) d'un ensemble d'outils pour l'ensemble entier, ou une [entrée `configs` (csharp, go: `Configs`)](https://platform.claude.com/docs/fr/managed-agents/permission-policies#override-an-individual-tool-policy) pour un seul outil. L'ensemble d'outils d'agent et les ensembles d'outils MCP l'acceptent tous deux. Aucun ensemble d'outils n'utilise `auto` par défaut. L'exemple suivant définit `auto` comme valeur par défaut pour l'ensemble d'outils d'agent et pour l'ensemble d'outils MCP `github`, et remplace `bash` par `always_ask` : ```bash cURL agent=$(curl -fsSL https://api.anthropic.com/v1/agents \ -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": "Ops Agent", "model": "claude-opus-5-5", "mcp_servers": [ {"type": "url", "name": "github", "url": "https://mcp.example.com/github"} ], "tools": [ { "type": "agent_toolset_20260401", "default_config": { "permission_policy": {"type": "auto"} }, "configs": [ {"name": "bash", "permission_policy": {"type": "always_ask"}} ] }, { "type": "mcp_toolset", "mcp_server_name": "github", "default_config": { "permission_policy": {"type": "auto"} } } ] }') ``` ```bash CLI ant apply agent.md ``` ```markdown --- name: Ops Agent model: claude-opus-5-5 mcp_servers: - type: url name: github url: https://mcp.example.com/github tools: - type: agent_toolset_20260401 default_config: permission_policy: type: auto configs: - name: bash permission_policy: type: always_ask - type: mcp_toolset mcp_server_name: github default_config: permission_policy: type: auto --- ``` ```python Python agent = client.beta.agents.create( name="Ops Agent", model="claude-opus-5-5", mcp_servers=[ {"type": "url", "name": "github", "url": "https://mcp.example.com/github"}, ], tools=[ { "type": "agent_toolset_20260401", "default_config": { "permission_policy": {"type": "auto"}, }, "configs": [ {"name": "bash", "permission_policy": {"type": "always_ask"}}, ], }, { "type": "mcp_toolset", "mcp_server_name": "github", "default_config": { "permission_policy": {"type": "auto"}, }, }, ], ) ``` ```typescript TypeScript const agent = await client.beta.agents.create({ name: "Ops Agent", model: "claude-opus-5-5", mcp_servers: [{ type: "url", name: "github", url: "https://mcp.example.com/github" }], tools: [ { type: "agent_toolset_20260401", default_config: { permission_policy: { type: "auto" } }, configs: [{ name: "bash", permission_policy: { type: "always_ask" } }] }, { type: "mcp_toolset", mcp_server_name: "github", default_config: { permission_policy: { type: "auto" } } } ] }); ``` ```csharp C# using Anthropic.Models.Beta.Agents; var agent = await client.Beta.Agents.Create(new() { Name = "Ops Agent", Model = BetaManagedAgentsModel.ClaudeOpus5_5, McpServers = [ new() { Type = BetaManagedAgentsUrlMcpServerParamsType.Url, Name = "github", Url = "https://mcp.example.com/github", }, ], Tools = [ new BetaManagedAgentsAgentToolset20260401Params { Type = BetaManagedAgentsAgentToolset20260401ParamsType.AgentToolset20260401, DefaultConfig = new() { PermissionPolicy = new BetaManagedAgentsAutoPolicy(), }, Configs = [ new BetaManagedAgentsBashToolConfigParams { PermissionPolicy = new BetaManagedAgentsAlwaysAskPolicy { Type = "always_ask" }, }, ], }, new BetaManagedAgentsMcpToolsetParams { Type = BetaManagedAgentsMcpToolsetParamsType.McpToolset, McpServerName = "github", DefaultConfig = new() { PermissionPolicy = new BetaManagedAgentsAutoPolicy(), }, }, ], }); ``` ```go Go agent, err := client.Beta.Agents.New(ctx, anthropic.BetaAgentNewParams{ Name: "Ops Agent", Model: anthropic.BetaManagedAgentsModelConfigParams{ ID: anthropic.BetaManagedAgentsModelClaudeOpus5_5, }, MCPServers: []anthropic.BetaManagedAgentsURLMCPServerParams{{ Type: anthropic.BetaManagedAgentsURLMCPServerParamsTypeURL, Name: "github", URL: "https://mcp.example.com/github", }}, Tools: []anthropic.BetaAgentNewParamsToolUnion{ { OfAgentToolset20260401: &anthropic.BetaManagedAgentsAgentToolset20260401Params{ Type: anthropic.BetaManagedAgentsAgentToolset20260401ParamsTypeAgentToolset20260401, DefaultConfig: anthropic.BetaManagedAgentsAgentToolsetDefaultConfigParams{ PermissionPolicy: anthropic.BetaManagedAgentsAgentToolsetDefaultConfigParamsPermissionPolicyUnion{ OfAuto: &anthropic.BetaManagedAgentsAutoPolicyParam{}, }, }, Configs: []anthropic.BetaManagedAgentsAgentToolConfigParamsUnion{{ OfBash: &anthropic.BetaManagedAgentsBashToolConfigParams{ PermissionPolicy: anthropic.BetaManagedAgentsBashToolConfigParamsPermissionPolicyUnion{ OfAlwaysAsk: &anthropic.BetaManagedAgentsAlwaysAskPolicyParam{ Type: anthropic.BetaManagedAgentsAlwaysAskPolicyTypeAlwaysAsk, }, }, }, }}, }, }, { OfMCPToolset: &anthropic.BetaManagedAgentsMCPToolsetParams{ Type: anthropic.BetaManagedAgentsMCPToolsetParamsTypeMCPToolset, MCPServerName: "github", DefaultConfig: anthropic.BetaManagedAgentsMCPToolsetDefaultConfigParams{ PermissionPolicy: anthropic.BetaManagedAgentsMCPToolsetDefaultConfigParamsPermissionPolicyUnion{ OfAuto: &anthropic.BetaManagedAgentsAutoPolicyParam{}, }, }, }, }, }, }) if err != nil { panic(err) } _ = agent ``` ```java Java import com.anthropic.models.beta.agents.*; var agent = client.beta().agents().create( AgentCreateParams.builder() .name("Ops Agent") .model(BetaManagedAgentsModel.CLAUDE_OPUS_5_5) .addMcpServer( BetaManagedAgentsUrlMcpServerParams.builder() .type(BetaManagedAgentsUrlMcpServerParams.Type.URL) .name("github") .url("https://mcp.example.com/github") .build() ) .addTool( BetaManagedAgentsAgentToolset20260401Params.builder() .type(BetaManagedAgentsAgentToolset20260401Params.Type.AGENT_TOOLSET_20260401) .defaultConfig( BetaManagedAgentsAgentToolsetDefaultConfigParams.builder() .permissionPolicy(BetaManagedAgentsAutoPolicy.builder().build()) .build() ) .addConfig( BetaManagedAgentsBashToolConfigParams.builder() .permissionPolicy( BetaManagedAgentsAlwaysAskPolicy.builder() .type(BetaManagedAgentsAlwaysAskPolicy.Type.ALWAYS_ASK) .build() ) .build() ) .build() ) .addTool( BetaManagedAgentsMcpToolsetParams.builder() .type(BetaManagedAgentsMcpToolsetParams.Type.MCP_TOOLSET) .mcpServerName("github") .defaultConfig( BetaManagedAgentsMcpToolsetDefaultConfigParams.builder() .permissionPolicy(BetaManagedAgentsAutoPolicy.builder().build()) .build() ) .build() ) .build() ); ``` ```php PHP use Anthropic\Beta\Agents\BetaManagedAgentsAgentToolset20260401Params; use Anthropic\Beta\Agents\BetaManagedAgentsAgentToolsetDefaultConfigParams; use Anthropic\Beta\Agents\BetaManagedAgentsAlwaysAskPolicy; use Anthropic\Beta\Agents\BetaManagedAgentsAutoPolicy; use Anthropic\Beta\Agents\BetaManagedAgentsBashToolConfigParams; use Anthropic\Beta\Agents\BetaManagedAgentsMCPToolsetDefaultConfigParams; use Anthropic\Beta\Agents\BetaManagedAgentsMCPToolsetParams; use Anthropic\Beta\Agents\BetaManagedAgentsURLMCPServerParams; $agent = $client->beta->agents->create( name: 'Ops Agent', model: 'claude-opus-5-5', mcpServers: [ BetaManagedAgentsURLMCPServerParams::with( type: 'url', name: 'github', url: 'https://mcp.example.com/github', ), ], tools: [ BetaManagedAgentsAgentToolset20260401Params::with( type: 'agent_toolset_20260401', defaultConfig: BetaManagedAgentsAgentToolsetDefaultConfigParams::with( permissionPolicy: BetaManagedAgentsAutoPolicy::with(), ), configs: [ BetaManagedAgentsBashToolConfigParams::with( permissionPolicy: BetaManagedAgentsAlwaysAskPolicy::with(type: 'always_ask'), ), ], ), BetaManagedAgentsMCPToolsetParams::with( type: 'mcp_toolset', mcpServerName: 'github', defaultConfig: BetaManagedAgentsMCPToolsetDefaultConfigParams::with( permissionPolicy: BetaManagedAgentsAutoPolicy::with(), ), ), ], ); ``` ```ruby Ruby agent = client.beta.agents.create( name: "Ops Agent", model: "claude-opus-5-5", mcp_servers: [ {type: "url", name: "github", url: "https://mcp.example.com/github"} ], tools: [ { type: "agent_toolset_20260401", default_config: { permission_policy: {type: "auto"} }, configs: [ {name: "bash", permission_policy: {type: "always_ask"}} ] }, { type: "mcp_toolset", mcp_server_name: "github", default_config: { permission_policy: {type: "auto"} } } ] ) ``` Ce que vous publiez dans les événements `user.message` compte comme votre intention, et cela peut amener le serveur à autoriser un appel qu'il refuserait autrement. Le serveur ne déduit pas d'intention d'un résultat d'outil, d'une page web récupérée, de la réponse d'un serveur MCP ou d'un message échangé entre [fils de session](https://platform.claude.com/docs/fr/managed-agents/session-threads#tool-permissions-and-custom-tools). Il évalue ce contenu, mais n'en reçoit pas d'instructions. Le serveur évalue certains appels comme présentant un risque élevé, quel que soit le demandeur. Si vous relayez des entrées non fiables d'utilisateurs finaux dans des événements `user.message`, le serveur interprète également ces entrées comme votre intention, et elles peuvent faire autoriser un appel. Configurez `always_ask` sur les outils que vous ne laisseriez pas cet utilisateur final exécuter sans vérification. `auto` n'est pas un point de contrôle humain. Si le serveur détermine qu'un appel est sûr, l'appel s'exécute avant que quiconque ne le voie, et ses effets peuvent ne pas être réversibles. Si une personne doit examiner les appels d'un outil avant leur exécution, configurez `always_ask` sur cet outil. ## Voir comment chaque appel a été évalué Quelle que soit la politique d'autorisation, chaque événement `agent.tool_use` et `agent.mcp_tool_use` comporte `evaluated_permission`. Ce champ indique le résultat de la vérification d'autorisation de l'appel : `"allow"`, `"ask"` ou `"deny"`. La plupart des événements comportent également un objet `evaluation`, dont le `type` nomme la politique qui a produit ce résultat. Sous `auto`, l'objet enregistre aussi la conclusion du serveur. Il inclut en outre un `reason_code` lorsque le résultat est `ask` ou `deny`. Par exemple, lorsque `bash` est sous `auto` et que le serveur évalue un appel comme étant à haut risque, l'appel refusé apparaît ainsi dans le flux d'événements : ```json { "type": "agent.tool_use", "id": "sevt_01pqr...", "name": "bash", "input": { "command": "rm -rf /workspace/reports" }, "evaluated_permission": "deny", "evaluation": { "type": "auto", "evaluated_permission": { "type": "deny", "reason_code": "high_risk" } }, "processed_at": "2026-03-25T14:05:12Z" } ``` L'objet `evaluation` prend l'une des formes du tableau suivant. | `evaluation` | `evaluated_permission` de niveau supérieur | Signification | | ------------------------------------------------------------------------------------------- | ------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------- | | `{"type": "always_allow"}` | `"allow"` | La politique résolue est `always_allow`, l'appel s'est donc exécuté. | | `{"type": "always_ask"}` | `"ask"` | La politique résolue est `always_ask`, l'appel s'est donc mis en pause pour obtenir votre approbation. | | `{"type": "auto", "evaluated_permission": {"type": "allow"}}` | `"allow"` | Sous `auto`, le serveur a déterminé que l'appel était sûr, et celui-ci s'est exécuté. | | `{"type": "auto", "evaluated_permission": {"type": "ask", "reason_code": "indeterminate"}}` | `"ask"` | Sous `auto`, le serveur n'est parvenu à aucune conclusion, l'appel s'est donc mis en pause pour obtenir votre approbation. | | `{"type": "auto", "evaluated_permission": {"type": "deny", "reason_code": "high_risk"}}` | `"deny"` | Sous `auto`, le serveur a évalué l'appel comme étant à haut risque et l'a refusé. | Lorsque `evaluation.type` vaut `"auto"`, son champ imbriqué `evaluated_permission.type` reprend le `evaluated_permission` de niveau supérieur de l'événement. Vous pouvez donc lire le résultat dans l'un ou l'autre champ. Un `reason_code` est une valeur destinée à orienter la logique de votre client et à être conservée dans les journaux d'audit. Ce n'est pas un texte à afficher aux utilisateurs finaux. `evaluation` est absent dans deux cas. Dans le premier, l'agent nomme un outil qui n'est pas activé dans la session. Le serveur refuse alors l'appel sans évaluer de politique : l'événement comporte `evaluated_permission: "deny"` et aucun `evaluation`. Dans le second, les événements ont été enregistrés avant l'introduction de `evaluation` et l'omettent donc. Interprétez-les comme `always_allow` lorsque `evaluated_permission` vaut `"allow"`, et comme `always_ask` lorsqu'il vaut `"ask"`. Concevez votre client pour qu'il tolère un `evaluation.type` ou un `reason_code` qu'il ne reconnaît pas. Les événements `agent.custom_tool_use` ne comportent aucun de ces deux champs, car les politiques d'autorisation ne régissent pas les [outils personnalisés](https://platform.claude.com/docs/fr/managed-agents/permission-policies#custom-tools). ## Répondre aux demandes de confirmation Un appel d'outil aboutit à `ask` dans deux cas : sous une politique `always_ask`, ou sous `auto` lorsque le serveur ne parvient à aucune conclusion. Dans ce cas : 1. La session émet un événement `agent.tool_use` ou `agent.mcp_tool_use`. 2. La session se met en pause avec un événement `session.status_idle` dont le `stop_reason.type` est `requires_action`. Les identifiants des événements bloquants se trouvent dans le tableau `stop_reason.event_ids`. La session attend une réponse indéfiniment. Un appel provenant d'un fil d'une [exécution de workflow](https://platform.claude.com/docs/fr/managed-agents/workflow-runs#while-a-run-is-open) parvient à votre client sur le flux principal. Tant qu'un autre élément de la session est en cours de traitement, la session peut rester `running` et n'envoyer aucun `session.status_idle` ; répondez donc directement à l'événement d'utilisation d'outil. L'appel n'attend que jusqu'à ce que l'exécution en ait terminé avec ce fil ou que l'exécution se termine. Une interruption peut le laisser en attente ; autorisez-le ou refusez-le donc vous-même. 3. Envoyez un événement `user.tool_confirmation` pour chaque événement bloquant, en transmettant l'ID de l'événement dans le paramètre `tool_use_id` (java: `toolUseId`; php: `toolUseID`; csharp, go: `ToolUseID`). Définissez `result` (csharp, go: `Result`) sur `"allow"` ou `"deny"`. Utilisez `deny_message` (java, php: `denyMessage`; csharp, go: `DenyMessage`) pour expliquer un refus. Vous pouvez envoyer plusieurs confirmations dans une seule requête `events`. 4. Une fois tous les événements bloquants résolus, la session repasse à l'état `running`. Les outils autorisés s'exécutent. Les outils refusés ne s'exécutent pas, et l'agent reçoit un résultat d'outil indiquant que l'appel a été rejeté, incluant votre `deny_message` (java, php: `denyMessage`; csharp, go: `DenyMessage`). Par exemple, un appel `bash` mis en pause sous une politique `always_ask` apparaît dans le flux comme suit : ```json { "type": "agent.tool_use", "id": "sevt_01def...", "name": "bash", "input": { "command": "pip install -r requirements.txt" }, "evaluated_permission": "ask", "evaluation": { "type": "always_ask" }, "processed_at": "2026-03-25T14:01:45Z" } ``` Si vous envoyez un `user.tool_confirmation` pour un événement dont le `evaluated_permission` (java, php: `evaluatedPermission`; csharp, go: `EvaluatedPermission`) n'est pas `ask`, l'API le rejette avec une erreur 400. Cela inclut les appels que le serveur a refusés sous `auto` : votre client ne peut pas passer outre. Pour répondre de manière interactive, utilisez plutôt `ant beta:sessions connect`. Cette commande affiche l'appel en attente et envoie cet événement lorsque vous l'autorisez ou le refusez. Consultez [Se connecter à une session Managed Agents depuis votre terminal](https://platform.claude.com/docs/fr/cli-sdks-libraries/cli/sessions-connect#follow-and-steer-the-session). Dans les exemples suivants, les ID des événements d'utilisation d'outils proviennent du tableau `stop_reason.event_ids` de l'événement `session.status_idle`. Pour en savoir plus sur la réception des événements, consultez le guide [Flux d'événements de session](https://platform.claude.com/docs/fr/managed-agents/events-and-streaming#stream-events), ou [abonnez-vous aux webhooks](https://platform.claude.com/docs/fr/managed-agents/webhooks) pour être averti lorsqu'une session se met en pause en attente d'une entrée. ```bash cURL # Autoriser l'exécution de l'outil. curl -fsSL "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.tool_confirmation", "tool_use_id": "'$AGENT_TOOL_USE_EVENT_ID'", "result": "allow" } ] }' # Ou la refuser avec une explication. curl -fsSL "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.tool_confirmation", "tool_use_id": "'$MCP_TOOL_USE_EVENT_ID'", "result": "deny", "deny_message": "Don'\''t create issues in the production project. Use the staging project." } ] }' ``` ```bash CLI # Autoriser l'exécution de l'outil ant beta:sessions:events send \ --session-id "$SESSION_ID" \ --event "{type: user.tool_confirmation, tool_use_id: $AGENT_TOOL_USE_EVENT_ID, result: allow}" # Ou la refuser avec une explication ant beta:sessions:events send \ --session-id "$SESSION_ID" \ --event "{type: user.tool_confirmation, tool_use_id: $MCP_TOOL_USE_EVENT_ID, result: deny, deny_message: Don't create issues in the production project. Use the staging project.}" ``` ```python Python # Autoriser l'exécution de l'outil client.beta.sessions.events.send( session.id, events=[ { "type": "user.tool_confirmation", "tool_use_id": agent_tool_use_event.id, "result": "allow", }, ], ) # Ou la refuser avec une explication client.beta.sessions.events.send( session.id, events=[ { "type": "user.tool_confirmation", "tool_use_id": mcp_tool_use_event.id, "result": "deny", "deny_message": "Don't create issues in the production project. Use the staging project.", }, ], ) ``` ```typescript TypeScript // Autoriser l'exécution de l'outil await client.beta.sessions.events.send(session.id, { events: [ { type: "user.tool_confirmation", tool_use_id: agent_tool_use_event.id, result: "allow" } ] }); // Ou la refuser avec une explication await client.beta.sessions.events.send(session.id, { events: [ { type: "user.tool_confirmation", tool_use_id: mcp_tool_use_event.id, result: "deny", deny_message: "Don't create issues in the production project. Use the staging project." } ] }); ``` ```csharp C# // Autoriser l'exécution de l'outil await client.Beta.Sessions.Events.Send(session.ID, new() { Events = [ new BetaManagedAgentsUserToolConfirmationEventParams { Type = BetaManagedAgentsUserToolConfirmationEventParamsType.UserToolConfirmation, ToolUseID = agentToolUseEvent.ID, Result = "allow", }, ], }); // Ou la refuser avec une explication await client.Beta.Sessions.Events.Send(session.ID, new() { Events = [ new BetaManagedAgentsUserToolConfirmationEventParams { Type = BetaManagedAgentsUserToolConfirmationEventParamsType.UserToolConfirmation, ToolUseID = mcpToolUseEvent.ID, Result = "deny", DenyMessage = "Don't create issues in the production project. Use the staging project.", }, ], }); ``` ```go Go // Autoriser l'exécution de l'outil _, err = client.Beta.Sessions.Events.Send(ctx, session.ID, anthropic.BetaSessionEventSendParams{ Events: []anthropic.BetaManagedAgentsEventParamsUnion{{ OfUserToolConfirmation: &anthropic.BetaManagedAgentsUserToolConfirmationEventParams{ Type: anthropic.BetaManagedAgentsUserToolConfirmationEventParamsTypeUserToolConfirmation, ToolUseID: agentToolUseEvent.ID, Result: anthropic.BetaManagedAgentsUserToolConfirmationEventParamsResultAllow, }, }}, }) if err != nil { panic(err) } // Ou la refuser avec une explication _, err = client.Beta.Sessions.Events.Send(ctx, session.ID, anthropic.BetaSessionEventSendParams{ Events: []anthropic.BetaManagedAgentsEventParamsUnion{{ OfUserToolConfirmation: &anthropic.BetaManagedAgentsUserToolConfirmationEventParams{ Type: anthropic.BetaManagedAgentsUserToolConfirmationEventParamsTypeUserToolConfirmation, ToolUseID: mcpToolUseEvent.ID, Result: anthropic.BetaManagedAgentsUserToolConfirmationEventParamsResultDeny, DenyMessage: anthropic.String("Don't create issues in the production project. Use the staging project."), }, }}, }) if err != nil { panic(err) } ``` ```java Java // Autoriser l'exécution de l'outil client.beta().sessions().events().send( session.id(), EventSendParams.builder() .addEvent( BetaManagedAgentsUserToolConfirmationEventParams.builder() .type(BetaManagedAgentsUserToolConfirmationEventParams.Type.USER_TOOL_CONFIRMATION) .toolUseId(agentToolUseEvent.id()) .result(BetaManagedAgentsUserToolConfirmationEventParams.Result.ALLOW) .build() ) .build() ); // Ou la refuser avec une explication client.beta().sessions().events().send( session.id(), EventSendParams.builder() .addEvent( BetaManagedAgentsUserToolConfirmationEventParams.builder() .type(BetaManagedAgentsUserToolConfirmationEventParams.Type.USER_TOOL_CONFIRMATION) .toolUseId(mcpToolUseEvent.id()) .result(BetaManagedAgentsUserToolConfirmationEventParams.Result.DENY) .denyMessage("Don't create issues in the production project. Use the staging project.") .build() ) .build() ); ``` ```php PHP use Anthropic\Beta\Sessions\Events\ManagedAgentsUserToolConfirmationEventParams; // Autoriser l'exécution de l'outil $client->beta->sessions->events->send( $session->id, events: [ ManagedAgentsUserToolConfirmationEventParams::with( type: 'user.tool_confirmation', toolUseID: $agentToolUseEvent->id, result: 'allow', ), ], ); // Ou la refuser avec une explication $client->beta->sessions->events->send( $session->id, events: [ ManagedAgentsUserToolConfirmationEventParams::with( type: 'user.tool_confirmation', toolUseID: $mcpToolUseEvent->id, result: 'deny', denyMessage: "Don't create issues in the production project. Use the staging project.", ), ], ); ``` ```ruby Ruby # Autoriser l'exécution de l'outil client.beta.sessions.events.send_( session.id, events: [ { type: "user.tool_confirmation", tool_use_id: agent_tool_use_event.id, result: "allow" } ] ) # Ou la refuser avec une explication client.beta.sessions.events.send_( session.id, events: [ { type: "user.tool_confirmation", tool_use_id: mcp_tool_use_event.id, result: "deny", deny_message: "Don't create issues in the production project. Use the staging project." } ] ) ``` ## Outils personnalisés Les politiques d'autorisation ne s'appliquent pas aux outils personnalisés. Lorsque l'agent invoque un outil personnalisé, votre application reçoit un événement `agent.custom_tool_use` et est chargée de décider s'il faut l'exécuter avant de renvoyer un `user.custom_tool_result`. Consultez [Flux d'événements de session](https://platform.claude.com/docs/fr/managed-agents/events-and-streaming#answer-tool-calls-that-pause-the-session) pour le flux complet. ## Étapes suivantes Attachez à votre agent une expertise réutilisable, basée sur le système de fichiers, pour des flux de travail spécifiques à un domaine. Envoyez des événements, diffusez les réponses en streaming, et interrompez ou redirigez votre session en cours d'exécution.