OpenHands
Open-source autonomous AI software engineer (the Devin alternative)
AICoding score
Prerequisites: Node 22.12+, Docker and uv. The Docker-only path is shown in the Setup section.
Quick Verdict
8.2 / 10 — The most mature open-source autonomous coding agent in 2026 — MIT licensed, model-agnostic, Docker-sandboxed, and free to self-host. The closest open-source answer to Devin.
OpenHands (formerly OpenDevin) is a self-hosted AI software engineer that completes entire tasks end to end — read the repo, write code, run tests in a sandbox, and open a PR. You bring any LLM (Claude, GPT, Gemini, or a local Ollama model), so there is no vendor lock-in and no per-seat bill.
The payoff is Devin-like autonomy at zero software cost with full data control; the trade-off is Docker/self-hosting setup and results that depend on the model you choose.
If you want a managed, turnkey product, Devin or Claude Code fit better; if you want to own the infrastructure and the loop, OpenHands is the category leader in open source.
Use OpenHands if…
- You want a free, MIT-licensed autonomous agent (the Devin alternative) with no subscription
- You want model-agnostic freedom — Claude, GPT, Gemini or local Ollama
- You need sandbox-isolated, event-sourced, auditable runs for safety or compliance
- You run backlog automation or parallel agent fleets across many repos
Skip OpenHands if…
- You want a fully managed, turnkey product with first-party support (Devin / Claude Code)
- You dislike Docker / self-hosting setup and infra work
- You need guaranteed production stability this month — setup and model quality drive results
Core Features
Autonomous end-to-end agent
Describe a task in natural language and OpenHands runs the whole loop: read the repo, write and edit code, run tests in a sandbox, browse the web, iterate, and open a pull request for human review. It completes the entire task — not just the next line. This is the "AI software engineer" model Devin popularized, delivered open source.
Model-agnostic by design
Bring your own model: Anthropic Claude, OpenAI GPT, Google Gemini, or open-weight models (Llama, Qwen) via any OpenAI-compatible endpoint or litellm. Local models through Ollama keep code fully on-premises. The OpenHands Index benchmarks rank models on real SWE performance so you can tune the price/quality mix — Claude Opus for hard tasks, a cheaper model for routine steps.
Sandboxed execution by default
Every agent runs in an isolated Docker or Kubernetes container with its own filesystem, shell, browser and editor. It cannot reach your host machine or other projects, and fine-grained access controls decide what it may do. Sandboxing is the default, not an add-on — the core safety story for autonomous agents.
Event-sourced, auditable runs
Agent state is derived from an immutable log of typed events (Action → Execution → Observation) rather than a mutable variable. That means runs are replayable, branchable, and fully auditable — you can step back to any point and see exactly what the agent saw and did. Enterprise-grade traceability for regulated teams.
Parallel agent orchestration ("fleet")
Spin up hundreds or thousands of agents simultaneously, each in its own container, to process an entire backlog in parallel — dependency bumps, CVE remediation, codebase migrations, and test-coverage expansion across many repos at once. This is what turns OpenHands from a productivity tool into an engineering force multiplier.
Integrations & MCP
Native connectors for GitHub, GitLab, Slack, Jira and Linear, plus Model Context Protocol support that lets the agent connect any MCP server (Postgres, Notion, logs, monitoring) dynamically without changing source. Repo-specific microagents add team knowledge. OpenHands plugs into the stack you already run.
Integrations & Ecosystem
Models
Top reliability on SWE-bench; the common default for hard tasks. Add the key in Settings > LLM Profiles.
Settings → LLM Profiles GPT-5.x / 4o family via an OpenAI key — strong general coding and tool-calling.
Settings → LLM Profiles Gemini 2.x/3 for cost-efficient autonomous runs and long context.
Settings → LLM Profiles Open-weight models for on-prem autonomy; within 2-6 pts of frontier on SWE-bench through OpenHands.
Settings → LLM Profiles Run any local GGUF model — zero data egress, $0 cost, ideal for proprietary or regulated code.
Settings → LLM Profiles Your stack (MCP)
Assign issues, open PRs and review directly from the agent — the core autonomous loop.
UI → Integrations Mirrors the GitHub flow for GitLab orgs; branches, MRs and pipelines from chat.
UI → Integrations Assign tasks and get progress where your team already talks — Slack, Jira and Linear connectors.
UI → Integrations Agent queries your database through any MCP server — no source changes to connect.
add MCP server Any MCP server plugs in dynamically — knowledge bases, logs and metrics become agent tools on the fly.
add MCP server Agent protocol
Agent Canvas connects Claude Code, OpenAI Codex and Gemini CLI as the agent backend — keep your existing tools and subs.
Agent Canvas Repo-specific knowledge + action agents persisted as files; share team conventions across the org.
microagents/ folder Pricing
The entire platform — SDK, CLI, web GUI, REST API, autonomous agent loop, sandboxing and audit log. No feature is gated behind a paid tier; the code is MIT and runs on your own machines.
- MIT open source
- SDK · CLI · GUI · API
- Docker/K8s sandbox
- No paid tier
Connect any LLM — Claude, GPT, Gemini, or a local Ollama model — in Settings > LLM Profiles. No subscription, no vendor lock-in, and data stays with you. Local models cost $0 and keep code on-prem.
- Any tool-calling LLM
- Local models via Ollama
- No subscription
- Zero vendor lock-in
Hosted option for teams that skip self-hosting: a free tier for individuals and paid plans for team/cloud agents and managed runs. Pricing scales with cloud agent usage; see openhands.dev for current rates.
- No infra to run
- Free individual tier
- Team/cloud agents
- Managed runs
Kubernetes deployment inside your own VPC with RBAC, audit logging, the Agent Control Plane for fleet orchestration, and compliance features for ITAR/HIPAA/finance. Source code never leaves your perimeter.
- In-your-VPC K8s
- RBAC + audit logs
- Agent Control Plane
- Compliance-ready
* Estimates from published usage reports & community benchmarks. Your API cost depends on model choice and volume. Local models via Ollama cost $0.
OpenHands vs The Field
OpenHands vs Devin
Open-source Devin alternativeBoth run the same autonomous "agent completes the ticket" loop. OpenHands is MIT-licensed, model-agnostic and free to self-host; Devin is a managed commercial product on a per-seat subscription with vendor-locked infrastructure. OpenHands wins on cost and freedom (and you keep your own model + data); Devin wins on polished UX, managed reliability and first-party support. Pick OpenHands if you want Devin-like autonomy without the bill.
OpenHands for cost/freedom · Devin for managed UXOpenHands vs Claude Code
Autonomous agent vs terminal CLIClaude Code is a CLI coding agent locked to Anthropic models, run locally with a mature first-party UX. OpenHands is a web-UI autonomous agent that is model-agnostic and runs in a sandboxed container, built for unattended end-to-end completion (it opens the PR for you). Claude Code for interactive terminal pair-work; OpenHands for delegating whole issues to a self-hosted agent.
Claude Code for maturity · OpenHands for autonomy + freedomOpenHands vs Cline
Whole-task agent vs in-editor pairCline is a VS Code sidebar agent that edits files with you watching and approving each step inside your editor. OpenHands is a full autonomous agent in a sandbox that completes entire tasks and opens PRs without supervision. Cline gives tighter editor control; OpenHands gives hands-off task completion. Many teams run Cline for daily edits and OpenHands for backlog automation.
OpenHands for autonomy · Cline for in-editor controlWho OpenHands Is Best For
Autonomous bug fixing & issue triage
Assign a GitHub issue and the agent reproduces the bug, writes the fix, adds a regression test and opens a PR — often same-day. The strongest, most-proven OpenHands use case for support and maintenance backlogs.
Escape Devin's price tag
Get Devin-like autonomous development without the per-seat subscription. Self-host OpenHands, bring your own model key, and pay only for LLM tokens — often a fraction of a managed agent's monthly cost.
Legacy & large-scale migration
Parallel agent fleets migrate codebases, modernize patterns, and apply dependency or framework upgrades systematically across whole repos — the agent understands old patterns and applies the new ones consistently.
Enterprise self-hosted (data residency)
Deploy in your own VPC with RBAC and audit logging so source code never leaves your perimeter. Meets ITAR / HIPAA / finance constraints that cloud-only agents cannot.
Local & private models
Run with Ollama or on-prem GPUs to get near-SWE-bench results with zero data egress and $0 model cost. Ideal for proprietary or regulated codebases.
Open-source contributions & boilerplate
Use the CLI for personal projects and OSS contributions: scaffold microservices, API endpoints and DB schemas, generate tests and release notes from commit history.
Getting Started
Install prerequisites
You need Node.js 22.12+ (with npm/npx), Docker, and uv. Docker runs the sandboxed backend; uv is used by the local agent-server runtime. For a fully containerized path you can skip Node and just use Docker.
Launch Agent Canvas
The fastest path is the npx one-liner. It pulls the launcher and starts the full local stack — Canvas client, Agent Server, Automation Server and ingress — on http://localhost:8000. For a reusable command run npm install -g @openhands/agent-canvas then agent-canvas. Docker-only alternative: docker run -p 8000:8000 -v ~/.openhands:/home/openhands/.openhands -v ~/projects:/projects ghcr.io/openhands/agent-canvas:latest.
Configure a model
Open the UI, go to Settings > LLM Profiles, and add a provider key (Anthropic, OpenAI, Google, OpenHands LLM API, or an OpenAI-compatible endpoint such as Ollama). You can switch models per conversation.
Open a workspace
Before chatting, choose Open Workspace and point the agent at the repo or folder you want it to work in. The backend needs a workspace to read files, write changes, and run tests.
Assign a task
Describe the work in plain language — e.g. "fix the pagination off-by-one bug in src/components/Pagination.tsx (issue #123)". The agent reads the repo, edits code, runs tests in its sandbox, and opens a PR for your review.
Connect your stack (optional)
Add GitHub / GitLab for issues and PRs, Slack / Jira / Linear for tracking, and MCP servers (Postgres, Notion, logs) so the agent can act on live systems. Repo microagents let you persist team conventions. For org-wide fleet deployments use the self-hosted Kubernetes build with the Agent Control Plane.
FAQ
Is OpenHands free?
Yes. OpenHands is MIT-licensed open source — the agent platform, SDK, CLI, web UI and REST API are free to self-host forever. You only pay for the LLM you connect (or $0 if you run local models via Ollama). There is no paid tier locking features behind a subscription; the project is backed by an $18.8M Series A but the software stays open.
Is OpenHands the same as OpenDevin?
Yes — OpenHands was previously called OpenDevin. It rebranded to OpenHands in 2024 but is the same project: the open-source autonomous AI software engineer. You will still see "OpenDevin" in older articles and the GitHub history, but both names refer to the same codebase (All-Hands-AI/OpenHands).
What is OpenHands used for?
OpenHands is an autonomous AI software engineer that completes entire engineering tasks end to end: it reads your codebase, writes and edits code, runs tests in a sandbox, browses the web, and opens a pull request for human review. Common uses are fixing GitHub issues, resolving bugs same-day, migrating legacy code, generating tests and docs, and running parallel agent fleets for dependency bumps or CVE remediation across many repos.
How is OpenHands different from Devin?
OpenHands is the open-source, self-hosted alternative to Devin. Both run the same autonomous "agent completes the ticket" loop, but OpenHands is MIT-licensed, model-agnostic (bring Claude, GPT, Gemini or a local model), and free to run — Devin is a managed commercial product on a per-seat subscription with vendor-locked infrastructure. OpenHands wins on cost and freedom; Devin wins on polished UX and managed reliability.
How is OpenHands different from Claude Code?
Claude Code is a CLI coding agent locked to Anthropic models, run locally in your terminal with a mature, first-party UX. OpenHands is a web-UI autonomous agent that is model-agnostic, runs in a sandboxed Docker/K8s container, and is built for unattended end-to-end task completion (it opens the PR for you). Use Claude Code for interactive terminal work; use OpenHands when you want to delegate whole issues to a self-hosted agent.
What models does OpenHands support?
Any LLM with tool-calling: Anthropic Claude, OpenAI GPT, Google Gemini, and open-weight models (Llama, Qwen) via any OpenAI-compatible endpoint or litellm. Local models run through Ollama keep your code fully on-premises. The OpenHands Index benchmarks rank models on agentic SWE performance so you can pick the best price/quality mix; the common pattern is Claude Opus for hard tasks and a cheaper model for routine steps.
Is OpenHands safe? Does it sandbox the agent?
Yes. Every agent runs in an isolated Docker or Kubernetes container with its own filesystem, shell, browser and editor — it cannot touch your host machine or other projects. Fine-grained access controls decide what the agent may do, and every action is logged and replayable (event-sourced). For regulated teams, the enterprise build deploys inside your own VPC so source code never leaves your perimeter.
Can I run OpenHands locally or self-host it?
Yes. The standard local install is `npx @openhands/agent-canvas` (or `npm install -g @openhands/agent-canvas` then `agent-canvas`), which opens Agent Canvas at http://localhost:8000. Add your LLM key in Settings > LLM Profiles. A Docker-only path is also available: `docker run -p 8000:8000 -v ~/.openhands:/home/openhands/.openhands -v ~/projects:/projects ghcr.io/openhands/agent-canvas:latest`. For organizations, OpenHands offers a self-hosted Kubernetes deployment with RBAC, audit logging and an Agent Control Plane for orchestrating fleets of agents across repositories.
What is OpenHands' SWE-bench score?
OpenHands scores roughly 70-77% on SWE-bench Verified in full autonomous mode, depending on the underlying model — about 72% with Claude Opus 4.6, among the top results for any open-source coding agent. Open-weight models via OpenHands come within 2-6 points of frontier models, so you can get near-state-of-the-art autonomy while keeping code on-premises.
Does OpenHands have a CLI?
Yes. OpenHands ships a layered interface: a composable Python SDK for building agents in code, a CLI that feels familiar to Claude Code / Codex users, a browser-based GUI (React + REST API) for watching and guiding agents, and a REST/WebSocket API for remote control and the hosted Cloud. You pick the surface that fits the job — script it, type it, or click it.