OpenHands Agent Canvas – Self-Hosted Developer Control Center

TL;DR

TL;DR: OpenHands Agent Canvas turns any machine into an always-on AI engineering team — run Claude Code, Codex, or open-source agents on your own hardware with a unified control center for automations and integrations.

Source and Accuracy Notes

⚠️ This section is MANDATORY. All links must be verified from actual source, not guessed.

• Project page: openhands.daytona.io
• Source repository: github.com/openhands/openhands
• License: MIT (verified via GitHub API license.spdx_id)
• Docs: docs.openhands.dev
• HN launch thread: not found — the project predates its Show HN thread (launched 2024)

What Is OpenHands Agent Canvas?

OpenHands Agent Canvas is a self-hosted developer control center for running coding agents. It lets you run OpenHands, Claude Code, Codex, Gemini, or any ACP-compatible agent across local, remote, and cloud backends — keeping your agents running even when your laptop is shut.

From the README: “OpenHands Agent Canvas turns your coding agents into a self-hosted, always-on engineering team. It’s a developer control center for starting conversations and automating everyday tasks — like generating reports that publish to Slack or automatically decomposing GitHub issues into tasks.”

The key difference from hosted AI coding tools is that everything runs on your own infrastructure. Agents can access projects under a PROJECTS_PATH you control, integrate with your internal services, and continue running 24/7 on a server rather than tying up your local machine.

Setup Workflow

Option 1: Without a Sandbox (direct install)

Requires Node.js 22.12.x or later and uv.

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

This starts the full local stack. You can also run components separately:

agent-canvas --frontend-only  # static frontend + ingress only
agent-canvas --backend-only    # agent server + automation backend + ingress only

[!WARNING] Running without a sandbox gives the agent full access to your filesystem. Use a sandboxed setup for untrusted agents.

Option 2: With a Docker Sandbox (recommended for safety)

Prerequisites: Docker (Docker Desktop on macOS/Windows, Docker Engine on Linux) and a host directory for PROJECTS_PATH.

macOS / Linux:

export PROJECTS_PATH="$HOME/projects"  # directory containing your project folders
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.15.0

Option 3: From Source

git clone https://github.com/OpenHands/OpenHands.git
cd OpenHands
npm install
npm run dev

Requires Node.js 22.12.x or later, npm, and uv (for running the agent server via uvx).

Deeper Analysis

Backend flexibility

Agent Canvas supports multiple backend environments simultaneously. From the docs:

“Switch between local, remote, and cloud agents without losing focus. You can share an Agent Server with your team for agents doing code review and dependency updates, then have your personal agents running on your laptop.”

Supported backends include local (direct install), Docker containers, VMs, and cloud-hosted options.

Bring your own model

LLM profiles let you configure which model any agent uses. The docs confirm support for “Use with any LLM” — you are not locked into a specific provider.

Prebuilt automations

The automation system integrates with Slack, GitHub, Linear, and more. Automations can run on a schedule or trigger from webhook events. Example use cases from the docs:

• Generate reports that publish to Slack on a cron schedule
• Automatically decompose GitHub issues into tasks
• Code review workflows that post results to your team channel

ACP agent compatibility

The Agent-Client Protocol (ACP) means you are not locked into OpenHands. Any agent implementing ACP can be plugged in — including Claude Code and Codex.

Practical Evaluation Checklist

• [ ] Clone a repo and have the agent implement a small feature via PR
• [ ] Set up a scheduled automation (e.g., daily standup report to Slack)
• [ ] Switch between local Docker backend and remote VM backend
• [ ] Configure a non-default LLM provider via LLM profiles
• [ ] Verify agent filesystem access is scoped to PROJECTS_PATH

Security Notes

Running an agent without a sandbox gives it full filesystem access. The Docker sandbox approach isolates the agent, but the agent still has read/write access to PROJECTS_PATH. The SELF_HOSTING.md covers security hardening steps — review them before running on sensitive infrastructure.

FAQ

Q: How is this different from Claude Code or Codex directly? A: Claude Code and Codex are hosted or locally-installed tools you interact with directly. Agent Canvas wraps them (and open-source agents) into a control plane with automation, multi-backend support, and webhook triggers — so agents can run unattended on a server and integrate with your toolchain autonomously.

Q: Can I use agents other than OpenHands? A: Yes. The docs explicitly state support for “OpenHands, Claude Code, Codex, Gemini, or any agent with Agent-Client Protocol (ACP).” Not all agents implement ACP, so compatibility depends on the agent.

Q: Does the agent run continuously or only when I am online? A: When running on a server or cloud VM (vs. your laptop), agents can run 24/7. The Docker and VM backend options are designed for always-on deployments.

Q: What infrastructure do I need? A: Minimum: a machine (laptop, Mac Mini, or cloud VM) with Docker and Node.js 22.12.x. The PROJECTS_PATH directory should contain the codebases you want the agent to work on.

Conclusion

OpenHands Agent Canvas fills the gap between interactive AI coding tools (Claude Code, Codex) and fully autonomous CI/CD pipelines. It is MIT-licensed, actively maintained (85k GitHub stars, pushed 2026-08-24), and runs entirely on infrastructure you own. If you want agents that work while you sleep, integrate with Slack and GitHub on a schedule, and are not locked to a single hosted provider, this is worth a weekend experiment.

Start with the Docker one-liner on a spare machine, point it at one repo, and see what the agent produces by morning.