OpenHands

Autonomous AI coding agents, honestly reviewed. What you get when you run your own software engineer at the cost of LLM tokens.

TL;DR

• What it is: Open-source (MIT core) autonomous AI coding agent — think Devin, but running on your own infrastructure with whatever LLM you choose [4][5].
• Who it’s for: Developers and engineering teams who want a full agentic code-write-test-commit loop without paying $500/month for Devin or trusting a black-box SaaS with their codebase [3][4].
• Cost savings: Devin runs $500/month. OpenHands self-hosted costs you API tokens and a machine to run Docker on — effectively $0 in platform fees, just model inference costs [3][4].
• Key strength: Model-agnostic, genuinely autonomous loop (writes code, runs terminal commands, browses the web, opens GitHub PRs) inside a sandboxed Docker environment. 77.6 score on SWE-Bench, resolves 87% of bug tickets same-day per the team’s claim [4][website].
• Key weakness: Performance is only as good as the LLM you connect. Self-hosting requires real technical setup. The agent occasionally goes off in the wrong direction and burns tokens before you can intervene — though Planning Mode (beta, March 2026) is designed to fix exactly that [1][4].

---

What is OpenHands

OpenHands is an open-source platform for running autonomous AI software agents. You give it a task — “fix the failing test in this file” or “implement the feature described in this GitHub issue” — and it spins up a sandboxed environment, writes code, executes shell commands, browses the web if needed, and iterates until the task is done or it gets stuck [4][5].

The project started as OpenDevin in early 2024, a community-driven response to Cognition’s $500/month Devin announcement. It rebranded to OpenHands in late 2024 under the All-Hands-AI organization, raised an $18.8M Series A, and has grown to 69,000+ GitHub stars with 490+ contributors [4][2]. The ICLR 2025 paper that formally describes the platform had already accumulated 2,000+ contributions from 186 contributors in under six months of development — it’s a fast-moving project with serious research backing [5].

There are four ways to use it. The CLI is the closest thing to Claude Code or Codex — familiar terminal experience, connect your own API key, go. The Local GUI is a Docker-based web interface where you can watch the agent work in real time. OpenHands Cloud is their hosted SaaS with a free tier (powered by the Minimax model), plus Slack, Jira, and Linear integrations, RBAC, and multi-user support. Enterprise is self-hosted OpenHands Cloud inside your own VPC via Kubernetes, with a commercial license required after the first month [README].

The core openhands and agent-server Docker images are fully MIT-licensed. The enterprise directory in the repository has a separate license. That distinction matters when you’re deciding how deep to go.

---

Why people choose it over Devin, Cursor, and GitHub Copilot

The reviews converge on a clear narrative: OpenHands wins on autonomy, cost, and ownership, and loses on reliability and setup friction.

Versus Devin. This is the comparison OpenHands was practically born to win. Devin’s $500/month price tag was the punchline that launched the original OpenDevin project, and the math remains punishing: a team running five concurrent agents on Devin spends $2,500/month before writing a line of code [3]. OpenHands delivers the same conceptual capability — plan, code, test, PR — for the cost of the underlying LLM API calls. One blogger put it plainly: “As I followed the Devin saga and their ridiculous $500/month price I was excited to try OpenHands as it solves the same use-case of using a coding agent to accelerate your dev work.” [3]

Versus Cursor / GitHub Copilot. These are coding assistants, not agents. Cursor makes you a faster writer; OpenHands tries to be the writer. The vibecoding.app review [4] makes the distinction explicit: “This is not autocomplete. It is a full agent that can clone a repo, set up dependencies, write a feature, run tests, and commit the result.” For developers who want to delegate entire tickets rather than just tab-complete lines, that difference is what matters.

On the model-agnostic angle. One of the more defensible long-term reasons to choose OpenHands is vendor independence. The comparateur-ia.com review [2] names this directly as a structural advantage for engineering teams: “Multi-LLM support avoids vendor lock-in, which is crucial for engineering teams that want to remain free in their technology choices.” You can run Claude 4.5 Sonnet today and swap to Gemini or a local Llama variant tomorrow without changing your workflow. The vibecoding.app review [4] confirms from hands-on use that Claude 4.5 Sonnet handles complex multi-step tasks better than alternatives, GPT-4o is solid for straightforward work, and smaller local models struggle with the reasoning depth the agent requires.

