Table of Contents
- What AIO Sandbox gives your agent
- Pick the workflow before picking the host
- Start with a private, pinned evaluation
- Decide where the agent runs and where files survive
- Choose isolation and access controls together
- Hosting AIO Sandbox on Agent37: use the VM path
- Budget compute, retained disk, and model use separately
- AIO Sandbox questions to settle before deployment
- Is AIO Sandbox a managed cloud service?
- Can I use a standard Agent37 sandbox for the Docker example?
- What should I measure in a trial?
- What is the next step?
Do not index
AIO Sandbox packages a browser, terminal, file tools, and code runtimes in one Docker environment. It suits agents that download something, process it, and return an artifact without copying files between separate services. For cloud deployment, choose a host that supports its runtime requirements; Agent37's full VMs provide Docker, while its standard gVisor instances cannot run a Docker daemon.
The useful buying question is what it takes to operate that environment reliably: access controls, durable files, enough memory, and a bill tied to the time you actually need it. This guide covers the open-source agent-infra project and a concrete way to evaluate those costs.
What AIO Sandbox gives your agent
The agent-infra project is Apache-2.0 licensed software. Its introduction describes a shared filesystem connecting browser activity, shell commands, file operations, and development tools. That is the practical benefit: a downloaded report can become input to a script in the same environment.
Consider a reporting task. Your agent opens an authenticated web application, downloads a CSV, checks its columns, calculates totals, and produces a new file. Separate browser and code services require you to transfer the download and coordinate its location. An all-in-one environment lets the tools work on the same files.
The project also provides visual access through VNC and a browser-based code editor. Those interfaces help you inspect a failed step rather than infer everything from the agent's final response. They are access paths into the execution environment, so protect them alongside the API.
The name needs one clarification. Alibaba Cloud also documents an AIO Sandbox offering. That is a managed service with its own templates, regional endpoints, credentials, and lifecycle rules. Its service limits are not automatically limits of the open-source Docker image discussed here.
Pick the workflow before picking the host
Use AIO when multiple tools genuinely need the same workspace. A browser-only screenshot task may fit a smaller browser service. A script that processes an already uploaded CSV may only need code execution. Installing a whole interactive environment for either task adds components you must size and maintain.
For a browser-plus-code workflow, define three explicit handoffs: the downloaded input, the validated intermediate file, and the final exported artifact. Give each task its own directory. Your application should know which files it expects and when they are complete.
AIO's browser documentation supports programmatic control through Chrome DevTools Protocol, including Playwright integration, as well as visual interaction. Choose the interface your task needs. A visible browser is useful for intervention; it does not make a task more reliable by itself.
The download guide places normal Chromium downloads under
/home/gem/Downloads and describes download-progress events. Wait for completion before processing a file. Seeing a filename is not enough if the browser is still writing it.With unified code execution, Python uses a Jupyter kernel and JavaScript uses Node.js. Check execution status and output, not just whether the HTTP request succeeded. An accepted request can still contain a failed computation.
Start with a private, pinned evaluation
The upstream quick start requires Docker and at least 2 GB of available RAM. Treat that as an entry requirement, not a capacity promise for several browser tabs, notebooks, and concurrent users.
For a disposable evaluation on a trusted, single-user Docker host, pin the documented 1.11.0 release and bind its port to loopback:
docker run --name aio-eval --rm -it \
--security-opt seccomp=unconfined \
-p 127.0.0.1:8080:8080 \
ghcr.io/agent-infra/sandbox:1.11.0Keep that terminal open. In a second terminal on the same host, check the shell API with a harmless command:
curl --fail-with-body --silent --show-error \
http://127.0.0.1:8080/v1/shell/exec \
-H 'Content-Type: application/json' \
--data '{"command":"pwd"}'These commands follow the upstream interface; they are not a benchmark or a claim that we deployed this image for this article. The example has no authentication and belongs only on that private evaluation host. Other local users may still reach loopback. Do not change the binding to a public address to make remote access easier.
Use the API documentation at
http://127.0.0.1:8080/v1/docs to inspect the running release. Match SDK versions and authentication configuration to that release before building an integration. The 1.11.0 README includes JWT configuration, while the current main README additionally describes API-key authentication. A newer README is not evidence that an older image implements every newer option.Stop the evaluation with Ctrl-C when finished. This command removes the container and does not retain a mounted workspace. Export anything you need before stopping it.
Decide where the agent runs and where files survive
AIO supports an external agent calling sandbox APIs or an agent running inside the sandbox. That choice changes what you must recover after a failure.
An external controller can keep the job record, credentials, and retry decisions outside the execution environment. It can replace a failed worker and continue from a recorded artifact. An internal agent shares the container's resource budget and lifecycle with its tools, which can simplify a single workspace but couples their failures.
For a customer-facing service, a practical design keeps durable job state outside the worker. Record the input identifier, current step, output location, and cleanup deadline. A restarted container should not be the only place that knows whether a customer report was delivered.
Filesystem sharing also differs from persistence. A file visible to every tool can still disappear when you remove its container. AIO's workspace configuration uses
WORKSPACE to select the working directory and documents mounting a host path there. Mount a dedicated task directory, not your entire home folder or a directory containing production credentials.Test recovery with harmless data: create an artifact, stop the container, recreate it with the intended mount, and verify the artifact. Then test deletion separately. Keeping data and cleaning data are two different requirements, and both belong in your deployment plan.
Choose isolation and access controls together
The evaluation command includes
seccomp=unconfined because upstream uses it. That disables Docker's default seccomp filtering for that container. Docker's seccomp documentation describes the filter as a restriction on available system calls. Removing it is a compatibility decision that changes the container's protections; it is not an isolation feature.A Docker image does not choose your entire security boundary. For untrusted customer jobs, evaluate the host runtime, task separation, mounted files, credentials, and outbound network access. A VM adds a guest-kernel boundary, but it does not prevent a permitted process from misusing credentials inside that VM.
The upstream cloud deployment guide recommends keeping port 8080 private behind a reverse proxy or Ingress with TLS and access control. Its Kubernetes example uses a private ClusterIP service. Follow those boundaries rather than exposing the evaluation listener directly.
The authentication guide documents
JWT_PUBLIC_KEY verification and short-lived tickets for browser access. Configure and test the authentication supported by your image, including browser and WebSocket paths. The security guide also recommends short-lived task credentials and keeping secrets out of images and generated files.Before adding tenants, test that one customer's job cannot retrieve another customer's files or browser session. An API key proving caller identity does not, on its own, establish that separation.
Hosting AIO Sandbox on Agent37: use the VM path
Agent37 provides standard gVisor sandboxes and full VMs. For the Docker-daemon deployment described above, choose a full VM. Standard instances cannot run that daemon, so their lower compute rate is not the correct budget for this route.
The VM documentation describes
agent37-ubuntu, which includes Docker, Compose, and a running Docker daemon. Create it with type: "vm" through the dashboard or instances API. VM creation requires a positive wallet balance.Check available disk before pulling the image. On these VMs, Docker data belongs on the billed persistent disk; the Ubuntu template already configures its daemon accordingly. Leave space for image layers, browser downloads, working files, and logs. The default 12 GB disk is a configuration default, not a verified AIO capacity recommendation.
There is no systemd init in the VM entrypoint. Use the documented process model, and verify your services return after the lifecycle events you plan to use. Follow instance management for lifecycle operations, and test browser connections after a restart.
For a first evaluation, use SSH access and a tunnel to the private listener. If you later publish an application endpoint, review the platform's authenticated networking and AIO's own authentication together. The VM supplies infrastructure; you still configure and operate the application inside it.
Budget compute, retained disk, and model use separately
AIO's open-source license does not make its hosting free. Your operating bill includes the machine, stored files, any separately charged services, model calls, and the work needed to maintain the deployment.
Agent37's published pricing uses standard monthly-equivalent rates of $0.80 per vCPU and $0.70 per GB of RAM for 730 running hours. Full-VM compute costs 2.5 times those rates. Disk costs $0.09 per GB per 730 hours retained, including when compute is stopped.
For one full VM with 2 vCPU, 4 GB RAM, and an explicitly selected 20 GB disk, the compute component is $11 per 730 running hours. The disk component is $1.80 per 730 retained hours. Here is the resulting planning budget:
Usage pattern for that VM | Compute | Disk | Infrastructure total |
Run 60 hours, retain disk for 730 hours | $0.90 | $1.80 | $2.70 |
Run 60 hours, then delete the instance | $0.90 | $0.15 | $1.05 |
Run and retain disk for 730 hours | $11.00 | $1.80 | $12.80 |
These are rounded estimates from the published rates, not measured AIO performance. The 20 GB disk is an example allocation, not proof that a particular workload fits. Model calls and other separately charged services are excluded. A running VM bills compute even while its CPU waits for a model response.
The Ubuntu template's omitted-resource default is 2 vCPU, 4 GB RAM, and 12 GB disk, listed at $12.08 for 730 hours. Explicitly select your disk allocation and retention policy when comparing quotes.
For intermittent work, record total running hours across all workers. Ten workers running six hours each have 60 aggregate compute hours, but ten retained disks cost ten times as much as one disk of the same size. Auto-sleep must be enabled; deletion ends the instance meter and also ends your ability to rely on its retained files.
AIO Sandbox questions to settle before deployment
Is AIO Sandbox a managed cloud service?
The agent-infra project is software you deploy. A provider may host that software or offer a similarly named service, but its billing and lifecycle contract must be evaluated separately. Establish which project or service a tutorial describes before copying its endpoints.
Can I use a standard Agent37 sandbox for the Docker example?
Use a full VM for this Docker-daemon route. That is the documented fit. A custom-image route is a different deployment choice and needs its own compatibility validation; this guide does not claim it was tested.
What should I measure in a trial?
Run your actual browser-to-file-to-code workflow. Record completion rate, peak memory, disk growth, time waiting on external services, and recovery after interruption. Test authentication and artifact export too. Those results tell you more than a generic startup-time claim.
What is the next step?
Start with one private environment and one representative task. If you want a broader operating comparison, read our managed sandbox versus self-hosted guide. When the VM route fits, create an Agent37 sandbox, choose a full VM, and budget the disk you will retain between runs.
