Give coding agents, evals, and agent runs their own gVisor sandbox from a versioned template, with workspaces that can survive between sessions. Quave ONE handles allocation, persistence, pause and resume, idle and lifetime limits, and termination. Your agents drive it all through the API or MCP.
curl -X POST https://api.quave.cloud/api/public/v1/sandbox/create \
-H 'Authorization: YOUR_TOKEN' \
-H 'Content-Type: application/json' \
-d '{
"accountId": "ACCOUNT_ID",
"appId": "APP_ID",
"templateId": "TEMPLATE_ID",
"workloadProfile": "QUAVE_INTERACTIVE_AGENT",
"ownerKind": "AGENT_CONVERSATION",
"ownerId": "CONVERSATION_ID",
"region": "us-5",
"idempotencyKey": "conversation-42-turn-7"
}'
# then run a command inside it
curl -X POST https://api.quave.cloud/api/public/v1/sandbox/execute \
-H 'Authorization: YOUR_TOKEN' \
-H 'Content-Type: application/json' \
-d '{
"accountId": "ACCOUNT_ID",
"sandboxId": "SANDBOX_ID",
"command": ["sh", "-c", "npm test"]
}'You decide what a sandbox looks like. Quave ONE runs the whole lifecycle.
Define a sandbox template once. Each revision is immutable and pins the image, resources, persistence mode, and lifetime limits.
Your agent asks for a sandbox from the template. Quave ONE allocates it in an isolated gVisor runtime. Retries with the same idempotency key return the same sandbox.
Execute commands inside the sandbox through the API or MCP and get the exit code and output back.
Pause releases the compute and keeps the sandbox shared volume. Resume brings the same sandbox back, or it resumes on the next command.
Terminate when you are done. Idle sandboxes are terminated after the template idle timeout, and every sandbox ends at its hard lifetime.
Isolation is the start. Your agents also keep their work, reach only what they should, and run for as long as the job takes.
Bring a Linux container image with your languages and tools preinstalled. Every sandbox runs exactly the version you approved.
Keep a live folder that saves as files are written, snapshot the whole workspace when you pause, or both. The next sandbox picks up where the last one stopped.
Store sandbox data on Quave ONE object storage or in your own S3-compatible bucket, encrypted with your own key.
Pause to stop paying for compute. The next command wakes the sandbox with its files in place, with no extra call.
Allow only the domains or IP ranges a sandbox needs. Internal networks are always out of reach.
Hand an API key to a single command. It is never stored in the template, the image, or the logs.
Run builds and agent sessions for hours. Idle and lifetime limits stop forgotten sandboxes, and a runaway process hits its memory cap without taking the sandbox down.
Sandboxes start in seconds when capacity is warm, and the pool grows on its own under load. No per-app caps: run as many as your workload needs.
The same operations are available as REST endpoints and as tools on the Quave ONE MCP server. Scoped keys decide what each agent may do.
No sandbox platform fee on either plan. Sandboxes are fully allocated, so you pay for the zClouds the template reserves, not measured usage.
At the default $7.50 per zCloud per month, a sandbox costs $0.03125 per zCloud-hour. 1 zCloud = 0.5 vCPU and 0.5 GB RAM. Your region's rate may differ.
| Shape | zClouds | Per hour |
|---|---|---|
| 1 vCPU / 1 GB | 2 | $0.0625 |
| 2 vCPU / 2 GB | 4 | $0.125 |
Example: a 2 vCPU / 2 GB sandbox that runs for 10 hours costs $1.25. Time spent paused is not billed. Full billing rules
If you are evaluating hosted sandboxes for agents, here is where Quave ONE fits.
On 1:1 CPU-to-RAM shapes, Direct comes in a few percent under E2B list compute pricing. See the dated comparison below.
On Connect, sandboxes run on your AWS, GCP, Azure, or OCI nodes and are included in the license. Useful when data must stay in your account or you want to use existing cloud credits.
Apps, databases, Functions, Jobs, observability, and Warren run on the same platform, on one bill, with one MCP server.
| Shape | Quave ONE Direct | E2B list price* |
|---|---|---|
| 1 vCPU / 1 GB | $0.0625/h | about $0.067/h |
| 2 vCPU / 2 GB | $0.125/h | about $0.133/h |
* E2B compute prices from e2b.dev/pricing as checked on October 5, 2026; they may have changed since. Quave ONE prices use the default $7.50 per zCloud per month. Only 1:1 CPU-to-RAM shapes are compared: on memory-heavy shapes such as 2 vCPU / 4 GB, Direct is not cheaper than E2B.
Warren is a software factory you install on Quave ONE as a Solution. It runs each coding-agent job in its own Agent Sandbox, so one client's work never shares a runtime with another's. Its change portal gives your clients a simple loop from request to live.
Run client changes through Warren in Agent Sandboxes, with a preview the client accepts before it goes live.
Agents, evals, and batch agent runs that need isolation, per-second billing, and pause and resume.
Host the app and the agents that build or extend it on the same platform.
Vibe to productionKeep sandboxes inside your own cloud account with Connect and pay for the nodes with your existing credits.
Quave ONE Connect