Managed Agents

"Permission policies" (kebijakan izin) mengontrol apakah alat yang dieksekusi server, yaitu "toolset" (kumpulan alat) agen bawaan dan toolset MCP, berjalan secara otomatis, menunggu persetujuan Anda, atau setiap panggilannya dievaluasi oleh server. "Custom tools" (alat kustom) dieksekusi dan dikendalikan oleh aplikasi Anda sendiri, sehingga tidak diatur oleh kebijakan izin.

Jenis kebijakan izin

Kebijakan	Perilaku
`always_allow`	Alat dieksekusi secara otomatis tanpa konfirmasi.
`always_ask`	Sesi dijeda dan menunggu persetujuan Anda sebelum alat dieksekusi. Lihat Menanggapi permintaan konfirmasi untuk alur event-nya.
`auto`	Server mengevaluasi setiap panggilan, lalu menjalankannya, menolaknya, atau menjeda untuk meminta persetujuan Anda. Lihat Biarkan server mengevaluasi setiap panggilan dengan `auto`.

Setiap jenis toolset memiliki default-nya sendiri: toolset agen default-nya always_allow, dan toolset MCP default-nya always_ask.

Kebijakan izin mengontrol kapan alat yang diaktifkan berjalan. Untuk menghapus alat dari agen sepenuhnya, nonaktifkan alat tersebut. Lihat Menonaktifkan alat tertentu.

Menetapkan kebijakan untuk toolset

Anda menetapkan kebijakan izin dalam konfigurasi tools agen saat Anda membuat agen, dan Anda dapat mengubahnya nanti dengan memperbarui agen. Sesi yang sedang berjalan mempertahankan konfigurasi toolset yang digunakan saat sesi tersebut dibuat. Pembaruan berlaku untuk sesi yang dibuat setelahnya.

Izin toolset agen

Saat membuat agen, Anda dapat menerapkan kebijakan ke setiap alat dalam agent_toolset_20260401 menggunakan default_config.permission_policy:

bash

  agent=$(curl -fsSL https://haijun.my.id/v1/agents \
    -H "x-api-key: $JUGLOW_API_KEY" \
    -H "juglow-version: 2023-06-01" \
    -H "juglow-beta: managed-agents-2026-04-01" \
    -H "content-type: application/json" \
    -d '{
      "name": "Coding Assistant",
      "model": "haijun-opus-5-5",
      "tools": [
        {
          "type": "agent_toolset_20260401",
          "default_config": {
            "permission_policy": {"type": "always_ask"}
          }
        }
      ]
    }')

bash

    ant apply agent.md

markdown

      ---
      name: Coding Assistant
      model: haijun-opus-5-5
      tools:
        - type: agent_toolset_20260401
          default_config:
            permission_policy:
              type: always_ask
      ---

python

  agent = client.beta.agents.create(
      name="Coding Assistant",
      model="haijun-opus-5-5",
      tools=[
          {
              "type": "agent_toolset_20260401",
              "default_config": {
                  "permission_policy": {"type": "always_ask"},
              },
          },
      ],
  )

typescript

  const agent = await client.beta.agents.create({
    name: "Coding Assistant",
    model: "haijun-opus-5-5",
    tools: [
      {
        type: "agent_toolset_20260401",
        default_config: {
          permission_policy: { type: "always_ask" }
        }
      }
    ]
  });

