Agent-Infra Introduces AIO Sandbox — Unified Environment for AI Agents with Browser and Shell

Agent-Infra released AIO Sandbox — an open-source runtime environment for AI agents, where a browser, terminal, file system, and MCP services are bundled in a single container. The project is not aimed at improving reasoning models, but at a more practical problem: how to give an agent an isolated and convenient place for real actions.

The Bottleneck of Agents

Today, many agentic scenarios hit a bottleneck not in model intelligence, but in the infrastructure around it. LLMs can write code, plan steps, and invoke tools, but from there chaos ensues: the browser runs separately, the Python runtime separately, the shell separately, and files have to be passed between them manually. Each such transition adds latency, breaks session state, and requires additional glue code that is difficult to maintain.

On paper, this is solved with Docker containers, but in real pipelines another problem emerges — fragmentation. If an agent downloaded a CSV through the browser, that file still needs to be transferred to the processing environment, then the result saved and passed to the next tool. The more steps there are, the higher the risk of desynchronization and errors at the service boundaries.

AIO Sandbox attempts to remove precisely this layer of engineering routine and give the agent one unified workspace instead of a set of loosely coupled modules.

What's Inside Sandbox

Essentially, AIO Sandbox is a single Docker runtime where the main interfaces needed by a modern agent are already bundled. Instead of separately configuring browser automation, terminal, IDE, and connection protocol, the developer gets a ready-made environment with native access to these components. In the repository, the project is described as an all-in-one sandbox environment, oriented both toward agents and toward developers who want to observe, debug, and reproduce system behavior.

• Chromium with management via CDP and Playwright support
• Pre-configured Python and Node.js runtimes
• Bash terminal and shared file layer for all modules
• Built-in VSCode Server and Jupyter Notebook for debugging
• MCP servers for browser, files, shell, and document-to-Markdown conversion

The key idea is a unified file system. A file that an agent downloads via Chromium is immediately available to a Python script, a bash command, or a file API without intermediate transfers. For agentic tasks, this is more important than it sounds: you can open a web portal, pull data, immediately clean it in Python, and save the result in the same working directory. MCP integration is also separately useful: tools are already prepared and don't require teams to do manual wiring for basic operations.

How It Runs

Agent-Infra emphasizes that Sandbox is suitable not only for local experimentation but also for production deployment. The documentation includes quick start via a single Docker command, as well as examples for Docker Compose and Kubernetes. The container can be limited by CPU and memory, and agent code executes in isolation from the host system.

At the same time, the environment remains stateful: terminal sessions and working state can be preserved across multi-step tasks rather than being reset after each action.

Above the runtime, APIs and SDKs are available through which the application can read and write files, execute shell commands, control the browser, run Jupyter code, and connect MCP services. Out of the box, a VNC interface for visual browser control and VSCode Server for manual inspection of agent actions are also available.

Such a combination is especially useful for teams building web operators, internal automation scenarios, or hybrid pipelines where site navigation, local data processing, and verifiable isolation need to be combined.

What It Means

If the trend toward agentic systems continues, the next competitive field will be not only model quality but also the quality of the execution environment. AIO Sandbox shows where the market is moving: toward a standard runtime where browser, code, files, and tool protocols are already interconnected.

For teams, this is a chance to spend less time on infrastructure gluing and bring agents from demo to working service faster.