---
read_when: You want a dedicated explanation of sandboxing or need to tune agents.defaults.sandbox.
status: active
summary: 'Cara kerja sandboxing OpenClaw: mode, cakupan, akses workspace, dan gambar'
title: Sandboxing
x-i18n:
    generated_at: "2026-04-14T02:08:38Z"
    model: gpt-5.4
    provider: openai
    source_hash: 2573d0d7462f63a68eb1750e5432211522ff5b42989a17379d3e188468bbce52
    source_path: gateway/sandboxing.md
    workflow: 15
---

# Sandboxing

OpenClaw dapat menjalankan **alat di dalam backend sandbox** untuk mengurangi dampak jika terjadi masalah.
Ini **opsional** dan dikendalikan oleh konfigurasi (`agents.defaults.sandbox` atau
`agents.list[].sandbox`). Jika sandboxing dimatikan, alat berjalan di host.
Gateway tetap berada di host; eksekusi alat berjalan di sandbox terisolasi
saat diaktifkan.

Ini bukan batas keamanan yang sempurna, tetapi secara nyata membatasi akses
filesystem dan proses ketika model melakukan sesuatu yang bodoh.

## Apa yang masuk ke sandbox

- Eksekusi alat (`exec`, `read`, `write`, `edit`, `apply_patch`, `process`, dll.).
- Browser sandbox opsional (`agents.defaults.sandbox.browser`).
  - Secara default, browser sandbox akan mulai otomatis (memastikan CDP dapat dijangkau) saat alat browser membutuhkannya.
    Konfigurasikan melalui `agents.defaults.sandbox.browser.autoStart` dan `agents.defaults.sandbox.browser.autoStartTimeoutMs`.
  - Secara default, container browser sandbox menggunakan jaringan Docker khusus (`openclaw-sandbox-browser`) alih-alih jaringan global `bridge`.
    Konfigurasikan dengan `agents.defaults.sandbox.browser.network`.
  - `agents.defaults.sandbox.browser.cdpSourceRange` opsional membatasi ingress CDP di tepi container dengan allowlist CIDR (misalnya `172.21.0.1/32`).
  - Akses pengamat noVNC dilindungi kata sandi secara default; OpenClaw mengeluarkan URL token berumur singkat yang menyajikan halaman bootstrap lokal dan membuka noVNC dengan kata sandi di fragmen URL (bukan di log query/header).
  - `agents.defaults.sandbox.browser.allowHostControl` memungkinkan sesi dalam sandbox menargetkan browser host secara eksplisit.
  - Allowlist opsional membatasi `target: "custom"`: `allowedControlUrls`, `allowedControlHosts`, `allowedControlPorts`.

Tidak masuk sandbox:

- Proses Gateway itu sendiri.
- Alat apa pun yang secara eksplisit diizinkan berjalan di luar sandbox (misalnya `tools.elevated`).
  - **Elevated exec melewati sandboxing dan menggunakan jalur escape yang dikonfigurasi (`gateway` secara default, atau `node` saat target exec adalah `node`).**
  - Jika sandboxing dimatikan, `tools.elevated` tidak mengubah eksekusi (karena sudah berjalan di host). Lihat [Mode Elevated](/id/tools/elevated).

## Mode

`agents.defaults.sandbox.mode` mengontrol **kapan** sandboxing digunakan:

- `"off"`: tanpa sandboxing.
- `"non-main"`: sandbox hanya untuk sesi **non-main** (default jika Anda ingin chat normal berjalan di host).
- `"all"`: setiap sesi berjalan di dalam sandbox.
  Catatan: `"non-main"` didasarkan pada `session.mainKey` (default `"main"`), bukan id agen.
  Sesi grup/channel menggunakan key mereka sendiri, sehingga dihitung sebagai non-main dan akan masuk sandbox.

## Cakupan

`agents.defaults.sandbox.scope` mengontrol **berapa banyak container** yang dibuat:

