Kebijakan

Teks asli berbahasa Inggris -- terjemahan menunggu tinjauan teknis

Supported modes: Hosted Hybrid Local Available in: Free Solo Teams (audit retention is a configured window by tier: Free 7 days, Solo 90 days, Teams 365 days, see Feature Availability)

Kebijakan adalah aturan yang mengendalikan apa yang dapat dan tidak dapat dilakukan agen AI Anda. Halaman ini mencakup semuanya: cara menyusunnya, bagaimana kebijakan terhubung ke pemanggilan SDK Anda, urutan evaluasi, wildcard, kondisi, enkripsi, dan caching.

Konsep Inti

Kebijakan adalah kumpulan aturan yang diberi nama. Setiap aturan menyatakan: "Ketika agen mencoba aksi X pada sumber daya Y, jawabannya adalah izinkan atau tolak."

{
  "name": "my-policy",
  "rules": [
    {
      "effect": "allow",
      "action": "llm:generate",
      "resource": "model/gpt-4"
    }
  ]
}

Ketika kode SDK Anda memanggil cz.guard("llm", method="generate", args={"model": "gpt-5.4"}), SDK menemukan aturan ini, melihat bahwa efeknya adalah allow, dan membiarkan aksi berlanjut.

Format string aksi: String aksi dalam aturan kebijakan menggunakan format pemisah titik dua (tool:method). Pemanggilan SDK meneruskan tool dan method sebagai parameter terpisah, dan keduanya dicocokkan sebagai tool:method. Contoh: llm:generate, tool:call, data:read, api:request.

Bagaimana Pemanggilan SDK Dipetakan ke Aturan Kebijakan

Ini adalah hal terpenting untuk dipahami. Pemanggilan guard() memetakan nama alat dan metode ke aksi kebijakan, dan args ke kondisi kebijakan:

SDK call:                                       Policy rule:
cz.guard(                                       {
    "llm",                                          "action": "llm:generate",
    method="generate",                    -->       "resource": "model/gpt-5.4",
    args={                                -->       "conditions": {
        "model": "gpt-5.4",                            "agent_id": "agent-*"
        "agent_id": "agent-001",                    },
    },                                              "effect": "allow"
)                                               }

• Nama alat dan metode membentuk string aksi kebijakan (mis., "llm" + "generate" = "llm:generate").
• Dictionary args dicocokkan dengan objek conditions aturan (jika ada).
• Jika semua field cocok, effect aturan menentukan hasilnya.

Menyusun Kebijakan: Langkah demi Langkah

Langkah 1: Pilih Aksi Anda

Aksi menjelaskan apa yang coba dilakukan agen. Anda menentukan konvensi penamaannya. Berikut pola yang umum:

Aksi	Artinya	Kapan Digunakan
llm:generate	Memanggil LLM untuk pembuatan teks	Sebelum pemanggilan chat.completions.create() atau messages.create() apa pun
llm:embed	Menghasilkan embedding	Sebelum pemanggilan embeddings.create() apa pun
tool:call	Memanggil alat atau fungsi	Sebelum mengeksekusi alat yang diminta LLM
mcp.tool:call	Memanggil alat MCP	Sebelum memanggil alat melalui protokol MCP
mcp.resource:read	Membaca sumber daya MCP	Sebelum membaca data melalui MCP
data:read	Membaca dari sumber data	Sebelum mengkueri basis data atau vector store
data:write	Menulis ke sumber data	Sebelum menyisipkan atau memperbarui data
file:read	Membaca file	Sebelum mengakses file di disk
file:write	Menulis file	Sebelum menulis atau mengubah file
api:request	Membuat permintaan HTTP keluar	Sebelum memanggil API eksternal
*	Aksi apa pun	Aturan menyeluruh (catch-all)

Anda juga dapat membuat nama aksi sendiri. Nama-nama itu hanyalah string. SDK dan aturan kebijakan menggunakan string yang sama. Begitulah keduanya terhubung.

