Tools

OpenComputer in Practice: A Self-Hosted Coding Agent

OpenComputer runs coding agents inside a company's own AWS, GCP, or Azure account. Its persistent VMs, Git worktrees, and portable session state could give enterprises more control, but independent benchmarks and operational costs remain unclear.

Font size

OpenComputer deploys coding agents into a company's own AWS, GCP, or Azure account. The project says its agent produced its first code commit in 24 seconds. Here is a look at its persistent VM, session isolation, and task-migration design.

OpenComputer is an open-source cloud coding agent built for teams. Companies can place its runtime in their own AWS, GCP, or Azure accounts rather than handing source code, credentials, and tasks to a third-party hosting platform.

Project author Utpal described the architecture on Hacker News. OpenComputer runs the agent harness and sandbox together on the same persistent VM. In the project's published benchmark, the agent made its first code commit in 24 seconds, compared with 53 to 72 seconds for other candidates.

The 24-second figure should not be read as proof of a “Devin killer.” The more important trend is that the execution environment for AI agents is becoming an engineering asset that enterprises can own, audit, and move between platforms.

24 Seconds Is More Than a Benchmark Number

The “first commit in 24 seconds” metric measures the time from an agent receiving a task to producing its first code commit. It does not represent the time needed to finish the entire task, nor does it measure engineering productivity across the board.

The metric is still useful. A typical coding-agent work cycle involves reading a repository, preparing the environment, calling a model, executing commands, modifying files, running tests, and committing changes. Before that first commit, the agent spends substantial time setting up its environment.

OpenComputer places the agent harness and sandbox on the same durable VM rather than separating the control layer from the execution environment. According to the project author, the official benchmark produced its first commit in 24 seconds, more than twice as fast as the other candidates, which took 53 to 72 seconds.

One caveat is essential: these are project-reported figures that have not yet been independently reproduced. The choice of tasks, whether the environment was warmed up, machine specifications, model versions, and where the timer starts can all materially affect the result.

Still, the 24-second result is consistent with the system's design. A persistent VM can retain its file system, process state, and tool caches. The time savings may cover more than booting a machine; they may also eliminate repeated dependency installation, Git repository initialization, and workspace restoration.

For coding agents, those delays are not background noise. They consume inference turns, slow the feedback loop, and increase the failure rate caused by timeouts and interruptions.

Self-Hosting Is Not Primarily About Saving Money

When enterprises consider coding agents, cost is usually the first concern. OpenComputer starts from a more direct premise: code, credentials, and tasks run inside the company's own cloud account.

This differs fundamentally from a hosted model such as Devin. Whether code leaves the enterprise network, who holds cloud credentials, which resources the agent can access, and how each tool call is logged all become architectural decisions controlled by the enterprise.

The benefits extend beyond lower hosting fees. Self-hosting provides several additional control boundaries:

  • IAM permissions can be tightened by team and network environment;
  • Egress traffic can pass through corporate proxies and audit gateways;
  • Source code and execution logs can remain in enterprise-controlled storage;
  • Sandbox lifecycles can fit into existing Terraform, Pulumi, or Kubernetes operations;
  • Data-residency requirements can map directly to regional policies in AWS, GCP, or Azure.

Self-hosting also means taking responsibility back. Network configuration, patching, image builds, key rotation, cost control, and log retention can no longer be left entirely to a platform vendor.

One VM Per Team, Git for Session Isolation

OpenComputer uses one VM per team and can add capacity through horizontal scaling. Individual sessions are isolated with Git worktrees.

That is a practical trade-off.

A team-level VM provides a shared foundation. Language runtimes, dependency caches, container images, and system tools can be reused, so multiple agent sessions do not each need to begin with an empty environment.

Git worktrees allow multiple working directories for the same repository. Each session gets its own branch and file changes without requiring frequent stashing, branch switching, and workspace restoration. For teams handling several issues in parallel, this is considerably more reliable than having agents compete over one checkout.

Horizontal scaling is also straightforward: replicate the team-level VM and distribute the load. However, these are not stateless services. Caches, credentials, and temporary files on a VM may all contain state, so scaling out also requires session routing, state synchronization, and cleanup policies.

