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.

เซิร์ฟเวอร์ MCP แบบโฮสต์

npx add-mcp 'https://sandbox.wbx.cz/mcp'

ติดตั้งลง Claude Code, Codex, Cursor และอื่นๆ

เอกสาร

Give your AI a computer of its own.

Connect ChatGPT or Claude in a minute and ask for real results: a game you can play, a document read aloud, a chart from your spreadsheet, code that passes its tests. Your assistant does the work on a safe, disposable computer in the EU – for programmers it is a full Linux microVM with an API.

Start free Connect your AI

See it in action – check out our YouTube channel

  • No card required to start
  • Works with ChatGPT and Claude
  • Servers in the EU
  • Pay only for what you use
  • Save tokens with the sandbox
  • IPv4 and IPv6
# 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

Ask for things, get them done

Your assistant gets a real Linux computer of its own. It installs what it needs, does the work there and hands you the result. Here is what you can type – and what actually happens.

Make me a Snake game I can play in my browser.

It writes the game, starts it and sends you a private link – play on your phone or computer.Under the hood: HTML + JavaScript served from the sandbox, HTTPS link with an access token

Read this PDF aloud and give me an MP3.

It pulls the text out of the document, turns it into speech and gives you the file to download.Under the hood: pdftotext, open-source text-to-speech, ffmpeg

Which month had the best sales? Draw me a chart.

Real numbers computed from your spreadsheet, not estimated – plus the chart as an image.Under the hood: Python, pandas, matplotlib

Shrink these photos for the web and make a GIF from the video.

Smaller files and a short animation, done by proper tools.Under the hood: ImageMagick, ffmpeg

Take screenshots of our website on a phone and on a laptop.

Pictures of how the page really looks, from a real browser.Under the hood: headless Chromium (browser template), Playwright

Clone my repository, run the tests and fix what fails.

Changes that pass the tests, with a short summary instead of a wall of logs.Under the hood: git, your test runner, log digest for the AI

Process all 500 files overnight and tell me when it is done.

You close the chat; the work keeps running and the results wait for you.Under the hood: background jobs and batches with a price limit

Is this script from the internet safe? Run it and tell me what it does.

An answer without the script ever touching your computer.Under the hood: sandbox without network, deleted afterwards

Typical requests – how the work is done is up to your assistant. The sandbox has internet by default (you can limit it or turn it off) and full root, so your assistant can install other tools with pip, npm or apt.

Fewer tokens. Better answers.

Every line your assistant reads costs tokens and fills its memory. With WBX, the heavy lifting happens next to the data, and the chat only gets what it needs.

Work happens in the sandbox

Downloads, calculations and builds run there – large files never pass through the chat.

Only the result comes back

Long logs and test runs are condensed into a short summary with the errors that matter.

No checking again and again

For long jobs, your assistant waits on our server instead of asking every few seconds.

[job failed, exit 1 – summary of the full log]
tests: 211 passed, 1 failed
  FAILED tests/test_api.py::test_refund
errors:
  File "app/payments.py", line 88, in refund
ValueError: amount exceeds charge

Ready in three steps

  1. Create a free account No card needed. You get welcome credit to try it out.
  2. Add WBX to your assistant In ChatGPT or Claude, add a connector with one address and sign in. Step-by-step guide with screenshots
  3. Just ask “Use WBX Sandbox to…” – your assistant takes it from there.

Safe by default

A fresh machine for every task

Each sandbox is its own small virtual computer with its own system, separate from everyone else.

Nothing kept longer than needed

An idle machine falls asleep and keeps its files for your next request; one you no longer use is deleted automatically, or right away when you ask.

Your computer stays out of it

Nothing runs on your laptop – the assistant only gets the results.

You set the spending limits

Prepaid credit and price limits on background jobs, so there are no surprise bills.

Building your own agent?

Everything above works for developers too – and there is much more: background jobs, batches of up to 1,000 tasks, WebAssembly, budget limits, execution receipts and a Python SDK.

Works with LangChain Deep Agents

WBX Sandbox is listed among the sandbox integrations in the LangChain documentation. Install one package and your deep agent runs its commands and file tools in its own microVM instead of on your machine.

LangChain sandbox integrations langchain-wbxsandbox on PyPI Source on GitHub

# pip install langchain-wbxsandbox
from deepagents import create_deep_agent
from langchain_wbxsandbox import WBXSandbox

with WBXSandbox.create(template="base") as sandbox:
    agent = create_deep_agent(model=model, backend=sandbox)
    agent.invoke({"messages": [
        {"role": "user", "content": "Write fib.py and run it."}]})
# the sandbox is destroyed when the block ends

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

Turn on Developer mode, then Apps & Connectors → Create → MCP server URL, OAuth sign-in.

Claude

claude.ai and Claude Desktop: Customize → Connectors → Add → 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 labeled 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.

  1. Submit

    One API call, an SDK function or an MCP tool. You get a job ID back immediately.
  2. Guard the budget

    Before accepting the work, WBX reserves the maximum possible cost and refuses what would exceed your limit.
  3. Execute in isolation

    A Firecracker microVM with its own kernel, or a WASI module in a restricted process. Retries and timeouts included.
  4. 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.

Templates

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.

Jobs API

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.

Batches

Lightweight WebAssembly

Run WASI modules without starting a virtual machine – an isolated, unprivileged process with no network. Ideal for short, focused computations.

WebAssembly jobs

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.

Budgets

Execution receipts and artifacts

The command, the exact template build, input and output file hashes, runtime and isolation, timing, measured resources, network policy and price – an operational record you can audit later, signed by WBX on request.

Receipts

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.

WebAssembly job reference

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.

How compute classes work

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, IPv4 and IPv6

Full internet over IPv4, IPv6 or both, a list of allowed destinations, or no network at all. With IPv6 each sandbox gets its own public address. 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

LangChain

A sandbox backend for Deep Agents, listed in the LangChain docs. Example

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 labeled 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. A sandbox that asked for IPv6 never quietly starts with IPv4 only.

Operational receipts, not marketing

Receipts record what the platform measured, the exact template build and checksums of inputs and outputs. WBX can sign them so nobody can edit them later. They are still an audit trail, not an attestation that the computation could not have been altered – and we say so in every receipt.

We give good servers a second life

WBX runs on refurbished enterprise servers. Data centers 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.

Simple, transparent pricing.

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.

Pay as you go

Everything you need to use WBX with your own agent. Welcome credit for testing

$0.00

Pay only for usage

  • 10 concurrent sandboxes
  • 10 vCPU / 10 GB RAM in total
  • Up to 6 hours per sandbox
  • Background jobs, batches and Budget Guard
  • Execution receipts and artifacts
  • Welcome credit included
  • Start free – no card required
  • MCP, Python SDK and REST API Start free

Solo

For one developer – a fixed monthly price, no usage charges.

$15.00

per month, excl. VAT – no usage charges

  • Fixed monthly price – no usage charges
  • 3 concurrent sandboxes
  • 6 vCPU / 8 GB RAM in total
  • Up to 4 hours per sandbox
  • Fair use applies
  • MCP, Python SDK and REST API Choose Solo

Pro

For developers shipping agents to production.

$49.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.

$99.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

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

Let your AI do the work, not just talk about it.

Connect ChatGPT or Claude, ask in plain words, and get finished results – while the heavy lifting stays in a safe machine in the EU.

Start free Connect your AI