TL;DR:

  • OpenHands is an MIT-licensed AI software engineering agent that can write code, run commands, browse the web, and submit pull requests — all inside a sandboxed Docker environment
  • With Claude Opus 4.6 as its backbone, it now scores 68.4% on SWE-bench Verified, making it one of the strongest open-source options for autonomous coding tasks
  • Version 1.7.0 (May 2026) supports any major LLM and can be self-hosted on your own infrastructure in minutes

If you’ve watched commercial AI coding tools evolve but wanted something you could actually run yourself, inspect, and extend, OpenHands deserves your attention. With 70,000+ GitHub stars, 490+ contributors, and a recent $18.8M Series A, it has moved well beyond the experimental phase it was in when it launched as OpenDevin in early 2024.

What OpenHands Actually Does

OpenHands is not a code completion plugin or a chat interface for your codebase. It’s an autonomous agent that takes a task description, plans steps, and then executes them: writing files, running shell commands, browsing documentation sites, calling APIs, and committing changes. All of this happens inside a sandboxed Docker container, so the agent has a full Linux environment but can’t affect your host system unless you explicitly allow it.

A typical OpenHands task looks like: “Add input validation to the create_user endpoint and write unit tests.” The agent reads the relevant files, identifies what changes are needed, writes the code, runs the test suite, iterates on failures, and opens a pull request. You review the PR rather than writing from scratch.

The SWE-bench Verified benchmark measures exactly this capability — resolving real GitHub issues from popular open-source projects. OpenHands with Claude Opus 4.6 scores 68.4%, which is competitive with significantly more expensive proprietary solutions.

Self-Hosting in Under Ten Minutes

The quickest way to run OpenHands is via Docker:

docker pull ghcr.io/all-hands-ai/runtime:0.28-nikolaik
docker run -it --rm \
  -e SANDBOX_RUNTIME_CONTAINER_IMAGE=ghcr.io/all-hands-ai/runtime:0.28-nikolaik \
  -e LOG_ALL_EVENTS=true \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v ~/.openhands-state:/.openhands-state \
  -p 3000:3000 \
  ghcr.io/all-hands-ai/openhands:0.28

Open http://localhost:3000, configure your LLM provider and API key, and you have a full UI for assigning tasks to the agent. OpenHands works with OpenAI, Anthropic, Google Gemini, Azure OpenAI, and local models via Ollama — you’re not locked into a single provider.

For team deployment, OpenHands can be exposed as a service. The project also offers a hosted version at app.all-hands.dev if you’d rather not manage infrastructure.

Models and What They’re Best For

Model choice significantly affects both quality and cost. The benchmark results are instructive:

  • Claude Opus 4.6: 68.4% SWE-bench Verified — strongest for complex, multi-file refactoring and bug fixes
  • Claude Sonnet 4.6: Lower cost, good for routine tasks like adding tests or updating documentation
  • GPT-4o: Solid performance, useful if your team already has Azure OpenAI licensing
  • Local models (Llama 3, Qwen 2.5): Much lower accuracy but zero API cost — viable for low-stakes tasks or evaluation

For production automation workflows, pairing OpenHands with Claude Sonnet 4.6 gives a practical balance: strong enough for most issues, cheap enough to run at scale.

Where It Fits in an Agent Workflow

OpenHands is well-suited for automating repetitive engineering tasks that currently eat senior engineer time:

Dependency upgrades. Tasks like “update all packages flagged in our npm audit to their latest safe version, run tests, fix any breaking changes” are a natural fit. The agent can iterate on test failures without you watching.

Test coverage. “Add unit tests for any function in services/payments.py that has less than 60% coverage” produces passable test files that you review rather than write.

Documentation generation. OpenHands can read your codebase and write accurate API documentation, README sections, or inline docstrings — tasks that developers reliably deprioritise.

Bug triage. Pipe GitHub issues into OpenHands via webhook, have it attempt a fix, and only escalate to a human when it gets stuck. The agent comments on the issue with what it tried, so context isn’t lost.

Integration Patterns

GitHub Actions. The OpenHands team maintains an action that triggers the agent on issue labels. Add the label fix-with-openhands to an issue, and the agent picks it up, attempts a fix, and opens a PR. This requires no developer intervention until review.

Webhook-driven pipelines. For custom integrations, OpenHands exposes a REST API. You can send tasks from any system — project management tools, monitoring alerts, CI pipelines — and poll for results or configure a callback.

MCP tools. OpenHands supports the Model Context Protocol, so you can give the agent access to your internal APIs, databases, or documentation stores via MCP servers.

Limitations Worth Knowing

OpenHands performs best on well-scoped, bounded tasks. Open-ended requests like “improve the architecture of our authentication system” rarely produce useful results without more specific acceptance criteria. The agent also works best when the codebase has tests: without a test suite to run, it has less signal for verifying its own work.

For tasks requiring business context or domain judgment — deciding whether to use one data model vs. another — human review remains essential. OpenHands is a force multiplier for the mechanical parts of software engineering, not a replacement for engineering judgment.

The SWE-bench score, while impressive, is measured on isolated bug fixes in well-maintained open-source projects. Your internal codebase, with its specific conventions and dependencies, may see lower success rates until you invest in good task specification and prompting.

Getting Started

The fastest path from zero to productive:

  1. Install Docker and pull the OpenHands image
  2. Run locally with your Anthropic or OpenAI API key
  3. Pick one recurring task type your team handles (dependency updates, test writing, doc generation)
  4. Run OpenHands on five real examples from that category
  5. Measure time saved and PR quality — then decide whether to automate it

The project’s documentation at docs.all-hands.dev covers configuration, model setup, and the GitHub Actions integration in detail.

References