June 2026 Summaries

Claude Code is a versatile coding agent that performs tasks such as reading files, running commands, and managing server processes, often working unattended with minimal permission prompts. The text evaluates various sandbox environments for hosting Claude Code, emphasizing the importance of isolation and the need for a robust development environment. Freestyle VMs are highlighted as the optimal choice, providing a comprehensive, hardware-virtualized Linux environment that supports persistent terminal sessions, SSH access, preview URLs, and the ability to run indefinitely. This makes Freestyle particularly suitable for long-term projects requiring a live workspace with real Linux semantics. Other platforms such as Blaxel, E2B, Daytona, and Vercel offer varied levels of support and capabilities, with Freestyle standing out for its complete and durable VM model, making it the preferred choice when Claude Code needs a reliable and extensive development computer.

An AI agent runtime environment is essential for transforming code execution into a tangible product by hosting filesystems, maintaining services, and preserving states between user interactions. Among the evaluated platforms, Freestyle VMs emerge as the superior choice due to their ability to function as durable, full-fledged Linux virtual machines. These VMs provide a comprehensive computing environment suitable for long-lived, multi-service, user-facing products by supporting persistent terminal sessions, SSH access, and public domain mappings. Freestyle VMs surpass other platforms like Blaxel, Runloop, E2B, and Northflank by offering advanced lifecycle management, including the ability to resize, fork, and maintain live runtime states, making them ideal for applications where the runtime must serve as an interactive workspace rather than merely executing code snippets.

OpenAI's Agents SDK emphasizes the importance of using a robust sandbox environment for running agents, highlighting the need for an isolated workspace that can handle files, commands, and state persistence beyond a single model turn. The article ranks several sandbox solutions for OpenAI Agents SDK, with Freestyle VMs taking the top spot due to their ability to provide a full Linux VM environment, allowing for complex operations like running servers, maintaining terminals, and handling user interactions efficiently. Other sandboxes like Runloop Devboxes, E2B, Daytona Sandboxes, and Vercel Sandbox offer varying levels of functionality, with each suited to specific use cases such as software engineering workflows, code interpretation, broad programmability, or integration with the Vercel platform. The choice of sandbox should align with the agent's operational needs, from executing simple scripts to providing a durable and interactive workspace.

Deno Sandbox is a new product in the agent infrastructure market, designed to provide developers with Linux microVMs and a direct path to Deno Deploy, making it ideal for securely running generated TypeScript code that needs to be inspected and either discarded or deployed. It serves as a bounded, secure execution environment for untrusted Deno code with features such as SSH, HTTP exposure, and secret protection, while also offering a seamless integration with Deno Deploy, allowing code to be tested in a sandbox and then directly deployed. However, for more complex and long-running Deno agent tasks that require a persistent workspace, Freestyle VMs are preferred, as they offer more robust features like real Linux environments, durable terminals, and the ability to fork live workspaces. While Deno Sandbox is well-suited for fast, bounded, and secure execution of untrusted code, Freestyle VMs are better equipped for scenarios where a continuous, interactive development environment is necessary, especially for AI agents and app builders requiring a long-lasting runtime context.

Vercel Sandbox offers isolated Linux microVMs designed for executing untrusted code, testing applications, and managing files with features like persistence, snapshots, and network control, making it suitable for Vercel-native workflows that require bounded execution environments. However, it is limited by its inability to serve as a permanent workspace, as it is constrained by session timeouts and lacks continuous runtime capabilities. In contrast, Freestyle VMs provide a more robust solution for AI agents and long-running applications, offering hardware virtualization, persistent PTY sessions, SSH access, and the ability to run indefinitely, thus serving as a durable and inspectable Linux workspace. Freestyle VMs allow for seamless transitions between different states, such as running, stopped, or forked, making them ideal for complex, multi-service environments that require continuous operation and real-time interaction. While both solutions can execute code, the choice between Vercel Sandbox and Freestyle depends on whether the need is for isolated, temporary executions or a comprehensive, long-term runtime environment.