csharp

  using Juglow.Models.Beta.Agents;

  var agent = await client.Beta.Agents.Create(new()
  {
      Name = "Coding Assistant",
      Model = BetaManagedAgentsModel.HaijunOpus5_5,
      Tools =
      [
          new BetaManagedAgentsAgentToolset20260401Params
          {
              Type = BetaManagedAgentsAgentToolset20260401ParamsType.AgentToolset20260401,
              DefaultConfig = new()
              {
                  PermissionPolicy = new BetaManagedAgentsAlwaysAskPolicy { Type = "always_ask" },
              },
          },
      ],
  });

  agent, err := client.Beta.Agents.New(ctx, juglow.BetaAgentNewParams{
  	Name: "Coding Assistant",
  	Model: juglow.BetaManagedAgentsModelConfigParams{
  		ID: "haijun-opus-5-5",
  	},
  	Tools: []juglow.BetaAgentNewParamsToolUnion{{
  		OfAgentToolset20260401: &juglow.BetaManagedAgentsAgentToolset20260401Params{
  			Type: juglow.BetaManagedAgentsAgentToolset20260401ParamsTypeAgentToolset20260401,
  			DefaultConfig: juglow.BetaManagedAgentsAgentToolsetDefaultConfigParams{
  				PermissionPolicy: juglow.BetaManagedAgentsAgentToolsetDefaultConfigParamsPermissionPolicyUnion{
  					OfAlwaysAsk: &juglow.BetaManagedAgentsAlwaysAskPolicyParam{
  						Type: juglow.BetaManagedAgentsAlwaysAskPolicyTypeAlwaysAsk,
  					},
  				},
  			},
  		},
  	}},
  })
  if err != nil {
  	panic(err)
  }
  _ = agent