On the benchmark claim. The 87% same-day bug ticket resolution figure appears on the OpenHands homepage and in the Comparateur-IA review [2], sourced from a company testimonial. The SWE-Bench score of 77.6 [README] is a published benchmark result linked from the repo. Both are credible data points, but treat the 87% figure as a marketing number — it reflects a specific company’s (Flextract’s) deployment, not a universal result. Your mileage will vary with the LLM you choose and how well-scoped your issues are [4].

---

Features: what it actually does

The agentic loop:

• Write and edit files, execute shell commands, browse the web, call APIs — all inside a sandboxed Docker container [4][5]
• Full action log so you can review every step the agent took [4]
• GitHub integration: point it at an issue URL, it reads context, branches, writes a fix, runs tests, and opens a PR [4]
• GitLab integration available; Slack, Jira, and Linear integrations on the Cloud tier [README][website]

Planning Mode (beta as of March 2026): The newest and most significant UX improvement. Instead of immediately executing, the agent creates a plan and asks for approval before writing a single line. This directly addresses the most common complaint — agents charging off in the wrong direction and making a mess you have to undo [4]. It’s still beta and the vibecoding.app review [4] describes it as “still early,” but it’s the right architectural direction.

Model support:

• Works with any LLM via OpenRouter, direct API keys, or local models via Ollama [4][3]
• You can switch models per task or per session [3]
• No dependency on any single provider — important if you’re processing proprietary code [2]

Deployment modes:

• CLI (no Docker required for the agent itself) [README]
• Local GUI (Docker, web interface, REST API, single-page React app) [README]
• OpenHands Cloud (hosted, free tier with Minimax, paid tiers for enterprise features) [README]
• Enterprise self-hosted via Kubernetes (commercial license) [README]

SDK and extensibility:

• Python SDK for embedding OpenHands into your own apps or orchestrating multiple agents [README][website]
• REST API included in the local GUI deployment [README]
• Chrome extension available [README]
• Evaluation infrastructure published separately for benchmarking [README][5]

Enterprise features (Cloud and Enterprise tiers only):

• Slack, Jira, Linear integrations [README]
• Multi-user support, RBAC, permissions [README]
• Conversation sharing and collaboration [README]
• These are not available in the MIT self-hosted version

---

Pricing: SaaS vs self-hosted math

OpenHands Cloud:

• Free: available using the Minimax model, sign in with GitHub or GitLab [README]
• Paid tiers: not published at the time of this review — contact sales for Cloud and Enterprise pricing

Self-hosted (MIT core):

• Software license: $0 [README]
• Infrastructure: a machine with Docker and enough RAM to run the containers ($5–20/month VPS, or your existing hardware)
• LLM costs: your API key charges. Running Claude 4.5 Sonnet on complex tasks will burn tokens meaningfully — one Medium reviewer [1] reported approximately $25 in API costs across trials and experiments

Devin for comparison:

• $500/month per seat [3]
• Annual commitment available; pricing per user, not per task

Cursor (closest commercial alternative for many teams):

• Free tier, Pro at $20/month, Business at $40/month per user
• These are coding assistant tiers, not autonomous agent pricing

Concrete math for a developer team:

Say you’re a team of three engineers delegating about 40 bug tickets per month to an AI agent. On Devin, that’s $1,500/month ($500 × 3 seats). On OpenHands with Claude 4.5 Sonnet, the cost depends entirely on average tokens-per-task — a well-scoped bug ticket might run $0.50–$2.00 in API costs, putting 40 tickets at $20–$80/month total. Self-hosted infrastructure on Hetzner adds another $10–20/month.

Annual comparison: Devin ≈ $18,000/year for 3 seats. OpenHands ≈ $400–$1,200/year in API costs plus a few hours of setup. The gap is large enough that the calculus is obvious for any team that’s comfortable running Docker.

The caveat the comparateur-ia.com review [2] correctly flags: the local open-source version requires an external LLM API key. There is no free inference included — you’re trading the platform subscription for direct API costs.

---

Deployment reality check

The honest deployment picture from the reviews:

What works smoothly:

• Docker deployment is the primary path and it’s reasonably well-documented [3][4]
• GitHub integration with a personal access token is described as “relatively easy” to set up — provide the token, select a repository, start a session [1]
• The web interface gives you real-time visibility into what the agent is doing, which is important for catching runaway sessions before they burn tokens [1]

