OpenHands

OpenHands is an MIT-licensed project whose repository now leads with Agent Canvas, a self-hosted control center for running coding agents and automations. It runs its own OpenHands agent and can drive Claude Code, Codex, Gemini CLI, Pi and OpenCode. Self-hosting is free; the paid Teams plan is $500 a month. Checked 31 October 2026.

At a glance

What it is now

Older write-ups describe OpenHands (formerly OpenDevin) as an open source AI software engineer with a web UI. The repository today looks different. Its README is titled "Agent Canvas" and calls it "the self-hosted developer control center for coding agents and automations."

In plain terms: Agent Canvas is a dashboard on your own machine or server where you start agent conversations, schedule automations and switch between places where agents run. The README says it "turns your coding agents into a self-hosted, always-on engineering team."

Key ideas from the README:

• Bring your own agent. It runs the open source OpenHands agent out of the box, and it can use third-party agents including Claude Code, Codex, Gemini CLI, Pi and OpenCode, or any agent that speaks the Agent Client Protocol (ACP).
• Multiple backends. Run agents locally, in Docker containers, on VMs, or in your company infrastructure, and switch between them from the same interface. A team can share an agent server for code review and dependency updates while individuals run personal agents on their laptops.
• Automations. Build workflows that connect to Slack, GitHub, Linear and more, on a schedule or in response to webhook events. Examples in the README: reports that publish to Slack, or decomposing GitHub issues into tasks.
• Bring your own model. Use with any LLM, with profiles in the settings.
• Cloud options. You can choose to run agents on OpenHands Cloud or OpenHands Enterprise infrastructure.

This makes OpenHands less a competitor to Claude Code than a layer above it. It can host Claude Code. That is unusual, and it matters for teams that use several agents and want one place to manage them.

Install

Four options in the README. Pick by how much you trust the agent with your machine.

The npm route needs Node.js 24 or later and uv. Open http://localhost:8000. For the Docker image, the interface is at http://localhost:8000/canvas.

The README's warning for options 1 and 4 is blunt: "This runs the agent-server directly on the machine you're installing on, so the agent will have full access to your filesystem!"

A minimal Docker run, from the README:

export PROJECTS_PATH="$HOME/projects"
mkdir -p "$PROJECTS_PATH" "$HOME/.openhands"
docker run -it --rm \
  -p 127.0.0.1:8000:8000 \
  -e AGENT_CANVAS_ALLOW_LAN_SESSION_KEY=true \
  -v "$HOME/.openhands:/home/openhands/.openhands" \
  -v "${PROJECTS_PATH}:/projects" \
  ghcr.io/openhands/agent-canvas:1.34.0

Option 3 is the one for several agents at once: each new conversation gets its own container with its own agent server. Workspace files and history survive container replacement, but conversations that use the same host workspace share those files, so use separate directories or worktrees to avoid conflicts. Windows steps are in a separate README.

Network exposure

By default, local launchers bind to loopback only (127.0.0.1). To listen on all interfaces you pass a host flag, and then the auto-injected session key is not used and the UI asks for an API key. If you publish the Docker port on a LAN or public interface, set a strong LOCAL_BACKEND_API_KEY. The project also has a self-hosting guide with security hardening notes. Treat an agent server as a remote-execution service: anyone who can reach it can ask an agent to run commands.

Plans and prices

From openhands.dev/pricing on 31 October 2026:

The page lists no Cloud prices and does not mention credits. OpenHands Cloud is described in the docs as "the hosted cloud version of OpenHands", with sign-in through GitHub, GitLab or Bitbucket at app.all-hands.dev and guides for those providers and for a Slack app. Neither the pricing page nor the Cloud docs state a Cloud price or credits, so check the app for those.

You also pay for models. Agent Canvas uses your own LLM key; third-party agents such as Claude Code bring their own billing. See LLM API prices.

Automations in practice

The README names three kinds of automation: scheduled runs, webhook-triggered runs, and integrations with Slack, GitHub, Linear and similar tools. Here is how a team might use them, as an illustration of the design, not a tested recipe.

