Isolated Linux microVMs in the EU, for AI assistants without code and for agents you build yourself.

AI assistants are good at writing code. Running it is a different story. The assistant can't install packages on your computer, it shouldn't touch your files, and a chat window is a poor place for a two-hour job.

WBX Sandbox gives the AI its own isolated computer in the EU. It installs what it needs, runs the code, and hands back the result: a file, a chart, a link, a test report. Nothing runs on your machine.

This post is a tour of what the platform does, so you can picture what to build with it: what you get if you just connect your assistant, and what's there when you write your own agents.

Two ways in

Without code: connect your AI assistant once.
WBX Sandbox is an MCP server at https://sandbox.wbx.cz/mcp. It works in Claude (web, desktop and mobile), ChatGPT (developer mode), Claude Code, Cursor, VS Code with GitHub Copilot, Codex CLI and Gemini CLI.

Connecting takes about two minutes: paste the address, sign in, turn the connector on, ask a question. After that you just talk to your assistant. When it needs a computer, it creates one.

With code: build your own agents.
There's a REST API, a Python SDK and a TypeScript SDK:

pip install wbxsandbox # Python npm install wbxsandbox # Node.js 20+, Deno, Bun 

There are also integrations for LangChain Deep Agents and the OpenAI Agents SDK, so a sandbox can be the place where your agent framework runs its tools.

Both paths use the same sandboxes. Anything below works from a chat prompt or from code.

Sandboxes and templates

Each sandbox is its own Firecracker microVM with its own kernel, root access and its own disk. It starts in milliseconds to seconds, depending on the template.

There are 10 templates:

Template What's inside
base Debian + Python 3.12
mini 1 vCPU, 256 MB, for small tasks
code-interpreter numpy, pandas, matplotlib, scipy, scikit-learn
browser Playwright + Chromium
desktop XFCE desktop (see the beta section below)
fullstack Node 22 + Python
node, go Language toolchains
rust Rust, 4 vCPU
ubuntu Ubuntu 24.04

On top of templates you pick a compute class: economy, balanced, performance or memory. A verified package cache for pip, npm and Go makes repeated installs faster.

We tested this on 21 November 2026: 50 sandboxes at the same time, 10 templates × 5. For each template that meant one source sandbox and 4 clones of it. All 50 worked.

Sleep, names and coming back later

A sandbox doesn't have to die when the chat ends.

  • Sleep. An idle sandbox falls asleep. The disk is kept and you don't pay for compute while it sleeps. The next request wakes it in a few seconds, with the same ID.
  • Names. Give a sandbox a name and it comes back in the next chat, files and all. "Create a sandbox called invoices" is enough.
  • Retention. How long a sleeping sandbox is kept depends on your plan, and you can set it per sandbox with keep_days.

One thing to know: /tmp lives in memory and is empty after a wake-up. Keep your work in /home/user.

Snapshots and clones

This is where it gets useful for agents.

A snapshot is a saved copy of a sandbox's disk. New sandboxes start from it with the same files and installed packages, so you set up an environment once and reuse it.

A clone is 1 to 10 copies of a running sandbox, made with one call. Each copy gets its own ID, its own network and its own identity: a new machine-id and new SSH keys. Copies inherit the lifetime, compute class, sleep settings and network policy, and a copy's network is never wider than its source's.

The typical pattern: prepare the environment once, then run several agents or several test variants on top of it at the same time.

from wbxsandbox import Sandbox # Set up one environment sb = Sandbox.create(template="base", name="demo-env") sb.run("pip install -q requests rich") sb.run("mkdir -p /home/user/app && " "echo 'print(\"hello from\", __import__(\"socket\").gethostname())' " "> /home/user/app/main.py") # Save it as a snapshot snap = sb.snapshot(name="demo-env-v1") # Three running copies, one call for clone in sb.clone(count=3): print(clone.id, clone.run("python3 /home/user/app/main.py").stdout.strip()) # Later: a fresh sandbox from the snapshot, packages already installed fresh = snap.create_sandbox() print(fresh.run("python3 -c 'import rich; print(\"rich is installed\")'").stdout) 