java

  import com.juglow.models.beta.agents.*;

  var agent = client.beta().agents().create(
      AgentCreateParams.builder()
          .name("Coding Assistant")
          .model(BetaManagedAgentsModel.HAIJUN_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

  use Juglow\Beta\Agents\BetaManagedAgentsAgentToolset20260401Params;
  use Juglow\Beta\Agents\BetaManagedAgentsAgentToolsetDefaultConfigParams;
  use Juglow\Beta\Agents\BetaManagedAgentsAlwaysAskPolicy;

  $agent = $client->beta->agents->create(
      name: 'Coding Assistant',
      model: 'haijun-opus-5-5',
      tools: [
          BetaManagedAgentsAgentToolset20260401Params::with(
              type: 'agent_toolset_20260401',
              defaultConfig: BetaManagedAgentsAgentToolsetDefaultConfigParams::with(
                  permissionPolicy: BetaManagedAgentsAlwaysAskPolicy::with(type: 'always_ask'),
              ),
          ),
      ],
  );

ruby

  agent = client.beta.agents.create(
    name: "Coding Assistant",
    model: "haijun-opus-5-5",
    tools: [
      {
        type: "agent_toolset_20260401",
        default_config: {
          permission_policy: {type: "always_ask"}
        }
      }
    ]
  )

default_config bersifat opsional. Jika Anda menghilangkannya, toolset agen diaktifkan dengan kebijakan izin default, always_allow.

Izin toolset MCP

Toolset MCP default-nya always_ask. Ini memastikan bahwa alat baru yang ditambahkan ke server MCP tidak dieksekusi di aplikasi Anda tanpa persetujuan. Untuk menyetujui secara otomatis alat dari server MCP tepercaya, tetapkan default_config.permission_policy pada entri mcp_toolset.

mcp_server_name harus cocok dengan name dari server dalam array mcp_servers.

Contoh ini menghubungkan server MCP GitHub dan mengizinkan alat-alatnya berjalan tanpa konfirmasi:

bash

  agent=$(curl -fsSL https://haijun.my.id/v1/agents \
    -H "x-api-key: $JUGLOW_API_KEY" \
    -H "juglow-version: 2023-06-01" \
    -H "juglow-beta: managed-agents-2026-04-01" \
    -H "content-type: application/json" \
    -d '{
      "name": "Dev Assistant",
      "model": "haijun-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

    ant apply agent.md

markdown

      ---
      name: Dev Assistant
      model: haijun-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

  agent = client.beta.agents.create(
      name="Dev Assistant",
      model="haijun-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

  const agent = await client.beta.agents.create({
    name: "Dev Assistant",
    model: "haijun-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

  using Juglow.Models.Beta.Agents;

  var agent = await client.Beta.Agents.Create(new()
  {
      Name = "Dev Assistant",
      Model = BetaManagedAgentsModel.HaijunOpus5_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" },
              },
          },
      ],
  });

  agent, err := client.Beta.Agents.New(ctx, juglow.BetaAgentNewParams{
  	Name: "Dev Assistant",
  	Model: juglow.BetaManagedAgentsModelConfigParams{
  		ID: "haijun-opus-5-5",
  	},
  	MCPServers: []juglow.BetaManagedAgentsURLMCPServerParams{{
  		Type: juglow.BetaManagedAgentsURLMCPServerParamsTypeURL,
  		Name: "github",
  		URL:  "https://mcp.example.com/github",
  	}},
  	Tools: []juglow.BetaAgentNewParamsToolUnion{
  		{
  			OfAgentToolset20260401: &juglow.BetaManagedAgentsAgentToolset20260401Params{
  				Type: juglow.BetaManagedAgentsAgentToolset20260401ParamsTypeAgentToolset20260401,
  			},
  		},
  		{
  			OfMCPToolset: &juglow.BetaManagedAgentsMCPToolsetParams{
  				Type:          juglow.BetaManagedAgentsMCPToolsetParamsTypeMCPToolset,
  				MCPServerName: "github",
  				DefaultConfig: juglow.BetaManagedAgentsMCPToolsetDefaultConfigParams{
  					PermissionPolicy: juglow.BetaManagedAgentsMCPToolsetDefaultConfigParamsPermissionPolicyUnion{
  						OfAlwaysAllow: &juglow.BetaManagedAgentsAlwaysAllowPolicyParam{
  							Type: juglow.BetaManagedAgentsAlwaysAllowPolicyTypeAlwaysAllow,
  						},
  					},
  				},
  			},
  		},
  	},
  })
  if err != nil {
  	panic(err)
  }
  _ = agent

java

  import com.juglow.models.beta.agents.*;

  var agent = client.beta().agents().create(
      AgentCreateParams.builder()
          .name("Dev Assistant")
          .model(BetaManagedAgentsModel.HAIJUN_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

  use Juglow\Beta\Agents\BetaManagedAgentsAgentToolset20260401Params;
  use Juglow\Beta\Agents\BetaManagedAgentsAlwaysAllowPolicy;
  use Juglow\Beta\Agents\BetaManagedAgentsMCPToolsetDefaultConfigParams;
  use Juglow\Beta\Agents\BetaManagedAgentsMCPToolsetParams;
  use Juglow\Beta\Agents\BetaManagedAgentsURLMCPServerParams;

  $agent = $client->beta->agents->create(
      name: 'Dev Assistant',
      model: 'haijun-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

  agent = client.beta.agents.create(
    name: "Dev Assistant",
    model: "haijun-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"}
        }
      }
    ]
  )

Mengganti kebijakan alat individual

Gunakan array configs untuk mengganti default untuk alat individual. Nilai name untuk toolset agen tercantum di Alat yang tersedia. Contoh ini mengizinkan seluruh toolset agen secara default tetapi memerlukan konfirmasi sebelum perintah bash apa pun dijalankan:

bash

  tools='[
    {
      "type": "agent_toolset_20260401",
      "default_config": {
        "permission_policy": {"type": "always_allow"}
      },
      "configs": [
        {
          "name": "bash",
          "permission_policy": {"type": "always_ask"}
        }
      ]
    }
  ]'

bash

    ant apply agent.md

markdown

      ---
      name: Coding Assistant
      model: haijun-opus-5-5
      tools:
        - type: agent_toolset_20260401
          default_config:
            permission_policy:
              type: always_allow
          configs:
            - name: bash
              permission_policy:
                type: always_ask
      ---

python

  tools = [
      {
          "type": "agent_toolset_20260401",
          "default_config": {
              "permission_policy": {"type": "always_allow"},
          },
          "configs": [
              {
                  "name": "bash",
                  "permission_policy": {"type": "always_ask"},
              },
          ],
      },
  ]

typescript

  const tools = [
    {
      type: "agent_toolset_20260401",
      default_config: {
        permission_policy: { type: "always_allow" }
      },
      configs: [
        {
          name: "bash",
          permission_policy: { type: "always_ask" }
        }
      ]
    }
  ] satisfies Juglow.Beta.AgentCreateParams["tools"];

csharp

  using Juglow.Models.Beta.Agents;
  using Tool = Juglow.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" },
              },
          ],
      },
  ];

  tools := []juglow.BetaAgentNewParamsToolUnion{{
  	OfAgentToolset20260401: &juglow.BetaManagedAgentsAgentToolset20260401Params{
  		Type: juglow.BetaManagedAgentsAgentToolset20260401ParamsTypeAgentToolset20260401,
  		DefaultConfig: juglow.BetaManagedAgentsAgentToolsetDefaultConfigParams{
  			PermissionPolicy: juglow.BetaManagedAgentsAgentToolsetDefaultConfigParamsPermissionPolicyUnion{
  				OfAlwaysAllow: &juglow.BetaManagedAgentsAlwaysAllowPolicyParam{
  					Type: juglow.BetaManagedAgentsAlwaysAllowPolicyTypeAlwaysAllow,
  				},
  			},
  		},
  		Configs: []juglow.BetaManagedAgentsAgentToolConfigParamsUnion{{
  			OfBash: &juglow.BetaManagedAgentsBashToolConfigParams{
  				PermissionPolicy: juglow.BetaManagedAgentsBashToolConfigParamsPermissionPolicyUnion{
  					OfAlwaysAsk: &juglow.BetaManagedAgentsAlwaysAskPolicyParam{
  						Type: juglow.BetaManagedAgentsAlwaysAskPolicyTypeAlwaysAsk,
  					},
  				},
  			},
  		}},
  	},
  }}
  _ = tools

