---
title: 権限ポリシー
url: https://platform.claude.com/docs/ja/managed-agents/permission-policies
description: エージェントツールとMCPツールの実行タイミングを制御します。
featureMetadata:
  topic:
    title: Managed Agents
    url: https://platform.claude.com/docs/en/managed-agents/overview
  status: beta
  betaHeader: managed-agents-2026-04-01
  zdr:
    eligibility: not-eligible
    note: セルフホスト型Managed Agentsを除き、ZDRの適格対象ではありません。セッションはステートフルなリソースであり、トランスクリプトは削除するまで保持されます。
  supportedModels:
    - claude-fable-5-2
    - claude-mythos-5-2
    - claude-fable-5-1
    - claude-mythos-5-1
    - claude-fable-5
    - claude-mythos-5
    - claude-mythos-preview
    - claude-opus-5-5
    - claude-opus-5
    - claude-sonnet-5-5
    - claude-sonnet-5
    - claude-haiku-5-5
    - claude-haiku-4-5-20251001
    - claude-opus-4-8
    - claude-opus-4-7
    - claude-opus-4-6
    - claude-sonnet-4-6
    - claude-opus-4-5-20251101
    - claude-sonnet-4-5-20250929
  supportedPlatforms:
    Claude API: beta
    Claude Platform on AWS: beta
    Claude Models on Google Cloud (Anthropic managed): beta
---

「permission policy」（パーミッションポリシー）は、サーバーで実行されるツール（事前構築済みのエージェントツールセットとMCPツールセット）に適用されます。ポリシーは、ツールの呼び出しを自動的に実行するか、承認を待つか、あるいはサーバーに送って各呼び出しを評価させるかを決定します。カスタムツールはアプリケーション側で実行され、ユーザー自身が制御するため、パーミッションポリシーはカスタムツールには適用されません。

## 権限ポリシーの種類

