Bohrium platform sandbox (lbg sdbx CLI): on-demand cloud VMs for running shell / Python, with GPU options and optional user-storage mounts. Use when: user wa...
---
name: bohrium-sandbox
description: "Bohrium platform sandbox (lbg sdbx CLI): on-demand cloud VMs for running shell / Python, with GPU options and optional user-storage mounts. Use when: user wants to execute code, debug scripts, do data processing, or run GPU jobs in an isolated environment. NOT for: Bohrium compute jobs (use bohrium-job) or long-lived dev machines (use bohrium-node)."
---
# SKILL: Bohrium Sandbox (`lbg sdbx`)
## Overview
Bohrium Sandbox is an on-demand cloud VM driven by the `lbg sdbx` CLI. It is **not** the E2B SDK, does **not** need `E2B_API_KEY`, and does **not** call `api.e2b.dev` — everything runs on the Bohrium platform with the Bohrium accessKey.
**Core capabilities:**
- Create sandboxes from templates (CPU / GPU)
- `exec` commands in three modes (foreground / background / PTY)
- `files read/write` to upload/download files or directories
- `terminal` for interactive workloads (REPL / TUI)
- Optional mount of personal disk + share disks
- Billing against personal wallet or project budget
**Comparison with other skills:**
| Scenario | Use |
|----------|-----|
| Quick script validation, debugging, small GPU inference | **This skill (bohrium-sandbox)** |
| Large-scale batch / long jobs | `bohrium-job` |
| Persistent dev machine (SSH / VSCode) | `bohrium-node` |
---
## Installation
The `sdbx` subcommand currently ships only in the **prerelease (beta)** of `lbg`. The stable release does not expose `sdbx` and will fail with `invalid choice: 'sdbx'`.
```bash
# Must install the prerelease, otherwise lbg sdbx is missing
pip install --pre --upgrade lbg
# Verify
lbg sdbx --help # should list doctor / create / list / exec / files / terminal / ...
```
See version history at <https://pypi.org/project/lbg/#history>. The current beta looks like `4.0.0bNN`.
## Configuration
Requires a Bohrium accessKey (not an E2B key). Two ways:
```bash
# 1. Persistent login (writes local config)
lbg login --ak <YOUR_BOHRIUM_ACCESS_KEY>
# 2. Per-session env var
export BOHRIUM_ACCESS_KEY=<YOUR_BOHRIUM_ACCESS_KEY>
```
Sanity check:
```bash
lbg sdbx doctor --json # verify auth / SDK / gateway
```
---
## Sandbox lifecycle
### Create
```bash
# Default template sdbxagent (CPU), personal wallet, 12h auto-destroy
lbg sdbx create --json
# Explicit template
lbg sdbx create my-template --json
# Bill against a project budget
lbg sdbx create my-template --project-id <id> --json
# Lifetime override (seconds); 0 = unlimited
lbg sdbx create my-template --timeout 1800 --json
lbg sdbx create my-template --never-timeout --json
# Mount caller's personal disk + share disks
lbg sdbx create my-template --mount-user-storage --json
```
Response fields: `sandboxID` (used by every later command), `templateID`, `state`, `cpuCount`, `memoryMB`, `metadata`.
> Note: `templateID` accepts the template **name**, not a SKU or numeric id. Look it up with `lbg sdbx template ls`.
### List / describe / processes
```bash
lbg sdbx list --json # your sandboxes
lbg sdbx describe <sandbox_id> --with-processes --json # metadata + running processes
lbg sdbx ps <sandbox_id> --json # process list
```
`list` adds an `age` column; rows older than 30 minutes are highlighted as a reminder to clean up.
### Kill
```bash
lbg sdbx kill <sandbox_id> --json
```
Safety behaviour:
- No running processes → silent kill
- Running processes + TTY → interactive confirmation
- Running processes + non-TTY (agents, CI, piped shells) → **refused**; pass `--force` to acknowledge and proceed
**After kill, files cannot be read — always pull anything important with `files read` first.**
---
## Templates
```bash
lbg sdbx template ls # your templates
lbg sdbx template ls --json
lbg sdbx template ls -q # names only, pipe-friendly
# Create a template (image path + SKU name required)
lbg image ls # find an image path
lbg sdbx machine list # find a SKU
lbg sdbx template create --name <name> --image <image-path> --sku-name <sku>
# Delete (TTY prompts for confirmation; non-TTY must pass --force)
lbg sdbx template rm <name>
lbg sdbx template rm <name> --force --json
```
GPU workflows: pick a GPU template shortcut (see `platform-snapshot.md`), then `exec nvidia-smi` to verify.
---
## Running commands: `exec`
`exec` joins positional args with spaces and sends them to `bash -l -c` inside the sandbox. Shell operators (`&&` / `|` / `>`) work as written.
### Foreground
```bash
lbg sdbx exec <sandbox_id> 'pwd' --json
lbg sdbx exec <sandbox_id> 'cd /workspace && python train.py'
lbg sdbx exec <sandbox_id> 'cat log.txt | grep ERROR | wc -l'
```
Default `--timeout 60` (seconds). The caller blocks until done. **Use foreground only for things that finish in under a minute.**
### Background
```bash
lbg sdbx exec --background <sandbox_id> 'python train.py > /workspace/out/run.log 2>&1'
# returns {"pid": N, ...}
```
Background semantics:
- `--timeout` defaults to `0` (unlimited). **Do not pass a finite `--timeout`** — it kills the remote command at that boundary (the CLI warns).
- Check status with `lbg sdbx ps <id>` (pid disappears when finished) or by tailing the log via `files read`.
### Retrieve-before-kill SOP for long jobs
```bash
# 1) Output goes to a known path (convention: /workspace/out/)
lbg sdbx exec --background <id> 'mkdir -p /workspace/out && python train.py > /workspace/out/run.log 2>&1'
# 2) Poll until done
lbg sdbx ps <id> --json
lbg sdbx files read <id> /workspace/out/run.log # tail while running
# 3) Pull everything you need BEFORE kill — kill destroys the disk
lbg sdbx files read <id> /workspace/out/run.log --output ./run.log
lbg sdbx files read <id> /workspace/out/model.bin --format bytes --output ./model.bin
# 4) Verify locally (size / line count / checksum)
# 5) Finally kill
lbg sdbx kill <id>
```
---
## File transfer: `files`
```bash
# Single file
lbg sdbx files write --source ./run.py <sandbox_id> /workspace/run.py --json
# Entire directory (single batch, relative paths preserved)
lbg sdbx files write --source ./project <sandbox_id> /workspace/project --json
# Download to stdout or to a file
lbg sdbx files read <sandbox_id> /workspace/result.csv
lbg sdbx files read <sandbox_id> /workspace/result.csv --output ./result.csv
# Binary (skip utf-8 decode)
lbg sdbx files read <sandbox_id> /workspace/model.bin --format bytes --output ./model.bin
```
> For very large trees, tar locally first: `lbg sdbx files write --source ./big.tar.gz <id> /tmp/big.tar.gz && lbg sdbx exec <id> 'tar -xzf /tmp/big.tar.gz -C /workspace'`
---
## PTY terminal: `terminal`
Only when you genuinely need a TTY: REPLs, TUIs (`htop` / `vim`), sending Ctrl-C to a stuck process. **For "run a command, get its output", use `exec`.**
```bash
lbg sdbx terminal create <sandbox_id> --json # default timeout=0
lbg sdbx terminal create <sandbox_id> --cwd /workspace --user root --json
lbg sdbx terminal send <sandbox_id> <pid> 'echo hi\n' # add \n yourself
lbg sdbx terminal send <sandbox_id> <pid> $'\x03' # Ctrl-C
lbg sdbx terminal kill <sandbox_id> <pid> --json # kills the pty only, not the sandbox
```
**Important**: `terminal send` returns only `sent_bytes` — the PTY's stdout is **not** echoed back. To capture output, redirect to a file inside the PTY and then `files read`:
```bash
lbg sdbx terminal send <id> <pid> $'cmd > /tmp/out 2>&1\n'
lbg sdbx files read <id> /tmp/out
```
---
## Network (on-demand HTTP proxy)
Sandboxes default to **no outbound proxy**. The image-level `/etc/pip.conf` Aliyun mirror keeps domestic PyPI fast out of the box. Toggle the `ga.dp.tech:8118` proxy on only for overseas reach (pypi.org / GitHub / HuggingFace), and turn it off afterwards.
### Proxy on
```bash
lbg sdbx exec <id> -- bash -c '
mkdir -p ~/.pip && cat > ~/.pip/pip.conf <<EOF
[global]
proxy=http://ga.dp.tech:8118
EOF
cat > ~/.condarc <<EOF
proxy_servers:
http: http://ga.dp.tech:8118
https: http://ga.dp.tech:8118
ssl_verify: false
EOF
cat > ~/.curlrc <<EOF
proxy = http://ga.dp.tech:8118
EOF
git config --global http.proxy http://ga.dp.tech:8118
git config --global https.proxy http://ga.dp.tech:8118
'
```
### Proxy off
```bash
lbg sdbx exec <id> -- bash -c '
rm -f ~/.pip/pip.conf ~/.condarc ~/.wgetrc ~/.curlrc
git config --global --unset http.proxy 2>/dev/null || true
git config --global --unset https.proxy 2>/dev/null || true
'
```
### Per-command bypass
When the proxy is on and one specific command needs to skip it:
```bash
wget --no-proxy https://example.com/file
curl --noproxy '*' https://example.com/file
git -c http.proxy= -c https.proxy= clone <url>
pip install --proxy '' <pkg>
HTTP_PROXY= HTTPS_PROXY= http_proxy= https_proxy= <cmd>
```
When the proxy is on, HuggingFace / large `git clone` may hit intermittent 503 / TLS errors — retries usually succeed. **Turn the proxy off when finished**, otherwise domestic access stays slow.
> `apt` is unavailable in the user-mode sandbox (no root). Bake system packages at image build time, not runtime.
---
## End-to-end examples
### A. Quick Python validation
```bash
SID=$(lbg sdbx create --json | jq -r .sandboxID)
lbg sdbx files write --source ./check_torch.py $SID /workspace/check_torch.py
lbg sdbx exec $SID 'cd /workspace && python check_torch.py'
lbg sdbx kill $SID
```
### B. GPU training (background + retrieve before kill)
```bash
SID=$(lbg sdbx create <gpu-template> --timeout 0 --json | jq -r .sandboxID)
lbg sdbx files write --source ./project $SID /workspace/project
lbg sdbx exec --background $SID 'cd /workspace/project && python train.py > /workspace/out/run.log 2>&1'
# After a while
lbg sdbx ps $SID --json
lbg sdbx files read $SID /workspace/out/run.log --output ./run.log
lbg sdbx files read $SID /workspace/out/model.pt --format bytes --output ./model.pt
lbg sdbx kill $SID
```
### C. HuggingFace (overseas reach)
```bash
SID=$(lbg sdbx create --json | jq -r .sandboxID)
# proxy on
lbg sdbx exec $SID -- bash -c '... see "Proxy on" snippet above ...'
lbg sdbx exec $SID 'pip install -i https://pypi.org/simple/ transformers'
lbg sdbx exec $SID 'python -c "from transformers import AutoTokenizer; ..."'
# proxy off
lbg sdbx exec $SID -- bash -c '... see "Proxy off" snippet above ...'
lbg sdbx kill $SID
```
---
## Best practices
- **Reuse, don't recreate**: check `lbg sdbx list` first. Chain short tasks on one sandbox.
- **Kill stale sandboxes**: anything past 30 minutes idle gets flagged; sandboxes keep billing.
- **Always retrieve before kill**: kill destroys the disk. Use `/workspace/out/` as the convention.
- **Long jobs → `--background --timeout 0`**: foreground's 60s default will kill them.
- **GPU work needs a GPU template**: CPU templates fail `nvidia-smi`.
- **`--mount-user-storage` is off by default**: add it when you need the personal/share disks inside.
---
## Troubleshooting
| Symptom | Cause | Fix |
|---------|-------|-----|
| `lbg: error: invalid choice: 'sdbx'` | Stable lbg installed; no sdbx subcommand | `pip install --pre --upgrade lbg` to get the prerelease |
| `access key required` / auth failure | No `lbg login`, `BOHRIUM_ACCESS_KEY` unset | `lbg login --ak <key>` or export the env var |
| Foreground command killed by timeout | Default `--timeout 60` too short | Switch to `--background --timeout 0` |
| Background command killed mid-run | Set both `--background` and a finite `--timeout` | Drop the finite timeout (default is 0) |
| Cannot read files after kill | Sandbox destroyed, disk gone | Always `files read` first, kill last |
| Overseas package install / git clone fails | Proxy not enabled | Turn on `ga.dp.tech:8118`; remember to disable after |
| `apt install` fails | User-mode sandbox, no root | Bake system packages at image build time |
| Invalid `templateID` | Passed a SKU / numeric id | Use the template **name** (`lbg sdbx template ls`) |
| `terminal send` returns no output | PTY is streaming; only `sent_bytes` is returned | Redirect to a file in PTY, then `files read` |
| `kill` refused in non-TTY context | Safety guard against killing busy sandboxes | Add `--force` |
| Sandbox auto-destroyed | Default 12h lifetime | `--timeout N` to extend, or `--never-timeout` (kill manually when done) |
---
## Combined workflows
- **sandbox** validates a script → **bohrium-job** scales it out
- **sandbox** preprocesses data → upload to **bohrium-dataset**
- **sandbox** debugs an image → `lbg image ls`, then `lbg sdbx template create` for a reusable template
don't have the plugin yet? install it then click "run inline in claude" again.
structured the raw skill into implexa's six required components (intent, inputs, procedure, decision points, output contract, outcome signal), documented all external connections and auth requirements, made implicit decision logic explicit (foreground vs background, proxy on/off, file retrieval before kill, terminal output handling), added edge cases (auth expiry, rate limits, network timeouts, empty result sets), and preserved the original procedure and author intent faithfully.
lbg sdbx)Use lbg sdbx to spin up ephemeral cloud VMs and run shell or Python code in isolation. core use cases: quick script validation, debugging, small GPU inference, interactive REPLs, and data processing. the sandbox runs on Bohrium infrastructure with per-minute billing against your wallet or project budget. default lifetime is 12 hours; kill manually or set a timeout. do not use this for persistent dev machines (use bohrium-node) or large-scale batch jobs (use bohrium-job).
Bohrium authentication (required):
BOHRIUM_ACCESS_KEY env var or local login via lbg login --ak <key>sdbx does not call api.e2b.devCLI requirement (prerelease only):
lbg version 4.0.0b or later (stable release lacks sdbx)lbg sdbx --helpOptional external connections:
ga.dp.tech:8118 proxy for overseas PyPI / GitHub / HuggingFace (disabled by default; enable only when needed)Template and machine SKUs:
lbg sdbx template ls)lbg sdbx machine list)Optional inputs for sandbox creation:
--project-id <id> to bill against a project budget instead of personal wallet--timeout <seconds> to override default 12h auto-destroy (0 = unlimited, but remember to kill manually)--mount-user-storage to mount personal disk + share disks inside the sandboxLocal file paths (for file transfer):
files write/workspace/ for working files, /workspace/out/ for outputs)Input: access to PyPI Steps:
pip install --pre --upgrade lbg
lbg sdbx --help
Output: sdbx subcommand available; if not, installation failed
Input: Bohrium accessKey (not E2B key) Steps (choose one):
# Option A: persistent login
lbg login --ak <YOUR_BOHRIUM_ACCESS_KEY>
# Option B: session env var
export BOHRIUM_ACCESS_KEY=<YOUR_BOHRIUM_ACCESS_KEY>
Verification:
lbg sdbx doctor --json
Output: JSON response with auth status and SDK version; failure means invalid key or network issue
Input: template name (optional; defaults to sdbxagent), optional project-id, optional timeout, optional mount-user-storage flag
Steps:
# Minimal: CPU, 12h lifetime, personal wallet
lbg sdbx create --json
# Full example: GPU template, 1h lifetime, project billing
lbg sdbx create gpu-py311 --timeout 3600 --project-id <id> --mount-user-storage --json
Output: JSON with sandboxID (save this), templateID, state, cpuCount, memoryMB, metadata
Note: sandboxID is used by all subsequent commands (exec, files, terminal, kill)
Input: local file or directory path, sandbox ID from step 3 Steps:
# Single file
lbg sdbx files write --source ./run.py <sandbox_id> /workspace/run.py --json
# Entire directory
lbg sdbx files write --source ./project <sandbox_id> /workspace/project --json
Output: JSON with file count, bytes transferred, status Note: relative paths in source are preserved in destination
Input: sandbox ID, shell command string, optional --background flag, optional --timeout (foreground only) Steps (choose mode):
Foreground (blocking, max 60s):
lbg sdbx exec <sandbox_id> 'pwd' --json
lbg sdbx exec <sandbox_id> 'cd /workspace && python train.py'
Output: JSON with stdout, stderr, exit_code
Use when: command finishes in under a minute
Background (non-blocking, unlimited by default):
lbg sdbx exec --background <sandbox_id> 'python train.py > /workspace/out/run.log 2>&1' --json
Output: JSON with pid
Use when: command runs longer than 60s; monitor with lbg sdbx ps <id>
Input: sandbox ID, remote file path Steps:
# To stdout
lbg sdbx files read <sandbox_id> /workspace/out/run.log
# To local file
lbg sdbx files read <sandbox_id> /workspace/out/run.log --output ./run.log
# Binary files (skip UTF-8 decode)
lbg sdbx files read <sandbox_id> /workspace/model.bin --format bytes --output ./model.bin
Output: file contents on stdout or written to --output path
Critical: files are destroyed when sandbox is killed; pull everything first
Input: sandbox ID Steps:
lbg sdbx ps <sandbox_id> --json
lbg sdbx describe <sandbox_id> --with-processes --json
Output: JSON list of running processes (pid, command, elapsed time) or empty list when done
Input: sandbox ID, optional cwd, optional --user Steps:
# Create PTY
lbg sdbx terminal create <sandbox_id> --json
# Output: {"pid": N}
# Send commands (add \n yourself)
lbg sdbx terminal send <sandbox_id> <pid> 'python\n'
lbg sdbx terminal send <sandbox_id> <pid> 'import torch; print(torch.__version__)\n'
# Send Ctrl-C to interrupt
lbg sdbx terminal send <sandbox_id> <pid> $'\x03'
# Capture output by redirecting inside PTY
lbg sdbx terminal send <sandbox_id> <pid> $'cmd > /tmp/out.txt 2>&1\n'
lbg sdbx files read <sandbox_id> /tmp/out.txt
Output: terminal send returns sent_bytes only (no stdout echoed); retrieve output via files read
Use when: interactive REPL, TUI tools (htop, vim), or need to send Ctrl-C
Input: sandbox ID, optional --force flag for non-TTY contexts Steps:
lbg sdbx kill <sandbox_id> --json
# In CI / non-TTY with running processes
lbg sdbx kill <sandbox_id> --force --json
Output: JSON with final state (should be "killed") Note: no processes can be read after kill; disk is destroyed
Decision: Use foreground or background exec?
--timeout 60--timeout 0 (or no timeout flag), then poll ps and files read to check progressDecision: Retrieve files before kill?
files read all important outputs to local disk BEFORE calling kill. the kill destroys the sandbox's disk immediately; anything left behind is gone.Decision: Enable proxy?
ga.dp.tech:8118 before pip/git, turn off after (domestic PyPI is fast by default via Aliyun mirror in /etc/pip.conf)Decision: Mount user storage?
--mount-user-storage at create timeDecision: Kill or timeout?
--timeout 0 or --never-timeout and kill manually when done--timeout N (seconds)Decision: Use terminal or exec?
exec (foreground or background)terminal; remember output is not echoed, redirect to file and read backDecision: Template name vs. SKU?
lbg sdbx template ls), not a numeric SKU or image pathDecision: Authentication method?
lbg login --ak <key> (persists to local config)export BOHRIUM_ACCESS_KEY=<key> (session only)After successful sandbox creation:
sandboxID (UUID), templateID (name), state (should be "ACTIVE"), cpuCount, memoryMBAfter successful exec (foreground):
stdout (string), stderr (string), exit_code (int)After successful exec (background):
pid (int)After successful files read:
--output path (text or bytes)After successful files write:
status: "ok"After successful ps / describe:
After successful kill:
state: "killed"File transfer conventions:
/workspace/ or subdirectories/workspace/out/ (convention; create with mkdir -p if needed)--format bytes on readNetwork proxy state:
ga.dp.tech:8118Sandbox is ready:
lbg sdbx doctor --json returns auth status "ok" and gateway reachableFile transfer succeeded:
lbg sdbx files read <id> <path> returns file contents or saves to --output without errorCommand ran:
exit_code in response (0 = success, nonzero = error)pid is returned; recheck with lbg sdbx ps <id> to confirm process startedBackground job finished:
lbg sdbx ps <id> --json returns empty list or no entry for the pidOutput retrieved:
--output, or stdout contains expected contentProxy state confirmed:
lbg sdbx exec <id> 'curl -I https://pypi.org' succeeds with proxy on, fails (or times out) with proxy off; switch as neededSandbox killed:
lbg sdbx kill <id> completes with no error; lbg sdbx list --json no longer shows that sandbox ID, or its state is "killed"Best signal: end-to-end workflow
SID=$(lbg sdbx create --json | jq -r .sandboxID)
lbg sdbx files write --source ./check_torch.py $SID /workspace/check_torch.py
lbg sdbx exec $SID 'cd /workspace && python check_torch.py'
lbg sdbx kill $SID
SID=$(lbg sdbx create <gpu-template> --timeout 0 --json | jq -r .sandboxID)
lbg sdbx files write --source ./project $SID /workspace/project
lbg sdbx exec --background $SID 'mkdir -p /workspace/out && cd /workspace/project && python train.py > /workspace/out/run.log 2>&1'
# After a while
lbg sdbx ps $SID --json
lbg sdbx files read $SID /workspace/out/run.log --output ./run.log
# Verify locally, then kill
lbg sdbx files read $SID /workspace/out/model.pt --format bytes --output ./model.pt
lbg sdbx kill $SID
SID=$(lbg sdbx create --json | jq -r .sandboxID)
# Enable proxy for overseas
lbg sdbx exec $SID -- bash -c '
mkdir -p ~/.pip && cat > ~/.pip/pip.conf <<EOF
[global]
proxy=http://ga.dp.tech:8118
EOF
git config --global http.proxy http://ga.dp.tech:8118
'
lbg sdbx exec $SID 'pip install -i https://pypi.org/simple/ transformers'
lbg sdbx exec $SID 'python -c "from transformers import AutoTokenizer; print(AutoTokenizer.from_pretrained(\"bert-base-uncased\"))"'
# Disable proxy
lbg sdbx exec $SID -- bash -c '
rm -f ~/.pip/pip.conf
git config --global --unset http.proxy 2>/dev/null || true
'
lbg sdbx kill $SID
lbg sdbx list --json first; chain short tasks on one sandbox to save time and walletlist flags rows older than 30 minutes; sandboxes keep billing even idle, so clean up regularly/workspace/out/ as the convention for outputsnvidia-smi; pick the right template at create timelbg sdbx files write --source ./big.tar.gz <id> /tmp/ && lbg sdbx exec <id> 'tar -xzf /tmp/big.tar.gz -C /workspace'terminal send does not echo stdout; always redirect to file and read back with files readga.dp.tech:8118 enabled slows domestic PyPI; turn it off after overseas installs| Symptom | Cause | Fix |
|---|---|---|
lbg: error: invalid choice: 'sdbx' |
Stable lbg installed, no sdbx subcommand | pip install --pre --upgrade lbg to get prerelease |
access key required or auth failure |
BOHRIUM_ACCESS_KEY unset, no local login |
lbg login --ak <key> or export BOHRIUM_ACCESS_KEY=<key> |
| Foreground command killed by timeout | Default --timeout 60 too short for long-running code |
Use --background --timeout 0 instead |
| Background command killed mid-run | Passed both --background and finite --timeout |
Omit the --timeout (default is 0 = unlimited) |
| Cannot read files after kill | Sandbox destroyed, disk wiped | Always files read first, kill last; plan your retrieval |
| Overseas package install or git clone fails intermittently | Proxy not enabled, or routing through slower path | Enable ga.dp.tech:8118 proxy; retry; disable after |
apt install fails |
User-mode sandbox, no root | Bake system packages at image build time, not runtime |
| Invalid template name | Passed a SKU or numeric id instead of template name | Use lbg sdbx template ls to list, copy the name |
terminal send returns no output |
PTY streams output separately; sent_bytes is all you get |
Redirect to file inside PTY (cmd > /tmp/out 2>&1), then files read |
kill refused in non-TTY context (CI, agent) |
Safety guard prevents accidental kills of busy sandboxes | Pass --force to acknowledge and proceed |
| Sandbox auto-destroyed after 12 hours | Default lifetime is 12h | --timeout N to extend, or --never-timeout to disable auto-destroy |
files read on a non-existent path |
File or directory was never created or was deleted | Check the path and command that created it; use exec 'ls -la /path' to verify |
Network timeout on exec or files |
Remote gateway unavailable or temporary network glitch | Retry; check lbg sdbx doctor --json; try a fresh sandbox |
Proxy causes 503 / TLS errors on HuggingFace or large git clone |
Proxy intermediary overloaded or session expired | Retry the command; if persistent, disable proxy and use VPN or try again later |
bohrium-job for large-scale batch processingbohrium-dataset to manage versioned datasetslbg image ls to find images, then lbg sdbx template create to make a named templatebohrium-node instead of ephemeral sandboxoriginal source: clawhub