OpenHands: from research project to daily driver
OpenHands started life as OpenDevin, a scrappy public effort to replicate the closed autonomous-coding demos everyone was arguing about in 2024. Two years on it has become something better than a replica: the open agent with the deepest research lineage, and the one I trust most to run genuinely unattended. Those two facts are connected.
The lineage shows
Most tools ship features. OpenHands ships features plus the evaluation harness that justifies them. The project has been a fixture of coding-agent benchmarks more or less since coding-agent benchmarks existed, and that culture shapes the engineering: agent behavior is specified and measured, not vibes-tuned. I won't quote numbers here (they churn too fast to be useful), but the habit of measuring is the point. It also means the project's claims tend to be checkable, a low bar the agent ecosystem still routinely fails.
Everything is an event
Under the hood, a session is a stream of events. The agent emits actions: run this command, edit this file, open this page. The environment answers with observations, appended to the same stream. That one decision buys a lot. Sessions are replayable and auditable after the fact. Debugging a failed run means reading a timeline, not grepping logs. And every frontend (CLI, web GUI, cloud) is a different view over the same stream, so they can't quietly drift apart in behavior.
If you build agents rather than just use them, study this design. It is the cleanest open implementation of the principle that an agent's every step should be observable, and observability is what makes the autonomy tolerable.
Autonomy behind glass
Execution happens in a sandboxed runtime, containerized away from your host shell. Inside the box the agent gets a real workspace: shell, filesystem, browser. Outside it, your machine stays yours. For supervised edit loops that is a nicety. For the long unattended runs OpenHands is actually built for, it is the difference between delegation and gambling. I've argued before that sandboxing is the precondition for real autonomy; OpenHands takes that argument more literally than any other open tool.
OpenHands is what happens when the people who publish the evals also have to operate the agent being evaluated.
The weight you carry
Now the honest part: all of this costs operational mass. The sandboxed runtime means a container engine becomes part of your toolchain. Cold start is slower than any single-binary CLI, and "quick question about this function" is simply not this tool's genre. There is more to configure, more that can quietly break on a Tuesday. Teams that already operate containers won't blink. A solo developer who wants edits in a terminal will feel the drag inside an hour. Budget an afternoon for your first real setup, not ten minutes.
The sane pattern is to match the mode to the task: CLI when you're watching, headless when CI is watching, GUI or cloud when nobody is watching and you'll review the long-running work after the fact.
The verdict splits along the unit of work. If you hand your agent edits, run something lighter from the landscape. If you hand it tasks (reproduce this bug, fix it, prove the fix holds), OpenHands is the open agent I'd give them to, precisely because it grew up being measured.