OpenHands is an open-source, autonomous software development agent platform created by All Hands AI that lets AI agents write code, run shell commands, browse the web, and edit files inside an isolated Docker sandbox to complete software engineering tasks end-to-end. Originally launched on March 12, 2024 under the name OpenDevin as a community-built alternative to Devin (AI software engineer), it was renamed to OpenHands on August 26, 2024 and is released under the permissive MIT License. On the SWE-bench Verified benchmark, OpenHands resolves 60.6 percent of real GitHub issues with a single attempt and 66.4 percent with an inference-time scaling strategy, making it one of the strongest open-source AI coding agents. [1] [7] As of June 2026 the GitHub repository had accumulated more than 76,000 stars, making it the most-starred open-source coding agent. [15]

The project's ICLR 2025 paper describes OpenHands as "a platform for the development of powerful and flexible AI agents that interact with the world in similar ways to those of a human developer: by writing code, interacting with a command line, and browsing the web." [1] Its default agent, CodeActAgent, implements the CodeAct framework, which unifies the agent's action space around executable code rather than structured tool calls. This design allows a single agent to fix bugs, implement features, resolve merge conflicts, write documentation, deploy infrastructure, and perform data analysis, all from a natural-language task description. OpenHands is model-agnostic by design: it routes LLM calls through LiteLLM and therefore supports models from Anthropic, OpenAI, Google, Mistral, Cohere, and local deployments via Ollama, vLLM, or SGLang. [1]

The inference-time scaling strategy runs five parallel attempts with Claude 3.7 Sonnet and selects the best solution using a trained critic model, which is what raised the SWE-bench Verified score from 60.6 to 66.4 percent. [7] These results placed OpenHands among the top-performing open-source systems on the benchmark as of late 2025.

When was OpenHands released? (History)

OpenDevin (March 2024)

The project that became OpenHands began as a direct response to the March 2024 debut of Devin (AI software engineer) by Cognition AI. Devin was the first commercially announced autonomous coding agent and generated widespread attention across the software engineering community. Within days of the announcement, Binyuan Hui and Junyang Lin, researchers working on the Qwen large language model series at Alibaba DAMO Academy, created a GitHub repository named OpenDevin with the stated goal of building an open-source equivalent. The repository's tagline, "Code Less, Make More," established the project's ambition to automate routine development work.

The project was created on March 12, 2024. Within weeks it became the number-one trending repository on GitHub, amassing 12,000 stars in its first days and demonstrating that the open-source community shared strong interest in accessible autonomous coding tools.

Graham Neubig, an associate professor at Carnegie Mellon University's Language Technologies Institute with extensive research in NLP and open-source tooling, joined the project early as a core maintainer. Xingyao Wang, a PhD candidate at the University of Illinois Urbana-Champaign studying interactive language agents, and Robert Brennan, who had held product and engineering leadership roles at the open-source Kubernetes governance company Fairwinds and had previously been a senior software engineer at Google, also became principal contributors. These three individuals would go on to co-found All Hands AI.

Formation of All Hands AI

As OpenDevin matured, Brennan, Neubig, and Wang founded All Hands AI to provide institutional backing for the open-source project, pursue commercial applications, and build a hosted cloud service. Brennan became CEO, Wang became Chief AI Officer, and Neubig became Chief Scientist. The company is headquartered in Boston.

On September 5, 2024, All Hands AI announced a $5 million seed round led by Menlo Ventures, with additional participation from Pillar VC, Betaworks, and Rebellion. [2] [3] Notable angels included Thom Wolf, co-founder of Hugging Face; Jeff Hammerbacher, co-founder of Cloudera; and Soumith Chintala, creator of PyTorch and a vice president at Meta. The seed round validated the thesis that open-source AI development tooling could sustain a commercial business.

At the time of the seed announcement, OpenDevin already had over 30,000 GitHub stars and more than 180 unique contributors. [2]

Rebrand to OpenHands (August 2024)

On August 26, 2024, Graham Neubig announced via social media that the project would be renamed from OpenDevin to OpenHands, coinciding with the release of version 0.9.0. [11] The rebrand was made to establish an independent identity separate from the Devin name and to signal that the platform had grown beyond an open-source clone into its own ecosystem. The new name reflected the project's collaborative, human-agent partnership ethos. The GitHub repository moved to the All-Hands-AI organization, and the main repository URL changed accordingly.