Langkah 2: Pilih Sumber Daya Anda

Sumber daya menjelaskan target dari aksi. Anda menentukan konvensi penamaannya:

Pola Sumber Daya	Yang Ditargetkan	Contoh Pemanggilan SDK
model/gpt-5.4	Model LLM tertentu	guard("llm", method="generate", context={"resource": "model/gpt-5.4"})
model/claude-*	Semua model Claude (wildcard)	guard("llm", method="generate", context={"resource": "model/claude-sonnet-4-6"})
tool/search_web	Alat tertentu	guard("tool", method="call", context={"resource": "tool/search_web"})
mcp://filesystem/read_file	Alat MCP tertentu	guard("mcp.tool", method="call", context={"resource": "mcp://filesystem/read_file"})
mcp://filesystem/*	Semua alat pada server MCP	Cocok dengan alat apa pun pada server filesystem
vectorstore/documents	Koleksi data	guard("data", method="read", context={"resource": "vectorstore/documents"})
https://api.example.com/*	Endpoint API	guard("api", method="request", context={"resource": "https://api.example.com/v1/users"})
*	Sumber daya apa pun	Menyeluruh (catch-all)

Langkah 3: Tetapkan Efek

Setiap aturan memiliki effect: allow atau deny.

[
  { "effect": "allow", "action": "llm:generate", "resource": "model/gpt-5.4" },
  { "effect": "deny", "action": "llm:generate", "resource": "model/gpt-4*" }
]

Langkah 4: Tambahkan Kondisi (Opsional)

Kondisi memungkinkan Anda membatasi aturan berdasarkan nilai runtime yang diteruskan dari SDK. Kondisi diimplementasikan di penegak kebijakan lokal (Python, Node, dan Go), sehingga bekerja di mode Hosted maupun Local.

{
  "effect": "allow",
  "action": "llm:generate",
  "resource": "model/gpt-4",
  "conditions": {
    "agent_id": "support-*",
    "environment": "production"
  }
}

Lihat bagian Kondisi khusus di bawah untuk semantik pencocokan lengkap.

Validasi

Ketika Anda mempublikasikan atau menyimpan versi kebijakan, platform memvalidasi setiap entri actions[*] di setiap aturan terhadap kumpulan aksi kanonis dan tabel alias (lihat Nama alat kanonis). Aturan yang menargetkan aksi yang tidak dikenal (salah ketik, nama karangan) ditolak dengan respons 422 validation_failed yang membawa daftar saran did_you_mean. Ini menangkap kelas bug "aturan masuk tetapi tidak pernah terpicu" secara diam-diam pada saat penulisan alih-alih setelah aturan dirilis ke produksi.

Contoh respons ketika aturan menargetkan database:queryy (salah ketik):

{
  "error": "validation_failed",
  "unknown_actions": ["database:queryy"],
  "suggestions": {
    "database:queryy": ["database:query (legacy)"]
  }
}

Editor aturan di dasbor menampilkan aturan yang bermasalah dengan batas merah dan tombol satu-klik "gunakan database:query" untuk setiap saran. Saran yang ditandai (legacy) berasal dari alias shim untuk aturan pra-kanonis; saran tanpa tanda adalah kelas kanonis modern (pilih yang itu untuk aturan baru).

SDK menjalankan validator yang sama sebagai peringatan pada saat pemuatan kebijakan sehingga pengguna mode kebijakan lokal (tanpa backend platform) tetap melihat salah ketik tersebut. Peringatan SDK tidak memblokir -- kebijakan tetap dimuat -- sehingga pelanggan yang menggunakan alat kustom yang belum dikenal SDK dapat terus berjalan sambil tetap melihat did-you-mean untuk salah ketik yang sebenarnya.

