---
title: 권한 정책
url: https://platform.claude.com/docs/ko/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
---
"Permission policy"(권한 정책)는 서버에서 실행되는 도구(사전 구축된 "agent toolset"(에이전트 도구 세트)과 MCP 도구 세트)를 자동으로 실행할지, 승인을 기다릴지, 아니면 서버가 각 호출을 평가하도록 할지를 제어합니다. "Custom tool"(사용자 정의 도구)은 애플리케이션이 실행하고 사용자가 직접 제어하므로 권한 정책의 적용을 받지 않습니다.
## 권한 정책 유형
| 정책 | 동작 |
| -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `always_allow` | 확인 없이 도구가 자동으로 실행됩니다. |
| `always_ask` | 실행 전에 세션이 일시 중지되고 승인을 기다립니다. 이벤트 흐름은 [확인 요청에 응답하기](https://platform.claude.com/docs/ko/managed-agents/permission-policies#respond-to-confirmation-requests)를 참조하세요. |
| `auto` | 서버가 각 호출을 평가하여 실행하거나, 거부하거나, 승인을 위해 일시 중지합니다. [`auto`로 서버가 각 호출을 평가하도록 하기](https://platform.claude.com/docs/ko/managed-agents/permission-policies#let-the-server-evaluate-each-call-with-auto)를 참조하세요. |
각 도구 세트 종류에는 고유한 기본값이 있습니다. 에이전트 도구 세트의 기본값은 `always_allow`이고, MCP 도구 세트의 기본값은 `always_ask`입니다.
권한 정책은 활성화된 도구가 언제 실행되는지를 제어합니다. 에이전트에서 도구를 완전히 제거하려면 대신 해당 도구를 비활성화하세요. [특정 도구 비활성화](https://platform.claude.com/docs/ko/managed-agents/tools#disabling-specific-tools)를 참조하세요.
## 도구 세트에 대한 정책 설정
권한 정책은 에이전트를 생성할 때 에이전트의 `tools` (csharp, go: `Tools`) 구성에서 설정하며, 나중에 [에이전트를 업데이트](https://platform.claude.com/docs/ko/managed-agents/agent-setup#update-an-agent)하여 변경할 수 있습니다. 실행 중인 세션은 생성될 때의 도구 세트 구성을 유지합니다. 업데이트는 이후에 생성되는 세션에 적용됩니다.
### 에이전트 도구 세트 권한
에이전트를 생성할 때 `default_config.permission_policy` (java, php: `defaultConfig.permissionPolicy`; csharp, go: `DefaultConfig.PermissionPolicy`)를 사용하여 `agent_toolset_20260401`의 모든 도구에 정책을 적용할 수 있습니다:
```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`)는 선택 사항입니다. 생략하면 에이전트 도구 세트가 기본 권한 정책인 `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 서버를 연결하고 해당 서버의 도구가 확인 없이 실행되도록 허용합니다:
```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"}
}
}
]
)
```
## 개별 도구 정책 재정의
`configs` (csharp, go: `Configs`) 배열을 사용하여 개별 도구의 기본값을 재정의하세요. 에이전트 도구 세트의 `name` (csharp, go: `Name`) 값은 [사용 가능한 도구](https://platform.claude.com/docs/ko/managed-agents/tools#available-tools)에 나열되어 있습니다. 이 예시는 기본적으로 전체 에이전트 도구 세트를 허용하지만 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"}
}
]
}
]
```
이 `tools` (csharp, go: `Tools`) 구성을 에이전트 생성 요청에 전달하세요(CLI 탭에 전체 명령이 표시됩니다). MCP 도구 세트도 동일한 도구별 재정의를 지원하며, 이때 `name` (csharp, go: `Name`)은 MCP 서버가 보고하는 도구 이름으로 설정합니다. [사용 가능한 MCP 도구 구성하기](https://platform.claude.com/docs/ko/managed-agents/mcp-connector#configure-which-mcp-tools-are-available)를 참조하세요.
## `auto`로 서버가 각 호출을 평가하도록 하기
`auto` 권한 정책을 사용하면 서버가 각 호출을 실행하기 전에 평가합니다. 평가는 도구, 호출의 입력, 그리고 그 시점까지의 세션 내용을 고려하므로, 서버는 동일한 도구에 대한 두 호출을 다르게 처리할 수 있습니다. 각 호출은 다음 세 가지 결과 중 하나를 갖습니다:
* **호출이 실행됩니다.** 서버가 호출이 안전하다고 판단하면, 도구는 `always_allow`에서와 같이 실행됩니다.
* **호출이 거부됩니다.** 서버가 호출을 고위험으로 평가하면 도구가 실행되지 않습니다. 에이전트는 `Permission to use {tool_name} has been denied.` 내용과 `is_error: true`가 포함된 오류 도구 결과를 받습니다. 세션은 계속 실행되며, 클라이언트는 이 거부를 재정의할 수 없습니다.
* **호출이 승인을 위해 일시 중지됩니다.** 서버가 판단을 내리지 못하면, 세션은 `always_ask`에서와 같이 일시 중지됩니다. [확인 요청에 응답하기](https://platform.claude.com/docs/ko/managed-agents/permission-policies#respond-to-confirmation-requests)를 참조하세요.
`auto`를 켜려면 `permission_policy`를 `{"type": "auto"}`로 설정하세요. 다른 정책과 동일한 두 위치에 설정합니다. 전체 도구 세트에 대해서는 도구 세트의 [`default_config` (java, php: `defaultConfig`; csharp, go: `DefaultConfig`)](https://platform.claude.com/docs/ko/managed-agents/permission-policies#set-a-policy-for-a-toolset)에, 하나의 도구에 대해서는 [`configs` (csharp, go: `Configs`) 항목](https://platform.claude.com/docs/ko/managed-agents/permission-policies#override-an-individual-tool-policy)에 설정합니다. 에이전트 도구 세트와 MCP 도구 세트 모두 이를 허용합니다. 기본적으로 `auto`를 사용하는 도구 세트는 없습니다.
다음 예시는 에이전트 도구 세트와 `github` MCP 도구 세트의 기본값으로 `auto`를 설정하고, `bash`를 `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"}
}
}
]
)
```
`user.message` 이벤트에 게시하는 내용은 사용자의 의도로 간주되며, 서버가 원래라면 거부했을 호출을 허용하도록 만들 수 있습니다. 서버는 도구 결과, 가져온 웹페이지, MCP 서버의 응답, 또는 [세션 스레드](https://platform.claude.com/docs/ko/managed-agents/session-threads#tool-permissions-and-custom-tools) 간의 메시지에서는 의도를 읽지 않습니다. 서버는 해당 내용을 평가하지만 그로부터 지시를 받지는 않습니다. 서버는 누가 요청하든 일부 호출을 고위험으로 평가합니다. 신뢰할 수 없는 최종 사용자 입력을 `user.message` 이벤트로 전달하는 경우, 서버는 그 입력도 사용자의 의도로 읽으며 이로 인해 호출이 허용될 수 있습니다. 해당 최종 사용자가 검토 없이 실행하도록 허용하지 않을 도구에는 `always_ask`를 구성하세요.
`auto`는 사람의 검토 단계가 아닙니다. 서버가 호출이 안전하다고 판단하면 누구도 확인하기 전에 호출이 실행되며, 그 효과는 되돌릴 수 없을 수도 있습니다. 도구의 호출이 실행되기 전에 사람이 반드시 검토해야 한다면 해당 도구에 `always_ask`를 구성하세요.
## 각 호출이 어떻게 평가되었는지 확인하기
어떤 권한 정책에서든 각 `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`은 두 가지 경우에 존재하지 않습니다. 에이전트가 세션에서 활성화되지 않은 도구를 지정하면, 서버는 정책을 평가하지 않고 호출을 거부합니다. 이때 이벤트에는 `evaluated_permission: "deny"`가 포함되고 `evaluation`은 포함되지 않습니다. `evaluation`이 도입되기 전에 기록된 이벤트에도 이 필드가 없습니다. 이러한 이벤트는 `evaluated_permission`이 `"allow"`이면 `always_allow`로, `"ask"`이면 `always_ask`로 해석하세요.
클라이언트는 인식하지 못하는 `evaluation.type` 또는 `reason_code`도 처리할 수 있도록 작성하세요. 권한 정책은 [사용자 정의 도구](https://platform.claude.com/docs/ko/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/ko/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`)를 사용하세요. 단일 `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/ko/cli-sdks-libraries/cli/sessions-connect#follow-and-steer-the-session)를 참조하세요.
다음 예시에서 도구 사용 이벤트 ID는 `session.status_idle` 이벤트의 `stop_reason.event_ids` 배열에서 가져옵니다. 이벤트 수신에 대한 자세한 내용은 [세션 이벤트 스트림](https://platform.claude.com/docs/ko/managed-agents/events-and-streaming#stream-events) 가이드를 참조하거나, 세션이 입력을 위해 일시 중지될 때 알림을 받으려면 [웹훅을 구독](https://platform.claude.com/docs/ko/managed-agents/webhooks)하세요.
```bash cURL
# 도구 실행을 허용합니다
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"
}
]
}'
# 또는 설명과 함께 거부합니다
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
# 도구 실행을 허용합니다
ant beta:sessions:events send \
--session-id "$SESSION_ID" \
--event "{type: user.tool_confirmation, tool_use_id: $AGENT_TOOL_USE_EVENT_ID, result: allow}"
# 또는 설명과 함께 거부합니다
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
# 도구 실행을 허용합니다
client.beta.sessions.events.send(
session.id,
events=[
{
"type": "user.tool_confirmation",
"tool_use_id": agent_tool_use_event.id,
"result": "allow",
},
],
)
# 또는 설명과 함께 거부합니다
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
// 도구 실행을 허용합니다
await client.beta.sessions.events.send(session.id, {
events: [
{
type: "user.tool_confirmation",
tool_use_id: agent_tool_use_event.id,
result: "allow"
}
]
});
// 또는 설명과 함께 거부합니다
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#
// 도구 실행을 허용합니다
await client.Beta.Sessions.Events.Send(session.ID, new()
{
Events =
[
new BetaManagedAgentsUserToolConfirmationEventParams
{
Type = BetaManagedAgentsUserToolConfirmationEventParamsType.UserToolConfirmation,
ToolUseID = agentToolUseEvent.ID,
Result = "allow",
},
],
});
// 또는 설명과 함께 거부합니다
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
// 도구 실행을 허용합니다
_, 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)
}
// 또는 설명과 함께 거부합니다
_, 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
// 도구 실행을 허용합니다
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()
);
// 또는 설명과 함께 거부합니다
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;
// 도구 실행을 허용합니다
$client->beta->sessions->events->send(
$session->id,
events: [
ManagedAgentsUserToolConfirmationEventParams::with(
type: 'user.tool_confirmation',
toolUseID: $agentToolUseEvent->id,
result: 'allow',
),
],
);
// 또는 설명과 함께 거부합니다
$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
# 도구 실행을 허용합니다
client.beta.sessions.events.send_(
session.id,
events: [
{
type: "user.tool_confirmation",
tool_use_id: agent_tool_use_event.id,
result: "allow"
}
]
)
# 또는 설명과 함께 거부합니다
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."
}
]
)
```
## 커스텀 도구
권한 정책은 사용자 정의 도구에 적용되지 않습니다. 에이전트가 사용자 정의 도구를 호출하면, 애플리케이션은 `agent.custom_tool_use` 이벤트를 받으며, `user.custom_tool_result`를 다시 보내기 전에 해당 도구를 실행할지 여부를 결정할 책임이 있습니다. 전체 흐름은 [세션 이벤트 스트림](https://platform.claude.com/docs/ko/managed-agents/events-and-streaming#answer-tool-calls-that-pause-the-session)을 참조하세요.
## 다음 단계
도메인별 워크플로를 위해 재사용 가능한 파일 시스템 기반 전문 지식을 에이전트에 연결하세요.
이벤트를 전송하고, 응답을 스트리밍하며, 실행 중인 세션을 중단하거나 방향을 전환하세요.