Version 0.9.0 shipped a number of new features including improved agent delegation, expanded browser support, and a redesigned event stream architecture. [11]

Series A (November 2025)

On November 18, 2025, All Hands AI, operating publicly as OpenHands, announced an $18.8 million Series A round led by Madrona Venture Group, with participation from Menlo Ventures, Pillar VC, Obvious Ventures, Fujitsu Ventures, and Alumni Ventures. [4] [5] The total capital raised across both rounds reached approximately $23.8 million.

At the time of the Series A, the project had more than 65,000 GitHub stars, more than 7,000 forks, and over three million total downloads. [4] Engineers at AMD, Apple, Google, Amazon, Netflix, TikTok, NVIDIA, Mastercard, and VMware had forked or cloned the repository. Early enterprise adopters reported reductions of up to 50 percent in code-maintenance backlogs by using OpenHands to automate dependency upgrades, lint fixes, and vulnerability remediation. [4]

Soma Somasegar, a partner at Madrona, stated: "Autonomous agents are transforming from side-projects into core members of the engineering team, and OpenHands' open, model-agnostic approach ensures this transformation happens safely, transparently, and at enterprise scale." [5]

One-Year Milestone (November 2025)

In a retrospective blog post published in November 2025, the team noted that the project had completed approximately 3,500 commits and had grown to more than 250 unique contributors since its founding. [6] The project was also accepted as a conference paper at ICLR 2025, lending it academic credibility alongside its practical deployment base. [1]

OpenHands V1 (December 2025)

On December 16, 2025, All Hands AI released OpenHands version 1.0.0, the first major-version release and the culmination of a multi-month rewrite that the team had outlined in a September 2025 post titled "The Path to OpenHands v1." [16] [13] The 1.0.0 release rebuilt the application on top of the new Software Agent SDK and replaced the original V0 architecture, which the maintainers described as a pub/sub EventStream that had accumulated technical debt over its first eighteen months and suffered from thread and async ordering issues. The V1 design adopts a stable, well-typed API intended to serve as a durable foundation for future development, and it reorganizes the codebase into three components: the OpenHands SDK core agent library, a rewritten command-line interface, and a new server that replaces the older AgentController. [16] Alongside the application rewrite, OpenHands Cloud moved to a flat $20 per month subscription with broader model choice and a refreshed graphical interface. [17]

The 1.0.0 release also introduced chat message queuing, a task-tracker interface, and an Azure DevOps integration, and it was followed by a steady cadence of point releases. Version 1.1.0 (December 30, 2025) added OAuth 2.0 Device Flow authentication for the CLI, conversation export, and Forgejo support. [13]

2026 developments

Through the first half of 2026, OpenHands shipped roughly monthly releases that expanded model support, enterprise deployment, and planning capabilities. [13]

In January 2026, All Hands AI launched the OpenHands Index, described as the first broad-coverage, continually updated public leaderboard that evaluates a wide range of language models across a variety of software engineering tasks rather than a single benchmark. [18] The index scores models in five categories, each backed by a specific benchmark: Issue Resolution (SWE-bench Verified), Greenfield Development (commit0), Frontend Development (SWE-bench Multimodal), Software Testing (SWT-Bench), and Information Gathering (GAIA). [18] Its first edition, published on January 29, 2026, evaluated nine models from Anthropic, OpenAI, Google, DeepSeek, and Alibaba Qwen on ability, cost, and runtime. [18] Claude 4.5 Opus was the overall leader, ranking first in issue resolution, frontend development, and test writing, while OpenAI's GPT-5.2-codex placed a close second and excelled at long-horizon greenfield development tasks. [18] The team published a follow-up review, "The OpenHands Index: 3 Months Out," in May 2026. [14]

On the model-support front, version 1.4.0 (February 17, 2026) added support for MiniMax M2.5, and an accompanying February 2026 blog post argued that open-weights models had caught up to Claude Sonnet on agentic coding tasks. [13] [14] Version 1.5.0 (March 11, 2026) introduced a planning agent and a Task List tab that surfaces the agent's real-time task status, along with a slash-command menu for skills and Bitbucket Data Center support. [13] Version 1.6.0 (March 30, 2026) added support for self-hosted Kubernetes deployment with multi-user role-based access control (RBAC), so that organizations can run OpenHands on their own clusters with code that never leaves their environment, and also added hooks support and a "/clear" command. [13] [14] Version 1.7.0 (May 1, 2026) displayed the active LLM on conversation cards and added a SANDBOX_KVM_ENABLED environment variable for KVM-accelerated sandboxes. [13]