Kumpulan aksi yang dikenal validator adalah gabungan dari alat ekstraktor SDK kanonis, alias alat host (mis. Read diselesaikan menjadi file_read), empat kelas semantik SQL kanonis (database:read|write|admin|exec), setiap alias SQL lama (database:query, database:SELECT, database:DROP, ...), dan wildcard (*, tool:*, *:method). Memperbarui tabel alias SDK otomatis memperluas apa yang diterima validator.

Referensi Field Aturan

Field	Tipe	Wajib	Deskripsi
effect	"allow" atau "deny"	Ya	Apakah aturan mengizinkan atau memblokir aksi
action	string	Ya	Aksi yang dicocokkan. Mendukung wildcard (*)
resource	string	Ya	Sumber daya yang dicocokkan. Mendukung wildcard (*)
conditions	objek	Tidak	Pasangan key-value yang semuanya harus cocok dengan konteks permintaan. Nilai mendukung pola glob
clients	daftar string	Tidak	Batasi aturan pada klien AI tertentu (cursor, claude-code, gemini-cli, codex-cli, windsurf, python-sdk, dll.). Kosong/tidak ada = cocok dengan setiap klien. Mendukung pola glob. Ditambahkan di #175.
projects	daftar string	Tidak	Batasi aturan pada ID proyek tertentu. Kosong/tidak ada = cocok dengan setiap proyek. Mendukung pola glob. Ditambahkan di #175.

Semantik selektor (clients / projects)

Aturan dengan daftar clients yang tidak kosong akan dilewati kecuali nama klien yang terdeteksi pada permintaan cocok dengan salah satu entri. Sama halnya untuk projects. Kedua selektor harus secara positif memilih permintaan: client_name yang kosong TIDAK cocok dengan clients: ["cursor"]. Pertama-cocok-menang tetap berlaku — tidak ada pengurutan ulang "yang paling spesifik menang" secara implisit. Ungkapkan prioritas dengan menulis aturan yang lebih spesifik sebelum yang lebih umum:

rules:
  - allow: delete_* # cursor-only override fires first
    clients: ['cursor']
  - deny: delete_* # global default applies to everything else

Catatan sintaks glob: dukungan glob clients / projects sama dengan aturan untuk action / resource — *, prefix*, *suffix di Rust + Go, ditambah ? dan [seq] di Python (melalui fnmatch.fnmatchcase). Ini adalah kelas perilaku lintas-SDK yang sudah ada sebelumnya dan juga berlaku untuk aksi dan sumber daya; kami menyarankan tetap menggunakan sintaks penyebut bersama terkecil (pencocokan persis, prefix*, *suffix) demi portabilitas.

Wildcard

Field action maupun resource mendukung wildcard bergaya glob:

[
  { "action": "llm:*", "resource": "*" },
  { "action": "mcp.tool:call", "resource": "mcp://filesystem/*" },
  { "action": "*", "resource": "*" }
]