What can go wrong:

The Medium reviewer [1] — a senior software developer who ran OpenHands on real production microservices — documents the friction honestly. The agent sometimes tries to push changes to the default branch instead of a feature branch. Credential handling in Git operations can go wrong. Pulling PR comments or checking CI status programmatically didn’t work reliably even when given the right CLI tools. The reviewer’s recommendation: “When your task is fulfilled — it is easier to start a new session for a next task. Otherwise, the LLM can get confused and mix up the requirements of all tasks in the session.” [1]

The vibecoding.app reviewer [4] found that task scoping matters enormously: “Clear, specific issues get good results. Vague feature requests tend to produce code that needs significant rework.”

ARM Mac users: The initial release had sandbox launch issues on ARM Mac machines. The Medium reviewer [1] confirms the latest version handles this, with the exception of the optional security analyzer, which can simply be disabled.

Local LLM setup: You can connect OpenHands to Ollama for fully local inference — no API costs, no data leaving your machine. But Ollama is a separate setup that you handle yourself; OpenHands doesn’t bundle it. Smaller local models tend to struggle with the reasoning depth the agent requires for non-trivial tasks [3][4].

Realistic time estimate for a technical developer: 30–60 minutes to a working local instance. For a less technical user following a guide: 2–4 hours, and you’ll need someone to handle Docker if you haven’t touched it before.

---

Pros and cons

Pros

• MIT license on the core. The core openhands and agent-server images are fully MIT-licensed — self-host, fork, embed without legal friction [4][README]. This is a real differentiator from Devin, which is fully closed.
• Full agentic loop, not just autocomplete. Code writing, terminal execution, web browsing, API calls, GitHub PR creation — all in one agent, in a sandboxed environment [4][5].
• Model-agnostic architecture. Swap LLMs without changing your workflow. Works with any provider or local models via Ollama [4][2][3]. No single-vendor dependency.
• 77.6 SWE-Bench score — a published, peer-reviewed benchmark result, not just marketing copy [README][5].
• ICLR 2025 paper — unusual for an open-source tool to have academic peer review, and it signals the team takes evaluation seriously [5].
• Planning Mode (beta) addresses the biggest UX problem with autonomous agents: charging off in the wrong direction before you can review the plan [4].
• Strong community velocity. 69,000+ GitHub stars, 490+ contributors, $18.8M raised, v1.6.0 shipping in March 2026 with Kubernetes support [4][2][README]. Not a hobby project.
• Multiple deployment modes from CLI to GUI to Cloud to Enterprise Kubernetes — meets teams where they are [README].

Cons

• Performance is a function of the LLM you choose. The agent itself is only as capable as the model behind it. Local models often can’t handle complex multi-step reasoning well [1][4]. This is a real cost: the “free” open-source version requires meaningful API spend to perform well.
• Token burn on failed sessions. If the agent goes in the wrong direction without Planning Mode catching it, you can burn significant API costs before noticing [1]. The $25 in API costs the Medium reviewer [1] accumulated during trials is a real data point.
• Git operations are unreliable. Pushing to wrong branches, credential handling issues, inability to pull PR comments programmatically — these were documented in hands-on use with real repositories [1]. Not showstoppers but they require supervision.
• Non-technical users will struggle. The comparateur-ia.com review [2] is direct about this: OpenHands is “not ideal for non-developers without programming technical skills.” You need to understand what the agent is doing to catch when it goes wrong.
• Enterprise features gated behind commercial license. Multi-user RBAC, Slack/Jira/Linear integrations, conversation sharing — none of these are in the MIT self-hosted version [README]. Fine for solo developers, a gap for teams above ~5 people.
• Cloud pricing not published. The paid Cloud and Enterprise tiers have no public pricing — contact sales. For a tool targeting cost-conscious developers, opaque pricing is an odd choice.
• Setup friction is real for beginners. Docker, API keys, reverse proxy for HTTPS — a non-trivial afternoon even for developers who know what they’re doing [1][3].

---

Who should use this / who shouldn’t

Use OpenHands if:

• You’re a developer or small engineering team paying $500+/month for Devin or equivalent and want the same capability without the platform lock.
• You want full control over which LLM handles your code — including the option to run locally with no data leaving your network.
• You have a backlog of well-specified bug tickets and want to delegate the boilerplate to an agent while you review the PRs.
• You’re comfortable with Docker and API keys, or you have someone on the team who is.
• You want to embed an autonomous coding agent into your own tooling via the Python SDK or REST API.

