OpenHands

OpenHands is an open-source platform for autonomous AI software development agents, built and maintained by All Hands AI (founded 2024, San Francisco). Where most coding assistants function as autocomplete tools or interactive pair programmers, OpenHands runs a full autonomous loop: the agent plans, writes code, executes shell commands, browses the web, and iterates on its own output inside a Docker-sandboxed environment. It started life as OpenDevin on GitHub in March 2024, accrued 50,000 stars within six months, then rebranded to OpenHands in September 2024 when All Hands AI raised a $5M seed round led by Menlo Ventures. As of May 2026 the project has 72,500+ GitHub stars, 102 releases, and a stable v1.7.0 released May 1, 2026.

The platform is model-agnostic: users supply API keys for Claude, GPT-4o, Gemini, DeepSeek, or any OpenAI-compatible endpoint. Core features include BrowserGym-integrated web automation, Jupyter-based code execution, Git and GitHub/GitLab API integration, multi-agent task delegation, and a REST/WebSocket API for programmatic control. The codebase is 62% Python and 36% TypeScript. Self-hosting is free under MIT license. The cloud product at openhands.dev offers a free individual tier (10 conversations per day) and a Pro tier at $20/month with higher limits and bring-your-own-key support, plus an Enterprise tier with private VPC deployment and SAML/SSO.

What OpenHands actually does in April 2026

OpenHands is not a code-suggestion engine. The agent receives a task, typically a GitHub issue URL, a natural language spec, or a failing test suite, and then handles every step autonomously: reading the repo, writing the fix, running tests, debugging failures, and pushing a commit. It can browse documentation, run arbitrary bash, call external APIs, and spawn sub-agents to parallelize work. The web UI surfaces a live action panel showing every command the agent executes, letting developers observe and interrupt without being forced into an approval loop at every micro-step.

The architecture centers on an event-stream model. Each action (write file, run bash, click browser element) is logged as a structured event the agent can replay or reference. Docker isolation means the agent operates in a clean, ephemeral environment per session, which limits blast radius for bad commands and makes the runs reproducible. SSH access within the container lets the agent handle virtually any Unix toolchain without special integration work.

On the SWE-bench Verified benchmark, OpenHands scored 60.6% baseline and 66.4% with inference-time scaling (April 17, 2025 blog post), making it the top open-source system on that leaderboard at the time. For context: closed commercial systems like Devin scored around 13.9% when first announced in 2024, though both architectures and benchmarks have evolved substantially since. The benchmark scores measure performance on real GitHub issue resolution, not toy tasks, which is why practitioners cite them when choosing between tools.

"~20% of the commits to the OpenHands codebase are now authored or co-authored by OpenHands itself. We are not even close to the point where AI can replace a software engineer. It's great at getting an existing PR over the line." - rbren (Robert Brennan, CEO of All Hands AI), Hacker News, January 17, 2025

The November 2025 cloud redesign introduced a cleaner start page, full-screen mode for the workspace, an expandable prompt input area, and direct git controls (push, pull, PR creation) inside the UI. The same update dropped cloud pricing from 2x Claude API cost to pass-through rates with no markup, and added multi-model support so cloud users are not locked into a single provider.

Where OpenHands sits versus Devin and SWE-Agent

The comparison that matters most is not feature-by-feature but architectural: what kind of developer workflow does each tool serve?

OpenHands vs. Devin (Cognition AI, closed source): Devin is a fully managed SaaS product with no self-hosting option. Pricing starts at $500/month, targeting enterprise engineering teams who want a turnkey agentic developer without managing infrastructure. Devin runs in Cognition's own cloud environment; you have no visibility into the agent's execution loop unless Cognition exposes it. OpenHands inverts this entirely: the code is public, the execution is local or in your own cloud, you can inspect every event in the stream, and you pay only your LLM provider's API rates. For teams that need data sovereignty, auditability, or simply cannot justify $500/month for an early-stage tool, OpenHands is the credible alternative. The tradeoff is that OpenHands requires Docker, API key management, and occasional debugging of the agent's environment setup, none of which Devin users encounter.

OpenHands vs. SWE-Agent (Princeton NLP, open source): SWE-Agent is a research project first and a production tool second. It installs via pip, runs entirely in CLI, and is designed around the Agent-Computer Interface (ACI) abstraction layer built for SWE-bench benchmark tasks. It has no web UI, no multi-agent delegation, no BrowserGym integration, and no enterprise support path. SWE-Agent scores roughly 74% on the SWE-bench Mini configuration, which is competitive with OpenHands on narrowly scoped benchmark tasks. But for teams running it on real repositories with non-standard toolchains, real CI/CD environments, and varying issue complexity, OpenHands's Docker isolation, web UI observability, and active production maintenance give it a significant practical edge. SWE-Agent is the right choice for researchers benchmarking agent architectures; OpenHands is the right choice for engineering teams that want to ship code.

