A glass cube held by metal brackets containing a swirl of blue energy, suggesting a powerful process contained inside a sandbox.
OpenHands runs its agent inside a sealed box: a sandboxed Docker runtime where it can safely write code, run commands, and browse.

OpenHands is an open-source platform for building AI agents that work like a human developer: writing code, running commands at a terminal, and browsing the web. The official research paper defines it as “a platform for the development of powerful and flexible AI agents that interact with the world in similar ways to those of a human developer.” It was previously called OpenDevin. It is maintained by All-Hands-AI, is written in Python and TypeScript, and is open source under the MIT license, with some bundled components under their own licenses.

The core idea is a sandboxed runtime. OpenHands executes the agent’s actions inside a Docker container that gives it a bash shell, a browser, and a Jupyter environment, isolated from your host. That makes autonomous execution safer: the agent can install packages and run code without touching your machine directly. The project has since grown into a broader self-hosted control center for coding agents, with a hosted OpenHands Cloud option and a Python Software Agent SDK; the standalone CLI and the older Docker GUI are now marked as legacy surfaces in the documentation.

Where OpenHands sits in the stack

Interfaces
CLI Web GUI GitHub Action OpenHands Cloud Software Agent SDK
Agent
Reasoning loop Emits actions Decides the next code edit, command, or web action
Agent server
REST API backend Actions in, observations out
Runtime (sandbox)
Docker container Bash shell Browser Jupyter Isolated execution of every agent action
Models
Any LiteLLM provider Anthropic, OpenAI, Google, Bedrock Local: vLLM, SGLang

Installation

The recommended path uses uv. Docker is a prerequisite, because the agent runs its actions inside a container.

bash
uv tool install openhands --python 3.12
openhands

There is also an official installer script.

bash
curl -fsSL https://install.openhands.dev/install.sh | sh
openhands

OpenHands can also run through a Docker image directly and as a GitHub Action for continuous integration. The Docker image tag is version-specific, so check the current docs for the exact tag rather than pinning an old one.

Two ways to use it

The first pattern is a local run. You install with uv, launch openhands in your terminal, and give it a task. The agent plans, then executes each step inside the Docker sandbox, returning what it did.

bash
openhands
# then describe the task, for example:
# "Add pagination to the /users endpoint and write a test for it."

The second pattern is delegating work in the cloud or in CI. OpenHands Cloud connects to GitHub, GitLab, or Bitbucket and can take an issue through to a pull request, and the GitHub Action runs the same agent headlessly on a trigger.

yaml
# .github/workflows/openhands.yml (illustrative)
name: OpenHands
on:
  issues:
    types: [labeled]
jobs:
  resolve:
    runs-on: ubuntu-latest
    steps:
      - uses: All-Hands-AI/OpenHands-Action@main
        with:
          issue-number: ${{ github.event.issue.number }}

Typical workflow

Step 1 Install and start Install with uv and launch openhands, with Docker running.
→
Step 2 Give a task Describe the change; the agent plans the steps to complete it.
→
Step 3 Act in the sandbox It writes code, runs commands, and browses inside the Docker runtime.
→
Step 4 Deliver Review the result locally, or let the cloud agent open a pull request.

How it compares

The clearest way to place OpenHands is on the autonomy axis: it is built to run tasks end to end, where a tool like Cline is built to pause for your approval at each step.

OpenHandsClineGooseOpenCode
AutonomyRuns tasks end to endApproval per actionOn-machine, interactiveInteractive, plan agent gates
IsolationDocker sandboxRuns in your IDERuns on your machineRuns on your machine
LicenseMIT (mixed)Apache-2.0Apache-2.0MIT
SurfacesCLI, GUI, CI, cloud, SDKVS Code, CLIDesktop, CLI, APITerminal, IDE, web
Best forAutonomous, sandboxed tasksReviewed IDE editsOn-machine automationProvider-agnostic coding

When not to use it

  • You cannot run Docker. The sandboxed runtime depends on Docker. In environments where you cannot run containers or grant Docker access, OpenHands will not work.
  • You want to approve every action. OpenHands is designed for autonomous execution. If you need a human confirming each edit and command, Cline is built around that gate.
  • You want a lightweight terminal tool. Running a sandbox and an agent server is heavier than a single-binary CLI. For quick local edits, Aider or OpenCode is lighter.
  • You need a stable, unchanging interface. The product is repositioning around its control center, Cloud, and SDK, with older surfaces marked legacy. Check the current docs before standardising a team on one entry point.

Further reading

Sources