August 2026 Summaries

Three open-source agent frameworks—Flue, Bindu, and Harbor—use boxd Linux machines for distinct deployment needs: isolated execution sandboxes, persistent agent servers, and disposable benchmark environments. Flue gives each programmable TypeScript agent its own VM and filesystem through a sandbox connector, enabling safe parallel execution and developer-controlled machine lifecycles. Bindu deploys agents as signed A2A microservices with stable HTTPS endpoints, using auto-suspend to conserve resources between requests while supporting options such as custom Docker images. Harbor uses isolated KVM microVMs with full Docker support to run agent and model evaluations against unmodified benchmark tasks, with snapshots improving startup times by reusing prepared machine states and Docker caches. Although their uses differ, the integrations rely on the same underlying capability: full Linux machines that frameworks can control directly, with all three implementations available as open source.

AI agents are portrayed as lowering the barriers that historically prevented narrowly useful software from being created, allowing individuals and small teams to build lightweight tools for limited audiences such as workflow automations, dashboards, trackers, and internal applications. The text argues that growth in GitHub repositories, developers, and commits reflects a surge in this “small software,” but says such tools often remain trapped on creators’ laptops because conventional deployment and cloud infrastructure impose complexity designed for large-scale services. It proposes treating a persistent, network-addressable running machine as the fundamental unit of software, so agents can directly edit the live application, users can share or fork it through access to the machine, and changes can occur continuously without separate deployment or release processes. Boxd is presented as a platform providing each small application with an inexpensive Linux machine, persistent storage, HTTPS access, snapshots, private networking, integrations, automation APIs, and root-level configurability, enabling agents and users to manage the entire operating environment and create additional machines as needed.

Agent swarms divide genuinely independent parts of a complex question among parallel coding agents, avoiding the context buildup and sequential delays of a single agent working through every subproblem. Boxd supports this approach by providing each worker with a rapidly launched, isolated Linux machine containing preconfigured coding agents such as Claude Code, Codex, and OpenCode, allowing workers to install software, run tests, investigate errors, and return reports through shell execution. A typical workflow uses a coordinator to create machines for specialized scouts, collect their outputs, and assign a separate lead agent to synthesize a final recommendation before the workers are destroyed. Workers can also communicate through privately addressable shared services when needed, while network partitioning and isolated environments limit unintended access between tasks. Warm machine forks and golden images can accelerate tasks requiring existing repositories, dependencies, or memory state, though the model emphasizes that swarms are most useful only for independent work, require careful synthesis, consume tokens per agent, and improve speed rather than cost.

boxd proposes improving reproducibility and speed in reinforcement learning by forking a fully initialized microVM rather than repeatedly rebuilding and reseeding environments. Because forks begin from identical memory, disk, processes, loaded weights, simulator state, and caches, they provide isolated warm-start rollouts that can be created rapidly and run in parallel, while reducing dependence on coordinating random seeds across every dependency. Developers still must control policy randomness and external nondeterminism such as clock reads, network responses, machine-specific identities, and nondeterministic accelerator operations, since forking does not make code itself deterministic. The approach supports forks for parallel copies of a baseline, checkpoints for restoring one machine to an earlier state, and versioned snapshots for preserving a reusable baseline across machines or training runs. It is presented as most useful for costly, stateful environments, while simpler environments with little setup may not justify the added infrastructure.

Boxd proposes a one-machine-per-tenant architecture for products that provide customers with persistent agents, workspaces, or app instances, using hardware-isolated virtual machines rather than shared-process sandboxing to prevent cross-tenant access by design. Developers prepare an agent or application harness once on a Linux machine, save it as a versioned snapshot, and have their signup backend create isolated tenant machines from that image, inject tenant-specific secrets through code, restart the service, and return a ready HTTPS URL. Snapshot versions support controlled rollouts by assigning new tenants updated images while allowing the application backend to decide when existing tenants are recreated. To reduce costs, idle machines can suspend while retaining RAM for near-instant resumption or hibernate to disk after inactivity, although hibernation should be disabled for background workloads without network traffic. Custom wildcard domains can place tenant URLs under a company’s brand, while isolation and network-label options determine whether machines can communicate. Boxd supplies the infrastructure, URLs, snapshots, and machine lifecycle capabilities, but customers remain responsible for their application harness, tenant-to-machine naming, secrets management, update policies, deletion flows, pricing, and capacity planning.

Boxd presents its sandboxing approach as hardware-level isolation through KVM microVMs, giving each workload its own kernel, network stack, and disk rather than relying on containers that share a host kernel. This design allows untrusted code to have root access within its disposable VM, including the ability to run Docker, modify system settings, or damage its own operating system, while limiting the effects to that machine; however, outbound internet access remains a potential route for data exfiltration. The platform claims fresh microVM boot times under 10 milliseconds and forks under 200 milliseconds, enabling per-task disposable environments, concurrent fleets, and snapshot-based provisioning with preinstalled tools. Machines can also persist and resume quickly, supporting longer-lived isolated environments such as tenant-specific infrastructure. The immutable `--isolated` setting removes access to an account’s default private network, in-VM Boxd credentials, connected integrations, and other owned machines, while retaining outbound internet, public HTTPS, SSH, and persistent storage. Selective connectivity can be restored through named network tags, allowing an isolated machine to access only explicitly designated non-isolated resources such as a job queue or database.