| ポリシー | 動作 |
| ----- | ----- |
| `always_allow` | ツールは確認なしで自動的に実行されます。 |
| `always_ask` | セッションは一時停止し、実行前に承認を待ちます。イベントフローについては、[確認リクエストに応答する](https://platform.claude.com/docs/ja/managed-agents/permission-policies#respond-to-confirmation-requests)を参照してください。 |
| `auto` | サーバーが各呼び出しを評価し、実行するか、拒否するか、承認を待つために一時停止します。[`auto`でサーバーに各呼び出しを評価させる](https://platform.claude.com/docs/ja/managed-agents/permission-policies#let-the-server-evaluate-each-call-with-auto)を参照してください。 |

ツールセットの種類ごとに独自のデフォルトがあります。エージェントツールセットのデフォルトは `always_allow`、MCPツールセットのデフォルトは `always_ask` です。

権限ポリシーは、有効化されたツールがいつ実行されるかを制御します。ツールをエージェントから完全に取り除くには、代わりにそのツールを無効化してください。[特定のツールを無効化する](https://platform.claude.com/docs/ja/managed-agents/tools#disabling-specific-tools)を参照してください。

## ツールセットにポリシーを設定する

権限ポリシーは、エージェントの作成時にエージェントの`tools` (csharp, go: `Tools`)設定で指定します。後から[エージェントを更新](https://platform.claude.com/docs/ja/managed-agents/agent-setup#update-an-agent)して変更することもできます。実行中のセッションは、作成時のツールセット設定を保持します。更新はその後に作成されたセッションに適用されます。

### エージェントツールセットの権限

エージェントを作成する際、`default_config.permission_policy` (java, php: `defaultConfig.permissionPolicy`; csharp, go: `DefaultConfig.PermissionPolicy`)を使用して、`agent_toolset_20260401`内のすべてのツールにポリシーを適用できます。

<CodeGroup defaultLanguage="CLI">
  ```bash cURL
  curl -fsSL https://api.anthropic.com/v1/agents \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -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"}
          }
        }
      ]
    }'
  ```

  <CodeGroupItem>
    ```bash CLI
    ant apply agent.md
    ```

    <File filename="agent.md">
      ```markdown
      ---
      name: Coding Assistant
      model: claude-opus-5-5
      tools:
        - type: agent_toolset_20260401
          default_config:
            permission_policy:
              type: always_ask
      ---
      ```
    </File>
  </CodeGroupItem>

  ```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
          {
              DefaultConfig = new()
              {
                  PermissionPolicy = new BetaManagedAgentsAlwaysAskPolicy(),
              },
          },
      ],
  });
  ```

  ```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{
  			DefaultConfig: anthropic.BetaManagedAgentsAgentToolsetDefaultConfigParams{
  				PermissionPolicy: anthropic.BetaManagedAgentsAgentToolsetDefaultConfigParamsPermissionPolicyUnion{
  					OfAlwaysAsk: &anthropic.BetaManagedAgentsAlwaysAskPolicyParam{},
  				},
  			},
  		},
  	}},
  })
  if err != nil {
  	panic(err)
  }
  ```

  ```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()
                  .defaultConfig(
                      BetaManagedAgentsAgentToolsetDefaultConfigParams.builder()
                          .permissionPolicy(BetaManagedAgentsAlwaysAskPolicy.builder().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(
              defaultConfig: BetaManagedAgentsAgentToolsetDefaultConfigParams::with(
                  permissionPolicy: BetaManagedAgentsAlwaysAskPolicy::with(),
              ),
          ),
      ],
  );
  ```

  ```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"}
        }
      }
    ]
  )
  ```
</CodeGroup>

`default_config` (java, php: `defaultConfig`; csharp, go: `DefaultConfig`)は省略可能です。省略した場合、エージェントツールセットはデフォルトの権限ポリシーである`always_allow`で有効化されます。

### MCPツールセットの権限

MCPツールセットのデフォルトは`always_ask`です。これにより、MCPサーバーに新しく追加されたツールが承認なしにアプリケーション内で実行されることを防ぎます。信頼できるMCPサーバーのツールを自動承認するには、`mcp_toolset`エントリに`default_config.permission_policy` (java, php: `defaultConfig.permissionPolicy`; csharp, go: `DefaultConfig.PermissionPolicy`)を設定します。

`mcp_server_name` (java, php: `mcpServerName`; csharp: `McpServerName`; go: `MCPServerName`)は、`mcp_servers` (java, php: `mcpServers`; csharp: `McpServers`; go: `MCPServers`)配列内のサーバーの`name` (csharp, go: `Name`)と一致している必要があります。

次の例では、GitHub MCPサーバーに接続し、そのツールを確認なしで実行できるようにします。

<CodeGroup defaultLanguage="CLI">
  ```bash cURL
  curl -fsSL https://api.anthropic.com/v1/agents \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -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"}
          }
        }
      ]
    }'
  ```

  <CodeGroupItem>
    ```bash CLI
    ant apply agent.md
    ```

    <File filename="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
      ---
      ```
    </File>
  </CodeGroupItem>

  ```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()
          {
              Name = "github",
              Url = "https://mcp.example.com/github",
          },
      ],
      Tools =
      [
          new BetaManagedAgentsAgentToolset20260401Params(),
          new BetaManagedAgentsMcpToolsetParams
          {
              McpServerName = "github",
              DefaultConfig = new()
              {
                  PermissionPolicy = new BetaManagedAgentsAlwaysAllowPolicy(),
              },
          },
      ],
  });
  ```

  ```go Go
  agent, err := client.Beta.Agents.New(ctx, anthropic.BetaAgentNewParams{
  	Name: "Dev Assistant",
  	Model: anthropic.BetaManagedAgentsModelConfigParams{
  		ID: anthropic.BetaManagedAgentsModelClaudeOpus5_5,
  	},
  	MCPServers: []anthropic.BetaManagedAgentsURLMCPServerParams{{
  		Name: "github",
  		URL:  "https://mcp.example.com/github",
  	}},
  	Tools: []anthropic.BetaAgentNewParamsToolUnion{
  		{
  			OfAgentToolset20260401: &anthropic.BetaManagedAgentsAgentToolset20260401Params{},
  		},
  		{
  			OfMCPToolset: &anthropic.BetaManagedAgentsMCPToolsetParams{
  				MCPServerName: "github",
  				DefaultConfig: anthropic.BetaManagedAgentsMCPToolsetDefaultConfigParams{
  					PermissionPolicy: anthropic.BetaManagedAgentsMCPToolsetDefaultConfigParamsPermissionPolicyUnion{
  						OfAlwaysAllow: &anthropic.BetaManagedAgentsAlwaysAllowPolicyParam{},
  					},
  				},
  			},
  		},
  	},
  })
  if err != nil {
  	panic(err)
  }
  ```

  ```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()
                  .name("github")
                  .url("https://mcp.example.com/github")
                  .build()
          )
          .addTool(BetaManagedAgentsAgentToolset20260401Params.builder().build())
          .addTool(
              BetaManagedAgentsMcpToolsetParams.builder()
                  .mcpServerName("github")
                  .defaultConfig(
                      BetaManagedAgentsMcpToolsetDefaultConfigParams.builder()
                          .permissionPolicy(BetaManagedAgentsAlwaysAllowPolicy.builder().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(
              name: 'github',
              url: 'https://mcp.example.com/github',
          ),
      ],
      tools: [
          BetaManagedAgentsAgentToolset20260401Params::with(),
          BetaManagedAgentsMCPToolsetParams::with(
              mcpServerName: 'github',
              defaultConfig: BetaManagedAgentsMCPToolsetDefaultConfigParams::with(
                  permissionPolicy: BetaManagedAgentsAlwaysAllowPolicy::with(),
              ),
          ),
      ],
  );
  ```

  ```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"}
        }
      }
    ]
  )
  ```
</CodeGroup>

## 個別のツールポリシーを上書きする

`configs` (csharp, go: `Configs`)配列を使用して、個別のツールのデフォルトを上書きします。エージェントツールセットの`name` (csharp, go: `Name`)の値は、[利用可能なツール](https://platform.claude.com/docs/ja/managed-agents/tools#available-tools)に記載されています。この例では、エージェントツールセット全体をデフォルトで許可しつつ、bashコマンドの実行前には確認を必須にしています。

<CodeGroup defaultLanguage="CLI">
  ```bash cURL
  curl -fsSL https://api.anthropic.com/v1/agents \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -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_allow"}
          },
          "configs": [
            {
              "name": "bash",
              "permission_policy": {"type": "always_ask"}
            }
          ]
        }
      ]
    }'
  ```

  <CodeGroupItem>
    ```bash CLI
    ant apply agent.md
    ```

    <File filename="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
      ---
      ```
    </File>
  </CodeGroupItem>

  ```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
      {
          DefaultConfig = new()
          {
              PermissionPolicy = new BetaManagedAgentsAlwaysAllowPolicy(),
          },
          Configs =
          [
              new BetaManagedAgentsBashToolConfigParams
              {
                  PermissionPolicy = new BetaManagedAgentsAlwaysAskPolicy(),
              },
          ],
      },
  ];
  ```

  ```go Go
  tools := []anthropic.BetaAgentNewParamsToolUnion{{
  	OfAgentToolset20260401: &anthropic.BetaManagedAgentsAgentToolset20260401Params{
  		DefaultConfig: anthropic.BetaManagedAgentsAgentToolsetDefaultConfigParams{
  			PermissionPolicy: anthropic.BetaManagedAgentsAgentToolsetDefaultConfigParamsPermissionPolicyUnion{
  				OfAlwaysAllow: &anthropic.BetaManagedAgentsAlwaysAllowPolicyParam{},
  			},
  		},
  		Configs: []anthropic.BetaManagedAgentsAgentToolConfigParamsUnion{{
  			OfBash: &anthropic.BetaManagedAgentsBashToolConfigParams{
  				PermissionPolicy: anthropic.BetaManagedAgentsBashToolConfigParamsPermissionPolicyUnion{
  					OfAlwaysAsk: &anthropic.BetaManagedAgentsAlwaysAskPolicyParam{},
  				},
  			},
  		}},
  	},
  }}
  ```

  ```java Java
  import com.anthropic.models.beta.agents.*;
  import java.util.List;

  var tools = List.of(
      AgentCreateParams.Tool.ofAgentToolset20260401(
          BetaManagedAgentsAgentToolset20260401Params.builder()
              .defaultConfig(
                  BetaManagedAgentsAgentToolsetDefaultConfigParams.builder()
                      .permissionPolicy(BetaManagedAgentsAlwaysAllowPolicy.builder().build())
                      .build()
              )
              .addConfig(
                  BetaManagedAgentsBashToolConfigParams.builder()
                      .permissionPolicy(BetaManagedAgentsAlwaysAskPolicy.builder().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(
          defaultConfig: BetaManagedAgentsAgentToolsetDefaultConfigParams::with(
              permissionPolicy: BetaManagedAgentsAlwaysAllowPolicy::with(),
          ),
          configs: [
              BetaManagedAgentsBashToolConfigParams::with(
                  permissionPolicy: BetaManagedAgentsAlwaysAskPolicy::with(),
              ),
          ],
      ),
  ];
  ```

  ```ruby Ruby
  tools = [
    {
      type: "agent_toolset_20260401",
      default_config: {
        permission_policy: {type: "always_allow"}
      },
      configs: [
        {
          name: "bash",
          permission_policy: {type: "always_ask"}
        }
      ]
    }
  ]
  ```
