OpenHands

OpenHands (formerly OpenDevin) is the leading open-source autonomous software engineering agent, built and maintained by All Hands AI. What started in early 2024 as a community-driven attempt to replicate Devin's capabilities has grown into a serious platform with 65,000+ GitHub stars and competitive scores on the SWE-bench coding benchmark. OpenHands runs every task inside a sandboxed Docker container, giving the agent real access to a browser, terminal, and file editor. It works with any major language model provider, including Claude Opus 4.7, GPT-5, and Gemini 3, so you're never locked into one vendor. The self-hosted path is completely free; All Hands AI also offers a managed cloud option for teams that want the capability without the infrastructure overhead.

When Devin launched in March 2024 with a $500/month price tag and a polished demo of an AI agent writing real software, the obvious question was: can the open-source community build the same thing? The answer arrived fast. OpenHands, initially called OpenDevin, started as exactly that attempt and has since grown into the most credible open-source autonomous coding agent available. With more than 65,000 GitHub stars and competitive SWE-bench scores, it’s no longer just a scrappy clone. It’s the tool that makes you seriously question whether you need to pay Devin’s rates at all.

Quick verdict

OpenHands is the right call for any engineering team that wants autonomous, PR-level coding capability without a proprietary cloud subscription. The UX won’t win any awards and the Docker setup takes an afternoon the first time, but the actual agent quality is genuinely competitive with the paid alternatives. If you can run Docker and supply your own model API key, you get a tool that can handle real engineering tasks at zero platform cost.

What is OpenHands, exactly?

The name OpenHands doesn’t tell the whole story. To understand why this project matters, you need the origin.

In early 2024, Cognition released Devin, billed as the first “AI software engineer.” The demos were impressive enough to generate enormous press coverage and kick off a wave of speculation about autonomous coding agents. Within weeks, a group of researchers and engineers launched OpenDevin on GitHub as an explicit attempt to build the same thing in the open. The project went viral. It hit tens of thousands of stars in its first month.

All Hands AI formed around the project in 2024, taking the community codebase and building a real company on top of it. They rebranded from OpenDevin to OpenHands, signaling that the tool had grown past its “Devin clone” origins into something with its own architectural identity.

The core innovation is the CodeAct architecture. Where some agents produce a plan and then ask a human to approve each step, OpenHands translates the model’s reasoning directly into executable shell actions. The agent thinks, then acts. It runs real commands in a sandboxed Docker container with genuine access to a file system, a terminal, and a headless browser. There’s no simulation layer between the model’s decisions and the environment.

The SWE-bench story is central to why the tool gets taken seriously. SWE-bench is the main industry benchmark for autonomous software engineering: it presents agents with real GitHub issues from popular Python projects and scores them on whether the agent produces a passing patch. OpenHands has ranked at or near the top of the open-source leaderboard across multiple evaluation rounds, and has traded positions with Devin on the overall leaderboard. Those numbers aren’t everything, but they’re not nothing either. They confirm the agent is doing real engineering work, not parlor tricks.

The features that earn its leaderboard ranking

Sandboxed Docker execution environment

Every task OpenHands runs lives inside its own Docker container. The agent gets a clean environment with a real shell, a real file system, and a real browser. This matters for two reasons.

First, it’s safe. The agent can’t accidentally delete your home directory or push to the wrong remote. When a task is done, the container is gone. Second, it’s reproducible. The environment is deterministic, which means you can debug what the agent did by examining exactly what happened in the container. This is a major practical advantage over agents that operate directly on your machine or in opaque cloud sandboxes you can’t inspect.

The Docker requirement is also the main friction point on Windows, but it’s a reasonable tradeoff for the safety guarantees it provides.

Multi-agent and microagent architecture

OpenHands supports a multi-agent model where a primary orchestrator agent can delegate to specialized subagents. The browser microagent handles web research and documentation lookups. There are dedicated agents for code review, summarization, and long-horizon task decomposition. This isn’t purely theoretical: it’s how the system handles tasks that require both coding work and research, like implementing a feature while checking the official API docs for the library you’re using.

The microagent system also lets you define custom agents in code and drop them into the pipeline. If your organization has specific conventions or internal tools, you can build a microagent that knows about them.

Browser, shell, and file tools

The agent has three core tool categories, and having all three in the same environment is what makes autonomous tasks actually work.

Shell access means it can run tests, install packages, execute build commands, and verify its own changes. File access means it reads and edits code with context from the full repository, not just pasted snippets. Browser access means it can look things up, read documentation, check a live URL, or even interact with a web interface as part of a task.

