OpenComputer Runs Coding Agents and Sandboxes on One Durable Cloud VM
By Mr.Xu Community Post
Published:
Summary:OpenComputer is an open-source cloud coding agent designed to run inside a team's own AWS, GCP, or Azure account. Its agent harness—the layer that orchestrates model calls, tools, and context—and the execution sandbox share one persistent VM. Sessions use separate Git worktrees, while session files are committed after every turn so work can resume on another VM. The founder reports a 24-second time to first commit, versus 53–72 seconds for the alternatives tested, and estimates that an always-o
Core release: bringing coding agents into a team's own cloud
Digger has published OpenComputer on GitHub, an open-source cloud coding agent for teams that can run in their own AWS, GCP, or Azure accounts. Its central design choice is the placement of the execution layer: the agent harness responsible for model calls, tool orchestration, and context management shares a durable VM with the sandbox that executes generated code.
The project positions itself as an open-source alternative to Devin, but the available material primarily establishes its deployment architecture and startup performance. It does not yet provide a controlled comparison of coding success or patch quality under identical tasks, models, and compute budgets. OpenComputer's immediate value is therefore a self-hosted and recoverable team deployment pattern, rather than proof that it matches Devin across the board.
Architecture: colocation, durable state, and worktree isolation
OpenComputer's architecture can be summarized in three layers:
User request → agent harness → tool call → sandbox execution → Git worktree → per-turn checkpoint
This is a conceptual flow reconstructed from the announcement, not a claim about the project's exact internal call sequence.
1. Agent harness and sandbox share a VM
Conventional cloud sandboxes often allocate an isolated environment at the start of every task, after which a remote agent control plane connects to it over the network. The resulting latency includes instance scheduling, container startup, network establishment, tool-command round trips, and context transfer. OpenComputer places control logic and execution in the same VM, allowing tool calls to avoid cross-service or cross-host transport while reusing warm dependencies, filesystem caches, and process state.
Durability means that the VM is not immediately discarded after one turn or session, allowing instance startup costs to be amortized. This advantage primarily applies to the warm path, however. Initial VM creation, image pulls, and repository initialization remain cold-start costs and should not automatically be assumed to be included in the reported time to first commit.
2. The team is the isolation and scaling unit
OpenComputer uses one VM per team and scales horizontally at the team level rather than allocating a separate sandbox for every session. Each session receives an isolated working directory through a Git worktree, while the repository's object database is shared. This avoids full repository copies and can reduce disk use and initialization time.
A worktree is a working-directory boundary, not a process, network, or privilege boundary. Sessions may still share Git references, hooks, credentials, CPU, memory, and outbound connectivity. Production deployments therefore need unique branch names, restricted concurrent writes, explicit credential scopes, and reliable worktree cleanup.
3. Every turn creates a portable checkpoint
Session files are backed up to the repository after each turn, allowing work to move to another VM and resume. This is easier to operationalize than retaining only a container disk and gives session state a version history. The tradeoff is continuous Git storage, object packing, network transfer, and lock contention. If logs, prompts, or environment variables are committed along with the state, sensitive information may also enter the repository. Production deployments should separate secrets from recoverable state and apply repository access controls, retention policies, and secret scanning.
Performance: 24 seconds validates the startup path, not the whole task
The project measures early responsiveness through time to first commit:
T_first_commit = t_commit_visible − t_task_available
The founder reports 24 seconds for OpenComputer, compared with 53–72 seconds for the alternatives tested. At the two ends of that range, the reported latency is approximately 54.7% and 66.7% lower; expressed differently, the comparison systems take about 2.2–3.0 times as long to produce their first commit.
The result supports the engineering hypothesis that a warm, colocalized VM can shorten the dispatch path. It does not establish that the entire coding task is faster. The announcement does not disclose the task set, model versions, prompts, warm-up procedure, concurrent load, network location, sample count, failure rate, or variance. It also does not separate model inference, repository initialization, and code execution. More importantly, a first commit is not the same as a correct final patch. Test pass rate, task completion, human acceptance, and recovery from long-horizon failures still require separate evaluation.
Engineering trade-offs: speed, cost, and isolation
Benefits and risks of a persistent VM
A persistent instance avoids per-session sandbox creation and can retain dependency caches, but it also enlarges the attack surface and failure radius. Coding agents execute untrusted generated code, so deployments should verify non-root execution, process or container isolation, syscall filtering, outbound allowlists, encrypted disks, patching mechanisms, and least-privilege cloud IAM. Because the harness and sandbox share a machine, their permission boundary must be explicit so that the agent cannot obtain host-level control through a tool interface.
Owning the cloud does not mean data never leaves
Running OpenComputer inside a team's cloud account controls the location of the execution environment. If model calls still traverse external APIs, however, prompts, code fragments, and tool results may leave that account. Operators should inspect model routing, telemetry, crash reporting, package-manager requests, Git remotes, and update services. Sensitive projects may require a private model endpoint or local model, together with a default-deny sandbox egress policy.
Interpreting the 640-session-hour crossover
If S is the monthly aggregate sandbox duration, p_sandbox is the hourly sandbox price, N is the number of sessions, and q_setup is the per-session setup fee, the per-session sandbox cost can be approximated as:
C_E2B = S × p_sandbox + N × q_setup
The always-on deployment can be approximated as:
C_VM = 24 × H × p_vm + C_storage
where H is the number of hours in the month and p_vm is the price of a 4-vCPU instance. Ignoring concurrency limits, egress charges, and plan-specific differences, the approximate crossover is:
S* = (C_VM − N × q_setup) ÷ p_sandbox
The reported 640 session-hours is an empirical result under particular cloud prices, traffic patterns, and session lengths; it should not be transferred directly to other regions. Assuming a 720-hour month and only one active session at a time, 640 session-hours corresponds to roughly 88.9% utilization of one instance. With concurrency, aggregate session-hours can exceed wall-clock hours, so this ratio cannot be interpreted directly as actual occupancy. The relevant production metric is total cost per accepted patch, not sandbox cost per session.
Developer adoption and deployment guidance
- Start with a dedicated team-level instance: use a dedicated 4-vCPU VM with an encrypted persistent volume and scale horizontally from the team queue. Validate concurrency limits against a fixed workload before moving to session-level scheduling.
- Constrain worktree lifecycles: assign a unique branch and directory to every session, remove stale worktrees, restrict concurrent pushes, and define whether recovery uses the latest checkpoint or an explicitly selected version.
- Separate state from secrets: commit only the files needed to resume a task. Store API keys, tokens, and complete environment variables in a dedicated secret manager rather than allowing them to enter Git with session state.
- Validate the sandbox boundary: check for non-privileged containers or microVMs, exposed host sockets, unrestricted cloud metadata access, and default-allow outbound networking.
- Reproduce the startup benchmark: record cold- and warm-start first-commit p50 and p95 while fixing the model, region, repository size, and prompts. Track test pass rate, patch acceptance, recovery success, GPU use, and model-token consumption at the same time.
- Design recovery around consistency: attach version identifiers, task IDs, and consistency markers to each checkpoint so that VM failover does not repeat completed tool calls or overwrite a concurrent branch.
Engineering conclusion
OpenComputer's most important contribution is not the isolated 24-second figure. It changes the state lifecycle of a coding agent from disposable sandboxes to a durable VM with worktree isolation, per-turn checkpoints, and cross-VM recovery. This model can reduce repeated scheduling overhead while giving teams stronger auditability and failure recovery. The current performance and cost figures nevertheless come from the project itself. Until independent task benchmarks, cold-start measurements, and security audits are available, OpenComputer is best treated as a promising self-hosted coding-agent infrastructure pattern rather than a fully validated Devin alternative.
— END —Source: GitHub Projects via Hacker News (2026-11-20)
Tags: #OpenComputer #Cloud Coding Agents #Git Worktree #Agent Sandboxing #Digger
Editorial & Fact-Checking Note: This article is compiled from primary research, official release documentation, and source papers by the ZICQ Newsroom pipeline with automated entity verification and human editorial review. If you notice any technical inaccuracy, please submit a correction via our corrections policy or email our editorial desk directly.
Community Comments