- `"agent"` (default): satu container per agen.
- `"session"`: satu container per sesi.
- `"shared"`: satu container dibagikan oleh semua sesi yang menggunakan sandbox.

## Backend

`agents.defaults.sandbox.backend` mengontrol **runtime mana** yang menyediakan sandbox:

- `"docker"` (default): runtime sandbox lokal berbasis Docker.
- `"ssh"`: runtime sandbox jarak jauh generik berbasis SSH.
- `"openshell"`: runtime sandbox berbasis OpenShell.

Konfigurasi khusus SSH berada di bawah `agents.defaults.sandbox.ssh`.
Konfigurasi khusus OpenShell berada di `plugins.entries.openshell.config`.

### Memilih backend

|                     | Docker                           | SSH                            | OpenShell                                              |
| ------------------- | -------------------------------- | ------------------------------ | ------------------------------------------------------ |
| **Tempat berjalan** | Container lokal                  | Host apa pun yang bisa diakses via SSH | Sandbox terkelola OpenShell                      |
| **Penyiapan**       | `scripts/sandbox-setup.sh`       | Kunci SSH + host target        | Plugin OpenShell diaktifkan                            |
| **Model workspace** | Bind-mount atau salin            | Remote-canonical (seed sekali) | `mirror` atau `remote`                                 |
| **Kontrol jaringan** | `docker.network` (default: none) | Bergantung pada host remote    | Bergantung pada OpenShell                              |
| **Browser sandbox** | Didukung                         | Tidak didukung                 | Belum didukung                                         |
| **Bind mount**      | `docker.binds`                   | T/A                            | T/A                                                    |
| **Paling cocok untuk** | Pengembangan lokal, isolasi penuh | Memindahkan beban ke mesin remote | Sandbox remote terkelola dengan sinkronisasi dua arah opsional |

### Backend Docker

Backend Docker adalah runtime default, yang menjalankan alat dan browser sandbox secara lokal melalui socket daemon Docker (`/var/run/docker.sock`). Isolasi container sandbox ditentukan oleh namespace Docker.

**Batasan Docker-out-of-Docker (DooD)**:
Jika Anda menerapkan Gateway OpenClaw itu sendiri sebagai container Docker, ia akan mengorkestrasi container sandbox saudara menggunakan socket Docker milik host (DooD). Ini menimbulkan batasan pemetaan path tertentu:

- **Konfigurasi Memerlukan Path Host**: Konfigurasi `workspace` pada `openclaw.json` HARUS berisi **path absolut milik Host** (misalnya `/home/user/.openclaw/workspaces`), bukan path internal container Gateway. Saat OpenClaw meminta daemon Docker untuk membuat sandbox, daemon mengevaluasi path relatif terhadap namespace OS Host, bukan namespace Gateway.
- **Paritas FS Bridge (Peta Volume Identik)**: Proses native OpenClaw Gateway juga menulis file heartbeat dan bridge ke direktori `workspace`. Karena Gateway mengevaluasi string yang sama persis (path host) dari dalam lingkungan container-nya sendiri, deployment Gateway HARUS menyertakan peta volume identik yang menautkan namespace host secara native (`-v /home/user/.openclaw:/home/user/.openclaw`).

Jika Anda memetakan path secara internal tanpa paritas absolut dengan host, OpenClaw akan melempar error izin `EACCES` secara native saat mencoba menulis heartbeat di dalam lingkungan container karena string path yang sepenuhnya memenuhi syarat itu tidak ada secara native.

### Backend SSH

Gunakan `backend: "ssh"` saat Anda ingin OpenClaw mensandbox `exec`, alat file, dan pembacaan media pada
mesin apa pun yang dapat diakses melalui SSH.