In the discussion surrounding AI agent filesystems, the emphasis is on the importance of preserving critical working states through checkpoints rather than merely syncing files. The challenge lies in determining when an AI agent's state is worth preserving, as agents often undergo complex and varied tasks that go beyond simple file changes, such as installing packages or running servers. While syncing is useful for straightforward tasks involving file transfers, it fails to capture the nuanced and dynamic environments in which AI agents operate. Checkpointing allows for the preservation of entire working environments, including running processes and interactive sessions, which are essential for understanding and improving agent performance. This approach ensures that the system can effectively track and maintain meaningful states, facilitating better decision-making and reliability in AI-driven operations. Freestyle VMs exemplify this concept by offering robust capabilities for managing agent states, supporting the creation of durable runtime objects that can be paused, forked, and resumed, thereby aligning the storage model with the agent's actual usage and needs.

In the realm of AI agent storage, a clear distinction is necessary between cloud storage and a working directory to avoid confusion and inefficiencies. Cloud storage excels at handling durable objects, such as uploaded files, datasets, and logs, but it is not a suitable substitute for an agent's active working environment, which requires the flexibility of a real working directory on a virtual machine (VM). This working directory allows agents to perform tasks like file creation, command execution, and process management in a dynamic and mutable space. By maintaining a separate VM workspace, agents can properly manage local state, dependencies, and processes, while cloud storage serves as a repository for artifacts and backups. This separation ensures that AI agents have a coherent and efficient environment, preventing common issues like data corruption and inadequate file control. The article underscores the importance of using cloud storage for its strengths in durability and accessibility, while relying on VMs for the active, stateful work needed by AI agents, thereby creating a balanced and functional storage strategy.

The evolving landscape of coding agents emphasizes the need for a robust computing environment, with a real Linux virtual machine (VM) being the optimal sandbox for agent command-line interfaces (CLIs). These agents require access to comprehensive system resources like terminals, environment variables, package managers, and long-lived processes that a simple command sandbox cannot provide. Freestyle VMs are highlighted as ideal because they support full Linux environments, enable persistent and interactive sessions through pseudo-terminals (PTYs), and accommodate complex service models, including networked services and secure data management. Utilizing Freestyle VMs allows for efficient handling of agent CLI operations by supporting real-time input/output, preserving state, and enabling features like snapshots and forking for parallel task execution. This setup ensures that agent CLIs operate as intended, transforming the runtime environment into a workspace that supports development and operational needs, including managing network traffic, storing configurations, and facilitating code reviews through integration with version control systems like Git.

Replit exemplifies the future of software by offering a seamless app development process where users describe an app, receive a workspace, iterate with the assistance of an agent, and publish the final product. It is designed for users seeking a hosted AI app builder with integrated features like a project editor and publishing flow. However, for teams looking to create a Replit-style product with a focus on complete control over the infrastructure, a real VM runtime is recommended. Freestyle VMs provide a durable and programmable environment that supports AI agents with features such as long-running sessions, SSH access, and the ability to run complex tasks on a Linux virtual machine. These VMs allow for granular control over the application's lifecycle, making them suitable for building products that require a robust backend infrastructure. Ultimately, the choice between using Replit and Freestyle VMs depends on whether the goal is to leverage a ready-made app-building environment or to construct a custom, controlled runtime for agent-driven applications.

AI agents require more than just persistent storage; they need a reliable runtime state model to function effectively. While persistent volumes are valuable for maintaining files between commands, caching installed packages, and logging, they alone do not encapsulate the complete working environment necessary for agents that perform complex tasks similar to developers, testers, or operators. The debate surrounding AI filesystems highlights the need for a clear distinction between file storage and agent memory as well as the need for a resumable computer environment. Projects like Microsoft's research paper and Letta's MemFS propose standards for agent-file interaction, emphasizing the necessity of files with product semantics. However, the true agent state encompasses processes, terminals, ports, and other runtime elements that persistent volumes alone cannot manage. Virtual Machine (VM) snapshots are more suited for preserving such comprehensive environments, offering features like lifecycle controls and domain routing, which allow agents to maintain a live, interactive workspace. The key consideration is understanding what state the agent needs to treat as true upon resumption, with persistent volumes being sufficient for file-centric tasks and VMs necessary for an environment-dependent workflow.