java

  import com.juglow.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

  use Juglow\Beta\Agents\BetaManagedAgentsBashToolConfigParams;
  use Juglow\Beta\Agents\BetaManagedAgentsAgentToolset20260401Params;
  use Juglow\Beta\Agents\BetaManagedAgentsAgentToolsetDefaultConfigParams;
  use Juglow\Beta\Agents\BetaManagedAgentsAlwaysAllowPolicy;
  use Juglow\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

  tools = [
    {
      type: "agent_toolset_20260401",
      default_config: {
        permission_policy: {type: "always_allow"}
      },
      configs: [
        {
          name: "bash",
          permission_policy: {type: "always_ask"}
        }
      ]
    }
  ]

Teruskan konfigurasi tools ini dalam permintaan pembuatan agen (tab CLI menampilkan perintah lengkapnya). Toolset MCP mendukung penggantian per alat yang sama, dengan name diatur ke nama alat yang dilaporkan oleh server MCP. Lihat Mengonfigurasi alat MCP mana yang tersedia.

Biarkan server mengevaluasi setiap panggilan dengan `auto`

Dengan kebijakan izin auto, server mengevaluasi setiap panggilan sebelum dijalankan. Karena evaluasi mempertimbangkan alat, input panggilan, dan konten sesi hingga titik tersebut, server dapat memperlakukan dua panggilan ke alat yang sama secara berbeda. Setiap panggilan memiliki salah satu dari tiga hasil:

Panggilan dijalankan. Ketika server menentukan bahwa panggilan tersebut aman, alat dijalankan seperti di bawah always_allow.

Panggilan ditolak. Ketika server mengevaluasi panggilan sebagai berisiko tinggi, alat tidak dijalankan. Agen menerima hasil alat berupa error dengan konten Permission to use {tool_name} has been denied. dan is_error: true. Sesi tetap berjalan, dan klien Anda tidak dapat membatalkan penolakan tersebut.

Panggilan dijeda untuk meminta persetujuan Anda. Ketika server tidak mencapai keputusan, sesi dijeda seperti di bawah always_ask. Lihat Menanggapi permintaan konfirmasi.

Untuk mengaktifkan auto, atur permission_policy ke {"type": "auto"}. Pengaturan ini ditempatkan di dua tempat yang sama seperti kebijakan lainnya: default_config milik toolset untuk seluruh toolset, atau entri configs untuk satu alat. Toolset agen dan toolset MCP sama-sama menerimanya. Tidak ada toolset yang menggunakan auto secara default.

Contoh berikut menetapkan auto sebagai default untuk toolset agen dan untuk toolset MCP github, serta menimpa bash menjadi always_ask:

bash

  agent=$(curl -fsSL https://haijun.my.id/v1/agents \
    -H "x-api-key: $JUGLOW_API_KEY" \
    -H "juglow-version: 2023-06-01" \
    -H "juglow-beta: managed-agents-2026-04-01" \
    -H "content-type: application/json" \
    -d '{
      "name": "Ops Agent",
      "model": "haijun-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

    ant apply agent.md

markdown

      ---
      name: Ops Agent
      model: haijun-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

  agent = client.beta.agents.create(
      name="Ops Agent",
      model="haijun-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

  const agent = await client.beta.agents.create({
    name: "Ops Agent",
    model: "haijun-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

  using Juglow.Models.Beta.Agents;

  var agent = await client.Beta.Agents.Create(new()
  {
      Name = "Ops Agent",
      Model = BetaManagedAgentsModel.HaijunOpus5_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(),
              },
          },
      ],
  });

  agent, err := client.Beta.Agents.New(ctx, juglow.BetaAgentNewParams{
  	Name: "Ops Agent",
  	Model: juglow.BetaManagedAgentsModelConfigParams{
  		ID: "haijun-opus-5-5",
  	},
  	MCPServers: []juglow.BetaManagedAgentsURLMCPServerParams{{
  		Type: juglow.BetaManagedAgentsURLMCPServerParamsTypeURL,
  		Name: "github",
  		URL:  "https://mcp.example.com/github",
  	}},
  	Tools: []juglow.BetaAgentNewParamsToolUnion{
  		{
  			OfAgentToolset20260401: &juglow.BetaManagedAgentsAgentToolset20260401Params{
  				Type: juglow.BetaManagedAgentsAgentToolset20260401ParamsTypeAgentToolset20260401,
  				DefaultConfig: juglow.BetaManagedAgentsAgentToolsetDefaultConfigParams{
  					PermissionPolicy: juglow.BetaManagedAgentsAgentToolsetDefaultConfigParamsPermissionPolicyUnion{
  						OfAuto: &juglow.BetaManagedAgentsAutoPolicyParam{},
  					},
  				},
  				Configs: []juglow.BetaManagedAgentsAgentToolConfigParamsUnion{{
  					OfBash: &juglow.BetaManagedAgentsBashToolConfigParams{
  						PermissionPolicy: juglow.BetaManagedAgentsBashToolConfigParamsPermissionPolicyUnion{
  							OfAlwaysAsk: &juglow.BetaManagedAgentsAlwaysAskPolicyParam{
  								Type: juglow.BetaManagedAgentsAlwaysAskPolicyTypeAlwaysAsk,
  							},
  						},
  					},
  				}},
  			},
  		},
  		{
  			OfMCPToolset: &juglow.BetaManagedAgentsMCPToolsetParams{
  				Type:          juglow.BetaManagedAgentsMCPToolsetParamsTypeMCPToolset,
  				MCPServerName: "github",
  				DefaultConfig: juglow.BetaManagedAgentsMCPToolsetDefaultConfigParams{
  					PermissionPolicy: juglow.BetaManagedAgentsMCPToolsetDefaultConfigParamsPermissionPolicyUnion{
  						OfAuto: &juglow.BetaManagedAgentsAutoPolicyParam{},
  					},
  				},
  			},
  		},
  	},
  })
  if err != nil {
  	panic(err)
  }
  _ = agent

java

  import com.juglow.models.beta.agents.*;

  var agent = client.beta().agents().create(
      AgentCreateParams.builder()
          .name("Ops Agent")
          .model(BetaManagedAgentsModel.HAIJUN_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

  use Juglow\Beta\Agents\BetaManagedAgentsAgentToolset20260401Params;
  use Juglow\Beta\Agents\BetaManagedAgentsAgentToolsetDefaultConfigParams;
  use Juglow\Beta\Agents\BetaManagedAgentsAlwaysAskPolicy;
  use Juglow\Beta\Agents\BetaManagedAgentsAutoPolicy;
  use Juglow\Beta\Agents\BetaManagedAgentsBashToolConfigParams;
  use Juglow\Beta\Agents\BetaManagedAgentsMCPToolsetDefaultConfigParams;
  use Juglow\Beta\Agents\BetaManagedAgentsMCPToolsetParams;
  use Juglow\Beta\Agents\BetaManagedAgentsURLMCPServerParams;

  $agent = $client->beta->agents->create(
      name: 'Ops Agent',
      model: 'haijun-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

  agent = client.beta.agents.create(
    name: "Ops Agent",
    model: "haijun-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"}
        }
      }
    ]
  )

