--- title: Berechtigungsrichtlinien url: https://platform.claude.com/docs/de/managed-agents/permission-policies description: Steuere, wann Agent- und MCP-Tools ausgeführt werden. featureMetadata: topic: title: Managed Agents url: https://platform.claude.com/docs/en/managed-agents/overview status: beta betaHeader: managed-agents-2026-04-01 --- „Permission policies" (Berechtigungsrichtlinien) steuern, ob serverseitig ausgeführte Tools (das vorgefertigte Agent-Toolset und das MCP-Toolset) automatisch laufen, auf deine Genehmigung warten oder jeden Aufruf vom Server bewerten lassen. „Custom tools" (benutzerdefinierte Tools) werden von deiner Anwendung ausgeführt und von dir gesteuert, daher unterliegen sie keinen Berechtigungsrichtlinien. ## Typen von Berechtigungsrichtlinien | Richtlinie | Verhalten | | -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `always_allow` | Das Tool wird automatisch ohne Bestätigung ausgeführt. | | `always_ask` | Die Sitzung pausiert und wartet vor der Ausführung auf deine Genehmigung. Den Ereignisablauf findest du unter [Auf Bestätigungsanfragen antworten](https://platform.claude.com/docs/de/managed-agents/permission-policies#respond-to-confirmation-requests). | | `auto` | Der Server bewertet jeden Aufruf und führt ihn aus, lehnt ihn ab oder pausiert für deine Genehmigung. Siehe [Den Server jeden Aufruf mit `auto` bewerten lassen](https://platform.claude.com/docs/de/managed-agents/permission-policies#let-the-server-evaluate-each-call-with-auto). | Jede Toolset-Art hat ihren eigenen Standardwert: Das Agent-Toolset verwendet standardmäßig `always_allow`, und MCP-Toolsets verwenden standardmäßig `always_ask`. Eine Berechtigungsrichtlinie steuert, wann ein aktiviertes Tool ausgeführt wird. Um ein Tool vollständig aus dem Agenten zu entfernen, deaktiviere es stattdessen. Siehe [Bestimmte Tools deaktivieren](https://platform.claude.com/docs/de/managed-agents/tools#disabling-specific-tools). ## Eine Richtlinie für ein Toolset festlegen Du legst Berechtigungsrichtlinien in der `tools` (csharp, go: `Tools`)-Konfiguration des Agenten fest, wenn du den Agenten erstellst, und du kannst sie später ändern, indem du [den Agenten aktualisierst](https://platform.claude.com/docs/de/managed-agents/agent-setup#update-an-agent). Laufende Sessions behalten die Toolset-Konfiguration, mit der sie erstellt wurden. Aktualisierungen gelten für danach erstellte Sessions. ### Berechtigungen für das Agent-Toolset Beim Erstellen eines Agenten kannst du mit `default_config.permission_policy` (java, php: `defaultConfig.permissionPolicy`; csharp, go: `DefaultConfig.PermissionPolicy`) eine Richtlinie auf jedes Tool in `agent_toolset_20260401` anwenden: ```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`) ist optional. Wenn du es weglässt, wird das Agent-Toolset mit der Standard-Berechtigungsrichtlinie `always_allow` aktiviert. ### Berechtigungen für MCP-Toolsets MCP-Toolsets verwenden standardmäßig `always_ask`. Dadurch wird sichergestellt, dass neue Tools, die einem MCP-Server hinzugefügt werden, in deiner Anwendung nicht ohne Genehmigung ausgeführt werden. Um Tools von einem vertrauenswürdigen MCP-Server automatisch zu genehmigen, setze `default_config.permission_policy` (java, php: `defaultConfig.permissionPolicy`; csharp, go: `DefaultConfig.PermissionPolicy`) im `mcp_toolset`-Eintrag. Der Wert `mcp_server_name` (java, php: `mcpServerName`; csharp: `McpServerName`; go: `MCPServerName`) muss mit dem `name` (csharp, go: `Name`) eines Servers im Array `mcp_servers` (java, php: `mcpServers`; csharp: `McpServers`; go: `MCPServers`) übereinstimmen. Dieses Beispiel verbindet einen GitHub-MCP-Server und erlaubt, dass dessen Tools ohne Bestätigung ausgeführt werden: ```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"} } } ] ) ``` ## Die Richtlinie eines einzelnen Tools überschreiben Verwende das Array `configs` (csharp, go: `Configs`), um den Standard für einzelne Tools zu überschreiben. Die `name` (csharp, go: `Name`)-Werte für das Agent-Toolset sind unter [Verfügbare Tools](https://platform.claude.com/docs/de/managed-agents/tools#available-tools) aufgeführt. Dieses Beispiel erlaubt standardmäßig das gesamte Agent-Toolset, verlangt aber eine Bestätigung, bevor ein Bash-Befehl ausgeführt wird: ```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"} } ] } ] ``` Übergib diese `tools` (csharp, go: `Tools`)-Konfiguration in der Anfrage zum Erstellen des Agenten (der CLI-Tab zeigt den vollständigen Befehl). MCP-Toolsets unterstützen dieselben Überschreibungen pro Tool, wobei `name` (csharp, go: `Name`) auf den vom MCP-Server gemeldeten Tool-Namen gesetzt wird. Siehe [Konfigurieren, welche MCP-Tools verfügbar sind](https://platform.claude.com/docs/de/managed-agents/mcp-connector#configure-which-mcp-tools-are-available). ## Den Server jeden Aufruf mit `auto` bewerten lassen Mit der Berechtigungsrichtlinie `auto` bewertet der Server jeden Aufruf, bevor er ausgeführt wird. Da die Bewertung das Tool, die Eingabe des Aufrufs und den bisherigen Inhalt der Sitzung berücksichtigt, kann der Server zwei Aufrufe desselben Tools unterschiedlich behandeln. Jeder Aufruf hat eines von drei Ergebnissen: * **Der Aufruf wird ausgeführt.** Wenn der Server feststellt, dass der Aufruf sicher ist, wird das Tool so ausgeführt wie unter `always_allow`. * **Der Aufruf wird abgelehnt.** Wenn der Server den Aufruf als hochriskant bewertet, wird das Tool nicht ausgeführt. Der Agent erhält ein fehlerhaftes Tool-Ergebnis mit dem Inhalt `Permission to use {tool_name} has been denied.` und `is_error: true`. Die Sitzung läuft weiter, und dein Client kann die Ablehnung nicht überschreiben. * **Der Aufruf pausiert für deine Genehmigung.** Wenn der Server zu keiner Entscheidung kommt, pausiert die Sitzung wie unter `always_ask`. Siehe [Auf Bestätigungsanfragen antworten](https://platform.claude.com/docs/de/managed-agents/permission-policies#respond-to-confirmation-requests). Um `auto` zu aktivieren, setze `permission_policy` auf `{"type": "auto"}`. Es gehört an dieselben zwei Stellen wie die anderen Richtlinien: in die [`default_config` (java, php: `defaultConfig`; csharp, go: `DefaultConfig`)](https://platform.claude.com/docs/de/managed-agents/permission-policies#set-a-policy-for-a-toolset) eines Toolsets für das gesamte Toolset oder in einen [`configs` (csharp, go: `Configs`)-Eintrag](https://platform.claude.com/docs/de/managed-agents/permission-policies#override-an-individual-tool-policy) für ein einzelnes Tool. Sowohl das Agent-Toolset als auch MCP-Toolsets akzeptieren es. Kein Toolset verwendet standardmäßig `auto`. Das folgende Beispiel setzt `auto` als Standard für das Agent-Toolset und für das `github`-MCP-Toolset und überschreibt `bash` mit `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"} } } ] ) ``` Was du in `user.message`-Ereignissen sendest, gilt als deine Absicht und kann dazu führen, dass der Server einen Aufruf erlaubt, den er sonst ablehnen würde. Der Server liest keine Absicht aus einem Tool-Ergebnis, einer abgerufenen Webseite, der Antwort eines MCP-Servers oder einer Nachricht zwischen [Session-Threads](https://platform.claude.com/docs/de/managed-agents/session-threads#tool-permissions-and-custom-tools). Er bewertet diese Inhalte, nimmt aber keine Anweisungen daraus entgegen. Manche Aufrufe bewertet der Server als hochriskant, unabhängig davon, wer fragt. Wenn du nicht vertrauenswürdige Eingaben von Endnutzern in `user.message`-Ereignissen weiterleitest, liest der Server diese Eingaben ebenfalls als deine Absicht, und sie können dazu führen, dass ein Aufruf erlaubt wird. Konfiguriere `always_ask` für die Tools, die dieser Endnutzer nicht ohne Überprüfung ausführen dürfte. `auto` ist kein menschlicher Kontrollpunkt. Wenn der Server feststellt, dass ein Aufruf sicher ist, wird der Aufruf ausgeführt, bevor ihn jemand sieht, und seine Auswirkungen sind möglicherweise nicht umkehrbar. Wenn eine Person die Aufrufe eines Tools vor ihrer Ausführung überprüfen muss, konfiguriere `always_ask` für dieses Tool. ## Sehen, wie jeder Aufruf bewertet wurde Unter jeder Berechtigungsrichtlinie enthält jedes `agent.tool_use`- und `agent.mcp_tool_use`-Ereignis `evaluated_permission`, das Ergebnis der Berechtigungsprüfung des Aufrufs: `"allow"`, `"ask"` oder `"deny"`. Die meisten Ereignisse enthalten außerdem ein `evaluation`-Objekt, dessen `type` die Richtlinie benennt, die dieses Ergebnis erzeugt hat. Unter `auto` hält das Objekt zusätzlich die Entscheidung des Servers fest, sowie einen `reason_code`, wenn das Ergebnis `ask` oder `deny` ist. Wenn beispielsweise `bash` unter `auto` steht und der Server einen Aufruf als hochriskant bewertet, erscheint der abgelehnte Aufruf im Ereignisstream wie folgt: ```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" } ``` Das `evaluation`-Objekt nimmt eine der Formen aus der folgenden Tabelle an. | `evaluation` | `evaluated_permission` auf oberster Ebene | Bedeutung | | ------------------------------------------------------------------------------------------- | ----------------------------------------- | ----------------------------------------------------------------------------------------------------- | | `{"type": "always_allow"}` | `"allow"` | Die aufgelöste Richtlinie ist `always_allow`, daher wurde der Aufruf ausgeführt. | | `{"type": "always_ask"}` | `"ask"` | Die aufgelöste Richtlinie ist `always_ask`, daher pausierte der Aufruf für deine Genehmigung. | | `{"type": "auto", "evaluated_permission": {"type": "allow"}}` | `"allow"` | Unter `auto` hat der Server festgestellt, dass der Aufruf sicher war, und er wurde ausgeführt. | | `{"type": "auto", "evaluated_permission": {"type": "ask", "reason_code": "indeterminate"}}` | `"ask"` | Unter `auto` kam der Server zu keiner Entscheidung, daher pausierte der Aufruf für deine Genehmigung. | | `{"type": "auto", "evaluated_permission": {"type": "deny", "reason_code": "high_risk"}}` | `"deny"` | Unter `auto` hat der Server den Aufruf als hochriskant bewertet und abgelehnt. | Wenn `evaluation.type` den Wert `"auto"` hat, wiederholt das verschachtelte `evaluated_permission.type` das `evaluated_permission` des Ereignisses auf oberster Ebene, sodass du das Ergebnis aus beiden Feldern lesen kannst. Ein `reason_code` ist ein Wert, anhand dessen dein Client verzweigen und den er in Audit-Aufzeichnungen festhalten kann, kein Text zur Anzeige für Endnutzer. `evaluation` fehlt in zwei Fällen. Wenn der Agent ein Tool benennt, das in der Sitzung nicht aktiviert ist, lehnt der Server den Aufruf ab, ohne eine Richtlinie zu bewerten: Das Ereignis enthält `evaluated_permission: "deny"` und kein `evaluation`. Ereignisse, die vor der Einführung von `evaluation` aufgezeichnet wurden, lassen es ebenfalls weg: Interpretiere diese als `always_allow`, wenn `evaluated_permission` den Wert `"allow"` hat, und als `always_ask`, wenn es `"ask"` ist. Schreibe deinen Client so, dass er einen `evaluation.type` oder `reason_code` toleriert, den er nicht kennt. `agent.custom_tool_use`-Ereignisse enthalten keines der beiden Felder, da Berechtigungsrichtlinien nicht für [benutzerdefinierte Tools](https://platform.claude.com/docs/de/managed-agents/permission-policies#custom-tools) gelten. ## Auf Bestätigungsanfragen antworten Ein Tool-Aufruf wird unter einer `always_ask`-Richtlinie zu `ask` ausgewertet, oder unter `auto`, wenn der Server zu keiner Entscheidung kommt. Wenn das passiert: 1. Die Session gibt ein `agent.tool_use`- oder `agent.mcp_tool_use`-Ereignis aus. 2. Die Session pausiert mit einem `session.status_idle`-Ereignis, dessen `stop_reason.type` den Wert `requires_action` hat. Die IDs der blockierenden Ereignisse befinden sich im Array `stop_reason.event_ids`. Die Session wartet unbegrenzt auf eine Antwort. Ein Aufruf aus einem Thread eines [Workflow-Runs](https://platform.claude.com/docs/de/managed-agents/workflow-runs#while-a-run-is-open) erreicht deinen Client über den primären Stream. Solange irgendetwas anderes in der Session arbeitet, kann die Session im Status `running` bleiben und kein `session.status_idle` senden, also antworte direkt auf das Tool-Use-Ereignis. Der Aufruf wartet nur, bis der Run mit diesem Thread fertig ist oder der Run endet. Eine Unterbrechung kann ihn wartend zurücklassen, also erlaube oder lehne ihn selbst ab. 3. Sende für jedes blockierende Ereignis ein `user.tool_confirmation`-Ereignis und übergib die Ereignis-ID im Parameter `tool_use_id` (java: `toolUseId`; php: `toolUseID`; csharp, go: `ToolUseID`). Setze `result` (csharp, go: `Result`) auf `"allow"` oder `"deny"`. Verwende `deny_message` (java, php: `denyMessage`; csharp, go: `DenyMessage`), um eine Ablehnung zu begründen. Du kannst mehrere Bestätigungen in einer einzigen `events`-Anfrage senden. 4. Sobald alle blockierenden Ereignisse aufgelöst sind, wechselt die Session zurück zu `running`. Erlaubte Tools werden ausgeführt. Abgelehnte Tools werden nicht ausgeführt, und der Agent erhält ein Tool-Ergebnis, das besagt, dass der Aufruf abgelehnt wurde, einschließlich deiner `deny_message` (java, php: `denyMessage`; csharp, go: `DenyMessage`). Ein `bash`-Aufruf, der unter einer `always_ask`-Richtlinie pausiert wurde, erscheint im Stream zum Beispiel wie folgt: ```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" } ``` Wenn du ein `user.tool_confirmation` für ein Ereignis sendest, dessen `evaluated_permission` (java, php: `evaluatedPermission`; csharp, go: `EvaluatedPermission`) nicht `ask` ist, lehnt die API es mit einem 400-Fehler ab. Das schließt Aufrufe ein, die der Server unter `auto` abgelehnt hat: Dein Client kann sie nicht überschreiben. Um stattdessen interaktiv zu antworten, verwende `ant beta:sessions connect`. Dieser Befehl zeigt den wartenden Aufruf an und sendet dieses Ereignis, wenn du ihn erlaubst oder ablehnst. Siehe [Von deinem Terminal aus eine Verbindung zu einer Managed-Agents-Sitzung herstellen](https://platform.claude.com/docs/de/cli-sdks-libraries/cli/sessions-connect#follow-and-steer-the-session). In den folgenden Beispielen stammen die IDs der Tool-Use-Ereignisse aus dem Array `stop_reason.event_ids` des `session.status_idle`-Ereignisses. Mehr über den Empfang von Ereignissen erfährst du im Leitfaden [Session-Ereignisstream](https://platform.claude.com/docs/de/managed-agents/events-and-streaming#stream-events), oder [abonniere Webhooks](https://platform.claude.com/docs/de/managed-agents/webhooks), um benachrichtigt zu werden, wenn eine Session für eine Eingabe pausiert. ```bash cURL # Erlaube die Ausführung des Tools 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" } ] }' # Oder lehne es mit einer Begründung ab 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 # Erlaube dem Tool die Ausführung ant beta:sessions:events send \ --session-id "$SESSION_ID" \ --event "{type: user.tool_confirmation, tool_use_id: $AGENT_TOOL_USE_EVENT_ID, result: allow}" # Oder lehne es mit einer Erklärung ab 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 # Erlaube die Ausführung des Tools client.beta.sessions.events.send( session.id, events=[ { "type": "user.tool_confirmation", "tool_use_id": agent_tool_use_event.id, "result": "allow", }, ], ) # Oder lehne sie mit einer Begründung ab 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 // Erlaube die Ausführung des Tools await client.beta.sessions.events.send(session.id, { events: [ { type: "user.tool_confirmation", tool_use_id: agent_tool_use_event.id, result: "allow" } ] }); // Oder lehne sie mit einer Begründung ab 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# // Erlaube die Ausführung des Tools await client.Beta.Sessions.Events.Send(session.ID, new() { Events = [ new BetaManagedAgentsUserToolConfirmationEventParams { Type = BetaManagedAgentsUserToolConfirmationEventParamsType.UserToolConfirmation, ToolUseID = agentToolUseEvent.ID, Result = "allow", }, ], }); // Oder lehne sie mit einer Begründung ab 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 // Erlaube die Ausführung des Tools _, 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) } // Oder lehne sie mit einer Erklärung ab _, 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 // Erlaube die Ausführung des Tools 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() ); // Oder lehne sie mit einer Begründung ab 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; // Erlaube die Ausführung des Tools $client->beta->sessions->events->send( $session->id, events: [ ManagedAgentsUserToolConfirmationEventParams::with( type: 'user.tool_confirmation', toolUseID: $agentToolUseEvent->id, result: 'allow', ), ], ); // Oder lehne sie mit einer Begründung ab $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 # Erlaube die Ausführung des Tools client.beta.sessions.events.send_( session.id, events: [ { type: "user.tool_confirmation", tool_use_id: agent_tool_use_event.id, result: "allow" } ] ) # Oder lehne sie mit einer Begründung ab 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." } ] ) ``` ## Benutzerdefinierte Tools Berechtigungsrichtlinien gelten nicht für benutzerdefinierte Tools. Wenn der Agent ein benutzerdefiniertes Tool aufruft, erhält deine Anwendung ein `agent.custom_tool_use`-Ereignis und ist dafür verantwortlich, zu entscheiden, ob sie es ausführt, bevor sie ein `user.custom_tool_result` zurücksendet. Siehe [Session-Ereignisstream](https://platform.claude.com/docs/de/managed-agents/events-and-streaming#answer-tool-calls-that-pause-the-session) für den vollständigen Ablauf. ## Nächste Schritte Füge deinem Agenten wiederverwendbares, dateisystembasiertes Fachwissen für domänenspezifische Workflows hinzu. Sende Ereignisse, streame Antworten und unterbrich oder lenke deine Session während der Ausführung um.