The debate around AI filesystems often misses the critical point that it's not just about where data is stored, but about providing agents with a reliable source of truth. While filesystems are appealing for their concrete nature, they can lead to issues if they are treated as the sole source of truth, as agents need to operate on a broader state that includes live processes, environments, and system states. Virtual filesystems can offer sophisticated interfaces but risk misleading agents into treating synthetic views as reality. The true challenge is to provide a runtime environment—like Freestyle VMs—that allows agents to verify, modify, and interact with the system while containing errors and preserving useful states. This ensures that agents have a comprehensive, trustworthy environment, leveraging filesystems for specific tasks while relying on a complete computational platform for executing and verifying actions.

The discussion on agent filesystems highlights the complexity of storage needs for AI agents, emphasizing that a single filesystem is insufficient to handle all responsibilities. It proposes a three-layer approach: a durable record for source and final artifacts, an active workspace for processes and commands, and an evidence layer for logs and traces, each serving distinct purposes. The debate centers on memory, storage, and work, with each requiring different storage solutions like object storage, databases, or VMs, rather than forcing one system to handle everything. The active layer should function as a genuine, durable computer environment, maintaining continuity between tasks and supporting interactive processes, while the durable layer should not be conflated with the active workspace, highlighting the need for separating execution from long-term storage and review processes. The argument concludes that combining various storage methods, such as Git for source control and VMs for execution, is more effective than relying on a single filesystem, ensuring both durability and functionality in agent operations.

Docker Compose's utility in software development becomes evident when comparing basic code runners to the comprehensive infrastructure needed for complex applications involving databases, services, and logs. While lightweight sandboxes may suffice for simple tasks, real-world applications require a more robust environment, such as a real Linux VM, to effectively manage multi-service applications. These VMs provide persistent terminals, support native Docker operations, and enable seamless transitions between tasks without the need for repeated setups, thanks to features like snapshotting. This allows for a continuous, interactive development process, where agents can execute tasks, debug live environments, and maintain workflow consistency. Freestyle VMs are highlighted as an effective solution for running Docker Compose, preserving the declared environments and reducing the need for provider-specific adaptations, thus bridging the gap between basic script execution and full-scale application management.

AWS Fargate is a serverless compute engine designed to run containers without the need to manage underlying servers, making it ideal for services, workers, and batch jobs. However, for AI agents that require a persistent and interactive environment, Fargate's container-centric approach may not suffice, as these agents often need a workspace where they can operate continuously, with access to a full operating system, persistent storage, and interactive terminals. Freestyle VMs provide a more suitable alternative for such workloads, offering hardware-virtualized environments where agents can maintain their state, run long-lived processes, and interact with the system in a way that resembles traditional computing. While Fargate abstracts server management and is efficient for predefined tasks, a virtual machine provides the flexibility and durability that complex AI agents need, allowing them to function as users within a complete OS environment rather than just executing isolated tasks.

The evolution of AI coding agents is shifting from merely writing code to proving its functionality, necessitating the development of sophisticated QA agents that can manage comprehensive testing processes. Unlike simple code execution, effective QA agents require a robust environment, ideally provided by real Linux VMs, to perform tasks such as booting applications, running tests, checking outputs, and preserving context for debugging. Freestyle VMs are highlighted as optimal for these tasks due to their ability to handle complex workloads and maintain a cohesive test environment. This includes capabilities to run app servers, browsers, databases, and other components in unison while providing operations like resizing, forking, and maintaining artifacts and logs. The necessity for a thorough and interactive testing setup underscores the importance of a QA agent's ability to replicate real-world software usage, and Freestyle VMs offer the infrastructure to support this by allowing agents to operate continuously and adaptively within a single, unified machine environment.

