OpenHands is an open source AI-driven development agent project. The goal is to allow Agents to perform analysis, modification and verification tasks in real code warehouses, improving the automation efficiency of engineering teams.

OpenHands

Core parameters and statistics of OpenHands

The official positioning of OpenHands is "a self-hosted developer control center for coding agents and automation." It is not a single-round question and answer assistant, but a complete agent runtime platform - covering conversational development, automated workflow orchestration, multi-backend switching and enterprise-level governance at the same time.

Projects	Public Information
Product positioning	The self-hosted developer control center for coding agents and automations
Code repository	OpenHands/OpenHands
Main languages	Python 65.1%, TypeScript 33.5%
Open source license	Repository public (see License)
Community size	81.2k+ stars, 10.4k+ forks, 519+ contributors
Mainline version	1.11.0 (2026-07-09)
Cloud version	cloud-1.46.2 (2026-07-15)
Delivery form	Open source code + Agent Canvas console + Agent Server API
Protocol standards	Agent-Client Protocol (ACP) compliant
Sandbox mechanism	Docker container isolation execution
Connect Ecosystem	MCP Server ~400+

Version line description: OpenHands maintains two version lines - the main line (1.x) is for open source community self-hosting scenarios, and the cloud version (cloud-1.x) is for SaaS users. Both share the core Agent runtime, but the cloud version includes enterprise-grade features (usage dashboard, budget alerting, SaaS certification). The latest version of the main line is 1.11.0, and the latest version of the cloud version is cloud-1.46.2. The two lines have evolved independently.

Deployment Flexibility: OpenHands supports mounting multiple backends in the same Agent Canvas frontend - local Docker containers, remote VMs, and OpenHands Cloud. The team can share an Agent Server for code review and dependency updates, and the individual Agent runs locally, and the two can be switched in the same UI. This "unified front-end, separated back-end" architecture is its core difference from similar tools.

User and market recognition of OpenHands

OpenHands' market recognition is reflected in the rapid growth of the open source community and the continuous improvement of enterprise-level functions.

Community Popularity: 81.2k+ stars and 10.4k+ forks, making it one of the highest-starred AI coding Agent projects on GitHub. The scale of 519 contributors shows that it has surpassed the individual project stage and formed a collaborative ecosystem driven by the core team and the community. In the past week (2026-07-08 to 2026-07-15), 8 versions have been released intensively, and the iteration rhythm is extremely fast.

Enterprise Signal: The existence of the Enterprise directory (including SaaS certified BYOR key management Agent Profiles, usage dashboard, and budget alerts) indicates that the project has incorporated enterprise-level governance into product planning. The continuous release of cloud version cloud-1.46.2 (2026-07-15) shows that its SaaS commercial version is rapidly iterating.

Undisclosed items: Official undisclosed data on the number of corporate customers and business revenue. The "adoption enthusiasm" of an open source project is not completely equivalent to the "production context stability". When evaluating, it is necessary to distinguish between the number of stars and the actual deployment volume.

Cost Advantages of OpenHands

The cost advantage of OpenHands comes from the three-tier structure of "open source core free + self-hosting optional + cloud service on demand", which allows teams to switch cost models according to development stages.

C side/individual: The open source code is completely free. Developers can start it with one click through npm install -g @openhands/agent-canvas and start using it at zero cost. The main cost for personal use is the LLM API calling fee (you need to bring your own API Key).

Developer/API: There is no software license fee in the self-hosted model, and the cost is concentrated on LLM calling fees, infrastructure (Docker or cloud server) and operation and maintenance manpower. For individual developers, a local computer plus an OpenAI/Anthropic API Key can run all functions.

Enterprise/privatization: Under the open source self-hosting model, enterprises only need to bear the server cost and operation and maintenance manpower. The pricing of the Enterprise Edition (OpenHands Cloud) has not been officially disclosed and needs to be confirmed by the business. The hidden costs of enterprise deployment include: security audit and compliance certification, manual review process design of MCP connector governance Agent output, and regression testing costs caused by version updates.

Deployment method	Software license fee	LLM calling fee	Infrastructure fee	Operation and maintenance manpower	Applicable scenarios
Self-hosted (local)	Free	Pay by yourself	None (already have a computer)	None	Personal development, learning
Self-hosted (server)	Free	Self-pay	Cloud server ~$20-200/month	Part-time operation and maintenance	Small team
OpenHands Cloud	Pay-as-you-go/subscription	Included with subscription	Included	Included	Teams who don’t want to self-host
Enterprise Edition	Business Confirmation	You can bring your own Key	Optional private deployment	Vendor support	Compliance-sensitive industries