OpenHands Enterprise and the Agent Control Plane (May 2026)

On May 6, 2026, All Hands AI launched OpenHands Enterprise, positioning it around an Agent Control Plane: an operational layer for orchestrating, securing, observing, and optimizing fleets of coding agents across an organization. [19] [14] The company framed the move as a shift "from agents to systems," addressing enterprise concerns such as runaway LLM spending and uncontrolled agent permissions. [14] The control plane tracks every token and associates it with a user, session, Git repository, and the skills or plugins involved, which lets teams measure the cost and return on investment of different use cases. [19] It enforces least-privilege access so that agents do not inherit broad developer permissions by default, scoping access to secrets, networks, and external systems at the workflow level. [19] OpenHands Enterprise is offered as a source-available product that customers self-host inside their own virtual private cloud via Kubernetes, with bring-your-own-LLM support across providers such as Anthropic, OpenAI, and Amazon Bedrock, and integrations with GitHub, GitLab, Slack, Jira, and Linear. [20]

As part of the same launch, OpenHands made its Automations feature generally available. [14] Automations let users wire an agent to a trigger such as a GitHub issue, a Slack message, a Jira ticket, or a cron schedule; when the trigger fires, the agent runs in an isolated cloud container, completes the work, and opens a pull request for human review. [20] [14]

How does OpenHands work? (Architecture)

Overview

OpenHands is designed around the principle that AI agents should interact with software environments in the same manner as human developers: by writing code, running commands, and navigating the web. The architecture separates three primary concerns: the agent, which decides what actions to take; the runtime, which executes those actions inside an isolated sandbox; and the event stream, which maintains a chronological log of all actions and observations.

Event Stream and State Model

All interactions between the agent and its environment flow through an append-only event stream. Each step of agent execution reads the full history of typed event objects, including prior actions, observations, and user messages, and appends a new action. This design provides several benefits: complete reproducibility of agent trajectories, straightforward multi-agent coordination through shared logs, and deterministic replay of past sessions for debugging.

The event stream records metadata alongside each event, including token counts for cost tracking and identifiers that enable a parent agent to spawn child agents and route their observations correctly.

Sandboxed Runtime

All agent code execution takes place inside Docker containers. The default runtime image includes a bash shell for system commands, a Jupyter IPython server for interactive Python execution, and a Chromium browser managed by Playwright for web navigation. An internal REST API server running inside the container manages communication between the host process and the sandbox.

This containerization approach means that agents can install arbitrary packages, modify files, and run networked processes without risk of affecting the host machine's state. It also makes agent environments reproducible across different operating systems and hardware configurations.

The BaseWorkspace abstraction supports two deployment modes. In local mode, the sandbox runs as a container on the developer's own machine, which is appropriate for interactive development and prototyping. In remote mode, the sandbox runs on a managed server, which enables headless execution, parallel agent runs, and cloud deployment. The Software Agent SDK formalizes this abstraction and allows the same agent code to operate in both environments with minimal configuration changes. With the V1 architecture, the agent server can also place ephemeral workspaces inside Kubernetes pods in addition to Docker containers. [13]

Action Space and CodeAct

OpenHands's default agent, CodeActAgent, operates within the CodeAct framework developed by Xingyao Wang and collaborators. Rather than exposing a fixed set of named tools, CodeAct expresses all agent actions as executable code. There are three primary action types:

IPythonRunCellAction: executes a Python code cell in the Jupyter kernel and returns its output and any raised exceptions.
CmdRunAction: runs a bash command and returns stdout, stderr, and the exit code.
BrowserInteractiveAction: sends a navigation or interaction command to the Chromium browser and returns an observation containing the HTML, DOM structure, accessibility tree, screenshot, and open-tab state.

A fourth action type, MessageAction, enables the agent to communicate with the human user in natural language to request clarification or confirmation before proceeding.

Because the action space is based on programming language primitives rather than a closed schema, agents can compose sequences of complex multi-step operations, install new tools at runtime, and adapt to tasks that were not anticipated at design time.

BrowserGym Integration