Judge0 is a robust, open-source online code execution system designed for running and managing code submissions within a sandboxed environment, offering features like language support, custom inputs, and resource limits, making it ideal for one-off executions such as online judging or educational grading systems. However, its submission-based model limits its capacity to serve AI agents that require persistent, interactive environments. For more complex tasks where AI agents need to install packages, maintain state, and run continuous services, Freestyle VMs offer a more suitable solution by providing hardware-virtualized Linux environments that can support prolonged operations, interactive shells, and network services. Freestyle VMs cater to the needs of AI products by offering a real workspace that allows for dynamic setups, persistent environments, and SSH access for debugging, distinguishing it from Judge0's focus on deterministic code execution.

Building an effective AI sandbox for WebSocket applications requires more than just a basic command runner; it demands a virtual machine (VM) capable of simulating a real machine environment. Unlike simple code snippets, WebSocket apps function as live services that need to maintain state and handle ongoing connections, making it necessary for the sandbox to support long-running processes, stable connection paths, and interactive debugging tools. Freestyle VMs, which are hardware-virtualized Linux machines, offer the required capabilities for managing these complex tasks, including port exposure for public traffic, URL mapping for previews, and persistent state management. This setup ensures the sandbox can act like a real computer, running the WebSocket server, maintaining terminal sessions, and allowing for live debugging and iterative development. The VM-based approach provides a robust framework for developing, testing, and previewing WebSocket applications, emphasizing the importance of preserving the live state and operational continuity essential for real-time software.

Riza is a code interpreter API designed for executing model-generated code securely, providing an efficient solution for scenarios that require running short scripts, transforming data, or validating code execution. It operates within a controlled environment using WebAssembly, making it suitable for languages like Python, JavaScript, Ruby, and PHP, and focuses on returning outputs such as stdout, stderr, and exit codes. However, for more complex tasks that require a persistent workspace, such as running long-term processes, managing files, or supporting interactive sessions, a virtual machine (VM) like Freestyle, which offers a full Linux environment with SSH access, package management, and the ability to run services, is more appropriate. Riza is ideal when each execution is a discrete unit of work, while VMs are preferable when a dynamic workspace, capable of maintaining state and facilitating human intervention, is necessary.

Google Cloud Run offers robust infrastructure for deploying containerized applications, particularly suited for running HTTP services, webhooks, and scheduled tasks, but it may not be ideal for AI agent operations that require a persistent, interactive environment. While Cloud Run excels at handling stateless, containerized services with its scalable and request-driven architecture, it falls short for workloads that demand a stateful, user-visible development environment with features like live previews, terminal sessions, and interactive processes. Freestyle VMs provide a more suitable alternative for AI agents, offering a real Linux environment that supports continuous operations, interactive shells, and SSH access, allowing agents to maintain their workspace with installed dependencies, file systems, and ongoing processes. This enables AI agents to perform complex tasks, debug issues, and manage stateful sessions that cannot be easily accommodated within the constraints of Cloud Run's container deployment model. Consequently, while Cloud Run remains an excellent choice for traditional container workloads, Freestyle VMs are better aligned with the needs of AI agents, offering greater flexibility and control over the computing environment.

E2B is a suitable platform for initial code execution tasks, such as building a code interpreter or running snippets within a sandbox environment. However, as agent products evolve and require more complex functionalities, such as persistent workspaces and the ability to run multiple services, a transition to a more robust solution like a hardware-virtualized Linux VM becomes necessary. Unlike E2B, which is primarily an execution tool, VMs provide a complete environment that supports long-running tasks, stateful processes, interactive terminals, and web previews, making them ideal for AI agents and development environments that need to maintain state and facilitate collaboration. Freestyle VMs, in particular, are highlighted as a strong alternative due to their ability to handle real processes, files, terminals, and debugging paths, thereby offering a more durable and flexible infrastructure that aligns with the needs of stateful AI agents. As agent products grow beyond simple code execution, the choice between E2B and VMs hinges on whether the environment is execution-shaped or computer-shaped, with VMs offering a more comprehensive solution for complex, interactive, and shared development tasks.