Main features of OpenHands

The core capabilities of OpenHands are not a single function, but platform-level capabilities built around the "Agent development life cycle":

• Agent conversational development: Conduct multiple rounds of dialogue with the AI Agent in Agent Canvas, and the Agent independently completes operations such as code writing, terminal command execution, file reading and writing, and web browsing. Every step of the operation is visually presented, and users can observe the Agent's decision-making process in real time and intervene at any time.

• Automated Workflow Orchestration: Supports setting up automated tasks driven by scheduled triggers or Webhook events - such as automatically generating reports every day and publishing them to Slack, automatically decomposing GitHub Issues into subtasks, and automatically running tests after code merging. The automation system is supported by a separate Automation Server.

• Flexible switching of multiple backends: The same Agent Canvas front end can connect to multiple Agent Server backends - switch between local Docker containers, remote VMs, and OpenHands Cloud at any time, and sessions and history remain continuous. A shared Agent Server handles team tasks, and individual Agents handle local development.

• MCP and third-party integration: Supports connecting external tools and services through the MCP protocol. The official warehouse describes about 400 MCP Servers, covering development tools such as Slack, GitHub, Linear, and Datadog. Agent can directly read work orders, send messages, and query monitoring data through the MCP tool, forming an end-to-end automated process.

• Agent-Client Protocol (ACP) Compatible: Not locked to own Agent. The ACP protocol allows access to any compatible Agent backend—including third-party Agents such as Claude Code, Codex, and Gemini. OpenHands can be used as the "Agent control plane" to uniformly manage multiple encoding agents.

• Enterprise-level governance: The enterprise version provides usage dashboards, budget alarm Agent Profiles, BYOR (Bring Your Own Key) key management SaaS certification, audit logs and other functions. Supports visual monitoring and budget control of Agent usage, token consumption, and execution costs.

OpenHands Tool open list

OpenHands Agent interacts with external context through the following toolset, and the large model autonomously selects and calls to complete the interaction context based on the task context:

Tool name	Function description	Typical usage scenarios
read	Read file content	Analyze existing code and view configuration files
write	Write/create files	Generate new code files, modify configurations
edit	Locate lines of replacement text	Precisely modify specific parts of existing code
bash	Execute Shell commands	Run tests, install dependencies, start services
ls	List directory contents	Browse project structure and find files
grep	Text search	Find function definitions and keyword positioning across files
browse	Web browsing and navigation	Check documents and search for technical solutions
screenshot	Page screenshot	Verify UI modification effect
execute	Run code snippets	Quickly verify algorithm logic
mcp_tool	Call MCP Server	Send Slack message, create GitHub Issue
git_operation	Git operations	Submit code, create PR, merge branches

Interaction is closed: LLM receives user tasks → decomposes them into multi-step plans → calls tools to execute in sequence → observes the returned results → adjusts the next action → until the task is completed. The tool invocation process is displayed to the user in real time through streaming output.

OpenHands model and version evolution

The version iteration of OpenHands will accelerate significantly in the first half of 2026. From 1.5.0 (2026-03-11) to 1.11.0 (2026-07-09), 7 mainline version releases were completed in just 4 months, and the cloud version reached the intensive rhythm of cloud-1.46.2.

Mainline release (open source core)

Version	Release Date	Key Changes
1.5.0	2026-03-11	Preorder version nodes in consecutive iterations
1.6.0	2026-03-30	Mainline version node, stability improved
1.7.0	2026-05-01	GitHub Releases public version
1.9.3	2026-07-08	Fix: DB migration index column ACP is enabled by default
1.10.0	2026-07-08	Newly added: SMTP email service, user login tracking, usage dashboard
1.11.0	2026-07-09	New: Warehouse metadata delivery Agent Profiles, budget management dashboard

Cloud version (SaaS business line)

Version	Release Date	Key Changes
cloud-1.43.0	2026-07-08	Added usage dashboard SMTP mail service
cloud-1.46.0	2026-07-10	Added BYOR key alias configuration and archive list enhancement
cloud-1.46.2	2026-07-15	Fix: MCP authentication key saving DB connection pool optimization