```json5
{
  agents: {
    defaults: {
      sandbox: {
        mode: "all",
        backend: "ssh",
        scope: "session",
        workspaceAccess: "rw",
        ssh: {
          target: "user@gateway-host:22",
          workspaceRoot: "/tmp/openclaw-sandboxes",
          strictHostKeyChecking: true,
          updateHostKeys: true,
          identityFile: "~/.ssh/id_ed25519",
          certificateFile: "~/.ssh/id_ed25519-cert.pub",
          knownHostsFile: "~/.ssh/known_hosts",
          // Atau gunakan SecretRef / isi inline alih-alih file lokal:
          // identityData: { source: "env", provider: "default", id: "SSH_IDENTITY" },
          // certificateData: { source: "env", provider: "default", id: "SSH_CERTIFICATE" },
          // knownHostsData: { source: "env", provider: "default", id: "SSH_KNOWN_HOSTS" },
        },
      },
    },
  },
}
```

Cara kerjanya:

- OpenClaw membuat root remote per-cakupan di bawah `sandbox.ssh.workspaceRoot`.
- Pada penggunaan pertama setelah create atau recreate, OpenClaw melakukan seed workspace remote tersebut dari workspace lokal satu kali.
- Setelah itu, `exec`, `read`, `write`, `edit`, `apply_patch`, pembacaan media prompt, dan staging media masuk berjalan langsung terhadap workspace remote melalui SSH.
- OpenClaw tidak menyinkronkan perubahan remote kembali ke workspace lokal secara otomatis.

Materi autentikasi:

- `identityFile`, `certificateFile`, `knownHostsFile`: gunakan file lokal yang sudah ada dan teruskan melalui konfigurasi OpenSSH.
- `identityData`, `certificateData`, `knownHostsData`: gunakan string inline atau SecretRef. OpenClaw menyelesaikannya melalui snapshot runtime secret normal, menuliskannya ke file sementara dengan `0600`, lalu menghapusnya saat sesi SSH berakhir.
- Jika `*File` dan `*Data` sama-sama disetel untuk item yang sama, `*Data` menang untuk sesi SSH tersebut.

Ini adalah model **remote-canonical**. Workspace SSH remote menjadi state sandbox yang sebenarnya setelah seed awal.

Konsekuensi penting:

- Edit lokal di host yang dibuat di luar OpenClaw setelah langkah seed tidak akan terlihat secara remote sampai Anda membuat ulang sandbox.
- `openclaw sandbox recreate` menghapus root remote per-cakupan dan melakukan seed lagi dari lokal pada penggunaan berikutnya.
- Browser sandboxing tidak didukung pada backend SSH.
- Pengaturan `sandbox.docker.*` tidak berlaku pada backend SSH.

### Backend OpenShell

Gunakan `backend: "openshell"` saat Anda ingin OpenClaw mensandbox alat dalam
lingkungan remote yang dikelola OpenShell. Untuk panduan penyiapan lengkap, referensi
konfigurasi, dan perbandingan mode workspace, lihat
[halaman OpenShell](/id/gateway/openshell) khusus.

OpenShell menggunakan kembali transport SSH inti yang sama dan bridge filesystem remote seperti
backend SSH generik, lalu menambahkan lifecycle khusus OpenShell
(`sandbox create/get/delete`, `sandbox ssh-config`) serta mode workspace `mirror`
opsional.

```json5
{
  agents: {
    defaults: {
      sandbox: {
        mode: "all",
        backend: "openshell",
        scope: "session",
        workspaceAccess: "rw",
      },
    },
  },
  plugins: {
    entries: {
      openshell: {
        enabled: true,
        config: {
          from: "openclaw",
          mode: "remote", // mirror | remote
          remoteWorkspaceDir: "/sandbox",
          remoteAgentWorkspaceDir: "/agent",
        },
      },
    },
  },
}
```

Mode OpenShell:

- `mirror` (default): workspace lokal tetap canonical. OpenClaw menyinkronkan file lokal ke OpenShell sebelum exec dan menyinkronkan workspace remote kembali setelah exec.
- `remote`: workspace OpenShell menjadi canonical setelah sandbox dibuat. OpenClaw melakukan seed workspace remote satu kali dari workspace lokal, lalu alat file dan exec berjalan langsung terhadap sandbox remote tanpa menyinkronkan perubahan kembali.

