OpenHands Canvas runs agents on local backends

The OpenHands Agent Canvas operates as a self-hosted control center for running multiple coding agents, announced by @GithubProjects on Jul 7, 2026 in a post that garnered 16.1K views. This tool transforms local development environments into an always-on engineering team by orchestrating diverse agent backends without context loss. True autonomy demands the flexibility to switch infrastructure layers dynamically while maintaining smooth integration with existing workflow tools.

The Canvas runs OpenHands, Claude Code, Codex, or any ACP-compatible agent on hardware the team owns, and a session survives the move between a local process, Docker, a VM, and a cloud backend. Automations reach Slack, GitHub, and Linear from either side of that boundary. What the arrangement costs is ownership: container images, network policy, and uptime stop being someone else's problem.

Backends, Isolation, and the State That Moves Between Them

Deploying Multi-Backend Automations with Slack and Linear

Engineers build Slack and Linear automations by routing events through local or remote agent backends without breaking session state. This configuration allows teams to trigger OpenHands, Claude Code, or Codex via webhooks while preserving the full conversation history across infrastructure boundaries. The system executes logic on Docker containers or virtual machines, isolating tool use from the host operating system.

Running the OpenHands Agent Canvas locally ensures proprietary code never leaves the corporate network perimeter, which is the whole reason to accept the operational bill that comes with it.

Operational overhead increases notably. Managing Docker images and network policies requires more effort than consuming a managed API. This cost grants precise control over tool permissions and execution logs. Teams can configure specific agents for distinct tasks, such as using Codex for documentation and OpenHands for refactoring, all coordinated through a single interface. Such flexibility supports complex workflows where security boundaries dictate execution location.

That burden shifts to the engineering team, which now owns the security patches and uptime guarantees a vendor used to carry. The OpenHands Agent Canvas turns coding agents into a self-hosted, always-on engineering team, but only if the underlying network permits persistent connections to external tool APIs without aggressive timeout policies.

Smooth Context Persistence During Backend Switching

State continuity survives backend migration by serializing the agent state to a persistent volume before execution handoff. When an operator switches from a local process to a Docker container, the system decouples the logical workflow from the physical runtime environment. This mechanism prevents context loss during backend switching, ensuring that conversation history and file system modifications remain intact regardless of the underlying sandbox.

Unlike local-only helpers, cloud-hosted agent backends maintain server-side processes that survive laptop shutdowns, enabling true 24/7 operation. This architecture allows teams to scale from individual prototyping on local machines to sustained, automated engineering workflows on remote infrastructure without manual state transfer.

Maintaining this continuity introduces a dependency on the storage backend's availability and latency. If the persistent volume locks or lags during a handoff, the orchestration layer may timeout, forcing a restart of the agent loop rather than a smooth resume. Builders must configure storage backends with concurrent read-write access to prevent race conditions when multiple agents attempt to access the same context window.

Docker Containers Versus Virtual Machines for Agent Isolation

Docker containers prioritize startup latency while Virtual Machines enforce hardware-level boundaries for execution. Choosing between these backends determines the isolation depth available to agentic workflows. Docker uses kernel namespaces to separate processes, offering rapid scaling for ephemeral coding tasks. Conversely, Virtual Machines virtualize the underlying hardware, creating a stricter perimeter against malicious code execution. Organizations maintaining strict data sovereignty often prefer the latter so proprietary code never traverses public internet boundaries unless explicitly configured. Resource consumption defines the constraint. VMs incur higher overhead than containerized counterparts.

Deploying and Configuring the Agent Control Center

Defining the Local-First Agent Control Center Architecture

The local-first architecture supports running agents across local, cloud, and remote backends to maintain data sovereignty. This control center orchestrates workloads across four distinct environments: local machines, Docker containers, Virtual Machines, and private company infrastructure. Unlike proprietary assistants requiring cloud execution, the platform runs entirely on user-owned systems unless explicitly configured for remote backends. The OpenHands project has accumulated over 65,000 stars on GitHub, indicating a significant level of community engagement and adoption within the open-source system.