Most coding agents have some version of these tools. What OpenHands gets right is the integration: they share the same container, the same environment variables, and the same working directory. The agent doesn’t have to context-switch between disconnected tool environments.

Bring your own model with broad provider support

OpenHands uses LiteLLM for model routing, which means it connects to essentially any frontier model provider. Claude Opus 4.7 and Sonnet 4.6 work well and are the most commonly recommended choices in the community for complex tasks. GPT-5, Gemini 3, Mistral, and locally-hosted models through Ollama are all supported.

The practical implication is that you control your model costs and vendor relationships. If Anthropic raises prices, you switch providers. If you need to run fully air-gapped, you point OpenHands at a local Ollama instance. There’s no lock-in to a specific model, which is a meaningful contrast with proprietary agents that are built around one provider’s API.

CLI, web, and headless modes

OpenHands ships three interaction modes, and each serves a different use case.

The web UI gives you a chat-style interface with a live view of what the agent is doing in its container. It’s comparable to the Devin experience conceptually, though visually simpler. The CLI mode is closer to working with Claude Code or Codex CLI: you interact with the agent from your terminal, which appeals to developers who live in the command line.

Headless mode is where things get interesting for automation. You can invoke OpenHands with a task description and a repo pointer, and it’ll run the task, open a PR, and exit. This is what you use in CI pipelines, scheduled jobs, or ticket-driven automation. It’s also how teams integrate OpenHands with GitHub issues: a new issue triggers a headless run, and the agent opens a draft PR without a human in the loop at all.

Pricing

The self-hosted version of OpenHands is free under the MIT license. You download it, run it with Docker, plug in your own model API keys, and that’s it. The platform costs nothing. Your only ongoing expense is the API usage on whatever model you’re running.

For a developer running a few dozen tasks a week with Claude Sonnet 4.6, real-world model costs are typically in the $20 to $60/month range depending on task complexity. For heavier usage or more expensive models, that number climbs, but you’re still looking at a fraction of what a Devin subscription costs.

All Hands AI offers a managed cloud product at app.all-hands.dev. A free trial is available via GitHub sign-in. The cloud version adds managed infrastructure, multi-user support, RBAC, usage controls, budget limits, and integrations with GitHub, GitLab, Bitbucket, Slack, Jira, and Linear. Exact pricing for paid cloud tiers isn’t listed publicly and requires a conversation with the team. Based on the feature set and positioning, it’s targeting engineering teams and enterprises rather than individual developers.

Self-hosted is the right choice for solo developers and small teams comfortable with Docker. The cloud option makes sense for larger teams that want the capability without the infrastructure management, or that need the enterprise features like audit logging and RBAC.

There’s no meaningful lock-in with either path. The agent is the same codebase whether you’re running it locally or through their cloud.

Where OpenHands wins and where it doesn’t

OpenHands wins on the fundamentals that matter most to engineers: capability, transparency, and cost. The agent genuinely handles real tasks. You can read the code to understand exactly how it works. You can run it for essentially nothing if you’re careful about model usage.

The honesty is that it doesn’t match the UX polish of Devin or Lovable or similar products built by teams that have invested heavily in product design. The web interface is functional but it has rough edges. Progress indicators during long tasks are sparse. Error messages when things go wrong are sometimes cryptic. The documentation is thorough in some areas and thin in others, especially for less common configurations.

Long tasks are also where OpenHands is most likely to disappoint. A task that takes twenty steps and an hour of wall-clock time has a real chance of going sideways partway through, either by losing context or making a decision you’d have caught if you’d been watching. This is an agent architecture problem, not specific to OpenHands, but the proprietary tools have invested more in their monitoring and recovery UX.

Where OpenHands clearly wins is on data privacy. If your code can’t leave your network, your choices are limited. OpenHands running on your own hardware with a locally-hosted model is one of the only ways to get autonomous coding capability with a genuine air-gap guarantee.

Who OpenHands is built for

The clearest fit for OpenHands is an engineer who knows what they want the agent to do, is comfortable reviewing the resulting PR, and doesn’t want to pay a per-seat subscription to do it. That profile covers most self-employed developers, small engineering teams, and anyone working on open-source projects.

Security-conscious teams at larger companies are a strong secondary audience. If your security posture means no external code transfer, OpenHands with a self-hosted model is one of the few viable options. The Docker sandbox and full audit trail help with compliance conversations.