</CodeGroup>

この`tools` (csharp, go: `Tools`)設定をエージェントの作成時に渡します。MCPツールセットも同じツールごとの上書きをサポートしており、`name` (csharp, go: `Name`)にはMCPサーバーが報告するツール名を設定します。[利用可能なMCPツールを設定する](https://platform.claude.com/docs/ja/managed-agents/mcp-connector#configure-which-mcp-tools-are-available)を参照してください。

## `auto`でサーバーに各呼び出しを評価させる

`auto`権限ポリシーでは、サーバーが各呼び出しを実行前に評価します。評価ではツール、呼び出しの入力、およびその時点までのセッションの内容が考慮されるため、サーバーは同じツールへの2つの呼び出しを異なる方法で扱うことがあります。各呼び出しの結果は次の3つのいずれかになります。

* **呼び出しが実行される。** サーバーが呼び出しを安全と判断した場合、ツールは`always_allow`の場合と同様に実行されます。
* **呼び出しが拒否される。** サーバーが呼び出しを高リスクと評価した場合、ツールは実行されません。エージェントは、内容が`Permission to use {tool_name} has been denied.`で`is_error: true`のエラーツール結果を受け取ります。セッションは実行を継続し、クライアントはこの拒否を上書きできません。
* **呼び出しが承認待ちで一時停止する。** サーバーが判断に至らなかった場合、セッションは`always_ask`の場合と同様に一時停止します。[確認リクエストに応答する](https://platform.claude.com/docs/ja/managed-agents/permission-policies#respond-to-confirmation-requests)を参照してください。

`auto`を有効にするには、`permission_policy` (java, php: `permissionPolicy`; csharp, go: `PermissionPolicy`)を`{"type": "auto"}`に設定します。設定場所は他のポリシーと同じ2か所です。ツールセット全体に対してはツールセットの[`default_config` (java, php: `defaultConfig`; csharp, go: `DefaultConfig`)](https://platform.claude.com/docs/ja/managed-agents/permission-policies#set-a-policy-for-a-toolset)、1つのツールに対しては[`configs` (csharp, go: `Configs`)エントリ](https://platform.claude.com/docs/ja/managed-agents/permission-policies#override-an-individual-tool-policy)です。エージェントツールセットとMCPツールセットの両方がこれを受け付けます。デフォルトで`auto`を使用するツールセットはありません。

次の例では、エージェントツールセットと`github` MCPツールセットのデフォルトとして`auto`を設定し、`bash`を`always_ask`に上書きしています。

<CodeGroup defaultLanguage="CLI">
  ```bash cURL
  curl -fsSL https://api.anthropic.com/v1/agents \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -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"}
          }
        }
      ]
    }'
  ```

  <CodeGroupItem>
    ```bash CLI
    ant apply agent.md
    ```

    <File filename="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
      ---
      ```
    </File>
  </CodeGroupItem>

  ```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()
          {
              Name = "github",
              Url = "https://mcp.example.com/github",
          },
      ],
      Tools =
      [
          new BetaManagedAgentsAgentToolset20260401Params
          {
              DefaultConfig = new()
              {
                  PermissionPolicy = new BetaManagedAgentsAutoPolicy(),
              },
              Configs =
              [
                  new BetaManagedAgentsBashToolConfigParams
                  {
                      PermissionPolicy = new BetaManagedAgentsAlwaysAskPolicy(),
                  },
              ],
          },
          new BetaManagedAgentsMcpToolsetParams
          {
              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{{
  		Name: "github",
  		URL:  "https://mcp.example.com/github",
  	}},
  	Tools: []anthropic.BetaAgentNewParamsToolUnion{
  		{
  			OfAgentToolset20260401: &anthropic.BetaManagedAgentsAgentToolset20260401Params{
  				DefaultConfig: anthropic.BetaManagedAgentsAgentToolsetDefaultConfigParams{
  					PermissionPolicy: anthropic.BetaManagedAgentsAgentToolsetDefaultConfigParamsPermissionPolicyUnion{
  						OfAuto: &anthropic.BetaManagedAgentsAutoPolicyParam{},
  					},
  				},
  				Configs: []anthropic.BetaManagedAgentsAgentToolConfigParamsUnion{{
  					OfBash: &anthropic.BetaManagedAgentsBashToolConfigParams{
  						PermissionPolicy: anthropic.BetaManagedAgentsBashToolConfigParamsPermissionPolicyUnion{
  							OfAlwaysAsk: &anthropic.BetaManagedAgentsAlwaysAskPolicyParam{},
  						},
  					},
  				}},
  			},
  		},
  		{
  			OfMCPToolset: &anthropic.BetaManagedAgentsMCPToolsetParams{
  				MCPServerName: "github",
  				DefaultConfig: anthropic.BetaManagedAgentsMCPToolsetDefaultConfigParams{
  					PermissionPolicy: anthropic.BetaManagedAgentsMCPToolsetDefaultConfigParamsPermissionPolicyUnion{
  						OfAuto: &anthropic.BetaManagedAgentsAutoPolicyParam{},
  					},
  				},
  			},
  		},
  	},
  })
  if err != nil {
  	panic(err)
  }
  ```

  ```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()
                  .name("github")
                  .url("https://mcp.example.com/github")
                  .build()
          )
          .addTool(
              BetaManagedAgentsAgentToolset20260401Params.builder()
                  .defaultConfig(
                      BetaManagedAgentsAgentToolsetDefaultConfigParams.builder()
                          .permissionPolicy(BetaManagedAgentsAutoPolicy.builder().build())
                          .build()
                  )
                  .addConfig(
                      BetaManagedAgentsBashToolConfigParams.builder()
                          .permissionPolicy(BetaManagedAgentsAlwaysAskPolicy.builder().build())
                          .build()
                  )
                  .build()
          )
          .addTool(
              BetaManagedAgentsMcpToolsetParams.builder()
                  .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(
              name: 'github',
              url: 'https://mcp.example.com/github',
          ),
      ],
      tools: [
          BetaManagedAgentsAgentToolset20260401Params::with(
              defaultConfig: BetaManagedAgentsAgentToolsetDefaultConfigParams::with(
                  permissionPolicy: BetaManagedAgentsAutoPolicy::with(),
              ),
              configs: [
                  BetaManagedAgentsBashToolConfigParams::with(
                      permissionPolicy: BetaManagedAgentsAlwaysAskPolicy::with(),
                  ),
              ],
          ),
          BetaManagedAgentsMCPToolsetParams::with(
              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"}
        }
      }
    ]
  )
  ```
</CodeGroup>

`user.message`イベントで送信した内容はあなたの意図として扱われ、サーバーが本来なら拒否する呼び出しを許可する根拠になることがあります。サーバーは、ツール結果、取得したWebページ、MCPサーバーの応答、または[セッションスレッド](https://platform.claude.com/docs/ja/managed-agents/session-threads#tool-permissions-and-custom-tools)間のメッセージからは意図を読み取りません。サーバーはそれらの内容を評価しますが、そこから指示を受け取ることはありません。一部の呼び出しは、誰が要求したかにかかわらず、サーバーによって高リスクと評価されます。信頼できないエンドユーザーの入力を`user.message`イベントで中継する場合、サーバーはその入力もあなたの意図として読み取り、それによって呼び出しが許可される可能性があります。そのエンドユーザーにレビューなしで実行させたくないツールには、`always_ask`を設定してください。

<Warning>
  `auto`は人間によるチェックポイントではありません。サーバーが呼び出しを安全と判断した場合、その呼び出しは誰かが確認する前に実行され、その影響は元に戻せない可能性があります。ツールの呼び出しを実行前に人が確認する必要がある場合は、そのツールに`always_ask`を設定してください。
</Warning>

## 各呼び出しがどのように評価されたかを確認する

どの権限ポリシーの下でも、各`agent.tool_use`および`agent.mcp_tool_use`イベントには、呼び出しの権限チェックの結果である`evaluated_permission`（`"allow"`、`"ask"`、または`"deny"`）が含まれます。ほとんどのイベントには`evaluation`オブジェクトも含まれ、その`type`はその結果を生成したポリシーを示します。`auto`の下では、このオブジェクトにサーバーの判断も記録され、結果が`ask`または`deny`の場合は`reason_code`も記録されます。

たとえば、`bash`が`auto`の下にあり、サーバーが呼び出しを高リスクと評価した場合、拒否された呼び出しはイベントストリーム上で次のように表示されます。

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

`evaluation`オブジェクトは、次の表のいずれかの形式をとります。

| `evaluation` | トップレベルの`evaluated_permission` | 意味 |
| ----- | ----- | ----- |
| `{"type": "always_allow"}` | `"allow"` | 解決されたポリシーが`always_allow`であるため、呼び出しが実行されました。 |
| `{"type": "always_ask"}` | `"ask"` | 解決されたポリシーが`always_ask`であるため、呼び出しは承認待ちで一時停止しました。 |
| `{"type": "auto", "evaluated_permission": {"type": "allow"}}` | `"allow"` | `auto`の下で、サーバーが呼び出しを安全と判断し、実行されました。 |
| `{"type": "auto", "evaluated_permission": {"type": "ask", "reason_code": "indeterminate"}}` | `"ask"` | `auto`の下で、サーバーが判断に至らなかったため、呼び出しは承認待ちで一時停止しました。 |
| `{"type": "auto", "evaluated_permission": {"type": "deny", "reason_code": "high_risk"}}` | `"deny"` | `auto`の下で、サーバーが呼び出しを高リスクと評価し、拒否しました。 |

`evaluation.type`が`"auto"`の場合、ネストされた`evaluated_permission.type`はイベントのトップレベルの`evaluated_permission`と同じ値になるため、どちらのフィールドからでも結果を読み取れます。`reason_code`は、クライアントで分岐処理に使用したり監査記録に保存したりするための値であり、エンドユーザーに表示するためのテキストではありません。

`evaluation`が存在しないケースは2つあります。エージェントがセッションで有効化されていないツールを指定した場合、サーバーはポリシーを評価せずに呼び出しを拒否します。このとき、イベントには`evaluated_permission: "deny"`が含まれ、`evaluation`は含まれません。また、`evaluation`が導入される前に記録されたイベントにも含まれません。そのようなイベントは、`evaluated_permission`が`"allow"`の場合は`always_allow`、`"ask"`の場合は`always_ask`として解釈してください。

クライアントは、認識できない`evaluation.type`や`reason_code`を許容するように実装してください。権限ポリシーは[カスタムツール](https://platform.claude.com/docs/ja/managed-agents/permission-policies#custom-tools)には適用されないため、`agent.custom_tool_use`イベントにはどちらのフィールドも含まれません。

## 確認リクエストに応答する

ツール呼び出しは、`always_ask`ポリシーの下、またはサーバーが判断に至らなかった場合の`auto`の下で、`ask`と評価されます。その場合、次のようになります。

1. セッションが `agent.tool_use` または `agent.mcp_tool_use` イベントを発行します。
2. セッションは、`stop_reason.type`が`requires_action`である`session.status_idle`イベントとともに一時停止します。ブロックしているイベントIDは`stop_reason.event_ids`配列に含まれます。セッションは応答を無期限に待ちます。[ワークフロー実行](https://platform.claude.com/docs/ja/managed-agents/workflow-runs#while-a-run-is-open)のスレッドからの呼び出しは、プライマリストリーム上でクライアントに届きます。セッション内で他の処理が動作している間、セッションは`running`のままで`session.status_idle`を送信しないことがあるため、ツール使用イベント自体に応答してください。呼び出しが待機するのは、実行がそのスレッドの処理を終えるか、実行が終了するまでです。中断によって待機状態のまま残る可能性があるため、自分で許可または拒否してください。
3. ブロックしている各イベントに対して`user.tool_confirmation`イベントを送信し、`tool_use_id` (java: `toolUseId`; php: `toolUseID`; csharp, go: `ToolUseID`)パラメータにイベントIDを渡します。`result` (csharp, go: `Result`)を`"allow"`または`"deny"`に設定します。拒否の理由を説明するには`deny_message` (java, php: `denyMessage`; csharp, go: `DenyMessage`)を使用します。1回の`events`リクエストで複数の確認を送信できます。
4. ブロックしているすべてのイベントが解決されると、セッションは`running`に戻ります。許可されたツールは実行されます。拒否されたツールは実行されず、エージェントは呼び出しが拒否されたことを示すツール結果（`deny_message` (java, php: `denyMessage`; csharp, go: `DenyMessage`)を含む）を受け取ります。

たとえば、`always_ask`ポリシーの下で一時停止した`bash`呼び出しは、ストリーム上で次のように表示されます。

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

`evaluated_permission` (java, php: `evaluatedPermission`; csharp, go: `EvaluatedPermission`)が`ask`ではないイベントに対して`user.tool_confirmation`を送信すると、APIは400エラーでそれを拒否します。これには`auto`の下でサーバーが拒否した呼び出しも含まれ、クライアントはそれらを上書きできません。

代わりに対話的に応答するには、`ant beta:sessions connect`を使用します。このコマンドは待機中の呼び出しを表示し、許可または拒否したときにこのイベントを送信します。[ターミナルからManaged Agentsセッションに接続する](https://platform.claude.com/docs/ja/cli-sdks-libraries/cli/sessions-connect#follow-and-steer-the-session)を参照してください。

以下の例では、ツール使用イベントのIDは`session.status_idle`イベントの`stop_reason.event_ids`配列から取得しています。詳しくは、セッションイベントストリームガイドの[イベントの受信](https://platform.claude.com/docs/ja/managed-agents/events-and-streaming#stream-events)を参照するか、セッションが入力待ちで一時停止したときに通知を受け取るために[Webhookを購読](https://platform.claude.com/docs/ja/managed-agents/webhooks)してください。

<CodeGroup>
  ```bash cURL
  # ツールの実行を許可します
  curl -fsSL https://api.anthropic.com/v1/sessions/sesn_011CZkZAtmR3yMPDzynEDxu7/events \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "anthropic-beta: managed-agents-2026-04-01" \
    -H "content-type: application/json" \
    -d '{
      "events": [
        {
          "type": "user.tool_confirmation",
          "tool_use_id": "sevt_011CZkZbMpR8aS3Wtv5Yq2Ln",
          "result": "allow"
        }
      ]
    }'

  # 理由を添えて別の呼び出しを拒否します
  curl -fsSL https://api.anthropic.com/v1/sessions/sesn_011CZkZAtmR3yMPDzynEDxu7/events \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "anthropic-beta: managed-agents-2026-04-01" \
    -H "content-type: application/json" \
    -d '{
      "events": [
        {
          "type": "user.tool_confirmation",
          "tool_use_id": "sevt_011CZkZcNqT9bT4Xuw6Zr3Mo",
          "result": "deny",
          "deny_message": "Do not create issues in the production project. Use the staging project."
        }
      ]
    }'
  ```

  ```bash CLI
  # ツールの実行を許可します
  ant beta:sessions:events send \
    --session-id sesn_011CZkZAtmR3yMPDzynEDxu7 \
    --event '{type: user.tool_confirmation, tool_use_id: sevt_011CZkZbMpR8aS3Wtv5Yq2Ln, result: allow}'

  # 理由を添えて別の呼び出しを拒否します
  ant beta:sessions:events send \
    --session-id sesn_011CZkZAtmR3yMPDzynEDxu7 \
    --event '{type: user.tool_confirmation, tool_use_id: sevt_011CZkZcNqT9bT4Xuw6Zr3Mo, result: deny, deny_message: "Do not create issues in the production project. Use the staging project."}'
  ```

  ```python Python
  # ツールの実行を許可します
  client.beta.sessions.events.send(
      "sesn_011CZkZAtmR3yMPDzynEDxu7",
      events=[
          {
              "type": "user.tool_confirmation",
              "tool_use_id": "sevt_011CZkZbMpR8aS3Wtv5Yq2Ln",
              "result": "allow",
          },
      ],
  )

  # 理由を添えて別の呼び出しを拒否します
  client.beta.sessions.events.send(
      "sesn_011CZkZAtmR3yMPDzynEDxu7",
      events=[
          {
              "type": "user.tool_confirmation",
              "tool_use_id": "sevt_011CZkZcNqT9bT4Xuw6Zr3Mo",
              "result": "deny",
              "deny_message": "Do not create issues in the production project. Use the staging project.",
          },
      ],
  )
  ```

  ```typescript TypeScript
  // ツールの実行を許可します
  await client.beta.sessions.events.send("sesn_011CZkZAtmR3yMPDzynEDxu7", {
    events: [
      {
        type: "user.tool_confirmation",
        tool_use_id: "sevt_011CZkZbMpR8aS3Wtv5Yq2Ln",
        result: "allow"
      }
    ]
  });

  // 理由を添えて別の呼び出しを拒否します
  await client.beta.sessions.events.send("sesn_011CZkZAtmR3yMPDzynEDxu7", {
    events: [
      {
        type: "user.tool_confirmation",
        tool_use_id: "sevt_011CZkZcNqT9bT4Xuw6Zr3Mo",
        result: "deny",
        deny_message: "Do not create issues in the production project. Use the staging project."
      }
    ]
  });
  ```

  ```csharp C#
  using Anthropic.Models.Beta.Sessions.Events;

  // ツールの実行を許可します
  await client.Beta.Sessions.Events.Send("sesn_011CZkZAtmR3yMPDzynEDxu7", new()
  {
      Events =
      [
          new BetaManagedAgentsUserToolConfirmationEventParams
          {
              ToolUseID = "sevt_011CZkZbMpR8aS3Wtv5Yq2Ln",
              Result = "allow",
          },
      ],
  });

  // 説明を付けて別の呼び出しを拒否します
  await client.Beta.Sessions.Events.Send("sesn_011CZkZAtmR3yMPDzynEDxu7", new()
  {
      Events =
      [
          new BetaManagedAgentsUserToolConfirmationEventParams
          {
              ToolUseID = "sevt_011CZkZcNqT9bT4Xuw6Zr3Mo",
              Result = "deny",
              DenyMessage = "Do not create issues in the production project. Use the staging project.",
          },
      ],
  });
  ```

  ```go Go
  // ツールの実行を許可します
  _, err := client.Beta.Sessions.Events.Send(ctx, "sesn_011CZkZAtmR3yMPDzynEDxu7", anthropic.BetaSessionEventSendParams{
  	Events: []anthropic.BetaManagedAgentsEventParamsUnion{{
  		OfUserToolConfirmation: &anthropic.BetaManagedAgentsUserToolConfirmationEventParams{
  			ToolUseID: "sevt_011CZkZbMpR8aS3Wtv5Yq2Ln",
  			Result:    anthropic.BetaManagedAgentsUserToolConfirmationEventParamsResultAllow,
  		},
  	}},
  })
  if err != nil {
  	panic(err)
  }

  // 説明を付けて別の呼び出しを拒否します
  _, err = client.Beta.Sessions.Events.Send(ctx, "sesn_011CZkZAtmR3yMPDzynEDxu7", anthropic.BetaSessionEventSendParams{
  	Events: []anthropic.BetaManagedAgentsEventParamsUnion{{
  		OfUserToolConfirmation: &anthropic.BetaManagedAgentsUserToolConfirmationEventParams{
  			ToolUseID:   "sevt_011CZkZcNqT9bT4Xuw6Zr3Mo",
  			Result:      anthropic.BetaManagedAgentsUserToolConfirmationEventParamsResultDeny,
  			DenyMessage: anthropic.String("Do not create issues in the production project. Use the staging project."),
  		},
  	}},
  })
  if err != nil {
  	panic(err)
  }
  ```

  ```java Java
  import com.anthropic.models.beta.sessions.events.BetaManagedAgentsUserToolConfirmationEventParams;
  import com.anthropic.models.beta.sessions.events.EventSendParams;

  // ツールの実行を許可します
  client.beta().sessions().events().send(
      "sesn_011CZkZAtmR3yMPDzynEDxu7",
      EventSendParams.builder()
          .addEvent(
              BetaManagedAgentsUserToolConfirmationEventParams.builder()
                  .toolUseId("sevt_011CZkZbMpR8aS3Wtv5Yq2Ln")
                  .result(BetaManagedAgentsUserToolConfirmationEventParams.Result.ALLOW)
                  .build()
          )
          .build()
  );

  // 理由を添えて別の呼び出しを拒否します
  client.beta().sessions().events().send(
      "sesn_011CZkZAtmR3yMPDzynEDxu7",
      EventSendParams.builder()
          .addEvent(
              BetaManagedAgentsUserToolConfirmationEventParams.builder()
                  .toolUseId("sevt_011CZkZcNqT9bT4Xuw6Zr3Mo")
                  .result(BetaManagedAgentsUserToolConfirmationEventParams.Result.DENY)
                  .denyMessage("Do not create issues in the production project. Use the staging project.")
                  .build()
          )
          .build()
  );
  ```

  ```php PHP
  use Anthropic\Beta\Sessions\Events\ManagedAgentsUserToolConfirmationEventParams;

  // ツールの実行を許可します
  $client->beta->sessions->events->send(
      'sesn_011CZkZAtmR3yMPDzynEDxu7',
      events: [
          ManagedAgentsUserToolConfirmationEventParams::with(
              toolUseID: 'sevt_011CZkZbMpR8aS3Wtv5Yq2Ln',
              result: 'allow',
          ),
      ],
  );

  // 理由を添えて別の呼び出しを拒否します
  $client->beta->sessions->events->send(
      'sesn_011CZkZAtmR3yMPDzynEDxu7',
      events: [
          ManagedAgentsUserToolConfirmationEventParams::with(
              toolUseID: 'sevt_011CZkZcNqT9bT4Xuw6Zr3Mo',
              result: 'deny',
              denyMessage: 'Do not create issues in the production project. Use the staging project.',
          ),
      ],
  );
  ```

  ```ruby Ruby
  # ツールの実行を許可します
  client.beta.sessions.events.send_(
    "sesn_011CZkZAtmR3yMPDzynEDxu7",
    events: [
      {
        type: "user.tool_confirmation",
        tool_use_id: "sevt_011CZkZbMpR8aS3Wtv5Yq2Ln",
        result: "allow"
      }
    ]
  )

  # 理由を添えて別の呼び出しを拒否します
  client.beta.sessions.events.send_(
    "sesn_011CZkZAtmR3yMPDzynEDxu7",
    events: [
      {
        type: "user.tool_confirmation",
        tool_use_id: "sevt_011CZkZcNqT9bT4Xuw6Zr3Mo",
        result: "deny",
        deny_message: "Do not create issues in the production project. Use the staging project."
      }
    ]
  )
  ```
</CodeGroup>

## カスタムツール

パーミッションポリシーはカスタムツールには適用されません。エージェントがカスタムツールを呼び出すと、アプリケーションは`agent.custom_tool_use`イベントを受け取り、`user.custom_tool_result`を返送する前に、そのツールを実行するかどうかを判断する責任を負います。フロー全体については、[セッションを一時停止させるツール呼び出しに応答する](https://platform.claude.com/docs/ja/managed-agents/events-and-streaming#answer-tool-calls-that-pause-the-session)を参照してください。

## 次のステップ

<CardGroup cols={2}>
  <Card title="スキル" icon="books" href="https://platform.claude.com/docs/ja/managed-agents/skills">
    ドメイン固有のワークフローのために、再利用可能なファイルシステムベースの専門知識をエージェントに付与します。
  </Card>

  <Card title="セッションイベントストリーム" icon="lightning" href="https://platform.claude.com/docs/ja/managed-agents/events-and-streaming">
    イベントを送信し、レスポンスをストリーミングし、実行中のセッションに割り込んだり方向を変えたりします。
  </Card>
</CardGroup>

## 利用可能状況

権限ポリシーはすべてのモデルでベータ版です。

### APIサポート

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

* 利用可能状況：常時有効

| ステータス | クラウドプラットフォーム |
| ----- | ----- |
| ベータ | サポートされているすべてのプラットフォーム |

### 必須のベータヘッダー

[ベータヘッダーの概要](https://platform.claude.com/docs/ja/api/beta-headers)

ベータヘッダーを使用すると、実験的な機能や新しいモデル機能が標準APIに組み込まれる前にアクセスできます。

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

### データの取り扱い

[データの取り扱いの概要](https://platform.claude.com/docs/ja/manage-claude/api-and-data-retention#feature-eligibility)

| 項目 | ゼロデータ保持 | HIPAA |
| ----- | ----- | ----- |
| ステータス | 対象外 | 対象外 |
| 詳細 | セルフホスト型Managed Agentsを除き、ZDRの適格対象ではありません。セッションはステートフルなリソースであり、トランスクリプトは削除するまで保持されます。 [詳細はこちら](https://platform.claude.com/docs/ja/managed-agents/self-hosted-data-and-access#how-long-data-is-kept) | HIPAAの適格対象ではありません。すべてのManaged Agentsのサブ機能に適用されます。 |

対象エンドポイント：

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