Network and public addresses

Each sandbox gets the network you choose:

  • Full internet, for downloads, scraping and package installs.
  • Allowlist: only the domains or ranges you list, for example PyPI and one API.
  • Blocklist: everything except what you exclude.
  • No network, for sensitive data or code you don't trust.

You can also choose IPv4, dual stack, or IPv6 only, in which case the sandbox gets its own public IPv6 address. Private ranges and SMTP are always blocked, whatever you choose.

Anything listening on a port can get a public HTTPS address, protected by a token. That's how an AI shows you its work: it builds a small game, a dashboard or a form, starts it, and sends you a link you can open on your phone.

Background jobs, batches and a price limit

Commands are fine for quick things. Longer work belongs in a job.

A job keeps running in the background even after the chat disconnects. The AI doesn't need to ask "done yet?" every few seconds: waiting happens on the server, or you get a signed webhook when it finishes. Jobs support retries and an idempotency key, so a repeated call doesn't start the work twice.

Output files come back as artifacts, each with a SHA-256. Logs are shortened for the AI: test results, errors with context and the end of the log. The raw log is still available when you need it.

A batch is 1 to 1,000 jobs at once, with dependencies between them, a concurrency limit and a CSV report at the end. A failure stays inside its job, and the others carry on.

Budget Guard puts a price limit on a job or a batch. Before anything runs, the platform calculates the worst-case cost. If that could exceed the limit, the work doesn't start at all. It doesn't stop halfway through. On top of that, you can set a monthly and a daily budget for the whole account.

Every job leaves a receipt: the command, template, runtime, exit code, CPU and memory used, and hashes of the output files. On request the receipt is signed with Ed25519 and can be checked against a public key. When an agent tells you "the tests passed", you can see what actually ran.

For short computations that don't need a network, there are WebAssembly (WASI) jobs that start in milliseconds.

Desktop and Computer Use (beta)

The desktop template gives the sandbox a graphical XFCE desktop. An agent controls it the way a person would: it takes screenshots, moves the mouse and types on the keyboard.

In the portal there's a live console where you can watch, take over the controls and hand them back to the agent. This part is in beta, so expect changes.

The portal

Not everything has to go through the AI. The web portal shows:

  • running sandboxes, with a terminal in the browser
  • metrics for the last hour: CPU, memory, network and disk
  • snapshots and jobs
  • usage and costs
  • API keys and your team

It's useful for checking what an agent left behind, or for finishing something by hand.

Security and where it runs

Each sandbox is an isolated virtual machine and never runs on your own computer. The AI can install anything, break anything and start over without touching your files.

The servers are in the EU. WBX Sandbox is run by an internet service provider, on refurbished enterprise servers given a second life. That makes the setup more economical and kinder to the environment than buying new hardware.

On pricing: there's a free plan with no credit card, then prepaid credit or a monthly plan. Billing is per second for the vCPU and memory a sandbox is given.

Getting started

The documentation is in English and Czech, with 11 step-by-step tutorials.

Without code: your first result in Claude or ChatGPT, working with files, and a workspace that persists.

With code: your own agent, snapshots and clones, a long job with a price limit, a batch of 100 jobs, running untrusted code safely, a web app with a public address, tests in CI, and an agent on a desktop.

If you've connected the MCP server, try a prompt like this one, with no code:

Create a sandbox called sales-report. Download the CSV from this link, build a chart of monthly totals with matplotlib, and save it as a PNG. Then start a small web page that shows the chart and send me the link. Don't paste the data into the chat.

The AI creates the machine, installs what it needs, does the work and gives you a link. Next week, the same name brings the same sandbox back.

Try it for free:

What would you run first on a computer your AI controls? Tell me in the comments. I'm especially curious which feature is missing for your agents.