Running an assistant on a persistent boxd Linux machine is presented as an alternative to building separate memory, credential, scheduling, and webhook systems in application code, since the machine provides durable files, cron jobs, stored logins, persistent workspaces, and a public HTTPS endpoint. Users can install agents such as Hermes through the `/boxd-setup-hermes` skill, connect it to messaging platforms, or use preinstalled coding agents including Claude Code, Codex, and OpenCode. Account-level integrations supply credentials for services such as Slack, Linear, and GitHub across personal machines, while additional API keys can be managed through encrypted environment variables and secrets. Machines normally hibernate when idle to reduce cost, but assistants that must execute scheduled background work require hibernation to be disabled. The approach turns an assistant from a temporary chat session into an inspectable, persistent process that can act independently, though it also introduces ordinary operational responsibilities such as monitoring storage, processes, and logs.

Boxd provides dedicated persistent virtual machines for coding agents, addressing the resource contention, broad local-file access, and session loss associated with running agents on a personal laptop. Each machine includes Claude Code, Codex, and OpenCode, along with agent-specific instruction files that explain the preconfigured environment, networking, proxy, machine-management commands, and cleanup procedures while allowing repository-level instructions to add project conventions. The pre-authenticated in-VM CLI lets agents create machines, execute commands, and expose ports, while Claude Code credentials can automatically carry to newly created machines, forks, and snapshots; Codex and OpenCode support credential inheritance for forks but currently require login on fresh machines. Agents can be run interactively or delegated through commands from a laptop, with session state persisting on the machine’s disk across disconnects and reboots. Long-running Claude sessions can remain active through tmux and be accessed remotely through Claude applications or a shell, although unattended work may require disabling auto-hibernation. Because each Boxd machine is a full Linux VM capable of running Docker, daemons, system packages, and other server workloads, it can support broader autonomous development tasks and can be expanded into multi-agent workflows across separate machines.

Per-pull-request preview environments can make code review more reliable by giving reviewers a live, isolated version of each branch rather than relying on diffs or a contested shared staging server. Using boxd, teams create a continually refreshed “golden” snapshot containing the working application, then clone it for each pull request, check out and rebuild the branch-specific changes, and expose the machine at a stable URL based on the pull request number. CI can automate creation or refresh on pull request updates, post the link for reviewers, prevent concurrent deployment conflicts, and delete the machine when the pull request closes. Auto-suspension and hibernation reduce idle costs while preserving quick wake times, although organization machine limits may restrict use for repositories with very large numbers of concurrent branches. Because each preview is a full Linux machine, reviewers and developers can access the exact running environment for debugging, testing, and isolated preview data, including databases inherited from the golden image.

Boxd proposes replacing a single shared local development setup with a flexible fleet of isolated Ubuntu virtual machines, allowing each task, branch, or coding agent to work on its own copy of an application without database, port, or file conflicts. Teams can configure one base machine with dependencies, seeded data, and running services, then fork it in milliseconds with its memory, processes, and disk state preserved, providing each task with an immediately usable environment and public HTTPS URL for review or collaboration. Named snapshots can serve as reusable team images for onboarding and standardized environments, while shared secrets and integrations are injected across machines and checkpoints allow individual machines to be restored independently. Machines automatically hibernate when inactive to limit costs, although long-running jobs without inbound network traffic require idle suspension to be disabled. The approach requires reliable network access and remains unsuitable for macOS- or iOS-specific builds, but it can be adopted gradually by starting with one project before expanding across a team.

Billions of Machines presents boxd as a cloud platform built around fast, isolated KVM virtual machines that provide persistent storage, root access, preinstalled development tools, immediate HTTPS URLs, and near-instant startup. It is designed for agent-driven development by letting coding agents work directly on the same machine that runs and exposes an application, allowing changes to be reviewed live without a separate deployment step. Users can fork running machines, including their memory and processes, to support parallel tasks; create reusable snapshots for prepared environments; and use checkpoints to restore a machine after risky changes. Machines automatically sleep without traffic while retaining their state and can wake almost instantly, reducing idle costs. The platform also supports terminal and SSH access, secure sharing, APIs and machine-to-machine orchestration, custom networking and domains, and workflows ranging from preview environments and sandboxes to agent swarms, per-user machines, and reproducible AI training environments.

Growing use of coding agents is presented as creating a major demand for isolated, rapidly provisioned computing environments, since developers and agents often cannot effectively run multiple tasks on a single laptop or shared development stack due to conflicts involving databases, ports, servers, and files. The argument cites sharply increasing GitHub commit volumes as evidence that agents are accelerating software production and contends that agents will increasingly need to create, branch, pause, resume, and hand off many complete development machines rather than merely use lightweight containers or worktrees. It identifies requirements such as dedicated kernel-level isolation, millisecond startup and wake times, stateful snapshots and forks, persistent memory and processes, API-driven orchestration, inexpensive idle operation, and environments that can directly serve the applications being edited. The company boxd presents its product as a neutral, EU-hosted and self-hostable platform for such “composable computers,” offering persistent Linux machines with APIs, snapshots, branching, HTTPS URLs, and support for any agent that can run on Linux.