On June 16, 2026, OpenHands introduced Agent Canvas, a self-hostable workspace for defining coding agent automations that run on schedules or in response to external events. Where OpenHands historically focused on interactive terminal sessions, Agent Canvas targets the operational layer: recurring repo hygiene, Slack-triggered fixes, GitHub webhook reactions, and Linear ticket follow-ups that should happen whether or not someone has a terminal open.
From One-Off Sessions to Durable Workflows
A single OpenHands session excels at exploratory work: read the codebase, run tests, iterate on a branch until the task is done. That model breaks down when the same job must run every Monday, or every time a dependency bot opens a PR, or when a Slack emoji reaction should spawn a background investigation.
Agent Canvas treats automations as first-class objects with triggers, execution environments, and audit history. You compose workflows visually (the "canvas" metaphor), attach prompts and tool policies, and let the platform dispatch runs when conditions match. Human sessions and automated runs share the same underlying agent runtime, but Canvas adds the scheduling, routing, and org visibility layers interactive CLI use never needed.
Triggers: Slack, GitHub, Linear, and Cron
Launch integrations cover the coordination surfaces web teams already inhabit:
- Slack. Kick off agent runs from channel messages, slash commands, or reactions when a human asks for help or approves automated work.
- GitHub. React to issues, PR comments, label changes, or CI conclusions without writing custom Actions YAML for every variant.
- Linear. Tie agent workflows to ticket state transitions so engineering bots update code when status moves from triage to in progress.
- Schedules. Cron-style triggers for weekly dependency reports, stale branch cleanup suggestions, or documentation drift checks.
The goal is not to replace GitHub Actions for deterministic CI. It is to host judgment-heavy agent tasks adjacent to the events that create them, with OpenHands handling sandboxing and model calls instead of bolting an LLM step onto a brittle shell script.
Deployment Path: Local, VM, Cloud
Agent Canvas follows OpenHands' established local to VM to cloud progression. Teams can prototype automations on a developer machine, promote the same definitions to a VM or Kubernetes deployment for team-wide triggers, and optionally use OpenHands Enterprise as the managed control plane for org policy, secrets, and run history.
Self-hosting matters for teams who cannot send repository contents to a vendor SaaS but still want event-driven agents. MIT licensing on the open-source components keeps the escape hatch visible: you can run Canvas on your infra without a perpetual cloud subscription, then add Enterprise features when you need centralized governance.
ACP: Claude Code, Codex, and Third-Party Harnesses
Agent Canvas integrates with external agent harnesses through the Agent Client Protocol (ACP). That means workflows can dispatch Claude Code or OpenAI Codex sessions rather than locking you into OpenHands' default model stack. ACP acts as the bridge between Canvas' orchestration layer and whichever CLI or IDE agent your team standardized on.
For organizations running multiple agent products, ACP reduces duplicate automation definitions. One Canvas workflow can route trivial tasks to a cheaper local model profile and escalate complex refactors to Claude Code with full repo tool access, all from the same trigger definition.
LLM Profiles and Cost Control
Scheduled automations can burn token budgets fast if every cron job invokes a frontier model on an entire monorepo. Agent Canvas introduces LLM Profiles: named bundles of model choice, temperature, max tokens, and tool allowlists you attach per workflow step.
A nightly "summarize open PRs" job might use a small, fast model. A "fix failing E2E on main" workflow might escalate to a larger model only when tests fail. Profiles make cost predictable and reviewable by platform teams who otherwise discover runaway bills after an agent looped for forty minutes.
OpenHands Enterprise Control Plane
The open-source Canvas runtime covers execution and triggers. OpenHands Enterprise adds the control plane larger orgs expect: SSO, role-based access to workflows, centralized secrets, run logs exportable to SIEM, and approval gates before automations with write access merge to default branches.
That split mirrors how many teams adopt infra tools: MIT core on their cluster, paid layer for compliance features. Agent Canvas is useful solo; Enterprise is for when legal asks who authorized the bot that pushed to production.
Contrast With Terminal-Only Agents
Claude Code, Cursor, and Copilot CLI optimize for a developer at a keyboard starting a session. Agent Canvas optimizes for org memory: the automation persists, triggers fire without human initiation, and run history accumulates for retrospectives.
GitHub Agentic Workflows (see our Agentic Workflows coverage) pursue a similar outcome inside Actions with Markdown-authored jobs. OpenHands positions Canvas as harness-neutral and self-hostable first, which appeals to teams who want Slack and Linear triggers without committing every agent job to GitHub's runtime and Copilot billing defaults.
Why It Matters for Web Developers
Web codebases generate repetitive agent-suitable work: update snapshots when components change, triage accessibility regressions from CI artifacts, sync design tokens from Figma exports, respond to Dependabot with reachability analysis. Canvas lets you codify that once and attach it to the event source instead of relying on someone remembering to run a script.
Start with read-only scheduled reports before granting write triggers on production repos. Use LLM Profiles aggressively. If you already run OpenHands interactively, Agent Canvas is the path from "this prompt worked once" to "this prompt runs every time the condition fires."