Apa yang Anda kirim dalam event user.message dihitung sebagai niat Anda, dan hal itu dapat membuat server mengizinkan panggilan yang sebaliknya akan ditolak. Server tidak membaca niat dari hasil alat, halaman web yang diambil, respons server MCP, atau pesan antar thread sesi. Server menilai konten tersebut tetapi tidak menerima instruksi darinya. Server mengevaluasi beberapa panggilan sebagai berisiko tinggi terlepas dari siapa yang memintanya. Jika Anda meneruskan input pengguna akhir yang tidak tepercaya dalam event user.message, server juga membaca input tersebut sebagai niat Anda, dan input itu dapat membuat suatu panggilan diizinkan. Konfigurasikan always_ask pada alat yang tidak akan Anda biarkan dijalankan oleh pengguna akhir tersebut tanpa peninjauan.

Warning: auto bukanlah titik pemeriksaan oleh manusia. Jika server menentukan bahwa suatu panggilan aman, panggilan tersebut dijalankan sebelum ada yang melihatnya, dan efeknya mungkin tidak dapat dibatalkan. Jika seseorang harus meninjau panggilan suatu alat sebelum dijalankan, konfigurasikan always_ask pada alat tersebut.

Melihat bagaimana setiap panggilan dievaluasi

Di bawah kebijakan izin apa pun, setiap event agent.tool_use dan agent.mcp_tool_use membawa evaluated_permission, yaitu hasil pemeriksaan izin panggilan tersebut: "allow", "ask", atau "deny". Sebagian besar event juga membawa objek evaluation yang type-nya menyebutkan kebijakan yang menghasilkan hasil tersebut. Di bawah auto, objek tersebut juga mencatat keputusan server, ditambah reason_code ketika hasilnya adalah ask atau deny.

Misalnya, ketika bash berada di bawah auto dan server mengevaluasi suatu panggilan sebagai berisiko tinggi, panggilan yang ditolak muncul di aliran event sebagai berikut:

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

Objek evaluation mengambil salah satu bentuk dalam tabel berikut.

`evaluation`	`evaluated_permission` tingkat atas	Arti
`{"type": "always_allow"}`	`"allow"`	Kebijakan yang berlaku adalah `always_allow`, sehingga panggilan dijalankan.
`{"type": "always_ask"}`	`"ask"`	Kebijakan yang berlaku adalah `always_ask`, sehingga panggilan dijeda untuk meminta persetujuan Anda.
`{"type": "auto", "evaluated_permission": {"type": "allow"}}`	`"allow"`	Di bawah `auto`, server menentukan bahwa panggilan tersebut aman, dan panggilan dijalankan.
`{"type": "auto", "evaluated_permission": {"type": "ask", "reason_code": "indeterminate"}}`	`"ask"`	Di bawah `auto`, server tidak mencapai keputusan, sehingga panggilan dijeda untuk meminta persetujuan Anda.
`{"type": "auto", "evaluated_permission": {"type": "deny", "reason_code": "high_risk"}}`	`"deny"`	Di bawah `auto`, server mengevaluasi panggilan sebagai berisiko tinggi dan menolaknya.

Ketika evaluation.type adalah "auto", evaluated_permission.type yang bersarang di dalamnya mengulang evaluated_permission tingkat atas milik event, sehingga Anda dapat membaca hasilnya dari salah satu field tersebut. reason_code adalah nilai yang dapat digunakan klien Anda untuk percabangan logika dan disimpan dalam catatan audit, bukan teks untuk ditampilkan kepada pengguna akhir.

evaluation tidak ada dalam dua kasus. Ketika agen menyebutkan alat yang tidak diaktifkan dalam sesi, server menolak panggilan tanpa mengevaluasi kebijakan: event membawa evaluated_permission: "deny" dan tanpa evaluation. Event yang dicatat sebelum evaluation diperkenalkan juga tidak menyertakannya: baca event tersebut sebagai always_allow ketika evaluated_permission adalah "allow" dan sebagai always_ask ketika nilainya "ask".