Web interaction is implemented through integration with BrowserGym, a standardized interface for browser-based agent tasks. The BrowsingAgent sub-agent uses BrowserGym's action primitives, including navigation, clicking, form filling, typing, and scrolling, and receives rich observations that include not only the rendered HTML but also the browser's accessibility tree and screenshots. This gives the agent multiple representations of the page state, which improves robustness on modern web applications that rely heavily on JavaScript rendering.

The BrowsingAgent can be invoked autonomously by CodeActAgent through the AgentDelegateAction mechanism, which instructs a parent agent to hand off a subtask to a specialized child agent and resume after receiving the child's result. This multi-agent delegation pattern allows OpenHands to decompose complex tasks: a code-writing agent can pause, delegate a web research subtask to the BrowsingAgent, incorporate the results, and continue coding.

Model-Agnostic LLM Routing

OpenHands routes all LLM calls through LiteLLM, a Python library that provides a unified interface to more than 100 model providers. This means that users can configure the platform to use any supported model by setting environment variables or configuration file entries, without changing any agent code. Supported providers include Anthropic (Claude family), OpenAI (GPT-4o and later), Google (Gemini), Mistral, Cohere, and local models served by Ollama, vLLM, or SGLang. The 2026 releases broadened this roster further, adding first-class support for newer open-weights models such as MiniMax M2.5. [13]

When running with local models, OpenHands requires that the model's context window be set to at least 22,000 tokens, as the default window of many local model servers is too small to hold the event stream for multi-step tasks. Some local models may struggle with reliable tool use if they were not fine-tuned on agent-style trajectories.

OpenHands LM

In November 2025, All Hands AI released OpenHands LM 32B v0.1, a fine-tuned model optimized specifically for use within the OpenHands platform. [9] The model is based on Qwen2.5-Coder-Instruct 32B and was trained using a reinforcement learning framework called SWE-Gym, which generates training data by having the agent attempt tasks on real open-source repositories and fine-tuning on trajectories that were successfully resolved. [9]

OpenHands LM 32B features a 128,000-token context window, making it well-suited for large codebases and long-horizon tasks. Despite having 32 billion parameters, the team reported that it achieves performance comparable to models with significantly more parameters, including DeepSeek V3 at 671 billion parameters, on coding agent benchmarks. [9] The model is published on Hugging Face under an open license. All Hands AI also announced a planned 7-billion-parameter variant for users with limited computational resources. [9]

The team also trained and released a critic model built on Qwen2.5-Coder-Instruct 32B that evaluates agent trajectories using temporal difference learning to propagate unit-test success signals backward through action sequences. [7] This critic model is used in the inference-time scaling approach that raised OpenHands's SWE-bench Verified score from 60.6 to 66.4 percent. [7]

How does OpenHands perform on SWE-bench?

SWE-bench is a benchmark that evaluates software engineering agents on real GitHub issues drawn from popular Python repositories. Each issue requires the agent to identify the relevant code, implement a fix, and produce a patch that passes the repository's test suite. SWE-bench Verified is a curated subset of 500 problems that have been manually validated for correctness of the problem statements.

OpenHands's performance on SWE-bench has improved substantially with each major release:

Version	Model	SWE-bench Lite	SWE-bench Verified
CodeActAgent v1.5	GPT-4o	~7%	N/A
CodeActAgent v1.8	Claude 3.5 Sonnet	26%	N/A
OpenHands (single attempt)	Claude 3.7 Sonnet	N/A	60.6%
OpenHands (5-attempt scaling)	Claude 3.7 Sonnet	N/A	66.4%
Software Agent SDK	Claude Sonnet 4.5	N/A	72%

Beyond SWE-bench, the ICLR 2025 paper reported results across 15 benchmarks covering software engineering, web navigation, and general reasoning tasks. [1] On HumanEvalFix, which evaluates bug repair, CodeActAgent v1.5 with GPT-4o achieved 79.3 percent. On GPQA, a graduate-level science reasoning benchmark, CodeActAgent v1.8 with Claude 3.5 Sonnet achieved 52 percent. On the OS portion of AgentBench, CodeActAgent v1.5 achieved 57.6 percent.

OpenHands also ranked first on Multi-SWE-Bench, a variant of SWE-bench covering eight programming languages including Python, JavaScript, TypeScript, Java, and Go. On LiveSWEBench, which uses issues created after the training cutoffs of common models to prevent contamination, OpenHands was among the top-performing systems as of late 2025.

