GO TO A SECTION

↑ ↓ to navigate · Enter to openExplore all sections →
FDEInterviews logo
ICLR 2025

OpenHands: An Open Platform for AI Software Developers as Generalist Agents

An open platform for agents that work like developers: one event stream of actions and observations, a sandboxed runtime with shell, Python and browser, and agents that hand off to each other.

Breakdown by FDE Interviews · 12 min read · Updated

About the original · 2024
AUTHORS
Wang, Li, Song, Xu, et al.
FROM
UIUC, CMU, Yale, UC Berkeley, All Hands AI, et al.
PUBLISHED
Jul 2024 · ICLR 2025
CITED BY
1,221Semantic Scholar · Oct 2026
IN THIS BREAKDOWN · 10 SECTIONS

You can read 19% of this breakdown.

01

The paper in one minute

By mid-2024 many teams were building agents that write code, run commands and browse the web, inspired by Cognition's Devin. Each had its own way of representing actions, executing them, keeping history and sandboxing. That made agents hard to compare and hard to build on. Xingyao Wang, Graham Neubig and a large group of collaborators from universities and companies built OpenHands (formerly OpenDevin) as a shared platform.

It has three core pieces. An agent is a class with a step method: it receives the current state and returns one action. The state includes an event stream, an ordered log of every action and observation, from the agent, the user and the environment, plus bookkeeping such as accumulated model cost. The runtime executes actions inside a Docker container per session: a bash shell, a Jupyter IPython kernel for Python, and a Playwright-driven Chromium browser using BrowserGym's action set. The agent never touches the host; the runtime turns each action into an observation and appends it to the stream.

Around these sit a library of reusable tools (AgentSkills, Python functions preloaded in the sandbox), a delegation action that lets one agent hand a subtask to another, support for running on any user-provided Docker image, a chat interface that shows what the agent is doing, and an evaluation harness covering 15 benchmarks. The default generalist, CodeActAgent, acts mainly by writing code. With one interface, it came close to specialist systems on software engineering, trailed them on web navigation, and beat prior results on graduate-level science questions.

THE IDEA, VISUALLY
AGENTS, AN EVENT STREAM, A SANDBOX Agent step(state) → action CodeAct, browsing, delegating agents Event stream actions and observations, in order; plus cost, metadata Runtime Docker sandbox: bash, IPython, Chromium browser workspace mounted actions → ← observations Actions run Python, run bash, browse (BrowserGym), message user, delegate, finish AgentSkills Python tools preloaded in the sandbox: file editing, PDF and image parsing Delegation e.g. the generalist hands web tasks to a BrowsingAgent Any image install the runtime API into a user's own Docker image Evaluation 15 benchmarks wired into the same harness ONE GENERALIST VS EACH SPECIALIST % on each benchmark (Table 3) SWE-bench Lite CodeActAgent v1.8 · Claude 3.5 Sonnet 26.0 Agentless · GPT-4o 27.3 WebArena CodeActAgent v1.8 · Claude 3.5 Sonnet 15.3 GPT-4 + Reflexion 20.2 GPQA CodeActAgent v1.5 · GPT-4o 53.1 GPT-4, few-shot chain of thought 38.8 Close to specialists on coding, behind on web tasks, ahead on hard science questions. The paper's case is the platform: one agent interface, many environments.
OpenHands separates what the agent decides from where actions run, with an ordered event stream in between. One generalist agent came close to specialists on coding and beat them on hard science questions, while trailing on web tasks.
Research notes: the problem, approach and results
15

benchmarks run through the same agent and runtime interface

26.0%

SWE-bench Lite resolved by the generalist CodeActAgent with Claude 3.5 Sonnet, at $1.10 per issue

188+

contributors and 2.1K contributions to the open-source project at writing

THE PROBLEM

Every research agent shipped its own loop, tools and sandbox, so agents could not be compared, reused or safely run against real environments. Building a software-engineering agent meant rebuilding the plumbing each time.

THE IDEA

Define an agent as a step function from state to action, record every action and observation in an event stream, execute actions in a Docker sandbox with a shell, a Python kernel and a browser, and support delegation, shared tools and benchmark harnesses on top.

THE RESULT

An MIT-licensed platform with over ten agents and 15 benchmarks wired in. Its generalist CodeAct agent reached 26% on SWE-bench Lite, 15% on WebArena and 53% on GPQA, close to or ahead of task-specific systems, with one interface for all.

02

Why it matters to an FDE

Whether you adopt OpenHands or build your own, its architecture is a good reference for the plumbing every customer agent needs. Most production problems with agents are plumbing problems: where code runs, what was done, and how to debug it.

Keep a complete, ordered event log. Every action and observation, with who issued it. It is your audit trail, your debugging tool and your evaluation data, and it lets you replay or resume a session.

Separate decision from execution. The agent proposes actions; a runtime executes them under its own rules. That is where you enforce sandboxing, permissions and resource limits, independent of which model or agent design you use.

Sandbox per session. A fresh container with only the customer's workspace mounted limits the blast radius of a bad command or an injected instruction.

Make agents swappable. A common interface lets you test a new model or agent design against the same tasks without touching the runtime.

Delegate to specialists. A generalist that hands web tasks to a browsing agent, or reviews to a checking agent, keeps each component simpler.

THE FULL BREAKDOWN

Understand the mechanism. Try it on a real problem.

Unlock this breakdown and 99 more papers.

Premium opens every paper in full, plus every answer, concept, course and guide on the site. One payment for six months of access.

6 months · One payment · No auto-renewal

Get Premium · ₹2,000 / $25
  • ◇1 architecture diagram
  • </>1 runnable code experiment
  • ▦2 results tables
  • ?5 interview questions with answers
  1. 03Key takeaways

    The agent abstraction, runtime, tools, delegation, evaluation, and misreadings to avoid

    Free account
  2. 04How it works

    The control loop, the runtime API, the browser, tools, delegation and the evaluation harness

    Premium
  3. 05The numbers that matter

    Results across coding, web and assistance tasks, costs, and how to read them

    Premium
  4. 06Try it yourself

    Build a miniature event-stream agent platform with a sandboxed runtime, delegation and replay

    Premium
  5. 07Where it breaks

    The limits of the platform and of its evaluation

    Premium
  6. 08Using it on a deployment

    Running developer-style agents for a customer with the right boundaries

    Premium
  7. 09Interview angles

    Five questions this paper prepares you for, with answer hints

    Premium
Back to the paper library →