Tulis klien Anda agar dapat menoleransi evaluation.type atau reason_code yang tidak dikenalinya. Event agent.custom_tool_use tidak membawa kedua field tersebut, karena kebijakan izin tidak mengatur alat kustom.

Merespons permintaan konfirmasi

Panggilan alat dievaluasi menjadi ask di bawah kebijakan always_ask, atau di bawah auto ketika server tidak mencapai keputusan. Ketika hal itu terjadi:

Sesi memancarkan event agent.tool_use atau agent.mcp_tool_use.

Sesi dijeda dengan event session.status_idle yang stop_reason.type-nya adalah requires_action. ID event yang memblokir terdapat dalam array stop_reason.event_ids. Sesi menunggu respons tanpa batas waktu.

Kirim event user.tool_confirmation untuk setiap event yang memblokir, dengan meneruskan ID event dalam parameter tool_use_id. Atur result ke "allow" atau "deny". Gunakan deny_message untuk menjelaskan penolakan. Anda dapat mengirim beberapa konfirmasi dalam satu permintaan events.

Setelah semua event yang memblokir diselesaikan, sesi bertransisi kembali ke running. Alat yang diizinkan dieksekusi. Alat yang ditolak tidak berjalan, dan agen menerima hasil alat yang menyatakan bahwa panggilan ditolak, termasuk deny_message Anda.

Jika Anda mengirim user.tool_confirmation untuk event yang evaluated_permission-nya bukan ask, API menolaknya dengan error 400. Hal ini termasuk panggilan yang ditolak server di bawah auto: klien Anda tidak dapat membatalkannya.

Untuk menjawab secara interaktif, gunakan ant beta:sessions connect, yang menampilkan panggilan yang sedang menunggu dan mengirim event ini ketika Anda mengizinkan atau menolaknya. Lihat Menghubungkan ke sesi Managed Agents dari terminal Anda.

Dalam contoh berikut, ID event tool-use berasal dari array stop_reason.event_ids pada event session.status_idle. Pelajari lebih lanjut tentang menerima event dalam panduan Aliran event sesi, atau berlangganan webhook untuk mendapatkan notifikasi ketika sesi dijeda untuk menunggu input.

bash

  # Izinkan alat untuk dieksekusi
  curl -fsSL "https://haijun.my.id/v1/sessions/$SESSION_ID/events" \
    -H "x-api-key: $JUGLOW_API_KEY" \
    -H "juglow-version: 2023-06-01" \
    -H "juglow-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"
        }
      ]
    }'

  # Atau tolak dengan disertai penjelasan
  curl -fsSL "https://haijun.my.id/v1/sessions/$SESSION_ID/events" \
    -H "x-api-key: $JUGLOW_API_KEY" \
    -H "juglow-version: 2023-06-01" \
    -H "juglow-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

  # Izinkan alat untuk dieksekusi
  ant beta:sessions:events send \
    --session-id "$SESSION_ID" \
    --event "{type: user.tool_confirmation, tool_use_id: $AGENT_TOOL_USE_EVENT_ID, result: allow}"

  # Atau tolak dengan penjelasan
  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

  # Izinkan alat untuk dieksekusi
  client.beta.sessions.events.send(
      session.id,
      events=[
          {
              "type": "user.tool_confirmation",
              "tool_use_id": agent_tool_use_event.id,
              "result": "allow",
          },
      ],
  )

  # Atau tolak dengan penjelasan
  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

  // Izinkan alat untuk dieksekusi
  await client.beta.sessions.events.send(session.id, {
    events: [
      {
        type: "user.tool_confirmation",
        tool_use_id: agent_tool_use_event.id,
        result: "allow"
      }
    ]
  });

  // Atau tolak dengan penjelasan
  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

  // Izinkan alat untuk dieksekusi
  await client.Beta.Sessions.Events.Send(session.ID, new()
  {
      Events =
      [
          new BetaManagedAgentsUserToolConfirmationEventParams
          {
              Type = BetaManagedAgentsUserToolConfirmationEventParamsType.UserToolConfirmation,
              ToolUseID = agentToolUseEvent.ID,
              Result = "allow",
          },
      ],
  });

  // Atau tolak dengan penjelasan
  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.",
          },
      ],
  });

  // Izinkan alat untuk dieksekusi
  _, err = client.Beta.Sessions.Events.Send(ctx, session.ID, juglow.BetaSessionEventSendParams{
  	Events: []juglow.BetaManagedAgentsEventParamsUnion{{
  		OfUserToolConfirmation: &juglow.BetaManagedAgentsUserToolConfirmationEventParams{
  			Type:      juglow.BetaManagedAgentsUserToolConfirmationEventParamsTypeUserToolConfirmation,
  			ToolUseID: agentToolUseEvent.ID,
  			Result:    juglow.BetaManagedAgentsUserToolConfirmationEventParamsResultAllow,
  		},
  	}},
  })
  if err != nil {
  	panic(err)
  }

  // Atau tolak dengan penjelasan
  _, err = client.Beta.Sessions.Events.Send(ctx, session.ID, juglow.BetaSessionEventSendParams{
  	Events: []juglow.BetaManagedAgentsEventParamsUnion{{
  		OfUserToolConfirmation: &juglow.BetaManagedAgentsUserToolConfirmationEventParams{
  			Type:        juglow.BetaManagedAgentsUserToolConfirmationEventParamsTypeUserToolConfirmation,
  			ToolUseID:   mcpToolUseEvent.ID,
  			Result:      juglow.BetaManagedAgentsUserToolConfirmationEventParamsResultDeny,
  			DenyMessage: juglow.String("Don't create issues in the production project. Use the staging project."),
  		},
  	}},
  })
  if err != nil {
  	panic(err)
  }