In January 2026, All Hands AI broadened its own benchmarking beyond a single number with the OpenHands Index, a continually updated leaderboard that pairs SWE-bench Verified (for issue resolution) with commit0, SWE-bench Multimodal, SWT-Bench, and GAIA to measure greenfield development, frontend work, test writing, and information gathering respectively. [18] In its first edition, Claude 4.5 Opus led overall and GPT-5.2-codex finished second, with the index reporting per-model ability, cost, and runtime so that users can pick a model based on their own priorities. [18]

OpenHands CLI

The OpenHands CLI provides terminal-native access to the OpenHands agent. It supports two primary modes of operation:

Interactive mode presents a conversational interface in the terminal in which the user types a task description and observes the agent's actions in real time. The CLI offers save-and-resume functionality so that interrupted sessions can be restarted from the last saved state. It also integrates with the Agent Communication Protocol (ACP), enabling IDE plugins and other developer tools to dispatch tasks to a running agent process.

Headless mode suppresses the interactive terminal display and accepts task instructions via command-line arguments or standard input. This mode is designed for use in CI/CD pipelines, cron jobs, and internal automation systems where human interaction is not required. In headless mode, the CLI can be invoked as a step in a GitHub Actions workflow, a Jenkins pipeline, or any shell script, and will return a structured exit code indicating success or failure.

The CLI also offers a confirmation mode in which the agent pauses before executing any destructive or irreversible action and prompts the user for approval, providing a safety net for local development without the overhead of reviewing every shell command. The V1 rewrite shipped with a fully rebuilt CLI on top of the Software Agent SDK, and later releases added OAuth 2.0 Device Flow login and a slash-command menu for invoking skills and built-in commands. [13] [16]

Software Agent SDK

In November 2025, All Hands AI published a companion paper titled "The OpenHands Software Agent SDK: A Composable and Extensible Foundation for Production Agents," along with the open-source SDK repository at github.com/OpenHands/software-agent-sdk. [10]

The SDK formalizes the internal architecture of OpenHands into a set of composable primitives that developers can use to build custom agents without adopting the full OpenHands application stack. It became the foundation of the OpenHands V1 application released in December 2025. [16] Key components include:

An event-sourced state model with deterministic replay, ensuring that agent sessions can be audited and reproduced exactly.
An immutable configuration system that separates agent behavior settings from runtime environment settings, making it easier to version and share agent configurations.
A typed tool system with native support for the Model Context Protocol (MCP), which enables agents to discover and invoke external tools from MCP-compatible servers.
A workspace abstraction that implements the same agent interface for both local Docker sandboxes and remote cloud sandboxes, so that agents developed locally can be deployed to production infrastructure without code changes.
A built-in REST and WebSocket server that exposes the agent's state and event stream to external clients, enabling the browser-based GUI, VNC desktop viewer, and CLI to all connect to the same running agent session.

On SWE-bench Verified, the SDK-based agent achieved a resolution rate of 72 percent when using Claude Sonnet 4.5 with extended thinking enabled. [10] On the GAIA benchmark for general assistant capabilities, it achieved 67.9 percent accuracy. [10]

All Hands AI Cloud

In November 2024, All Hands AI launched All Hands Online (beta), a hosted version of OpenHands accessible at app.all-hands.dev. [8] The cloud service removes the need for users to run Docker locally and provides several features that are difficult to replicate in a self-hosted deployment:

Stateless session architecture: agent session state is persisted externally so that cloud instances can be terminated and replaced without losing session history, and multiple server instances can serve users simultaneously.
GitHub integration: users connect their GitHub account and the platform automatically clones the selected repository, injects a GitHub token into the agent's environment for pushing commits and opening pull requests, and displays pull request status.
Mobile access: the web-based interface is accessible from mobile browsers, allowing users to monitor or redirect agents from any device.
Redesigned UI: a cleaner interface with improved visibility into agent actions and tool calls.

The hosted service is built on the same open-source codebase, and the team has committed that OpenHands will remain free and open-source for self-hosted use. The cloud service monetizes through a subscription model that adds user management, team coordination, and enterprise security features on top of the open core. Coinciding with the V1 release in December 2025, OpenHands Cloud adopted a flat $20 per month plan with expanded model choice and a redesigned interface. [17]

