OpenHands (formerly OpenDevin) is an open-source framework for autonomous coding agents — instead of a single vendor's closed CLI tool, it's a platform you self-host or run in a sandboxed container, with the agent architecture itself open for inspection and modification. That openness is the entire pitch: you're not trusting a black box with repo access, you can read exactly how it decides what to do.
Why OpenHands Matters (and When to Skip It)
Closed-source agents like Claude Code or Codex CLI are polished, well-supported, and require zero infrastructure setup — you install and go. OpenHands trades that convenience for transparency and control: you can inspect the agent loop, modify how it plans and executes, and run it entirely within infrastructure you control, which matters if your org has strict requirements about code never leaving a sandboxed environment you own.
Skip it if you want the smoothest, most polished experience with minimal setup — a self-hosted, open-source agent framework has more moving parts than a managed CLI tool, and that overhead only pays off if you actually need the control it buys you.
Getting Started
The most common path is running it via Docker, pointed at a sandboxed workspace:
docker run -it --rm \
-e SANDBOX_RUNTIME_CONTAINER_IMAGE=docker.all-hands.dev/all-hands-ai/runtime:latest \
-v /var/run/docker.sock:/var/run/docker.sock \
-p 3000:3000 \
docker.all-hands.dev/all-hands-ai/openhands:latest
This starts a local web UI where you connect a model (OpenAI, Anthropic, or a local model via Ollama), point it at a repo, and describe a task — the agent then plans and executes inside its own sandboxed container, isolated from your host machine.
Core Concepts Every Developer Should Know
1. Model-agnostic by design. Unlike vendor CLI tools tied to one model family, OpenHands lets you plug in whichever model you trust or are already paying for — including fully local models, which matters for sensitive codebases that can't touch a third-party API at all.
2. Sandbox isolation is structural, not optional. The agent operates inside a container by default — actions it takes don't touch your host filesystem unless you explicitly mount it in, which is a stronger isolation guarantee than permission-prompt-based safety.
3. Extensible agent architecture. Being open source, you can inspect and modify the actual planning and execution loop — useful for research, for building a custom agent behavior your org needs, or simply for understanding what "an agent" actually does under the hood instead of trusting a vendor's description.
4. Community and benchmark focus. OpenHands has been used heavily in academic and benchmark contexts (SWE-bench and similar) precisely because its architecture is inspectable and reproducible — a relevant signal if you care about how agent claims are actually verified, not just marketed.
Common Mistakes and How to Fix Them
Mistake 1: Underestimating setup and maintenance overhead. Self-hosting means you own the infrastructure, updates, and sandbox configuration — budget real time for this versus a managed tool's zero-setup experience.
Mistake 2: Skipping the sandbox and mounting your host filesystem directly. Doing this defeats the isolation that's the main reason to choose a self-hosted agent in the first place — keep the sandbox boundary intact unless you have a specific reason not to.
Mistake 3: Expecting parity with polished commercial tools out of the box. Open-source, community-driven tooling moves fast but unevenly — expect rougher edges in UX than a funded commercial product, in exchange for the transparency and control you're actually there for.
When Should You Use OpenHands?
Use it when transparency, self-hosting, or model flexibility are hard requirements — regulated industries, security-sensitive codebases, or research into agent behavior itself. Use a managed CLI tool when you just want the fastest path to a working agentic workflow without infrastructure overhead.
In Practice
I don't run OpenHands as a daily driver — Claude Code covers that — but it's worth knowing well if your constraints ever require full control over the agent loop and where your code is allowed to go. It's also a genuinely useful reference for understanding what "an autonomous coding agent" is actually doing mechanically, since the whole thing is there to read.
If model-agnostic, self-hosted agent execution is a real requirement for your org, OpenHands is the most mature open-source option worth trialing first.