How AIO Sandbox Works
AIO Sandbox is a Docker-based container that consolidates multiple isolated execution environments into a single, unified workspace. It integrates browser automation, shell access, file system operations, VS Code Server, Jupyter Notebook, and Model Context Protocol (MCP) servers behind a unified API. This design eliminates the need for separate services, enabling seamless workflows where files downloaded in the browser are instantly accessible in the terminal or VS Code. The container uses a shared filesystem to maintain consistency across all components, ensuring that operations in one interface reflect changes in others.
The architecture is built on lightweight sandboxing technology, ensuring secure execution of Python and Node.js code without exposing the host system to risks. Each component operates within the same container, connected through a centralized API that abstracts the underlying complexity. This approach simplifies deployment, reduces operational overhead, and enhances security by isolating agent activities within a controlled environment.
At its core, AIO Sandbox provides a pre-configured environment where AI agents can interact with web interfaces, execute shell commands, manipulate files, and develop code—all through a single API. The container includes built-in tools like VNC for visual browser interaction, Chrome DevTools Protocol (CDP) for programmatic control, and MCP servers for high-level automation tasks. This integration allows developers to build complex workflows without managing multiple disparate services.
The container is designed for reproducibility, with pinned release tags ensuring consistent deployments across environments. For cloud deployments, port 8080 is kept private and exposed through reverse proxies or Ingress controllers. The shared filesystem is mounted as a Docker volume, allowing persistent storage of workspace data across container restarts.
Unified File System
AIO Sandbox’s shared filesystem is a defining feature, enabling seamless data exchange between components. Files downloaded via the browser are automatically available in the terminal, VS Code, or Jupyter Notebook. This eliminates manual transfers and ensures that all tools operate on the same dataset. For example, a webpage scraped by the browser can be immediately processed in a Jupyter notebook or saved to a file for further analysis.
This directory persists across container restarts when mounted as a volume, making it ideal for long-running workflows or collaborative development environments.
Browser Automation and Control
The browser component supports multiple interfaces for interaction: VNC for visual access, Chrome DevTools Protocol (CDP) for programmatic control, and MCP for high-level automation.
For advanced use cases, the sandbox integrates with tools like Playwright for browser automation.
Development Tools and IDE Integration
AIO Sandbox includes VS Code Server, providing a full-featured IDE directly in the browser. This allows developers to edit code, debug applications, and manage projects without local installations. Jupyter Notebook is also integrated, offering interactive Python environments for data analysis or prototyping.
Port forwarding is automated, allowing users to preview web applications running inside the container. For instance, a Flask server can be accessed via /proxy or a custom domain, with intelligent routing based on port mappings. This feature is particularly useful for testing or demonstrating applications without exposing them to external networks.
Model Context Protocol (MCP) Servers
MCP servers are pre-configured within the container, providing specialized tools for browser automation, file operations, shell execution, and document processing. The MCP Browser server includes methods for navigation, screenshot capture, element interaction, and scrolling. The File server supports reading, writing, listing, searching, and replacing files, while the Shell server enables command execution, session management, and output control.
These servers are designed for AI agents, offering a standardized interface for integrating with larger systems.
API and SDK Access
The sandbox exposes a RESTful API at /v1, providing endpoints for core operations such as shell command execution, file management, browser automation, and Jupyter code execution. The API is language-agnostic, with SDKs available for Python, TypeScript/JavaScript, and Go, enabling integration with existing workflows.
AI Agent Development and Testing
AIO Sandbox is primarily designed for AI agents, providing a secure and isolated environment for testing and deployment. Agents can interact with web interfaces, execute system commands, and manipulate files—all within a controlled sandbox. This isolation prevents unintended system modifications and ensures reproducible experiments.
For example, an AI agent tasked with web research can use the browser to scrape data, process it in Jupyter, and store results in the filesystem—all without exposing the host machine to potential risks.
Web Automation and Scraping
The browser component is well-suited for web automation tasks, such as form submission, data extraction, or interactive testing.
This process involves scraping HTML, processing it in a Jupyter notebook, and saving the output—all within the same container. The shared filesystem ensures that intermediate files are accessible across tools, streamlining the pipeline.
Secure Code Execution and Development
Developers can use AIO Sandbox as a lightweight, portable development environment. The included VS Code Server and Jupyter Notebook provide full-featured tools for coding, debugging, and data analysis. The sandboxed execution of Python and Node.js ensures that code runs in an isolated environment, mitigating risks from malicious or unstable scripts.
For collaborative projects, the persistent workspace and shared filesystem allow multiple developers to work on the same files without conflicts. The container can be deployed in cloud environments, with port forwarding enabling secure access to internal services.
Enterprise and Cloud Deployments
AIO Sandbox supports enterprise-grade deployments through Docker Compose or Kubernetes.
For cloud deployments, the container is designed to run behind reverse proxies or Ingress controllers, exposing only necessary ports. The shared filesystem can be mounted as a volume, preserving data across restarts or updates.
Integration with External Tools
For instance, the OpenAI Codex CLI is integrated into the container, allowing users to run Codex commands directly from the shell or browser.
The sandbox also supports proxy mapping via GOST v3, which handles domain/IP/port routing, HTTPS redirection, and authentication.
Unified and Secure Execution Environment
AIO Sandbox consolidates multiple execution environments into a single container, reducing the complexity of managing separate services. The shared filesystem ensures that data is consistent across tools, while Docker’s isolation mechanisms provide security guarantees.
The container is pre-configured with MCP servers, development tools, and automation capabilities, eliminating the need for manual setup. This ready-to-use environment accelerates development cycles and reduces the risk of misconfigurations. For example, an AI agent can immediately start interacting with the browser or filesystem without additional dependencies.
Browser Automation and Policy Controls
The browser component offers multiple interaction methods, including VNC for visual access and CDP for programmatic control.
Development and Collaboration Tools
VS Code Server and Jupyter Notebook provide full-featured development environments directly in the browser. These tools are particularly useful for collaborative projects, where multiple developers can work on the same files without local installations.
Port forwarding automates the preview of web applications, allowing users to test or demonstrate projects without exposing them to external networks. The persistent workspace further enhances collaboration by maintaining file consistency across sessions.
MCP Integration and Agent Compatibility
MCP servers are pre-configured for common tasks, including browser automation, file operations, shell execution, and document processing. These servers provide a standardized interface for AI agents, simplifying integration with larger systems.
The MCP Browser server includes methods for navigation, screenshot capture, and element interaction, while the File server supports reading, writing, and searching files. This integration ensures that agents can perform complex tasks without custom scripting.
API-Driven Workflows and SDK Support
The sandbox exposes a RESTful API for core operations, including shell execution, file management, and browser automation.
MCP servers are also accessible via the API, with endpoints for browser automation, file operations, and shell execution.
Deployment Flexibility and Scalability
AIO Sandbox supports deployment via Docker Compose or Kubernetes, with configurations for security, resource limits, and environment variables.
For cloud environments, the container is designed to run behind reverse proxies or Ingress controllers, exposing only necessary ports. The shared filesystem can be mounted as a volume, preserving data across restarts or updates.
Advanced Features and Improvements
Recent releases have introduced several advanced features, including browser file-picker policy controls, custom Codex configurations, and improved shell output reliability.
Codex CLI integration enables direct access to OpenAI’s Codex tools, with custom configurations supported via environment variables. Shell output reliability has been improved, with better handling of long-running tasks and large outputs. The aio CLI tool provides direct access to browser, GUI, file, and MCP capabilities from the shell, simplifying workflows for agents and developers.