Pola	Cocok dengan	Tidak Cocok dengan
model/gpt-5.4	hanya model/gpt-5.4	model/gpt-5.4-mini
model/gpt-5.4*	model/gpt-5.4, model/gpt-5.4-mini	model/gpt-4-turbo
model/*	Model apa pun	tool/search_web
mcp://filesystem/*	mcp://filesystem/read_file, mcp://filesystem/write_file	mcp://github/create_issue
*	Semuanya	(cocok dengan semua)

Kondisi

Kondisi menyempurnakan aturan dengan pola glob key-value yang semuanya harus cocok pada saat runtime. Kondisi dievaluasi oleh penegak lokal di setiap SDK (Python dan Node), baik di mode Hosted maupun Local — tidak ada perjalanan pulang-pergi ke server.

Terhadap apa setiap kondisi dicocokkan

Ketika sebuah aturan memiliki conditions: { key: pattern, ... }, penegak membangun tampilan gabungan dari pemanggilan guard dan menguji setiap key terhadap tampilan tersebut. Aturan penggabungannya adalah:

1. Mulai dengan dict args dari pemanggilan.
2. Lapiskan context di atasnya (context menang jika ada tabrakan key).
3. Jika context["tags"] adalah mapping, ratakan ke tingkat atas dengan prioritas yang sama seperti context.
4. Setiap nilai kondisi adalah glob (wildcard *). Jika nilai pada key cocok dengan glob, kondisi lolos. Semua kondisi harus lolos.

Konsekuensi praktis: Anda dapat menggerakkan kondisi dari args, context tingkat atas, atau context["tags"] bersarang mana pun. Pilih yang paling alami bagi pemanggil.

Contoh: tag penyedia (pola wrapper yang disederhanakan)

- effect: allow
  action: 'llm:generate'
  conditions:
    provider: 'openai'

Aturan ini cocok jika salah satu pemanggilan berikut dilakukan:

# via top-level context (direct guard)
cz.guard("llm", method="generate", context={"provider": "openai"})

# via nested tags (simplified wrapper populates tags)
cz.guard("llm", method="generate", context={"tags": {"provider": "openai"}})

# via args (some integrations put it there)
cz.guard("llm", method="generate", args={"provider": "openai"})

Contoh: agen + lingkungan

{
  "effect": "allow",
  "action": "llm:generate",
  "conditions": {
    "agent_id": "support-*",
    "environment": "production"
  }
}

cz.guard(
    "llm",
    method="generate",
    context={
        "agent_id": "support-agent-1",   # matches "support-*"
        "environment": "production",     # matches "production"
    },
)

Contoh: tag bersarang

Ketika wrapper mengklasifikasikan pemanggilan dengan tag (penyedia, keluarga model, tingkat biaya), kondisi dapat mencocokkan tag tersebut seolah-olah berada di tingkat atas:

{ "effect": "deny", "action": "llm:generate", "conditions": { "cost_tier": "premium" } }

cz.guard(
    "llm",
    method="generate",
    context={"tags": {"cost_tier": "premium", "provider": "openai"}},
)
# Denied: conditions.cost_tier matches tags.cost_tier after flattening.

Urutan Evaluasi Kebijakan

Ketika beberapa aturan dapat cocok dengan pemanggilan guard() yang sama, Control Zero menerapkan prioritas berikut:

Tiga aturan:

1. Tolak eksplisit selalu menang. Jika ada aturan tolak yang cocok, aksi diblokir, bahkan jika aturan izinkan juga cocok.

2. Aturan yang lebih spesifik didahulukan daripada yang lebih luas. Aturan untuk model/gpt-4 mengalahkan aturan untuk model/*.

3. Tidak cocok = tolak (secara default). Jika tidak ada aturan yang cocok dengan aksi dan sumber daya, aksi ditolak.

   Teks asli berbahasa Inggris -- terjemahan menunggu tinjauan teknis

   This is the secure-by-default allow-list posture, and it is the default.

   Teks asli berbahasa Inggris -- terjemahan menunggu tinjauan teknis

   It is also a knob: the settings.default_action field controls the no-match path and can be set to deny (allow-list, the default), warn (log-and-proceed, for discovery rollouts), or allow (deny-list -- allow unmatched calls and block only the tools you explicitly deny:).

   Lihat Perilaku Penerapan untuk kontrak lengkap dan resep Daftar-tolak untuk kebijakan default_action: allow siap salin.

Contoh: Evaluasi dalam Praktik

Diberikan kebijakan berikut:

{
  "rules": [
    { "effect": "allow", "action": "llm:generate", "resource": "model/*" },
    { "effect": "deny", "action": "llm:generate", "resource": "model/gpt-4*" }
  ]
}

Pemanggilan SDK	Aturan 1 Cocok?	Aturan 2 Cocok?	Hasil
guard("llm:generate", "model/gpt-4")	Ya (izinkan)	Tidak	DIIZINKAN
guard("llm:generate", "model/gpt-3.5-turbo")	Ya (izinkan)	Tidak	DIIZINKAN
guard("llm:generate", "model/gpt-4-turbo")	Ya (izinkan)	Ya (tolak)	DITOLAK (tolak menang)
guard("tool:call", "tool/search")	Tidak	Tidak	DITOLAK (tidak cocok = tolak)

Contoh Kebijakan Lengkap

Contoh 1: Tata Kelola Model

Izinkan model tertentu, tolak yang lainnya:

{
  "name": "model-governance",
  "description": "Only approved models can be used",
  "rules": [
    {
      "effect": "allow",
      "action": "llm:generate",
      "resource": "model/gpt-5.4"
    },
    {
      "effect": "allow",
      "action": "llm:generate",
      "resource": "model/claude-sonnet-4-6"
    },
    {
      "effect": "deny",
      "action": "llm:generate",
      "resource": "model/*"
    }
  ]
}

Aturan terakhir bertindak sebagai catch-all: model apa pun yang tidak diizinkan secara eksplisit akan ditolak.

Di kode Anda:

cz.guard("llm", method="generate", context={"resource": "model/gpt-5.4"})         # ALLOWED
cz.guard("llm", method="generate", context={"resource": "model/claude-sonnet-4-6"}) # ALLOWED
cz.guard("llm", method="generate", context={"resource": "model/gpt-4o"})            # DENIED (catch-all)

Contoh 2: Kontrol Alat MCP

Kendalikan alat MCP mana yang dapat dipanggil agen:

{
  "name": "mcp-tool-control",
  "description": "Restrict MCP tool access per agent",
  "rules": [
    {
      "effect": "allow",
      "action": "mcp.tool:call",
      "resource": "mcp://filesystem/read_file",
      "conditions": { "agent_id": "analyst-*" }
    },
    {
      "effect": "deny",
      "action": "mcp.tool:call",
      "resource": "mcp://filesystem/write_file"
    },
    {
      "effect": "allow",
      "action": "mcp.tool:call",
      "resource": "mcp://github/*",
      "conditions": { "agent_id": "dev-agent" }
    },
    {
      "effect": "deny",
      "action": "mcp.tool:call",
      "resource": "mcp://*"
    }
  ]
}

Di kode Anda:

# Analyst agent reading a file: ALLOWED (rule 1 matches)
cz.guard(
    "mcp.tool",
    method="call",
    context={"resource": "mcp://filesystem/read_file", "agent_id": "analyst-42"},
)

# Any agent writing a file: DENIED (rule 2 matches)
cz.guard(
    "mcp.tool",
    method="call",
    context={"resource": "mcp://filesystem/write_file", "agent_id": "analyst-42"},
)

# Dev agent using GitHub: ALLOWED (rule 3 matches)
cz.guard(
    "mcp.tool",
    method="call",
    context={"resource": "mcp://github/create_issue", "agent_id": "dev-agent"},
)

# Unknown MCP tool: DENIED (rule 4 catch-all)
cz.guard(
    "mcp.tool",
    method="call",
    context={"resource": "mcp://slack/send_message", "agent_id": "analyst-42"},
)

Contoh 3: Kebijakan Produksi Multi-Lapis

Kebijakan yang menggabungkan tata kelola model, kontrol alat, akses data, dan pembatasan API:

{
  "name": "production-agent-policy",
  "description": "Full governance for production AI agents",
  "rules": [
    {
      "effect": "allow",
      "action": "llm:generate",
      "resource": "model/gpt-4",
      "conditions": { "environment": "production" }
    },
    {
      "effect": "allow",
      "action": "tool:call",
      "resource": "tool/search_web"
    },
    {
      "effect": "deny",
      "action": "tool:call",
      "resource": "tool/execute_code"
    },
    {
      "effect": "allow",
      "action": "data:read",
      "resource": "vectorstore/public-docs"
    },
    {
      "effect": "deny",
      "action": "data:read",
      "resource": "vectorstore/internal-*"
    },
    {
      "effect": "allow",
      "action": "api:request",
      "resource": "https://api.internal.example.com/*"
    },
    {
      "effect": "deny",
      "action": "api:request",
      "resource": "https://*.external.example.com/*"
    },
    {
      "effect": "deny",
      "action": "*",
      "resource": "*"
    }
  ]
}

Aturan terakhir adalah catch-all global: apa pun yang tidak diizinkan secara eksplisit akan ditolak.

Bundel Kebijakan

Kebijakan tidak dikirim ke SDK satu per satu. Sebaliknya, semua kebijakan aktif untuk sebuah proyek dikompilasi menjadi satu bundel kebijakan.

Cara Kerja Bundel

Ketika Anda mempublikasikan kebijakan di dasbor, Control Zero mengirimkannya ke SDK Anda sebagai satu bundel. Kebijakan baru menjadi aktif di agen Anda dalam sekitar satu menit, atau segera dengan penyegaran manual.

Keamanan Bundel

Teks asli berbahasa Inggris -- terjemahan menunggu tinjauan teknis

Every policy bundle is signed. The SDK verifies the signature before use, detects tampering, and rejects an invalid bundle. If this happens on a background refresh, it keeps enforcing the last known good policy; if it happens at startup, there is no verified policy to fall back to and calls are denied. A modified bundle cannot silently change enforcement either way.

Caching Lokal

SDK menyimpan bundel saat ini di disk. Ini menyediakan:

Teks asli berbahasa Inggris -- terjemahan menunggu tinjauan teknis

• Offline enforcement: If the SDK cannot reach the server, it enforces the last known good policy.

• Evaluasi tanpa latensi: Setiap pemanggilan guard() dievaluasi terhadap memori lokal.

  Teks asli berbahasa Inggris -- terjemahan menunggu tinjauan teknis

  No network round-trip.

Teks asli berbahasa Inggris -- terjemahan menunggu tinjauan teknis

• Resilience: Network outages or server maintenance do not interrupt policy enforcement.

Lokasi cache default:

• Python: ~/.controlzero/cache/
• Go: ~/.controlzero/cache/
• Node.js: ~/.controlzero/cache/

Menyegarkan Kebijakan

SDK memeriksa bundel baru setiap 60 detik secara default (setiap pemeriksaan adalah permintaan bersyarat ETag, sehingga kebijakan yang tidak berubah tidak memerlukan pengunduhan ulang). Setel CONTROLZERO_POLICY_STALENESS_S untuk memperlebar atau mempersempit jendela itu. Anda juga dapat memaksa penyegaran:

# Python: policies refresh automatically; close the client when done
client.close()

// Go
err := client.RefreshPolicies(ctx)

// Node.js
await cz.refreshPolicies();

Teks asli berbahasa Inggris -- terjemahan menunggu tinjauan teknis

Audit log retention

Audit log retention is a configured window by tier: Free 7 days, Solo 90 days, Teams 365 days (see Feature Availability). Automatic deletion of audit records at the end of the window is not currently running on the production audit store, so audit records are kept longer than the window. Deletion will be switched on only after dated notice to affected organizations. When tiered audit retention takes effect, Free organizations created before then keep their existing 30-day window unless an owner changes it, and an owner can set a shorter window. Compliance exports are available in Solo and Teams. View pricing

Mengendalikan pemanggilan alat MCP

Alat Model Context Protocol (MCP) memberi agen AI kapabilitas yang luas: akses sistem file, kueri basis data, eksekusi shell, pemanggilan API. Control Zero mengendalikan setiap pemanggilan alat MCP sebagai pasangan (action, resource) di mana aksinya adalah mcp.tool:call dan sumber dayanya mengikuti konvensi mcp://{server}/{tool}.

Bagian ini mendefinisikan pencocokan kebijakan MCP; penerapan yang sebenarnya bergantung pada cakupan hook yang terdokumentasi untuk setiap klien.

Pola umum

Agen hanya-baca -- izinkan baca, tolak tulis dan shell:

{
  "name": "read-only-agent",
  "rules": [
    { "effect": "allow", "action": "mcp.tool:call", "resource": "mcp://filesystem/read_file" },
    { "effect": "allow", "action": "mcp.tool:call", "resource": "mcp://filesystem/list_directory" },
    { "effect": "deny", "action": "mcp.tool:call", "resource": "mcp://filesystem/write_file" },
    { "effect": "deny", "action": "mcp.tool:call", "resource": "mcp://filesystem/delete_file" },
    { "effect": "deny", "action": "mcp.tool:call", "resource": "mcp://shell/execute" }
  ]
}

Pembaca basis data -- izinkan SELECT, tolak tulis:

{
  "name": "db-reader-agent",
  "rules": [
    { "effect": "allow", "action": "mcp.tool:call", "resource": "mcp://database/read_query" },
    { "effect": "deny", "action": "mcp.tool:call", "resource": "mcp://database/write_query" },
    { "effect": "deny", "action": "mcp.tool:call", "resource": "mcp://database/execute_query" }
  ]
}

Agen khusus-API -- izinkan HTTP keluar, tolak akses lokal:

{
  "name": "api-only-agent",
  "rules": [
    { "effect": "allow", "action": "mcp.tool:call", "resource": "mcp://http/request" },
    { "effect": "deny", "action": "mcp.tool:call", "resource": "mcp://filesystem/*" },
    { "effect": "deny", "action": "mcp.tool:call", "resource": "mcp://shell/*" },
    { "effect": "deny", "action": "mcp.tool:call", "resource": "mcp://database/*" }
  ]
}

Pola gateway kebijakan MCP

Untuk klien native-MCP, bungkus pemanggilan alat dalam gateway kecil yang memanggil guard() sebelum meneruskan ke server MCP yang sebenarnya:

from controlzero import Client
from typing import Any

cz = Client(api_key="cz_live_your_api_key_here")


class PolicyGateway:
    """MCP gateway that enforces Control Zero policies on tool calls."""

    def __init__(self, agent_id: str):
        self.agent_id = agent_id

    def call_tool(self, server: str, tool: str, arguments: dict) -> Any:
        cz.guard(
            "mcp.tool",
            method="call",
            context={"resource": f"mcp://{server}/{tool}", "agent_id": self.agent_id},
            args=arguments,
        )
        return self._forward_to_server(server, tool, arguments)

    def check_tool(self, server: str, tool: str) -> bool:
        """Check if a tool call would be allowed (without enforcing)."""
        decision = cz.guard(
            "mcp.tool",
            method="call",
            context={"resource": f"mcp://{server}/{tool}", "agent_id": self.agent_id},
        )
        return decision.effect == "allow"

    def _forward_to_server(self, server, tool, arguments):
        # Implementation depends on your MCP client library.
        pass

Memfilter daftar alat pada saat presentasi

Sebelum menyajikan alat kepada agen, filter katalog berdasarkan kebijakan agar model tidak pernah melihat alat yang tidak boleh dipanggilnya:

available_tools = [
    ("filesystem", "read_file"),
    ("filesystem", "write_file"),
    ("database", "read_query"),
    ("database", "write_query"),
    ("shell", "execute"),
    ("http", "request"),
]

allowed_tools = []
for server, tool in available_tools:
    decision = cz.guard(
        "mcp.tool",
        method="call",
        context={"resource": f"mcp://{server}/{tool}", "agent_id": "my-agent"},
    )
    if decision.effect == "allow":
        allowed_tools.append((server, tool))

Ini mencegah model bahkan mencoba alat yang ditolak, mengurangi token yang terbuang dan event audit yang berisik.

Langkah Berikutnya

• Mulai Cepat: Bangun agen yang berfungsi dengan penerapan kebijakan.
• Proyek: Organisasikan agen ke dalam proyek dengan kebijakan terpisah.
• Integrasi: Terapkan otomatis pada OpenAI, Anthropic, LangChain, dan lainnya.