Each of these keeps a person in the loop at the end: a message, a comment, a draft, a pull request. That is the safe pattern. Avoid automations that merge, deploy or delete without an approval step.

Running one shared agent server for a team

The README describes a pattern worth copying: a shared agent server for team work such as code review and dependency updates, while each person keeps personal agents on their laptop. To do it well:

1. Run the backend on a small server or VM, in a Docker sandbox, with a strong API key.
2. Put it behind your normal access controls: a VPN or an authenticating proxy, not a bare public port.
3. Use separate workspaces per repository, so one conversation cannot read another project.
4. Set budgets on the model keys that the shared agents use.
5. Log what agents do, and review the logs during the first month.
6. Decide who may start conversations. The Teams plan lists RBAC and SSO for this reason.

The OpenHands self-hosting guide in the repository covers security hardening, and the README points to it especially for cloud servers. Read it before exposing anything.

A short history, since old articles confuse

The GitHub repository dates from March 2024, and the hosted app lives at app.all-hands.dev. For a long time the project meant a single web app with its own agent. The current README presents Agent Canvas as the main product and treats the OpenHands agent as one agent among several. If an older tutorial tells you to run a different Docker image or start a different UI, check the date and follow the current README instead.

What it does well

• Self-hosted by design. Code and agent runs stay on infrastructure you choose.
• Agent neutral. One control center for several agents, through ACP.
• Isolation options. Docker sandboxes, down to one container per conversation.
• Automations. Scheduled and webhook-driven workflows tied to Slack, GitHub and Linear.
• MIT licence. Simple terms, and a very active project.
• Team features at a flat price. $500 a month for up to 10 users, with SSO.

Limits

• You operate it. Docker, networks, updates and keys are your job.
• Unsafe by default on the simplest route. Option 1 has full filesystem access.
• Moving target. The README's focus changed from an agent to a control center; older tutorials do not match.
• Teams cap. 5,000 sessions a month, and the pricing page lists "Up to 10 users" beside "+$50/mo per seat" without explaining how the two fit together, so ask OpenHands before you plan for more than 10 users.
• Third-party agents keep their own terms. Running Claude Code through Canvas does not change Anthropic's licence or billing.
• Pre-sales detail missing. We could not find Cloud pricing.

OpenHands versus the others

See open source AI agents and enterprise AI coding agent security.

Who should pick it

Pick OpenHands if you run several coding agents and want one self-hosted place to manage them, if your company needs agents to run on its own servers, or if you want scheduled automations tied to Slack and GitHub. It suits platform teams and security-conscious companies. It is overkill for a solo developer who wants one terminal agent; try OpenCode or Claude Code instead.

Before you adopt it for a team

Run a two-week pilot with a small group. Install option 3, with one container per conversation, on a spare server. Connect one repository and one automation, such as a weekday pull request summary posted to Slack. Track who uses it, what the agents did, and what you had to fix. At the end, decide on three things: whether the isolation model satisfies your security team, whether the Teams features justify $500 a month, and which third-party agents you will allow inside it. Write the decisions down so a new team member does not reinstall it without a sandbox.

A last practical note: record which agent and model produced each pull request, in the PR description or a label. When several agents run behind one control center, that record is the only way to learn which combination performs well, and which one to switch off.

Our take

This is an editorial reading of the repository and pricing page, not a hands-on test.

OpenHands made a smart move: instead of racing every vendor to build the best single agent, it became the place where agents run. If your team already uses Claude Code and Codex, a control center with isolation and automations is more useful than yet another agent. The MIT licence and the flat Teams price are attractive for the same reason.

The price of that design is operations. You choose the sandbox, the network exposure and the keys. Start with option 2 or 3, never option 1, bind to loopback until you have an authentication story, and write down who may start an agent that can run commands. For a single developer, the simpler tools remain simpler.

Checklist

• Decide whether you need a control center or just one agent
• Use a Docker sandbox, not the no-sandbox install
• Mount only the project directories the agent needs
• Keep the listener on loopback, or set a strong API key
• Give agents narrow credentials and spend caps
• Confirm Teams pricing and the session cap with the vendor
• Review each third-party agent's own terms before adding it