AWS Lambda, while an excellent tool for event-driven, stateless, and short-lived functions, is not ideally suited for AI agents that require a more persistent and interactive environment. AI agents need to manage dependencies, maintain state across sessions, handle long-running processes, and interact with terminals, which makes them more akin to developers working within a machine rather than simple function handlers. Freestyle VMs provide a better fit for such workloads by offering a persistent Linux environment with the ability to run indefinitely, manage files and processes like a real computer, and maintain session states across disconnections. While Lambda excels in scalability and simplicity for serverless applications, Freestyle VMs allow for a more natural workflow for AI agents, enabling them to perform complex tasks without the constraints of Lambda's short-lived function invocations. The choice between Lambda and VMs should be based on the nature of the workload, with Lambda being optimal for stateless, event-driven tasks, and VMs being preferable for stateful, interactive, and long-running processes that resemble a real computer's operations.

Runloop is a robust platform for AI coding agents, offering Devboxes as sandboxed execution environments that function as full Linux virtual machines with features like blueprints, disk snapshots, credential gateways, network policies, and SSH access. These environments are optimized for executing agent tasks such as pulling code from Git repositories, running browsers, and executing proprietary binaries. However, as AI coding products evolve from task execution to becoming live development environments, there is a shift in demand for platforms that offer a comprehensive virtual machine (VM) experience. This is where Freestyle VMs become relevant, as they offer a durable runtime object that accommodates long-lived workspaces with persistent terminals, interactive shells, and infrastructure that supports routing HTTPS traffic to services running inside the machine. Freestyle VMs allow users, agents, and support staff to share a live Linux environment, making them ideal for coding agents that require a real machine environment with the capability to fork, resume, and store code changes in a collaborative manner. The choice between Runloop and Freestyle depends on whether the focus is on controlled agent execution or on providing an environment that functions as the user's computer.

Cloudflare Sandbox SDK and Freestyle VMs both offer solutions for running untrusted code, but they cater to different needs based on the nature of the application workload. The Cloudflare Sandbox SDK is ideal for applications already operating within the Cloudflare ecosystem, providing a TypeScript API for managing tasks in isolated environments through containers. It excels in edge-native, request-shaped scenarios where tasks are short-lived and can tolerate losing runtime state after inactivity. In contrast, Freestyle VMs are designed for AI agents and applications requiring a persistent, machine-shaped workspace. These VMs offer a full Linux environment capable of running indefinitely, supporting long-running processes, and maintaining state across sessions, which makes them suitable for complex, multi-service setups where continuity and state preservation are crucial. Freestyle VMs are particularly advantageous for scenarios where branching and parallel processing are necessary, as they allow forking of running environments, maintaining the current state, and providing a robust platform for development and debugging.

StackBlitz WebContainers offer a unique way to run Node.js environments directly in the browser, providing advantages for interactive JavaScript examples, tutorials, and browser-native coding experiences by eliminating server round trips and facilitating an immediate, engaging user experience. However, for AI agents and other applications requiring persistent, complex, and resource-intensive tasks, browser constraints make WebContainers less suitable. These applications often demand a real Linux environment capable of running native binaries, maintaining processes independent of user presence, and offering multiple interfaces like SSH for debugging. Freestyle VMs present a more robust alternative for such needs, providing hardware-virtualized Linux machines that can run indefinitely, support standard Linux operations, and offer durable runtime capabilities. While WebContainers excel in scenarios where the browser is the main interface and user presence is constant, VMs are better suited for agent-first architectures where persistent compute resources and flexibility are required beyond the browser.