Detail transport remote:

- OpenClaw meminta konfigurasi SSH khusus sandbox dari OpenShell melalui `openshell sandbox ssh-config <name>`.
- Core menulis konfigurasi SSH tersebut ke file sementara, membuka sesi SSH, dan menggunakan kembali bridge filesystem remote yang sama seperti pada `backend: "ssh"`.
- Hanya pada mode `mirror` lifecycle-nya berbeda: sinkronkan lokal ke remote sebelum exec, lalu sinkronkan kembali setelah exec.

Batasan OpenShell saat ini:

- browser sandbox belum didukung
- `sandbox.docker.binds` tidak didukung pada backend OpenShell
- knob runtime khusus Docker di bawah `sandbox.docker.*` tetap hanya berlaku untuk backend Docker

#### Mode workspace

OpenShell memiliki dua model workspace. Ini adalah bagian yang paling penting dalam praktik.

##### `mirror`

Gunakan `plugins.entries.openshell.config.mode: "mirror"` saat Anda ingin **workspace lokal tetap canonical**.

Perilaku:

- Sebelum `exec`, OpenClaw menyinkronkan workspace lokal ke sandbox OpenShell.
- Setelah `exec`, OpenClaw menyinkronkan workspace remote kembali ke workspace lokal.
- Alat file tetap beroperasi melalui bridge sandbox, tetapi workspace lokal tetap menjadi sumber kebenaran di antara giliran.

Gunakan ini saat:

- Anda mengedit file secara lokal di luar OpenClaw dan ingin perubahan tersebut otomatis muncul di sandbox
- Anda ingin sandbox OpenShell berperilaku semirip mungkin dengan backend Docker
- Anda ingin workspace host mencerminkan penulisan sandbox setelah setiap giliran exec

Tradeoff:

- ada biaya sinkronisasi tambahan sebelum dan sesudah exec

##### `remote`

Gunakan `plugins.entries.openshell.config.mode: "remote"` saat Anda ingin **workspace OpenShell menjadi canonical**.

Perilaku:

- Saat sandbox pertama kali dibuat, OpenClaw melakukan seed workspace remote dari workspace lokal satu kali.
- Setelah itu, `exec`, `read`, `write`, `edit`, dan `apply_patch` beroperasi langsung terhadap workspace OpenShell remote.
- OpenClaw **tidak** menyinkronkan perubahan remote kembali ke workspace lokal setelah exec.
- Pembacaan media saat prompt tetap berfungsi karena alat file dan media membaca melalui bridge sandbox alih-alih mengasumsikan path host lokal.
- Transport menggunakan SSH ke sandbox OpenShell yang dikembalikan oleh `openshell sandbox ssh-config`.

Konsekuensi penting:

- Jika Anda mengedit file di host di luar OpenClaw setelah langkah seed, sandbox remote **tidak** akan melihat perubahan tersebut secara otomatis.
- Jika sandbox dibuat ulang, workspace remote akan di-seed lagi dari workspace lokal.
- Dengan `scope: "agent"` atau `scope: "shared"`, workspace remote tersebut dibagikan pada cakupan yang sama.

Gunakan ini saat:

- sandbox sebaiknya hidup terutama di sisi OpenShell remote
- Anda ingin overhead sinkronisasi per giliran lebih rendah
- Anda tidak ingin edit lokal di host diam-diam menimpa state sandbox remote

Pilih `mirror` jika Anda menganggap sandbox sebagai lingkungan eksekusi sementara.
Pilih `remote` jika Anda menganggap sandbox sebagai workspace yang sebenarnya.

#### Lifecycle OpenShell

Sandbox OpenShell tetap dikelola melalui lifecycle sandbox normal:

- `openclaw sandbox list` menampilkan runtime OpenShell maupun runtime Docker
- `openclaw sandbox recreate` menghapus runtime saat ini dan membiarkan OpenClaw membuatnya kembali pada penggunaan berikutnya
- logika prune juga memahami backend