java

  // Izinkan alat untuk dieksekusi
  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()
  );

  // Atau tolak dengan penjelasan
  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

  use Juglow\Beta\Sessions\Events\ManagedAgentsUserToolConfirmationEventParams;

  // Izinkan alat untuk dieksekusi
  $client->beta->sessions->events->send(
      $session->id,
      events: [
          ManagedAgentsUserToolConfirmationEventParams::with(
              type: 'user.tool_confirmation',
              toolUseID: $agentToolUseEvent->id,
              result: 'allow',
          ),
      ],
  );

  // Atau tolak dengan penjelasan
  $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

  # Izinkan alat untuk dieksekusi
  client.beta.sessions.events.send_(
    session.id,
    events: [
      {
        type: "user.tool_confirmation",
        tool_use_id: agent_tool_use_event.id,
        result: "allow"
      }
    ]
  )

  # Atau tolak dengan penjelasan
  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."
      }
    ]
  )

Alat kustom

Kebijakan izin tidak berlaku untuk alat kustom. Ketika agen memanggil alat kustom, aplikasi Anda menerima event agent.custom_tool_use dan bertanggung jawab untuk memutuskan apakah akan mengeksekusinya sebelum mengirim kembali user.custom_tool_result. Lihat Aliran event sesi untuk alur lengkapnya.

Langkah selanjutnya

Lampirkan keahlian berbasis filesystem yang dapat digunakan kembali ke agen Anda untuk alur kerja khusus domain.

Kirim event, lakukan streaming respons, dan interupsi atau alihkan sesi Anda di tengah eksekusi.

#Jenis kebijakan izin

#Menetapkan kebijakan untuk toolset

#Izin toolset agen

#Izin toolset MCP

#Mengganti kebijakan alat individual

#Biarkan server mengevaluasi setiap panggilan dengan auto

#Melihat bagaimana setiap panggilan dievaluasi

#Merespons permintaan konfirmasi

#Alat kustom

#Langkah selanjutnya

Jenis kebijakan izin

Menetapkan kebijakan untuk toolset

Izin toolset agen

Izin toolset MCP

Mengganti kebijakan alat individual

Biarkan server mengevaluasi setiap panggilan dengan `auto`

Melihat bagaimana setiap panggilan dievaluasi

Merespons permintaan konfirmasi

Alat kustom

Langkah selanjutnya