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.
Source trail
Primary papers, implementation pages, and external source records used to ground this explainer.
Continue reading
Related research
AI Agents
GitSwarm
GitSwarm turns inference-time work into a persistent, branchable body of reusable contributions that later agents can build on.
AI AgentsLongHarness
LongHarness helps agents reason over 100M-token document collections by keeping evidence and conclusions as explicit, revisable states that guide one another.
AI AgentsGenerative Agents
An agent architecture combining memory, retrieval, reflection, and planning to simulate believable long-horizon behavior.