WBX Sandbox
Compute platform for running code, testing applications, and executing AI agent workloads in isolated Firecracker microVMs and WebAssembly environments. Build with MCP, REST API, or Python SDK. Run background jobs, batch workflows, and collect logs, artifacts, and execution receipts. Built on carefully selected infrastructure, including second-life server hardware, with transparent usage-based pricing.
Hosted MCP Server
npx add-mcp 'https://sandbox.wbx.cz/mcp'Installs into Claude Code, Codex, Cursor and more
Documentation
Secure execution for AI agents. From one task to thousands.
Run code in isolated Firecracker microVMs or lightweight WebAssembly environments. Execute background jobs, process batches, control costs and retrieve auditable results – all through one developer-friendly platform.
Start free Explore documentation
# submit and disconnect – the job keeps running
POST /v1/jobs {"runtime": "wasi", "wasm": {…}, "max_cost": "0.05"}
→ job_7c1e…a90 queued → running → completed
GET /v1/jobs/job_7c1e…a90/receipt
runtime wasi · wasm-process
exit_code 0
duration 12 ms
artifacts output/result.json sha256 9f2c…41d0
actual_cost 0.000001 EUR (reserved 0.000310)
# 1,000 independent tasks, one call, one budget
POST /v1/batches {"jobs": [ …1000 ], "max_concurrency": 20,
"max_total_cost": "5.00"}
→ bat_41d9…02c accepted 1000 · reserved 3.84 EUR
GET /v1/batches/bat_41d9…02c
completed 996 failed 4 running 0
retried 11 spent 2.17 EUR
report /v1/batches/bat_41d9…02c/report?format=csv
from wbxsandbox import Sandbox
with Sandbox.create(template="code-interpreter") as sb:
sb.run("pip install pandas")
r = sb.run("python3 analyze.py")
# microVM ready from a memory snapshot
# pip install pandas exit 0 2.4 s (package cache)
# python3 analyze.py exit 0 0.8 s
# sandbox killed – disk and memory discarded
Plug it straight into the AI you already use
WBX Sandbox is a native MCP server. Add one URL, sign in, and your assistant can start sandboxes, run jobs and batches, wait for results and read compact logs – no API key to paste, no glue code.
ChatGPT
Apps & Connectors → Create → MCP server URL, OAuth sign-in.
Claude
claude.ai and Claude Desktop: Settings → Connectors → Add custom connector.
Claude Code
One command in the terminal, then /mcp to sign in.
Any MCP client
Streamable HTTP endpoint, or the local stdio binary for macOS, Windows and Linux.
MCP endpoint https://sandbox.wbx.cz/mcp
Step-by-step setup for each client
$ claude mcp add --transport http wbxsandbox https://sandbox.wbx.cz/mcp
$ claude
> /mcp # sign in to WBX Sandbox, approve access
# tools your assistant gets
create_sandbox run_command run_code write_file
run_job run_batch wait_jobs
get_job_logs mode=summary → tests + errors, not 5,000 lines
get_budget get_compute_classes download_job_artifact
What sets WBX apart
Most sandbox platforms give your agent a computer. WBX also tells it what happened – in a form it can use without wasting context, money or time.
Results your model can read
Recognized test results and a compact log digest – errors with context and the end of the log – instead of 5,000 lines in the context window. Built into the platform, on by default over MCP.
Know when it is done
Wait on the server for any or all jobs and batches, or get a signed webhook. No polling loops burning tokens.
A price limit on every job
Budget Guard reserves the worst case before a job or batch starts and refuses what would break your limit.
A receipt for every run
Runtime, isolation, measured resources, network policy, file hashes, test results and the actual cost – per job, kept after the sandbox is gone.
Batches that pass work along
Up to 1,000 jobs with dependencies; result files of one job become the input of the next.
Two runtimes, one API
Full Linux microVMs and lightweight WebAssembly side by side – each labelled honestly with its isolation level.
get_job_logs · mode=summary412 kB log → 1.6 kB
[job failed, exit 1, summary of 5,214 lines]
[wbx] tests (pytest): 211 passed, 1 failed, 212 total
FAILED tests/test_api.py::test_refund
– AssertionError: assert 400 == 200
[wbx] errors:
File "app/payments.py", line 88, in refund
raise ValueError("amount exceeds charge")
ValueError: amount exceeds charge
WARNING: retrying connection [×50]
[wbx] end of log:
=========== 1 failed, 211 passed in 41.2s ===========
Illustrative output. The same digest is in the portal, the REST API and the Python SDK; test results also go into the receipt and the webhook.
More than a sandbox. A complete execution platform for agents.
Your agent should not have to manage servers, retries, cleanup or billing surprises. It hands WBX a task; WBX runs it and returns the log, the files, the metrics and the price.
-
Submit
One API call, an SDK function or an MCP tool. You get a job ID back immediately. -
Guard the budget
Before accepting the work, WBX reserves the maximum possible cost and refuses what would exceed your limit. -
Execute in isolation
A Firecracker microVM with its own kernel, or a WASI module in a restricted process. Retries and timeouts included. -
Collect the result
Logs, output files with SHA-256 checksums, an execution receipt and the actual cost – kept after the environment is gone.
Secure Firecracker sandboxes
Disposable Linux environments with their own kernel, filesystem and network policy. Python, Node.js, Go, Rust, a real browser and more. Root access inside an isolated microVM, with enforced host and network boundaries.
Background jobs that finish the work
Submit a command and walk away. The job survives client disconnects; WBX handles execution, retries, cleanup, logs and persistent results.
Batch execution at scale
Up to 1,000 jobs in one batch. Limit concurrency, define dependencies, pass result files from one job to the next and follow the whole batch through one ID.
Lightweight WebAssembly
Run WASI modules without starting a virtual machine – an isolated, unprivileged process with no network. Ideal for short, focused computations.
Budget Guard
Spending limits for jobs and batches, plus a maximum cost per job. The worst case is reserved up front, the actual usage is billed – never more than you allowed.
Execution receipts and artifacts
Runtime and isolation, timing, measured resources, network policy, price, log checksum and output file hashes – an operational record you can audit later.
from wbxsandbox import run_job
job = run_job(
wasm_module=open("score.wasm", "rb").read(),
wasm_args=["--fast"], wasm_memory_mb=64,
artifacts=["output/"],
)
job.wait()
print(job.receipt()["runtime"]) # wasi · wasm-process
WebAssembly jobs: milliseconds instead of a VM boot
Not every task needs a whole Linux machine. Compile a parser, a scorer or a converter to WASI and run it as a job: no VM to start, no network, billed only for the time it actually runs. Thousands of them fit in one batch.
Start
Milliseconds – no kernel, no image, no warm pool
Network
None, by design – only /input, /output, /tmp
Limits
Module up to 8 MB inline (32 MB as input), 16–1024 MB memory, 10 min
Price
Run time × (1 vCPU + memory limit) at your plan's rates, billed in millionths of your currency
Isolation
Sandboxed, unprivileged process – stated in every receipt. For untrusted full Linux workloads use a microVM.
Choose performance. Or let WBX decide.
Pick a compute class per job, or set a default for your account once. The Smart Scheduler places the work on an eligible server by free capacity and your preference – price, balance or performance. A job never silently moves to a different class.
Economy
Cost-efficient execution for everyday automation.
Balanced
A practical balance between cost and performance.
Performance
Placement only on our faster eligible servers.
Memory
Larger environments for memory-intensive workloads.
Dedicated
Servers reserved exclusively for your organization.
Built for efficient execution
Fast start
Sandboxes boot from Firecracker memory snapshots, with warm pools for popular templates.
Verified package cache
Public PyPI, npm, Go and Rust packages are cached on the node after checksum verification. Read-only for sandboxes, never shared writable.
Network you control
Full internet, a list of allowed destinations, or no network at all. Private ranges, SMTP and the host are always blocked.
Automatic lifecycle
Timeouts, cleanup of abandoned environments and retries are handled by the platform – nothing is left running by accident.
Fair limits per sandbox
Bandwidth, packet and connection limits on every environment, so one noisy workload cannot starve the others.
EU-operated
Our own refurbished servers in the EU, run by an internet service provider – not resold cloud capacity.
Built for the way AI agents actually work
New to sandboxes? Agents write code to get things done. That code needs a computer – and it shouldn't be yours. What is a sandbox?
Coding agents Clone a repository, install dependencies, change code, run the tests and return the result. AI code execution Keep AI-generated or user-submitted code away from your own infrastructure. Browser automation A real browser in a disposable Linux machine: read pages, fill in forms, take screenshots. Data processing Transform files and fan out thousands of independent tasks with batch jobs. WebAssembly workloads Small, network-free WASI computations without starting a Linux VM.
Connect your agent in minutes
One execution interface for sandboxes, jobs, batches, logs and artifacts – whichever way your agent talks.
MCP
ChatGPT, Claude and other assistants. Sign in once, no key to paste. Set up in two minutes
Python SDK
Sandboxes, jobs, batches and budgets in a few lines, no dependencies. SDK reference
REST API
Plain HTTPS and JSON from any language. API reference
from wbxsandbox import run_batch
batch = run_batch(
[{"command": f"python score.py {i}"} for i in range(500)],
max_concurrency=25, max_total_cost=3,
)
batch.wait()
print(batch.summary()) # states, cost, durations, errors
Security you can explain to your security team
We describe isolation as it is – no marketing shortcuts.
Hardware isolation for Linux workloads
Every sandbox and VM job is a separate KVM microVM with its own kernel, started by the Firecracker jailer in its own network namespace and cgroup. Designed to isolate workloads from other customers and restrict access to the host and internal network.
WebAssembly, honestly described
WASI modules run in a separate unprivileged process with its own user, namespaces, filesystem restrictions and memory limits – no sockets at all. Lighter than a VM and labelled as such, including in the receipt.
No silent downgrades
A job runs in the runtime and compute class you asked for. If that capacity is busy, it waits – it is never moved to weaker isolation or a different class.
Operational receipts, not marketing
Receipts record what the platform measured. They are an audit trail, not a cryptographic attestation – and we say so in every receipt.
We give good servers a second life
WBX runs on refurbished enterprise servers. Data centres retire solid machines every few years; we take them in, check them, burn them in and measure every core before they run a single job. It is not the newest silicon and we don't pretend it is – it is reliable hardware put back to useful work, and it is why our prices stay low.
Refurbished
Server-grade machines, tested and burned in before they join the cluster.
Measured
Every node is benchmarked per core. Compute classes are based on those numbers, not on promises.
Honest
Older cores are slower than the newest ones. Need more speed? The performance class runs only on our faster nodes.
Maintained
Run by an internet service provider that operates its own network. Jobs can retry automatically after a platform error, attempts that fail on our side are credited back, and a node in maintenance takes no new work.
Professional AI sandboxes. Sensibly priced.
Start free and scale with your workload. Pay per second for allocated vCPU and memory at your plan's rates, adjusted by the compute class.
Free
Everything you need to try WBX with your own agent.
$0.00
Pay only for usage
- 5 concurrent sandboxes
- Up to 1 hour per sandbox
- Background jobs, batches and Budget Guard
- Execution receipts and artifacts
- One-time welcome credit, no card required
- MCP, Python SDK and REST API
- Community support Start free
Pro
For developers shipping agents to production.
$55.00
per month, excl. VAT – includes $25.00 usage credit
- 25 concurrent sandboxes
- Up to 24 hours per sandbox
- 100 vCPU / 100 GB RAM in total
- Usage credit included every month
- Custom templates Choose Pro
Team
For teams running agents every day.
$119.00
per month, excl. VAT – includes $50.00 usage credit
- 100 concurrent sandboxes
- Up to 48 hours per sandbox
- 400 vCPU / 400 GB RAM in total
- Everything in Pro Choose Team
Enterprise
Custom
Annual agreement, invoiced
- Servers reserved exclusively for you
- Custom limits and quotas
- Contractual SLA
- Invoicing and custom terms Contact sales
Prices exclude VAT. They stay low because our hardware is on its second life. Budget limits apply to jobs and batches; sandboxes you start directly are billed by usage from your prepaid credit. Usage rates and details
Stop managing infrastructure. Start shipping agents.
Your agents write the code. WBX executes it – secure environments, background jobs, batch processing, cost control and persistent results in one platform.