OpenHands: the open-source Devin, with the operations included

What OpenHands actually is

OpenHands is an autonomous development platform rather than a single terminal chat. It can run through a command-line surface, a local web interface, headless automation, an SDK, a hosted service, or infrastructure you operate. The common job is to give an agent a repository task and an execution environment, let it inspect, edit, run commands, and iterate, then return a result for review.

The project was previously known as OpenDevin, which explains why both names still appear in queries and old links. The current name is OpenHands. The conceptual positioning survived the rename: an open platform for the Devin-shaped loop, where the environment and agent runtime are explicit parts of the system rather than hidden behind one chat box.

Calling it an open-source coding agent understates the scope. Aider and OpenCode are easier to understand as daily agent clients. OpenHands is closer to an application platform for autonomous jobs: environments, browser or network-capable tasks, headless execution, and programmable composition. That scope is why it is the plausible open-source Devin comparison and why it is excessive for someone who only wants help editing one function.

What open source covers, exactly

The core OpenHands code and the core agent-server images are MIT licensed in the site's existing source review. That permits inspection, modification, and redistribution of those components under a permissive license. The repository also contains an enterprise directory under a separate enterprise license. A public repository can contain more than one legal boundary, so “OpenHands is MIT” is directionally useful and insufficient for procurement.

An enterprise evaluator should inventory the exact images, directories, services, and SDK packages that will ship. Record the license for each, the source commit, the update owner, and whether any hosted dependency remains. The same exercise belongs in a security review because the component boundary and the trust boundary often align: the part that stores secrets or schedules jobs may not be the part described by the homepage badge.

Open source is valuable even when no fork is planned. It allows an organization to inspect permission handling, trace how commands reach the runtime, audit network integrations, pin a release, and repair a compatibility gap. Forkability is also an obligation. Once a private patch diverges, upstream security fixes and model changes become a merge problem for the team that wanted control.

The Docker sandbox is a boundary, not a force field

OpenHands recommends a Docker sandbox for local execution in the existing documentation coverage. That is a sound default because an autonomous development agent installs dependencies, runs arbitrary commands, writes files, may browse the web, and may talk to external services. A disposable container gives those actions a process and filesystem boundary separate from the host.

The boundary is only as narrow as its configuration. A repository mounted read-write can be changed or deleted. A home directory mounted for convenience exposes far more than the task requires. A token passed into the container can be used with every permission that token carries. Unrestricted outbound network access can move source or secrets outside the host. Docker reduces accidental reach; it does not override capabilities you deliberately hand through the wall.

The repository should enter as a clean, isolated worktree or clone. That gives the agent a disposable branch and gives the reviewer a precise diff. Do not mount a developer's already-dirty checkout and expect the container to preserve provenance. The container can isolate processes while git history still mixes human and agent changes.

OpenHands versus Devin

OpenHands and Devin overlap on autonomous software work. Both can accept a task, operate in an environment, use tools, test changes, and return a reviewable artifact. The durable distinction is who owns the platform. Cognition owns and integrates the managed Devin service. An OpenHands adopter can choose the hosted route or assume control of models, environments, policy, deployment, and operations.

Choose OpenHands when self-hosting is a requirement, the model route must remain under your control, the agent platform needs customization, or source-level inspection is part of policy. Choose Devin when the team wants one vendor to own the environment, account workflow, repository knowledge product, pull-request review surface, billing, and support.

Do not choose OpenHands merely to avoid Devin pricing. The current Devin Pro plan is $20 a month, while a self-hosted platform can consume many times that amount in engineering attention before the first reliable task. Conversely, do not choose Devin merely to avoid setup when code locality, custom policy, or provider independence is a hard requirement. Cheap managed service cannot satisfy a boundary it does not offer.

OpenHands versus a supervised agent workbench

OpenHands is also compared with products that look similar on a screenshot and solve a different problem. An autonomous platform owns the loop and environment for a delegated task. An agent workbench organizes sessions from other agents, keeps their branches and status visible, and lets a person intervene. Both may show terminals, diffs, tasks, and agents. The ownership boundary is the distinction.

Continuum is relevant to this guide because teams searching for an open-source Devin sometimes want neither source code nor a managed autonomous service. They want to run several Claude Code or Codex sessions, keep each in a worktree, see what is waiting, approve a plan from a phone, and understand quota and cost. That is an orchestration requirement. Installing an autonomous platform to solve session visibility is choosing the wrong layer.

The real OpenHands cost

The repository can be free while the system is expensive. An autonomous task consumes inference, a runtime, storage, network, image pulls, logs, and review. A production self-hosted service also needs deployment automation, secret rotation, monitoring, upgrades, rollback, and an owner when provider APIs or model identifiers change.

A local model can remove a per-token cash invoice after hardware exists. It can add latency, lower task reliability, and increase review or retries. A frontier API can finish faster while creating variable spend. The relevant measure is accepted work per dollar and per reviewer hour, not whether inference appears on a cloud bill.

Self-hosting is economical when it satisfies a hard constraint or reaches enough utilization to justify an internal platform. Code locality, model independence, custom policy, and integration with private infrastructure are coherent reasons. “The GitHub repository is free” is not. A small team with no operator should price the hosted OpenHands route and Devin alongside the self-hosted estimate rather than assuming the latter wins.

monthly cost =
  model inference or local hardware allocation
  + runtime compute and storage
  + platform engineering and upgrades
  + security and incident-response allocation
  + human scoping, review, and rework

A safe first deployment

The first OpenHands task should be boring, reversible, and cheap to prove. Do not start by granting a persistent service write access to every repository. The goal is to validate the environment and review path before testing autonomy depth.

Who should choose OpenHands

OpenHands is an unusually credible project when the organization wants to own the autonomous layer. It offers enough surfaces to be a platform rather than a demo, a documented container boundary for local execution, and permissive core code that can be inspected. Those are substantial advantages. They are not the same as a turnkey service.

Choose the smallest system that satisfies the hard requirement. If provider choice and a daily terminal are enough, OpenCode or Aider will be easier to operate. If asynchronous managed delegation is the requirement, Devin may be cheaper in total. If the requirement is a supervised fleet of agents already licensed elsewhere, use a workbench. OpenHands earns its complexity when the autonomous platform itself must belong to you.

Questions people ask

Keep reading