Skip it if:

• You’re not a developer. OpenHands requires you to understand what it’s doing well enough to catch when it goes wrong [2].
• You need reliable, production-grade results with minimal supervision. The agent’s Git handling has documented rough edges [1] and you’ll need to review every PR it opens.
• Your codebase has extreme confidentiality requirements and you’re not ready to self-host with a local LLM. The cloud version sends code to their infrastructure.
• You want zero setup and don’t have a technical person to deploy Docker for you.

Pick Devin instead if:

• You need a fully managed, support-backed autonomous agent where someone else handles reliability, uptime, and integrations — and the $500/month price is acceptable relative to the time saved.

Pick Cursor instead if:

• You want a fast, polished coding assistant that augments your own coding rather than autonomously doing it. Different jobs, different tools.

---

Alternatives worth considering

From the comparateur-ia.com alternatives section and the reviews:

• Devin (Cognition AI) — the original that inspired OpenHands. Fully managed, polished, $500/month per seat [3]. Pick it if reliability and support matter more than cost.
• Cursor — coding assistant, not an agent. Different category but most developers consider both.
• GitHub Copilot Workspace — GitHub’s own autonomous agent product, tighter GitHub integration, closed-source SaaS.
• Aider — open-source CLI coding agent with a smaller scope than OpenHands, simpler setup, no web GUI. Worth considering if you just want to drive coding from the terminal.
• SWE-agent — academic project from Princeton, SWE-Bench focused, less production-ready but interesting for researchers [5].
• Blaxel — persistent AI agent infrastructure with sandboxes on automatic standby (25ms resume latency), more infrastructure-focused than OpenHands [2].

For a developer choosing between open-source options, the realistic shortlist is OpenHands vs Aider. OpenHands has the fuller feature set, web GUI, SDK, and Cloud tier; Aider is simpler to set up and has a loyal following for terminal-first workflows.

---

Bottom line

OpenHands is the most credible open-source alternative to Devin right now. The core proposition holds up: autonomous agent loop, MIT license, model-agnostic, sandboxed Docker environment, GitHub PR creation — all without a platform subscription. The SWE-Bench score of 77.6 and the ICLR 2025 paper give it more academic credibility than most open-source tools in this space.

The limits are real. You’re buying the engine, not a finished product. Git operations have documented rough edges. The agent requires supervision, especially until Planning Mode matures. And the total cost includes LLM API fees that aren’t trivial when you’re running the agent on complex tasks with capable models.

For a developer already paying Devin rates, the economics are obvious. For an engineering team that wants to own their AI coding infrastructure rather than rent it, OpenHands is the serious answer. For a non-technical founder hoping to skip the command line entirely — that’s not this tool, not yet.

If the deployment friction is the blocker, that’s exactly what upready.dev handles for clients: one-time setup, you own the infrastructure, no recurring platform fees.

---

Sources

1. M. Chechulin, Medium — “Real-world experience with development using AI and OpenHands” (Nov 25, 2024). https://medium.com/@mchechulin/real-world-experience-with-development-using-ai-and-openhands-61d267bc6cd2

2. Comparateur-IA — “Review of OpenHands (2026): pros, cons, pricing & best alternatives” (Updated April 2026). https://comparateur-ia.com/en/reviews/openhands

3. Srujan Pakanati — “OpenHands: The Flawless Open-Source AI Coding Companion”. https://srujanpakanati.com/openhands-the-flawless-open-source-ai-coding-companion

4. vibecoding.app — “OpenHands Review (2026): 70K Stars. Worth the Setup?”. https://vibecoding.app/blog/openhands-review

5. Xingyao Wang et al., ICLR 2025 — “OpenHands: An Open Platform for AI Software Developers as Generalist Agents” (Jan 22, 2025). https://openreview.net/forum?id=OJd3ayDDoF

Primary sources:

• GitHub repository and README: https://github.com/OpenHands/OpenHands (69,313 stars, MIT license core, 490+ contributors)
• Official website: https://openhands.dev
• Documentation: https://docs.openhands.dev
• OpenHands Cloud: https://app.all-hands.dev
• Enterprise: https://openhands.dev/enterprise