AI sandboxes often struggle with managing background processes, which require ongoing operations beyond simple command execution. These processes include dev servers, database daemons, and queue workers that need to persist, restart, or remain visible even after user disconnection, which traditional sandboxes handling single command responses can't efficiently manage. Real Linux virtual machines (VMs), particularly Freestyle VMs, offer a powerful solution by enabling AI agents to perform complex operations with persistent services, terminals, and network routing. They provide essential features like running supervised processes under systemd, maintaining interactive PTY sessions, and supporting lifecycle management tasks such as starting, stopping, resizing, and taking snapshots of the environment. This approach allows agents to engage with a real operating system's capabilities, ensuring they can manage background processes effectively without adding undue complexity to applications. This capability is crucial for product teams building coding agents and other automated tools that require robust process orchestration beyond simple command execution.

CodeSandbox SDK is a platform designed for creating programmable development environments, offering features like sandboxed development, concurrent VMs, and AI agent runtimes. While it excels in providing fast, isolated environments for quick code execution and browser IDE setups, its limitations become apparent when more durable, long-lived environments are required. Freestyle VMs serve as a robust alternative, offering a hardware-virtualized Linux environment that supports long-running tasks, persistent state, and complex agent workspaces. These VMs enable SSH access, parallel forking, and the ability to route HTTPS traffic, making them ideal for products that require a seamless integration of user and agent interactions in a real Linux environment. The choice between CodeSandbox SDK and Freestyle depends on whether the primary need is for quick, transient execution or a comprehensive, persistent workspace that can support AI coding agents, application building, and internal automation tools.

OpenAI Code Interpreter is a tool designed for executing Python code in a sandboxed environment, ideal for tasks like data analysis, file processing, and math computations within a model's response. It is particularly effective when the model needs to perform operations such as analyzing CSVs, transforming images, or running short Python loops. However, for more complex and long-running tasks that require a persistent environment with capabilities beyond Python execution, such as installing system packages, maintaining terminal sessions, and running multiple services, Freestyle VMs present a more suitable alternative. These virtual machines provide a full Linux environment that supports commands, SSH sessions, and network traffic, making them ideal for AI coding agents, app builders, and other applications that require a durable runtime state. While the Code Interpreter is specialized for executing specific Python tasks, VMs offer a comprehensive environment where agents can perform a broader range of operations, including handling stateful processes and interacting with a full operating system.

In deciding how to transfer local files into a sandbox for an agent product, the choice of method significantly impacts workflow efficiency and architecture. Each file transfer method—Git, scp, rsync, archives, and file APIs—serves different purposes, and selecting the appropriate one depends on the specific requirements of the work. Git is ideal for preserving project history, branches, and reviews, especially in coding workflows, while scp facilitates quick manual transfers. rsync is suitable for repeated synchronization of directories, archives offer a portable way to transfer snapshots, and file APIs are optimal for controlled inputs within product workflows. Freestyle VMs, which run real Linux, provide the flexibility to employ these methods using standard developer tools, allowing for efficient and structured file management without necessitating custom solutions. The key is to differentiate between temporary file transfers and durable project states, ensuring that long-term states are stored in reviewable systems like Git while using VMs for execution.

AI agent sandboxes are most effective when they operate like real Linux environments, allowing agents to perform tasks beyond mere code execution. The ability to use apt install serves as a benchmark for a sandbox's capability to handle complex software development tasks, as it indicates the environment can manage native dependencies, run services, and maintain process states. Unlike simplified sandboxes, which might only support basic operations, environments like Freestyle VMs offer a comprehensive solution by providing full Linux virtual machines that support package installations, interactive terminals, service hosting, and state preservation. This ensures that agents can tackle real-world applications, enabling them to grow from simple code execution to managing entire workspaces and running user-facing services.