The practical value of a persistent environment for a coding agent goes beyond preserving code. It also preserves the tacit knowledge encoded in a manually configured development setup, such as internal CLIs, build scripts, private dependency sources, and debugging configurations.

If an agent starts from scratch every time, the team must continually rebuild those conditions. A persistent VM acts as a reusable engineering workbench.

Per-Turn Persistence Makes Agent Tasks Portable

Another key OpenComputer design choice is that session files are backed up to the code repository after every conversation turn. A task can therefore be moved to another VM and resumed there.

This addresses a practical problem in agent engineering. Tasks may run for minutes, hours, or days and may encounter instance restarts, model rate limits, permission approvals, or human handoffs. If execution state exists only in the memory of one agent process, a single failure can erase the entire context.

Persisting session files after each turn turns state into a repository asset that can be versioned, backed up, and transferred. During a migration, the model does not need to reread dozens of conversation turns to reconstruct the task.

In practice, this kind of design requires at least two operations: backing up the session file and locating the matching repository, branch, and worktree in the new environment. A production-ready migration process must also handle working directories, process state, uncommitted changes, and environment variables.

The project README gives the following installation instructions:

git clone https://github.com/diggerhq/opencomputer.git
cd opencomputer

The repository also provides a command for starting it locally:

make run

Dependencies and configuration options may change between versions, so deployments should follow the current README and Makefile in the repository.

What Still Needs Validation as an Open-Source Devin Alternative

The claim of a “first commit in 24 seconds” does not establish that OpenComputer delivers twice Devin's overall coding efficiency. The former is a single measure of startup-to-first-commit time. The latter requires complete task-success rates, test pass rates, human rework, and total cost.

At a minimum, evaluating OpenComputer as a Devin replacement would involve answering the following questions:

  1. Benchmark methodology: How large is the task set? Is it public? Are the tasks real issues or synthetic? Does the timing include environment preparation?
  2. Sandbox security: How broadly can the agent execute commands? Is sandbox escape possible? How is outbound network access restricted? Are credentials granted minimum necessary permissions?
  3. Model cost: Which models and how many tokens were used to achieve the 24-second result? What is the model cost per completed issue?
  4. Task-success rate: A first commit is only an intermediate state. Does the final result pass tests and merge cleanly, or does it require substantial human correction?
  5. Persistent isolation: Do Git worktrees actually prevent file, network, and credential cross-contamination between sessions?
  6. Maintenance activity: Is the project actively maintained? How quickly are cloud-provider API changes addressed?
  7. Failure recovery: Are sessions restored completely after VM restarts, process crashes, or model rate limits?
  8. Operational burden: How much staff effort is required for image upgrades, key rotation, workspace cleanup, and capacity planning?

Model cost is the factor most likely to be overlooked. Faster agent execution does not necessarily mean fewer model calls. If the initial phase involves repeated exploration, reading large portions of the repository, and generating multiple patches, the bill may still be substantial.

Editor's Take

OpenComputer's main significance is not that it reproduces Devin in 24 seconds. It turns the agent execution environment from a black box inside a platform into an engineering asset that enterprises can own and migrate. Saving session state after every turn and restoring tasks across VMs addresses long-term production requirements more directly than a one-time benchmark does.

Enterprises are likely to adopt it first as an infrastructure layer for self-hosted agents rather than immediately replacing an established managed product. The best early candidates are internal repositories with clear permission boundaries, repeatable environment templates, and tasks that require frequent human intervention.

The available material does not include independent benchmark validation. The 24-second figure comes from the project team, while the sample size, model cost, and task-success rate remain unknown. Until third parties reproduce those results, OpenComputer should not be presented as an open-source replacement for Devin.

What is different now is that open-source projects are no longer releasing only model weights or workflow frameworks; they are beginning to deliver complete agent runtimes. Competition will depend not just on model capability, but also on who can give enterprises the confidence to migrate tasks, control permissions, and retain their own engineering context.

Sources

Source: https://github.com/diggerhq/opencomputer