Untuk mode `remote`, recreate sangat penting:

- recreate menghapus workspace remote canonical untuk cakupan tersebut
- penggunaan berikutnya melakukan seed workspace remote baru dari workspace lokal

Untuk mode `mirror`, recreate terutama mereset lingkungan eksekusi remote
karena workspace lokal tetap canonical.

## Akses workspace

`agents.defaults.sandbox.workspaceAccess` mengontrol **apa yang dapat dilihat sandbox**:

- `"none"` (default): alat melihat workspace sandbox di bawah `~/.openclaw/sandboxes`.
- `"ro"`: me-mount workspace agen sebagai read-only di `/agent` (menonaktifkan `write`/`edit`/`apply_patch`).
- `"rw"`: me-mount workspace agen sebagai read/write di `/workspace`.

Dengan backend OpenShell:

- mode `mirror` tetap menggunakan workspace lokal sebagai sumber canonical di antara giliran exec
- mode `remote` menggunakan workspace OpenShell remote sebagai sumber canonical setelah seed awal
- `workspaceAccess: "ro"` dan `"none"` tetap membatasi perilaku tulis dengan cara yang sama

Media masuk disalin ke workspace sandbox aktif (`media/inbound/*`).
Catatan Skills: alat `read` berakar pada root sandbox. Dengan `workspaceAccess: "none"`,
OpenClaw mencerminkan Skills yang memenuhi syarat ke workspace sandbox (`.../skills`) agar
dapat dibaca. Dengan `"rw"`, Skills workspace dapat dibaca dari
`/workspace/skills`.

## Bind mount kustom

`agents.defaults.sandbox.docker.binds` me-mount direktori host tambahan ke dalam container.
Format: `host:container:mode` (misalnya `"/home/user/source:/source:rw"`).

Bind global dan per-agen **digabungkan** (bukan diganti). Di bawah `scope: "shared"`, bind per-agen diabaikan.

`agents.defaults.sandbox.browser.binds` me-mount direktori host tambahan ke dalam container **browser sandbox** saja.

- Saat disetel (termasuk `[]`), nilainya menggantikan `agents.defaults.sandbox.docker.binds` untuk container browser.
- Saat dihilangkan, container browser kembali menggunakan `agents.defaults.sandbox.docker.binds` (kompatibel ke belakang).

Contoh (source read-only + direktori data tambahan):

```json5
{
  agents: {
    defaults: {
      sandbox: {
        docker: {
          binds: ["/home/user/source:/source:ro", "/var/data/myapp:/data:ro"],
        },
      },
    },
    list: [
      {
        id: "build",
        sandbox: {
          docker: {
            binds: ["/mnt/cache:/cache:rw"],
          },
        },
      },
    ],
  },
}
```

Catatan keamanan:

- Bind melewati filesystem sandbox: bind mengekspos path host dengan mode apa pun yang Anda setel (`:ro` atau `:rw`).
- OpenClaw memblokir sumber bind berbahaya (misalnya: `docker.sock`, `/etc`, `/proc`, `/sys`, `/dev`, dan mount induk yang akan mengeksposnya).
- OpenClaw juga memblokir root kredensial umum di direktori home seperti `~/.aws`, `~/.cargo`, `~/.config`, `~/.docker`, `~/.gnupg`, `~/.netrc`, `~/.npm`, dan `~/.ssh`.
- Validasi bind bukan sekadar pencocokan string. OpenClaw menormalkan path sumber, lalu menyelesaikannya lagi melalui ancestor terdalam yang ada sebelum memeriksa ulang path yang diblokir dan root yang diizinkan.
- Artinya, upaya escape melalui parent symlink tetap gagal tertutup bahkan ketika leaf akhir belum ada. Contoh: `/workspace/run-link/new-file` tetap diselesaikan sebagai `/var/run/...` jika `run-link` menunjuk ke sana.
- Root sumber yang diizinkan juga dikanonikalisasi dengan cara yang sama, sehingga path yang hanya tampak berada di dalam allowlist sebelum resolusi symlink tetap ditolak sebagai `outside allowed roots`.
- Mount sensitif (secret, kunci SSH, kredensial layanan) sebaiknya `:ro` kecuali benar-benar diperlukan.
- Kombinasikan dengan `workspaceAccess: "ro"` jika Anda hanya memerlukan akses baca ke workspace; mode bind tetap independen.
- Lihat [Sandbox vs Kebijakan Alat vs Elevated](/id/gateway/sandbox-vs-tool-policy-vs-elevated) untuk cara bind berinteraksi dengan kebijakan alat dan elevated exec.