AI app builders have evolved from simple code generators to complex systems capable of handling a wide array of tasks, such as authentication, databases, and API integrations, effectively transforming the app development process. This evolution necessitates a shift from using narrow code execution sandboxes to employing real virtual machines (VMs) that can mimic a developer's computer environment, allowing for the installation of dependencies, running multiple services, and maintaining state across sessions. The runtime for these applications must support real Linux commands, multiple service execution, state preservation, and interactive terminals to accommodate the iterative, stateful development loop that users require. By leveraging Freestyle VMs, which offer a full Linux environment and the ability to handle complex, long-running tasks, AI app builders can create running applications, not just previews, and maintain source code integrity through integration with a Git repository. This approach provides the necessary infrastructure for building scalable, real-world applications, enabling users to iterate on live applications efficiently.

AI agents often face the challenge of limited tool schemas, which initially seem manageable but quickly become inadequate as tasks grow more complex, necessitating the use of Bash for its versatility and compatibility with existing software ecosystems. Although a narrow tool schema offers control and validation, it limits an agent's ability to perform common tasks like installing packages or troubleshooting. Bash provides a comprehensive interface that aligns with the shell-first design of package managers, build tools, and other software, allowing agents to effectively interact with the environment. Real agent work requires a stateful system, which virtual machines (VMs) like Freestyle VMs can offer by providing a real Linux environment that supports long-running, complex tasks. This setup allows agents to perform interactive and continuous operations, maintaining state across sessions and network interruptions. The key is to balance control and flexibility, ensuring that agents have access to a complete environment without compromising safety and security. Bash serves as a reliable adaptor for AI agents, enabling them to navigate tasks beyond the initial, limited toolset and adapt to the real-world demands of software operations.

Containers are a highly efficient infrastructure for predictable, short-lived workloads due to their ability to package software cleanly and leverage the host OS for resource control, making them ideal for tasks that can be fully delineated before execution. However, when dealing with AI agents or workloads requiring a persistent and complex environment, virtual machines (VMs) offer a more suitable solution, providing a durable and flexible runtime with its own operating system, which allows for inspecting, mutating, and debugging the environment. VMs are particularly advantageous for tasks where the agent needs to maintain state, explore multiple paths, or engage in interactive operations, as they support forking, persistent sessions, and easy debugging through familiar interfaces like SSH. The decision to use containers or VMs should be based on whether the runtime environment is merely an implementation detail or an essential part of the agent's operational context, with containers serving best for stateless, repeatable processes, and VMs being more appropriate for maintaining continuous, stateful interactions.

The text discusses the complexities and necessities of implementing a private networking system for AI agents, emphasizing the importance of separating public and private network boundaries to enhance security and functionality. In a production environment, AI agents require multiple interconnected components such as databases, queues, and background jobs that should not be exposed to the public internet. The use of Virtual Private Clouds (VPCs) allows these components to communicate internally over private IPs, maintaining a stable and secure infrastructure. Freestyle VMs provide the flexibility needed for such setups, supporting durable runtime objects that can be stopped, started, resized, and forked, ensuring efficient resource management. Debugging in private networks is facilitated through ephemeral WireGuard VPN sessions, allowing temporary access without exposing services publicly. The text also highlights the importance of using scoped tokens for client access to specific VMs, preventing the need to share broad API keys, and stresses that public domains should only be used when external accessibility is necessary. Overall, the document outlines best practices for creating a robust and secure agent architecture that can dynamically manage workloads while maintaining a clear boundary between public and private operations.

Browser agents, while seemingly straightforward in demos, are complex systems that require a full computing environment to function effectively. They rely on a comprehensive setup involving browsers like Chromium or Firefox, a display stack, browser profiles, and various other components for web operation and development tasks. Freestyle VMs provide a solution by offering a full Linux environment that supports the necessary browser and application stacks together, maintaining state across sessions and allowing for complex operations like pausing, resuming, and live forking to explore multiple paths. This setup transforms browser automation from a simple API interaction into a robust system capable of handling state, files, processes, and networking, making it suitable for serious product workflows. The architecture ensures persistence and continuity by storing browser profiles, downloads, and screenshots, and leveraging Git for code review and management, thus providing a comprehensive and efficient infrastructure for browser agents.