WBX Sandbox
격리된 Firecracker 마이크로VM 및 WebAssembly 환경에서 코드를 실행하고, 애플리케이션을 테스트하며, AI 에이전트 워크로드를 실행하는 컴퓨팅 플랫폼입니다. MCP, REST API 또는 Python SDK로 구축하세요. 백그라운드 작업과 배치 워크플로를 실행하고 로그, 아티팩트 및 실행 영수증을 수집하세요. 재사용 서버 하드웨어를 포함해 신중하게 선정한 인프라를 기반으로 하며, 사용량 기반 요금을 투명하게 공개합니다.
호스팅형 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.
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
- Create a free account No card needed. You get welcome credit to try it out.
- Add WBX to your assistant In ChatGPT or Claude, add a connector with one address and sign in. Step-by-step guide with screenshots
- 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.
-
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
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.
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, 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.