In May 2026, All Hands AI introduced OpenHands Enterprise, built around an Agent Control Plane that lets organizations orchestrate, govern, and observe fleets of agents, track per-session token cost and return on investment, and enforce least-privilege access. [19] [14] Enterprise customers self-host the source-available platform inside their own virtual private cloud via Kubernetes, bring their own LLM provider, and can make use of the generally available Automations feature, which triggers agents from GitHub, Slack, Jira, or a schedule and has them open pull requests autonomously. [20] [14]

All Hands AI has also announced partnerships with AMD, integrating AMD's Lemonade Server inference runtime with OpenHands to enable locally deployed coding agents on Ryzen AI PCs, emphasizing privacy and cost efficiency for enterprise users who cannot or prefer not to send code to external cloud services.

The platform supports integrations with GitHub, GitLab, Bitbucket, Slack, Jira, and Linear, enabling OpenHands to be embedded into existing engineering workflows.

How does OpenHands differ from Devin, Claude Code, and Cline?

OpenHands occupies a distinct position in the autonomous coding agent landscape by combining open-source availability, model agnosticism, and full-environment sandboxing.

Feature	OpenHands	Devin	Claude Code	Cline
License	MIT (open source)	Proprietary	Proprietary	MIT (open source)
Model support	Any (100+ via LiteLLM)	Proprietary only	Anthropic only	Any
Execution environment	Docker sandbox	Proprietary cloud VM	Host machine	VS Code terminal
Web browsing	Yes (BrowserGym + Playwright)	Yes	No (by default)	Limited
Interface	Web GUI, CLI, SDK	Web app	Terminal (CLI)	VS Code extension
Multi-agent delegation	Yes	Limited	No	No
Self-hosted	Yes	No	Yes (local)	Yes
Cloud hosted	Yes (All Hands Online)	Yes (Devin cloud)	No	No
Pricing	Free (self-hosted); subscription (cloud)	$20/month minimum	$20/month Claude Max	Free (API keys required)
SWE-bench Verified	66.4% (5-attempt)	Reported ~13.86% (original)	Varies by model	Varies by model

Devin by Cognition AI was the commercial product that inspired OpenHands. Devin runs in a fully managed cloud environment with its own browser, terminal, and IDE, and is designed for maximum autonomy with minimal human interaction. It is a closed-source, proprietary service. OpenHands offers comparable autonomous operation but in a fully open, auditable codebase that can be self-hosted and configured with any LLM.

Claude Code by Anthropic is a terminal-based coding assistant that runs directly on the user's machine without Docker. It benefits from tight integration with Anthropic's Claude models and produces high-quality multi-file reasoning. However, it is limited to Anthropic models, does not include built-in web browsing by default, and cannot run agents in the background on remote infrastructure. OpenHands offers greater environment flexibility, web browsing capability, and model choice at the cost of heavier setup requirements.

Cline is an open-source VS Code extension that can autonomously create files, run terminal commands, and apply multi-file changes within the VS Code environment. Like OpenHands, it supports any model provider. Its human-in-the-loop GUI requires approval for each file change or terminal command, which increases safety but reduces the level of autonomous task completion. OpenHands operates at a higher level of autonomy and supports longer-horizon tasks through its sandboxed environment and event-sourced state model, but lacks Cline's tight IDE integration.

What is OpenHands used for? (Use Cases)

OpenHands supports a range of software development use cases that can be delegated to an autonomous agent: [12]

Bug fixing: Given a GitHub issue or a failure description, the agent examines the repository, writes a failing test to reproduce the problem, implements the fix, and opens a pull request. The agent can be triggered automatically when a new issue is filed through GitHub Actions.

Feature implementation: Users describe a desired feature in natural language, and the agent explores the codebase, adds the required code and tests, and submits a pull request for human review.

CI failure diagnosis and repair: When a CI run fails due to a linting error, broken test, or environment issue, the agent can autonomously reproduce the failure, implement the fix, and push a corrected commit, eliminating the repeated push-check-fix cycle.

Merge conflict resolution: When a long-lived feature branch diverges from the main branch, the agent can resolve conflicts, run the relevant unit tests from the workflow configuration, and push a corrected branch.

Documentation generation: The agent reads source code and generates or updates documentation files, API reference pages, or README sections.

Dependency and vulnerability management: The agent scans repositories for outdated dependencies or known vulnerabilities, applies updates, verifies that tests still pass, and opens reviewable pull requests. Early enterprise adopters reported that this use case reduced vulnerability resolution times from days to minutes. [4]