Version Rhythm: After entering July, the mainline and cloud versions will enter a "weekly update" rhythm. Zhou Geng stated that the project is in a rapid iteration period, but it also means that the production environment requires a more rigorous version locking and regression testing strategy - it is recommended to verify connector compatibility and Agent output stability in the staging environment before upgrading the production environment.

Technical advantages of OpenHands

The technical advantage of OpenHands is not in the performance of a single model, but in the "unity of the Agent runtime architecture" and "the flexibility brought by multiple backend abstractions".

Architecture link: The core running link of OpenHands can be abstracted as:

User → Agent Canvas (UI) → Agent Server (REST API) → Agent Runtime Engine
                                                          ↓
                                              ┌──────────────────────────┐
                                              │ LLM Orchestration & Tool Routing │
                                              │ ┌────────┐ ┌────────┐ │
                                              │ │ Tool call │ │ MCP │ │
                                              │ │ connector │ │ connector │ │
                                              │ └────────┘ └────────┘ │
                                              └───────────┬─────────────┘
                                                          ↓
                                              ┌──────────────────────────┐
                                              │ Execution Sandbox │
                                              │ (Docker/Local/VM/Cloud) │
                                              └──────────────────────────┘

Control flow: The user intention is converted into an API request through Canvas → Agent Server starts the session → LLM generates an action plan → The tool caller performs specific operations (file reading and writing, command execution, web browsing) → The results are fed back to LLM to decide the next step → Repeat until the task is completed. The data return direction is the same as the execution path, and the execution logs and results of each step are pushed back to the UI in real time.

The value of multiple backend abstractions: Agent Server is a lightweight REST API that can be deployed in any environment that can run Python. Teams can use the same set of Agent orchestration logic to develop CI/CD pipelines locally and pre-release in the cloud, and only need to switch the backend address. This abstraction minimizes differences in Agent behavior between contexts.

Sandbox security mechanism: Provides Docker container isolation and no sandbox (direct running) modes. Docker mode is mandatory for production. All file operations and command execution of the Agent are completed within the container. Even if the Agent behaves abnormally, it will not affect the host system. The sandbox-less mode is suitable for quick verification of personal development situations and is not recommended for use on team shared servers.

ACP Protocol Prospective: The Agent-Client Protocol enables OpenHands not to be tied to a specific model or Agent implementation. When a new coding agent appears, it can access the OpenHands UI and automation system as long as it implements the ACP protocol. This "protocol-first" design reduces the risk of users being locked into a single vendor.

Engineering Pitfall Guide

Based on the architectural features of OpenHands, production context deployment needs to focus on the following issues:

1. Infinite loops and Token inflation control: Agents may fall into infinite loops during complex tasks - repeatedly reading files, trying the same operation, or confirming back and forth under vague instructions. It is recommended to set max_steps (maximum number of execution steps) and global timeout at the Agent Server level; set an upper limit of max_tokens for each tool call; enable repeated action detection - if the Agent executes the same command three times in a row and the result remains unchanged, the session will be automatically terminated. OpenHands' budget management dashboard (cloud 1.46.0+) can be used to set token consumption alarms.

2. Sandbox context overload: The file directory tree of a large code repository (such as a monorepo) can reach thousands of nodes, and the Agent may be "lost" due to the long context when browsing the project structure. It is recommended to use the .openhands_ignore file to exclude irrelevant directories (such as node_modules, dist, .git); in the prompt, guide the Agent to first use ls and grep to locate the target file instead of read the entire directory; for very large projects, first let the Agent use grep to locate key files before operating accurately.

3. Security and unauthorized management: Agent has file reading and writing and command execution capabilities, and may execute dangerous commands in non-sandbox mode. It is recommended that Docker sandbox mode be mandatory for production, and host sensitive directories (such as SSH key Kubernetes configuration) should not be mounted in the container; human-in-the-loop should be set for irreversible operations (git push --force, production database changes, file deletion); and OpenHands Enterprise's BYOR and SaaS authentication functions should be used to implement key isolation and operation auditing. Special note: When running an Agent in a CI/CD pipeline, a read-only token should be used to limit the Agent's code repository write permissions.

How to use OpenHands

OpenHands provides a variety of startup methods, covering the full spectrum of requirements from personal rapid verification to production context deployment:

How to use	Suitable for people	Features	Cost
Docker sandbox mode	All users (recommended)	Container isolation and safe execution, one-line command to start	Only Docker context
Local installation without sandbox	Personal developer	Run directly on the host, fastest startup	Zero cost
Build from source code	Secondary development/customization	Can modify source code and customize Agent behavior	Zero cost
OpenHands Cloud	Teams who don’t want to self-host	SaaS hosting with enterprise-grade features	Pay-as-you-go/Subscription
Enterprise private deployment	Compliance-sensitive industries	Full control over the data plane, support BYOR	Business confirmation

Quick Start—Docker Sandbox Mode (Recommended):

# Prerequisites: Docker, Node.js 22.12+
export PROJECTS_PATH="$HOME/projects"
mkdir -p "$PROJECTS_PATH" "$HOME/.openhands"

docker run -it --rm \
  -p 8000:8000 \
  -v "$HOME/.openhands:/home/openhands/.openhands" \
  -v "${PROJECTS_PATH}:/projects" \
  ghcr.io/openhands/agent-canvas:1

After starting, visit http://localhost:8000. Configure the LLM API Key (supports OpenAI, Anthropic, Google Gemini, etc.) in Settings to start using Agent in the browser.

Quick installation without sandbox:

npm install -g @openhands/agent-canvas
agent-canvas

LLM configuration instructions: OpenHands supports "Bring Your Own Model" (BYOM) and is compatible with API endpoints in the OpenAI format. It is recommended to use Claude Opus 4 or GPT-5.5 Pro for encoding tasks, and Claude Sonnet 4 or GPT-5.5 Flash for light tasks. Models can be dynamically switched on the Settings page of Agent Canvas without restarting the service. The specific list of supported models is subject to official documentation.

Getting Started Path Suggestion: First run a simple task (such as "Add README to this project") in Docker sandbox mode to verify the Agent's interaction process and output quality. Then gradually try automated workflow orchestration and multi-backend switching. For team deployment, it is recommended to establish a baseline of Agent execution quality in non-critical processes before expanding to more complex engineering scenarios.

Product Pricing for OpenHands

The pricing model is subject to the official real-time page. Usually a freemium or subscription system is adopted, basic functions can be used for free, and advanced functions or high-frequency use require payment.

Application scenarios of OpenHands

The implementation scenarios of OpenHands revolve around the main line of "letting the coding agent move from experimentation to production". The following three types of scenarios have been verified at scale:

Code review and dependency update automation: Agent can regularly review Pull Requests, run tests, check code style, and flag potential problems. In dependency update scenarios, Agent can automatically upgrade package versions, fix breaking changes, run regression tests, and submit PRs. Implementation Tips: The Agent's code review results should be used as an auxiliary reference, and key security reviews still require manual confirmation. It is recommended to verify the Agent review accuracy on non-core modules first, and then gradually expand to important modules.

GitHub Issue automatic decomposition and task allocation: When a new Issue is created, Agent can automatically analyze the description content, decompose it into an executable sub-task list, associate related code files, and even generate a preliminary repair plan. Combined with Automation Server's Webhook triggering, end-to-end automation from Issue creation to PR submission can be achieved. Implementation Tips: Automatically generated repair plans need to be manually verified before merging, especially tasks involving database migration, security repairs and API changes.

Slack/Teams Integrated Development Assistant: Agent Canvas can be connected to Slack as an "AI development colleague" of the team. Developers can initiate tasks to the Agent in the chat - "Check the production bounded error log", "Add unit tests to this PR", "Update API documentation". Agent execution results are directly sent back to the Slack channel. Implementation Tip: It is recommended to configure a separate Agent Server for Slack integration to avoid context confusion between personal sessions and production automation tasks.

Not applicable scenarios: OpenHands is not suitable for scenarios that require extremely high certainty in output results (such as financial transaction instruction generation, medical device control code), because the generated results of LLM are inherently uncertain. It is also not suitable for fully automated DevOps pipelines that do not require human review at all - the output of the Agent should always retain human review in the process. For industries that require strict compliance auditing (finance, medical, government affairs), the enterprise version of audit logs and BYOR are necessary prerequisites.

Applicable groups of OpenHands

OpenHands covers the full spectrum of users from individual developers to large enterprises through open source versions and multiple deployment paths:

