Templates
A template decides what is already installed when a sandbox starts. Pick the one closest to your task – your agent can always install more with pip, npm or apt, it just takes a few seconds longer.
| If you want to… | Template |
|---|---|
| run code an AI model wrote, call APIs, process files | base |
| analyse data and draw charts | code-interpreter |
| open web pages in a real browser, take screenshots | browser |
| work with JavaScript or TypeScript | node |
| build and test a whole web application | fullstack |
| run many small, quick jobs cheaply | mini |
| compile Go or Rust | go rust |
| have a clean Ubuntu and install things yourself | ubuntu |
base Python
The default workspace for AI agents.
Good for: Most agent tasks: running code the model wrote, calling APIs, processing files and small data jobs.
Typical tasks
- Run Python code generated by an LLM
- Call web APIs and parse JSON, HTML or CSV
- Install extra packages with pip on the fly
- Clone a git repository and run scripts
What's inside
- Debian, Python 3.12
- git, curl, jq, build tools (gcc, make)
- requests, httpx, numpy, pandas, BeautifulSoup, lxml, PyYAML
from wbxsandbox import Sandbox
with Sandbox.create(template="base") as sb:
sb.run("pip install feedparser")
r = sb.run_code("""
import feedparser
feed = feedparser.parse("https://hnrss.org/frontpage")
for e in feed.entries[:5]:
print(e.title)
""")
print(r.stdout)
mini Mini
A small, fast and cheap sandbox for light work.
Good for: Quick shell commands, short scripts and running tests – where you want many sandboxes at once and do not need much memory.
Typical tasks
- Run a quick script or a one-off shell command
- Check code an agent wrote with a linter or unit tests
- Fan out many small jobs in parallel
What's inside
- Debian, Python 3.12
- git, curl, jq
Has less memory than base – installing large packages (pandas, PyTorch) or building big projects may run out of RAM. Use base for those.
from wbxsandbox import Sandbox
with Sandbox.create(template="mini") as sb:
r = sb.run("python3 -c 'import sys; print(sys.version)'")
print(r.stdout)
code-interpreter Code interpreter
Data analysis and charts, like ChatGPT's code interpreter.
Good for: Let an assistant analyse spreadsheets and data, compute statistics and draw charts you can show to the user.
Typical tasks
- Load a CSV or Excel file and summarise it
- Draw charts (PNG) with matplotlib, seaborn or plotly
- Statistics and machine learning with scipy, statsmodels and scikit-learn
- Export results back to Excel
What's inside
- Python 3.12 with pandas, polars, numpy, scipy, scikit-learn, statsmodels, sympy
- matplotlib, seaborn, plotly (+ kaleido for images)
- openpyxl, xlsxwriter, pyarrow
- Jupyter kernel (ipykernel, jupyter_client)
from wbxsandbox import Sandbox
with Sandbox.create(template="code-interpreter") as sb:
sb.files.write("/home/user/sales.csv", open("sales.csv").read())
sb.run_code("""
import pandas as pd, matplotlib.pyplot as plt
df = pd.read_csv("/home/user/sales.csv")
df.groupby("month")["revenue"].sum().plot(kind="bar")
plt.savefig("/home/user/chart.png", dpi=150)
""").check()
open("chart.png", "wb").write(sb.files.read("/home/user/chart.png"))
browser Browser
A real Chromium browser your agent can control.
Good for: Reading pages that need JavaScript, filling in forms, taking screenshots and testing websites – without running a browser on your own machine.
Typical tasks
- Scrape pages that render with JavaScript
- Take screenshots or PDFs of a page
- Automate a flow: log in, click, fill a form
- End-to-end tests of your web app
What's inside
- Python 3.12, Playwright and headless Chromium
- requests, BeautifulSoup
from wbxsandbox import Sandbox
with Sandbox.create(template="browser") as sb:
sb.run_code("""
from playwright.sync_api import sync_playwright
with sync_playwright() as p:
page = p.chromium.launch().new_page()
page.goto("https://example.com")
page.screenshot(path="/home/user/shot.png", full_page=True)
print(page.title())
""").check()
open("shot.png", "wb").write(sb.files.read("/home/user/shot.png"))
node Node.js
JavaScript and TypeScript, ready to go.
Good for: Agents that write or test JavaScript/TypeScript, build web front ends or run npm tooling.
Typical tasks
- Run JavaScript or TypeScript the model wrote
- npm / pnpm / yarn / bun install and build a project
- Run a test suite (jest, vitest) and report results
What's inside
- Node.js 22 LTS, npm, pnpm, yarn, Bun
- TypeScript and tsx
- git, Python 3, build tools
from wbxsandbox import Sandbox
with Sandbox.create(template="node") as sb:
sb.run("git clone https://github.com/user/project && cd project && npm ci", timeout=300).check()
r = sb.run("npm test", cwd="/home/user/project", timeout=300)
print(r.exit_code, r.stdout[-2000:])
fullstack Full stack
Node.js and Python in one machine, with databases.
Good for: Agents that build and test whole web applications – a backend, a front end and a database together.
Typical tasks
- Generate a web app and run it end to end
- Run backend and front-end tests in one place
- Work with SQLite or connect to PostgreSQL
What's inside
- Node.js 22, npm, pnpm, Bun, TypeScript
- Python 3 with pip and venv
- SQLite, PostgreSQL client, jq
from wbxsandbox import Sandbox
with Sandbox.create(template="fullstack", timeout=1800) as sb:
sb.run("npx create-vite@latest app --template react-ts && cd app && npm install", timeout=600).check()
print(sb.run("cd app && npm run build", timeout=600).stdout[-1000:])
go Go
Build and test Go code.
Good for: Agents that write, compile and test Go programs.
Typical tasks
- Compile and run Go code
- go test ./... on a repository
- Format and vet code with gopls tooling
What's inside
- Latest Go 1.x
- gopls, git, build tools
from wbxsandbox import Sandbox
with Sandbox.create(template="go") as sb:
sb.files.write("/home/user/main.go", 'package main\nimport "fmt"\nfunc main(){ fmt.Println("hello") }\n')
print(sb.run("go run /home/user/main.go").stdout)
rust Rust
Compile and test Rust projects.
Good for: Agents that write Rust or need to check that a crate builds and its tests pass.
Typical tasks
- cargo build / cargo test
- clippy lints and rustfmt formatting
- Benchmark small programs
What's inside
- Rust stable with cargo, clippy, rustfmt
- git, build tools
Compiling Rust is memory hungry, so this template has more RAM and CPU than the others.
from wbxsandbox import Sandbox
with Sandbox.create(template="rust", timeout=900) as sb:
sb.run("cargo new hello", cwd="/home/user").check()
print(sb.run("cargo run --release", cwd="/home/user/hello", timeout=600).stdout)
ubuntu Ubuntu
A clean general-purpose Linux machine.
Good for: When you need a standard Ubuntu system and want the agent to install whatever it needs with apt.
Typical tasks
- Install system packages with apt
- Run shell tools and scripts
- Reproduce a bug in a clean environment
What's inside
- Ubuntu 24.04 with sudo
- Python 3, git, curl, wget, build tools
- networking tools (ping, dig, ip)
from wbxsandbox import Sandbox
with Sandbox.create(template="ubuntu") as sb:
sb.run("apt-get update && apt-get install -y ffmpeg", timeout=300).check()
print(sb.run("ffmpeg -version | head -1").stdout)
Good to know
- Start time: every template boots from a memory snapshot, so it's ready in milliseconds no matter how much software is inside.
- Size: vCPU and RAM are fixed per template. You pay for what the template has while the sandbox runs – smaller templates are cheaper and you can run more of them at once.
- Working directory:
/home/user(onubuntuit's/root). You are root inside the sandbox. - Need something preinstalled? If your agent installs the same packages every time, ask us for a custom template – it will be ready when the sandbox starts.