Legacy code migration: The agent can translate legacy codebases, such as COBOL systems, into modern languages with tests and validation, enabling organizations to modernize critical systems.

Data analysis and visualization: The agent can analyze datasets, generate charts, and produce summary reports using Python data science libraries within the Jupyter sandbox.

Infrastructure provisioning: The agent can interact with cloud provider APIs or infrastructure-as-code tools such as Terraform to provision resources, though users are advised to review such actions carefully before applying them to production environments.

Automated code review: Using the Software Agent SDK and GitHub Actions, OpenHands can post inline code review comments directly on pull requests, providing fast automated feedback typically within two to three minutes of a PR being opened.

Triggered automations: With OpenHands Automations, an agent can be attached to a GitHub issue, a Slack message, a Jira ticket, or a cron schedule so that the work runs unattended in an isolated cloud container and arrives as a pull request ready for review. [20] [14]

Reception

The project attracted substantial community attention from its first days. Reaching the top of GitHub Trending within weeks of its March 2024 launch demonstrated the extent of developer interest in open alternatives to commercial coding agents. The ICLR 2025 acceptance of the OpenHands paper represented significant academic recognition of the platform's technical contributions, particularly the CodeAct framework and the multi-agent delegation architecture. [1]

The TechCrunch coverage of the seed round in September 2024 helped bring the project to a wider audience outside the open-source AI community. [3] Joff Redfern, a partner at Menlo Ventures, noted: "AI is going to completely change how developers work." [3]

By the time of the Series A in November 2025, the project had demonstrated measurable enterprise value, with adopters at major technology companies reporting meaningful reductions in development toil. [4] The Madrona-led round signaled that institutional investors considered OpenHands's open-source-led, enterprise-monetization model viable.

The research community has engaged with the platform as both a subject of study and a tool for conducting evaluations. The 15-benchmark evaluation framework included in the OpenHands paper has been adopted or referenced by subsequent work on agent evaluation, and the public release of the critic model and the OpenHands LM 32B weights contributed to the reproducibility of benchmark results. [9]

In 2026 the OpenHands Index attracted attention as an independent, vendor-published view of how the leading models compare on practical software engineering tasks, offering performance, cost, and runtime data that is not generally available from closed commercial coding agents. [18] The May 2026 launch of the Agent Control Plane was covered by the technology and business press as part of a broader race to provide a governance layer for enterprise agent fleets, with commentary noting that OpenHands aimed to bundle budgeting, routing, security, and observability into a single platform before larger incumbents folded those capabilities into their own offerings. [19]

Is OpenHands open source? (Limitations)

OpenHands is fully open source under the MIT License for self-hosted use, and the team has committed to keeping the self-hosted edition free; only the hosted cloud and the source-available Enterprise edition are commercialized. [1] [20] Despite its capabilities, OpenHands has a number of documented limitations:

Context window degradation: Long multi-step tasks can fill the LLM's context window, forcing the platform to trim earlier portions of the event stream. When this trimming occurs, the agent may lose track of earlier instructions, previously established constraints, or the structure of files it has already seen, leading to inconsistent behavior or repeated work.

Sensitivity to model quality: The platform's performance is directly tied to the capabilities of the underlying LLM. Smaller local models frequently fail to use tools reliably, ignore provided instructions after a few steps, or produce repetitive action sequences. The minimum recommended model for productive use is a large frontier model or the purpose-built OpenHands LM 32B.

Single-user design of self-hosted instance: The community self-hosted version is intended to be run by a single user on a local workstation. It includes no built-in authentication, user isolation, or access control. Deploying it as a multi-tenant shared service historically required significant additional engineering, although the OpenHands Enterprise edition introduced in 2026 addresses this gap with Kubernetes-based multi-user deployment, RBAC, and SSO. [19] [13]

Task scope and complexity ceiling: While OpenHands performs well on well-defined, bounded tasks such as fixing a specific GitHub issue, it can struggle with very large-scale refactors that require coordinating changes across dozens of interacting subsystems, or with tasks that require sustained judgment calls about product direction rather than mechanical implementation.

Nondeterminism and hallucination: As with all LLM-based agents, OpenHands can produce incorrect code, misread error messages, or make incorrect assumptions about library APIs. The event stream provides a complete audit trail for detecting such errors, but the platform does not have a built-in mechanism to guarantee that generated code is semantically correct beyond running the available tests.