DevOps and platform engineers get real value from the headless mode. Automating repetitive maintenance tasks like dependency upgrades, linting fixes, test generation, and documentation updates is where the tool earns its place without requiring the agent to handle ambiguous product decisions.

It’s less well-suited for non-technical users who want a polished product experience, or for teams that need a tool their non-engineering stakeholders can operate directly. For that profile, Devin is the better fit despite the cost.

OpenHands vs the alternatives

OpenHands vs Devin

This is the main comparison people want. Devin starts at $500/month with no free tier. OpenHands is free to self-host. On SWE-bench, they’re close enough that the difference depends on which evaluation run you’re looking at and which model you’re using with OpenHands.

Where Devin earns its price is UX and integrations. The Devin interface is meaningfully better designed, and the Slack integration makes it accessible to non-engineers. If your organization needs an autonomous agent that non-developers can assign tasks to and review results from, Devin’s product investment pays off. If your users are all engineers comfortable with CLIs and PR review, the UX gap doesn’t justify a $500/month delta.

OpenHands vs Cline

Cline is a VS Code extension that gives you an agentic coding assistant in your editor. It’s excellent at context-aware in-editor assistance and it’s also open-source. The difference is scope: Cline is built for developer-in-the-loop workflows where you’re actively collaborating with the agent. OpenHands is built for autonomous, longer-horizon tasks where the agent works independently and surfaces a result.

They’re genuinely complementary. Many developers use Cline for interactive coding sessions and OpenHands for batch tasks that they want to run overnight or in CI.

OpenHands vs Claude Code

Claude Code is Anthropic’s own CLI agent, deeply integrated with Claude models. It’s excellent for exploratory coding and interactive refactoring, and it has first-party access to Claude’s capabilities. Claude Code doesn’t sandbox execution in a Docker container by default, which means it operates more directly in your environment, with both the speed and risk that implies.

OpenHands is the better fit when you want true autonomous execution with isolation, multi-agent delegation, and model flexibility. Claude Code is the better fit when you want fast, interactive agentic coding with the best possible Claude model integration and you trust the tool to operate in your working directory.

For a broader comparison of autonomous coding tools, see the best AI agents for coding guide and the Devin alternatives roundup.

Getting started

Running OpenHands locally takes about fifteen minutes assuming Docker is already installed.

Pull the latest image and run it with a single Docker command. You’ll need to pass your model provider API key as an environment variable and specify which model you want to use. The project’s README at github.com/All-Hands-AI/OpenHands has the exact command kept up to date with the current release.

Once the container is running, open your browser to http://localhost:3000. You’ll see the web interface with a chat input at the top. Start with a well-defined task on a small repository: something like “write a test for the parse_config function in src/config.py” rather than “add the user authentication feature.” Narrow scope gives the agent better footing and helps you calibrate what it can handle before you throw something complex at it.

For CLI usage, the openhands Python package is installable via pip and supports non-interactive mode with --task and --repo flags. That’s the path to CI integration. The docs at docs.openhands.dev cover both paths in detail.

The bottom line

OpenHands is the most capable open-source autonomous coding agent available, and it’s not particularly close. It has earned its leaderboard position through real engineering, not just benchmark optimization. The self-hosted path costs nothing beyond model API fees, runs your code on your own infrastructure, and supports every major frontier model.

The honest caveat is that it’s still a developer tool for developers. The setup requires Docker comfort, the UX has rough edges, and long tasks sometimes need human supervision to stay on track. If you’re willing to accept that tradeoff, you get something genuinely powerful without paying a premium subscription to a proprietary service.

For the right user profile, it’s one of the best deals in the AI tools space right now.

Key features

• Sandboxed Docker execution with full browser, shell, and file access
• CodeAct architecture that translates agent decisions into real shell commands
• Bring-your-own-model support for Claude, GPT-5, Gemini, and any LiteLLM provider
• Multi-agent orchestration with specialized microagents for browsing and research
• Web UI, CLI, and headless modes for interactive and automated workflows
• GitHub and GitLab integration for autonomous PR creation and review
• Self-hosted or managed cloud deployment with RBAC and audit logging

Pros and cons

Who is OpenHands for?

• Solo developers who want autonomous PR-driven coding without a $500/month subscription
• Security-conscious teams that cannot send source code to a third-party cloud
• DevOps and platform engineers automating repetitive maintenance, migrations, and test coverage
• Researchers and AI engineers who need a hackable autonomous agent baseline

Alternatives to OpenHands

If OpenHands isn't quite the right fit, the closest alternatives are devin , cline , and claude-code . See our full OpenHands alternatives page for side-by-side comparisons.