1. Install the core platform to access the local developer workflow for rapid prototyping.
2. Deploy agents within isolated sandboxes to ensure arbitrary commands cannot compromise the host system.
3. Bring your own LLM and agent server infrastructure to swap models dynamically.

The cost model changes shape rather than shrinking: no platform licence, but compute and model usage fees, plus custody of the sandbox environments themselves. The model-agnostic design keeps providers swappable on performance or price, which is what makes the arrangement workable for regulated industries where proprietary code must never leave controlled infrastructure.

Configuring Custom LLMs and Switching Agent Backends

Pointing the Canvas at your own LLM and agent server takes three steps, and the managed alternative is the OpenHands Cloud platform, generally available since March 31, 2025.

1. Specify the base URL and API key for your chosen provider within the LLM profile.
2. Select a target runtime, such as a local process or an isolated Docker container, to establish the execution boundary.
3. Initiate the session to load the agent state into the new environment.

This process decouples the interface from the underlying infrastructure, allowing operators to shift workloads without losing context. Startups apply this model-agnostic design to experiment with different providers for cost-efficiency while retaining the same agent interface. Cloud execution offers always-on availability but depends on network throughput, whereas local execution ties up host resources. Builders must weigh data sovereignty requirements against the convenience of managed cloud backends when selecting a deployment target. For detailed setup instructions, refer to the OpenHands documentation. AI Agents News recommends validating network policies before deploying to remote backends.

Resolving Integration Failures in Slack and External Tools

Connectivity issues may arise from configuration errors in the Slack integration setup.

1. Regenerate workspace credentials and update the configuration to restore API access.
2. Verify the event subscription URL points to a reachable endpoint if running behind a corporate firewall.
3. Confirm the agent possesses explicit write permissions for the specific channels targeted by automation rules.

Hybrid deployments require careful network configuration to ensure local instances can receive incoming webhooks from cloud-based collaboration tools. Teams using private company infrastructure must expose a secure tunnel or reverse proxy to allow external events to trigger local agent workflows. Without this bidirectional path, the system accepts commands but cannot report status updates or errors back to the user. The operational cost involves maintaining a persistent, secure tunnel rather than relying on simple polling mechanisms that increase latency.

This configuration gap creates a silent failure mode where agents appear active but remain disconnected from team communication streams.

Automating Engineering Workflows with Integrated AI Agents

Defining the ACP-Compatible Agent Integration Layer

ACP is what makes the roster open-ended: an agent that speaks the protocol drops into the same interface, so adding one does not mean standing up a second control plane. Validation is equally blunt, since compatibility is confirmed by running the agent across the runtimes the team actually uses.

The uptime guarantee moves with the deployment: a managed vendor carries it, a self-hosted Canvas does not, and whoever owns the compute owns the on-call rotation that keeps the platform always-on.

Automating Engineering Workflows Across GitHub, Slack, and Linear

Workflows link agents to Slack, GitHub, and Linear, unifying task management through simple triggers. A single message in a communication channel kicks off complex coding sequences across distributed backends. A developer posts a command in Slack, prompting an agent to fetch a Linear issue, analyze requirements, and generate a GitHub pull request without manual context switching.

Strict data governance remains possible because agent execution stays inside private company infrastructure while interactions happen via public SaaS tools. The "local-first" architecture supports running agents within isolated sandboxes or on-premises. Public internet boundaries protect proprietary code unless explicit configuration allows traversal. Cloud-only solutions cannot match this isolation level.

OpenHands vs Claude Code: Selecting the Right Agent Backend

Choice depends on prioritizing local data sovereignty or managed cloud convenience. Native execution runs directly inside Docker containers or on Virtual Machines, keeping proprietary code within isolated network boundaries. Routing tasks through Claude Code uses external API endpoints, simplifying setup while requiring external connectivity.

Because the integration layer sits above the provider, swapping one for another on price or capability does not touch the automation logic underneath. The split that remains is about the asset: code treated as protected needs the private agent server, code treated as a public commodity fits the managed endpoint.

References

• OpenCode 2026: Setup Guide for the Top Open-Source AI
• OpenHands - Features, Pricing & Review [AI Agent (Coding)]
• OpenHands | Ry Walker Research | Ry Walker: OpenHands