## Gambar + penyiapan

Gambar Docker default: `openclaw-sandbox:bookworm-slim`

Build sekali:

```bash
scripts/sandbox-setup.sh
```

Catatan: gambar default **tidak** menyertakan Node. Jika sebuah skill memerlukan Node (atau
runtime lain), buat custom image atau instal melalui
`sandbox.docker.setupCommand` (memerlukan egress jaringan + root yang dapat ditulis +
pengguna root).

Jika Anda ingin gambar sandbox yang lebih fungsional dengan alat umum (misalnya
`curl`, `jq`, `nodejs`, `python3`, `git`), build:

```bash
scripts/sandbox-common-setup.sh
```

Lalu setel `agents.defaults.sandbox.docker.image` ke
`openclaw-sandbox-common:bookworm-slim`.

Gambar browser sandbox:

```bash
scripts/sandbox-browser-setup.sh
```

Secara default, container sandbox Docker berjalan **tanpa jaringan**.
Override dengan `agents.defaults.sandbox.docker.network`.

Gambar browser sandbox bawaan juga menerapkan default startup Chromium yang konservatif
untuk workload dalam container. Default container saat ini mencakup:

- `--remote-debugging-address=127.0.0.1`
- `--remote-debugging-port=<derived from OPENCLAW_BROWSER_CDP_PORT>`
- `--user-data-dir=${HOME}/.chrome`
- `--no-first-run`
- `--no-default-browser-check`
- `--disable-3d-apis`
- `--disable-gpu`
- `--disable-dev-shm-usage`
- `--disable-background-networking`
- `--disable-extensions`
- `--disable-features=TranslateUI`
- `--disable-breakpad`
- `--disable-crash-reporter`
- `--disable-software-rasterizer`
- `--no-zygote`
- `--metrics-recording-only`
- `--renderer-process-limit=2`
- `--no-sandbox` dan `--disable-setuid-sandbox` saat `noSandbox` diaktifkan.
- Tiga flag hardening grafis (`--disable-3d-apis`,
  `--disable-software-rasterizer`, `--disable-gpu`) bersifat opsional dan berguna
  saat container tidak memiliki dukungan GPU. Setel `OPENCLAW_BROWSER_DISABLE_GRAPHICS_FLAGS=0`
  jika workload Anda memerlukan WebGL atau fitur browser/3D lainnya.
- `--disable-extensions` diaktifkan secara default dan dapat dinonaktifkan dengan
  `OPENCLAW_BROWSER_DISABLE_EXTENSIONS=0` untuk alur yang bergantung pada ekstensi.
- `--renderer-process-limit=2` dikendalikan oleh
  `OPENCLAW_BROWSER_RENDERER_PROCESS_LIMIT=<N>`, dengan `0` mempertahankan default Chromium.

Jika Anda memerlukan profil runtime yang berbeda, gunakan custom image browser dan sediakan
entrypoint Anda sendiri. Untuk profil Chromium lokal (non-container), gunakan
`browser.extraArgs` untuk menambahkan flag startup tambahan.

Default keamanan:

- `network: "host"` diblokir.
- `network: "container:<id>"` diblokir secara default (risiko bypass namespace join).
- Override break-glass: `agents.defaults.sandbox.docker.dangerouslyAllowContainerNamespaceJoin: true`.