• Individual Developers and Freelancers: Free to use via local installation or Docker sandbox. Suitable for daily coding assistance, project prototype building, technical learning and other scenarios. Not suitable for the boundary: For simple script tasks that do not require Agent interactive development, use OpenHands to increase startup complexity, and it is more efficient to directly use lightweight tools such as Claude Code or Cursor.

• R&D Team and Platform Engineering Team: the core target users of OpenHands. Teams can deploy Agent Server on a shared server, and members can use Agent capabilities through a unified console. Automated workflow orchestration helps teams standardize repetitive engineering tasks (dependency updates, code reviews, test completion). Implementation Tips: Before deployment, it is necessary to clarify the boundaries of the Agent's operation permissions - which code repositories can be modified, which contexts can be accessed, and whether operations require manual approval.

• DevOps and SRE Team: Use the scheduled triggering and Webhook capabilities of Automation Server to embed Agent into the operation and maintenance pipeline - automatically analyze alarm logs, generate incident reports, and execute regular operation and maintenance scripts. Not suitable for boundaries: Agent is not suitable for directly operating production-bound databases, configuration centers and sensitive permission systems. In operation and maintenance scenarios, Agent should remain in the "suggestion generation + manual confirmation" mode.

• Corporate R&D Manager: Pay attention to the quantitative improvement of development efficiency. The budget management dashboard and usage tracking function can help managers understand Agent usage frequency, token consumption and task completion. Purchasing Prerequisites: Enterprises should have clear AI coding-assisted implementation directions and quantifiable efficiency indicators (such as PR review cycle reduction percentage, automated task completion rate), and blind deployment for the sake of "getting to AI first" is not recommended.

Summary and Outlook

Through the combination of "open source Agent runtime + unified control plane + multi-backend abstraction + enterprise-level governance", OpenHands has established a differentiated competitive position in the field of AI coding Agents - it is not the most lightweight Agent tool, but it is probably the most complete "Agent operating system" in architecture.

Current Core Advantages: The open source community with 81.2k+ stars has verified its developer recognition. The three-layer architecture of Agent Canvas + Agent Server + Automation Server covers all scenarios from conversational development to production automation. The forward-looking design of the ACP protocol makes OpenHands not limited to a single agent vendor. The continued expansion of the MCP ecosystem (approximately 400 integrations) increases the platform’s connectivity.

Main current limitations: The project is still in a rapid iteration period with weekly updates, APIs and configuration items may change frequently, and long-running automation tasks need to pay attention to version compatibility. The pricing of the cloud version and enterprise version has not been disclosed, making it difficult for enterprise purchases to make a complete TCO assessment. Although the documentation and tutorials are available at https://docs.openhands.dev, some of the content is still under construction, and newbies need to spend some time to get started. The configuration complexity of sandbox mode and MCP connection is higher than that of pure command line tools (such as Claude Code), and is not suitable for users who pursue "zero configuration".

Follow-up observation points: When will the mainline version stabilize and enter the LTS rhythm; the number and maturity of third-party Agent access to the ACP protocol; the official pricing release of OpenHands Cloud; the degree of perfection of the enterprise version in compliance auditing and SSO; the maintenance quality of the MCP connector and the activity of community contributions.

Procurement and Adoption Risk Assessment: For individual developers and technical teams, there is no real risk in zero-cost trial and error of the open source version, and it is worth incorporating it into the Agent tool chain for verification. For enterprises, it is recommended to first try the open source version in non-critical processes (such as internal tool development, document generation, test completion), establish Agent execution quality benchmarks and human-computer collaboration processes, and then evaluate whether to upgrade to the Cloud or Enterprise version. Before purchasing, it is important to confirm: the data residency and compliance certification of the enterprise version, the key management granularity of the BYOR mode, and the impact assessment of model version updates on existing automation tasks. In any case, Agent tasks involving production context modifications and access to sensitive data should retain a manual review step.

Related tools: CrewAI, LangChain

How to use OpenHands

• Web client: You can use it by visiting the official website and registering an account. Most functions do not require installation.
• API Access: Provides RESTful API, developers can obtain the API Key and integrate it into their own applications.

Version Info

• OpenHands 1.7.0 ：The latest public version of GitHub Releases continues to strengthen AI-driven development capabilities. （2026-05-01）
• OpenHands 1.6.0 ：Mainline version node. （2026-03-30）
• OpenHands 1.5.0 ：Preamble version in successive iterations. （2026-03-11）