Research

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

Xingyao Wang12 min readResearch
FOUNDATIONALAI AgentsAdvanced

Key takeaway

Foundational work on production-oriented coding agents.

Updated on Oct 3, 2026

01

Abstract

  • OpenHands is an open platform for AI software-development agents designed to operate as generalist developers.
  • The platform provides agents with a computer environment where they can edit files, execute commands, browse, and interact with development tools.
  • Its architecture separates the agent from the execution runtime.
  • The paper emphasizes reproducibility, extensibility, and safe execution of agent actions.
  • OpenHands evaluates generalist software agents on real-world software-engineering benchmarks.
  • The platform supports multiple agent implementations rather than hard-coding one policy.
  • The work builds on the earlier OpenDevin project and presents the renamed OpenHands platform.

02

Introduction

  • AI coding agents need more than code generation: they must inspect repositories, execute programs, interact with terminals, and recover from failures.
  • Existing agent implementations often tightly couple model logic with environment-specific execution.
  • Tight coupling makes experimentation, debugging, and safe deployment difficult.
  • OpenHands separates agent reasoning from runtime execution through a standardized event-driven interface.
  • The platform is intended to support both research experiments and practical software-development workflows.
  • Generalist agents should be able to use multiple tools rather than being restricted to a single coding interface.
  • The paper focuses on building an open platform and evaluating agent performance at realistic software tasks.

03

Problem

  • The core problem is providing a reusable infrastructure for agents that perform complex software-development tasks.
  • Agents need a consistent interface for actions such as shell execution, file editing, browsing, and interaction with applications.
  • Runtime state must remain isolated from the model so that actions can be executed reproducibly.
  • The platform must support different agent policies and model backends.
  • Evaluation requires a common way to capture agent trajectories and outcomes.
  • The system must also provide safety boundaries around potentially destructive computer actions.
  • OpenHands addresses these requirements through an event-based agent-runtime architecture.

04

Methodology

  • The agent receives the task and current event history as context.
  • It chooses an action such as running a command, editing a file, or interacting with a browser.
  • The runtime validates and executes the action.
  • Execution results are appended to the event stream.
  • The agent observes those results and chooses the next action.
  • This creates an iterative observe → act → execute → observe loop.
  • Agent trajectories can be recorded for reproducibility and analysis.
  • The same loop supports coding, debugging, repository exploration, and other computer-use tasks.
Figure 1

05

Architecture

  • OpenHands separates the Agent layer from the Runtime layer.
  • The Agent layer implements reasoning and action selection.
  • The Runtime layer provides the controlled computer environment and tool execution.
  • An event stream connects the two layers.
  • The runtime can expose a shell, file system, browser, and other interaction mechanisms.
  • Docker-based sandboxing isolates agent execution from the host environment.
  • The architecture supports multiple agent implementations and model providers.
  • The separation enables researchers to compare agents while holding the execution environment constant.
  • It also makes runtime capabilities independently extensible.

06

Dataset

  • The main software-engineering evaluation uses SWE-bench.
  • SWE-bench contains real GitHub issues from open-source repositories.
  • The paper also evaluates general computer-use and software-development scenarios supported by the OpenHands platform.
  • SWE-bench instances provide issue descriptions, repository snapshots, and test suites.
  • Success is determined by whether the generated changes pass the benchmark's evaluation tests.
  • The platform can execute repository tests inside its isolated runtime.
  • Evaluation focuses on end-to-end task completion rather than only code-generation similarity.

07

Training

  • OpenHands is primarily a platform and inference-time agent framework rather than a newly trained foundation model.
  • Agents use pretrained language models to decide actions.
  • Model-specific behavior is isolated in the agent implementation.
  • The runtime provides tools and feedback without changing the model's parameters.
  • Agent trajectories can therefore be reproduced with different model backends.
  • The platform's main engineering contribution is the standardized interaction and execution layer.
  • This makes it possible to study model, prompt, tool, and runtime effects separately.

08

Experiments

  • The paper evaluates OpenHands agents on real software-engineering tasks.
  • SWE-bench is the central benchmark for issue resolution.
  • Experiments compare OpenHands configurations with other autonomous coding systems.
  • The evaluation measures resolved issue rate rather than textual similarity to developer patches.
  • Agent trajectories are inspected to identify tool-use and reasoning failures.
  • The platform is tested across repositories with different structures and issue types.
  • The experiments demonstrate that a general computer-use runtime can support software-development agents rather than only specialized code generators.

09

Baselines

  • Comparisons include prior autonomous coding agents evaluated on SWE-bench.
  • The platform is compared with systems such as SWE-agent and other contemporary coding agents.
  • A key baseline is the underlying language model without the full OpenHands tool/runtime loop.
  • SWE-bench's test-based evaluator provides the common success criterion.
  • Different agent implementations can be evaluated under the same runtime to isolate architecture effects.
  • The comparison emphasizes practical issue resolution rather than benchmark-specific answer generation.

10

Results

  • The paper reports competitive SWE-bench performance for OpenHands as a generalist software-development agent.
  • The platform demonstrates that an agent can combine shell, file, browser, and other tools within one trajectory.
  • Separating the agent from the runtime makes it possible to reproduce and compare trajectories.
  • Containerized execution provides an isolated environment for running untrusted generated code.
  • The event-stream architecture supports long trajectories with explicit action and observation records.
  • The results show that generalist computer-use infrastructure can support real repository issue resolution.
  • OpenHands provides a foundation for rapidly iterating on agent policies without rebuilding the execution layer.

11

Conclusion

  • OpenHands provides an open, extensible platform for generalist AI software developers.
  • Its event-driven architecture cleanly separates reasoning from computer execution.
  • The runtime provides a reusable sandbox with tools needed for real software development.
  • Agents can inspect, edit, execute, browse, and iteratively recover from failures.
  • SWE-bench demonstrates the platform's relevance to real GitHub issue resolution.
  • The architecture enables researchers to compare models and agent policies without rebuilding the environment.
  • The broader contribution is infrastructure for reproducible computer-use agent research as well as a practical coding-agent platform.

12

References

  • Primary paper: Xingyao Wang et al., “OpenHands: An Open Platform for AI Software Developers as Generalist Agents,” arXiv:2407.16741.
  • The paper was published at ICLR 2025.
  • The project is available at https://github.com/All-Hands-AI/OpenHands.
  • Primary source: https://arxiv.org/abs/2407.16741.
  • The platform evolved from the OpenDevin project and was renamed OpenHands.
  • Evaluation centers on software-development agents and SWE-bench.
  • The key architectural contribution is a decoupled agent-runtime system connected by an event stream.

Continue reading

Related research

Browse all research