Instalasi Docker dan Gateway dalam container ada di sini:
[Docker](/id/install/docker)

Untuk deployment Gateway Docker, `scripts/docker/setup.sh` dapat melakukan bootstrap konfigurasi sandbox.
Setel `OPENCLAW_SANDBOX=1` (atau `true`/`yes`/`on`) untuk mengaktifkan jalur tersebut. Anda dapat
mengganti lokasi socket dengan `OPENCLAW_DOCKER_SOCKET`. Referensi env dan
penyiapan lengkap: [Docker](/id/install/docker#agent-sandbox).

## setupCommand (penyiapan container satu kali)

`setupCommand` berjalan **sekali** setelah container sandbox dibuat (bukan pada setiap run).
Perintah ini dieksekusi di dalam container melalui `sh -lc`.

Path:

- Global: `agents.defaults.sandbox.docker.setupCommand`
- Per-agen: `agents.list[].sandbox.docker.setupCommand`

Jebakan umum:

- Default `docker.network` adalah `"none"` (tanpa egress), sehingga instalasi paket akan gagal.
- `docker.network: "container:<id>"` memerlukan `dangerouslyAllowContainerNamespaceJoin: true` dan hanya untuk break-glass.
- `readOnlyRoot: true` mencegah penulisan; setel `readOnlyRoot: false` atau buat custom image.
- `user` harus root untuk instalasi paket (hilangkan `user` atau setel `user: "0:0"`).
- Sandbox exec **tidak** mewarisi `process.env` host. Gunakan
  `agents.defaults.sandbox.docker.env` (atau custom image) untuk API key skill.

## Kebijakan alat + jalur escape

Kebijakan allow/deny alat tetap berlaku sebelum aturan sandbox. Jika sebuah alat ditolak
secara global atau per-agen, sandboxing tidak akan mengaktifkannya kembali.

`tools.elevated` adalah jalur escape eksplisit yang menjalankan `exec` di luar sandbox (`gateway` secara default, atau `node` saat target exec adalah `node`).
Direktif `/exec` hanya berlaku untuk pengirim yang berwenang dan tetap tersimpan per sesi; untuk menonaktifkan
`exec` secara permanen, gunakan deny pada kebijakan alat (lihat [Sandbox vs Kebijakan Alat vs Elevated](/id/gateway/sandbox-vs-tool-policy-vs-elevated)).

Debugging:

- Gunakan `openclaw sandbox explain` untuk memeriksa mode sandbox efektif, kebijakan alat, dan key konfigurasi perbaikan.
- Lihat [Sandbox vs Kebijakan Alat vs Elevated](/id/gateway/sandbox-vs-tool-policy-vs-elevated) untuk model mental “mengapa ini diblokir?”.
  Tetap kunci serapat mungkin.

## Override multi-agent

Setiap agen dapat meng-override sandbox + alat:
`agents.list[].sandbox` dan `agents.list[].tools` (serta `agents.list[].tools.sandbox.tools` untuk kebijakan alat sandbox).
Lihat [Sandbox & Alat Multi-Agent](/id/tools/multi-agent-sandbox-tools) untuk prioritas.

## Contoh pengaktifan minimal

```json5
{
  agents: {
    defaults: {
      sandbox: {
        mode: "non-main",
        scope: "session",
        workspaceAccess: "none",
      },
    },
  },
}
```

## Dokumen terkait

- [OpenShell](/id/gateway/openshell) -- penyiapan backend sandbox terkelola, mode workspace, dan referensi konfigurasi
- [Konfigurasi Sandbox](/id/gateway/configuration-reference#agentsdefaultssandbox)
- [Sandbox vs Kebijakan Alat vs Elevated](/id/gateway/sandbox-vs-tool-policy-vs-elevated) -- debugging "mengapa ini diblokir?"
- [Sandbox & Alat Multi-Agent](/id/tools/multi-agent-sandbox-tools) -- override per-agen dan prioritas
- [Keamanan](/id/gateway/security)