Docker dependency: The Docker requirement adds setup overhead compared to tools that run directly in the terminal or as IDE extensions. Users on shared servers, certain CI environments, or systems without Docker-in-Docker support may face configuration challenges.

References

Wang, Xingyao, et al. "OpenHands: An Open Platform for AI Software Developers as Generalist Agents." arXiv:2407.16741. Accepted at ICLR 2025. https://arxiv.org/abs/2407.16741
All Hands AI. "Press Release: All Hands Announces $5M to Scale AI Agent for Software Development." OpenHands Blog, September 5, 2024. https://openhands.dev/blog/press-release-all-hands-announces-5m-to-scale-ai-agent-for-software-development
Roof, Katie. "All Hands AI raises $5M to build open source agents for developers." TechCrunch, September 5, 2024. https://techcrunch.com/2024/09/05/all-hands-ai-raises-5m-to-build-open-source-agents-for-developers/
All Hands AI. "We've Just Raised $18.8M to Build the Open Standard for Autonomous Software Development." OpenHands Blog, November 17, 2025. https://openhands.dev/blog/weve-just-raised-18-8m-to-build-the-open-standard-for-autonomous-software-development
BusinessWire. "OpenHands Raises $18.8M Series A to Bring Open-Source Cloud Coding Agents to Enterprises." November 18, 2025. https://www.businesswire.com/news/home/20251118768131/en/OpenHands-Raises-$18.8M-Series-A-to-Bring-Open-Source-Cloud-Coding-Agents-to-Enterprises
All Hands AI. "One Year of OpenHands: A Journey of Open Source AI Development." OpenHands Blog, March 17, 2025. https://www.openhands.dev/blog/one-year-of-openhands-a-journey-of-open-source-ai-development
All Hands AI. "SOTA on SWE-Bench Verified with Inference-Time Scaling and Critic Model." OpenHands Blog, April 17, 2025. https://www.openhands.dev/blog/sota-on-swe-bench-verified-with-inference-time-scaling-and-critic-model
All Hands AI. "Announcing All Hands Online (Beta)." OpenHands Blog, November 2024. https://openhands.dev/blog/announcing-all-hands-online-beta
All Hands AI. "Introducing OpenHands LM 32B -- A Strong, Open Coding Agent Model." OpenHands Blog, 2025. https://openhands.dev/blog/introducing-openhands-lm-32b-a-strong-open-coding-agent-model
Wang, Xingyao, et al. "The OpenHands Software Agent SDK: A Composable and Extensible Foundation for Production Agents." arXiv:2511.03690, November 2025. https://arxiv.org/abs/2511.03690
Neubig, Graham. "Announcement: the maintainers team of the OpenDevin open AI software development agent have decided to rename the project to OpenHands." X (formerly Twitter), August 26, 2024. https://x.com/gneubig/status/1828097484599759349
All Hands AI. "8 Use Cases for Generalist Software Development Agents." OpenHands Blog, 2025. https://openhands.dev/blog/8-use-cases-for-generalist-software-development-agents
OpenHands GitHub Repository, Releases page (v1.0.0 through v1.7.0, December 2025 to May 2026). https://github.com/OpenHands/OpenHands/releases
OpenHands Official Website and Blog. https://openhands.dev and https://www.openhands.dev/blog
OpenHands GitHub Repository. https://github.com/OpenHands/OpenHands
All Hands AI. "The Path to OpenHands v1." OpenHands Blog, September 4, 2025. https://www.openhands.dev/blog/the-path-to-openhands-v1
All Hands AI. "All New OpenHands Cloud: More Model Choice, Lower Prices, Slicker Design." OpenHands Blog, November 2025. https://openhands.dev/blog/all-new-openhands-cloud-more-model-choice-lower-prices-slicker-design
All Hands AI. "Introducing the OpenHands Index." OpenHands Blog, January 29, 2026. https://www.openhands.dev/blog/openhands-index
BusinessWire. "OpenHands Launches an Agent Control Plane to Manage Software Agents." May 6, 2026. https://www.businesswire.com/news/home/20260506314667/en/OpenHands-Launches-an-Agent-Control-Plane-to-Manage-Software-Agents
OpenHands. "OpenHands for Enterprise: Secure, Scalable Agentic Software Development." https://www.openhands.dev/enterprise

Editing: OpenHands