cd /news/ai-agents/everything-your-ai-can-do-with-a-com… · home › topics › ai-agents › article
[ARTICLE · art-173855] src=dev.to ↗ pub= topic=ai-agents verified=true sentiment=↑ positive

Everything your AI can do with a computer of its own: a WBX Sandbox feature tour

WBX launched WBX Sandbox, an MCP server and REST/Python/TypeScript SDK platform that gives AI assistants and agents isolated Firecracker microVMs hosted in the EU, each with its own kernel, root access and disk. The service offers 10 templates (including code-interpreter, browser and desktop), four compute classes, snapshots and one-call cloning of running sandboxes, and integrates with Claude, ChatGPT, Cursor, VS Code Copilot, LangChain Deep Agents and the OpenAI Agents SDK. WBX reported that a 21 November 2026 test running 50 concurrent sandboxes across all 10 templates succeeded.

key takeaway

WBX Sandbox exposes isolated Firecracker microVMs as an MCP server at sandbox.wbx.cz/mcp plus Python and TypeScript SDKs, letting agents install packages and run code in disposable environments that can be snapshotted and cloned up to 10 times per call.

by read7 min views2 publishedNov 21, 2026

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.

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.

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.

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

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

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

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")

snap = sb.snapshot(name="demo-env-v1")

for clone in sb.clone(count=3):
    print(clone.id, clone.run("python3 /home/user/app/main.py").stdout.strip())

fresh = snap.create_sandbox()
print(fresh.run("python3 -c 'import rich; print(\"rich is installed\")'").stdout)

Each sandbox gets the network you choose:

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.

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.

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.

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

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

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.

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.

── more in #ai-agents 4 stories · sorted by recency
── more on @wbx 3 stories trending now
sponsored brought to you by zahid.host 4,200+ EU-deployed projects
reading about agents? ship yours in a single git push.

Run your AI side-project on zahid.host

EU-based hosting, git-push deploys, automatic HTTPS, no cold starts. Free tier with a custom domain — perfect for shipping the agent you just read about.

$git push zahid main
→ Live at https://your-agent.zahid.host ✓
Get free account → Pricing
from €0/mo · no card required
LIVE [news/everything-your-ai-c…] indexed:0 read:7min 2026-11-21 · —