Two other tools are worth placing in context. Aider is an interactive CLI pair programmer that makes every change a reviewed Git diff, using a repo-map strategy to compress large codebases into token-efficient summaries. You stay in control at every step. Cursor is a VS Code fork with deep inline AI integration, best for developers who want AI assistance inside their editor rather than a separate autonomous agent. OpenHands sits above both in autonomy and scope, at the cost of more infrastructure and more variance in outcomes.

What the agent loop reality looks like

The most reliable OpenHands workflow, documented across HN threads, Medium posts, and the project's own blog, is PR finishing: the developer opens a GitHub PR, shares the URL with the agent, and OpenHands clones the repo, reads failing CI checks, fixes the issues, and pushes commits. This is a scoped, well-defined task with clear success criteria (passing tests), which is exactly where autonomous agents perform best.

Batch microservice upgrades are another documented success pattern. One Medium author ran OpenHands across a list of microservices for a dependency upgrade, paying roughly $3 per service and getting the work done in background while doing other tasks. Not zero cost, but potentially faster than doing it manually. The key qualifier is that each service had good tests; without passing tests as a success signal, the agent has no reliable stopping criterion and will iterate past diminishing returns.

"I don't see how the secrets won't appear in the chat or the terminal. OpenHands doesn't have proper support for secrets now." - M. Chechulin, Medium, 2025 (note: secrets support was subsequently added in v0.42)

Where the loop breaks down: vague or open-ended tasks. Asking the agent to "add dark mode to this app" without a spec, component inventory, or defined acceptance criteria leads to planning drift, where the agent generates plausible-looking code that doesn't match what you wanted, then loops trying to fix test failures it introduced. One Hacker News commenter described catching the agent making a subtle edit error while adding license headers across multiple files, silently removing a final sentence in several source files. These quiet mistakes are harder to catch than obvious failures because they pass automated tests.

Cost unpredictability is the other reality check. Trivial single-file fixes cost $0.05 to $0.30 in LLM API charges. Real bug fixes with multiple iterations run $0.50 to $3. Complex multi-hour sessions resolving ambiguous issues can hit $10 to $30. There is no built-in hard cost cap in the self-hosted version, so a looping agent on a misconfigured or ambiguous task can consume significant API budget before you notice.

The prompt injection security vulnerability disclosed by researcher Johann Rehberger on August 9, 2025 is worth noting for enterprise evaluations. The disclosed attack allowed zero-click exfiltration of a user's GITHUB_TOKEN and chat history via a maliciously crafted image URL. All Hands AI was notified March 13, 2025; the public disclosure came 148 days later. Teams integrating OpenHands into automated pipelines that process untrusted content should review the current patch status before deploying.

Tools that pair well with OpenHands in practice: GitHub Copilot for inline suggestions during the human review phase, and Cline for developers who want a VS Code-integrated agent experience that sits between Aider's interactive model and OpenHands's full autonomy.

Who OpenHands is built for

OpenHands delivers the most value to backend and ML engineers who are comfortable with Docker, have their own LLM API keys, and work from well-specified GitHub issues. Teams with strong issue hygiene, good test coverage, and defined acceptance criteria will see the highest success rates. The enterprise tier targets organizations that need a self-hosted, auditable agent platform with RBAC, SSO, and Kubernetes deployment, use cases where paying Cognition $500/month for Devin is not viable and running a commercial SaaS is blocked by data governance requirements.

Researchers are a major user segment. The project is the reference platform for several academic benchmarks including SWE-bench Verified, Multi-SWE-Bench, and LiveSWEBench. The ICLR 2025 paper (accepted February 2025) describes the architecture formally. If you are evaluating agent architectures, OpenHands is the most capable open-source system to benchmark against.

Individual developers who want to experiment with autonomous coding agents can start on the free cloud tier, which allows 10 conversations per day using the Minimax model, no API key required. This is a reasonable evaluation path before committing to Docker setup and API costs.

What OpenHands is not

OpenHands is not a human-in-the-loop tool. If you want to review every change before it hits the codebase, Aider is the better fit: every action is a diff, every commit requires approval, and the tool is explicitly designed around that interaction model. OpenHands will run autonomously and push commits; that is the design, not a bug.

It is not a drop-in replacement for a developer on complex, open-ended product features. The founder said it directly: the agent is not close to replacing a software engineer. It excels at well-defined, test-verifiable tasks. Ambiguous product work, cross-cutting architectural decisions, and anything requiring sustained judgment across a long time horizon are outside its reliable operating envelope in 2026.

It is not suitable for environments without Docker. The sandboxed execution model is core to how the agent operates, not an optional deployment choice. Teams on restricted infrastructure without container support should plan for that setup cost before evaluating the tool.

Finally, it is not a zero-cost tool if you use it at scale. "Free and open source" refers to the software license and the lack of a vendor subscription. You still pay your LLM provider. On complex tasks, that cost is real and variable. Budget accordingly.