Always-On AI Coding Agents 2026: OpenClaw, Devin, and the Async Shift

We The Flywheel Research & Analysis

Published May 24, 2026 · Updated September 15, 2026

Always-on AI coding agents are autonomous harnesses that run continuously on their own infrastructure, take a task by message (Slack, Telegram, a GitHub issue) rather than a keystroke, and deliver a pull request without a developer staying in the loop. That is the split from an IDE copilot: the agent works asynchronously, across sessions, while the engineer does something else. Eight tools split across two architectures cover this category today: message-driven harnesses (OpenClaw, Hermes Agent, Claude Code Channels) and cloud-async agents (Devin, Cursor Cloud Agents, GitHub Copilot Coding Agent, OpenAI Codex, Jules).

What changed from copilot to always-on teammate?

For two years, mainstream AI coding meant autocomplete: a suggestion appears in the editor, the developer accepts or rejects it, and the tool goes quiet the moment the session ends. That model still dominates day-to-day coding, but it is no longer the only one on the market.

A second category runs asynchronously. An engineer messages the agent from Slack, Telegram, or a GitHub issue, describes the task, and moves on to something else. The agent plans, writes code, runs tests, and delivers the result as a pull request. Some of these tools run permanently on infrastructure the team controls, maintain memory across sessions, and expand their own skill libraries as they work.

The distinction matters for how engineering teams staff and manage delivery. An interactive copilot answers "what should I write next?" An always-on agent answers "what needs to get done?" The workflow shifts from pair programming to delegation and review.

This guide covers eight tools split across two architectural paradigms. For IDE-native and terminal extensions instead, see the open-source AI coding agents comparison.

What are the two paradigms for always-on agents?

The always-on category splits into two distinct architectures with different operational and governance tradeoffs.

Message-driven harnesses

These are daemons that stay running and bridge messaging platforms to an LLM backend. Engineers interact through Slack, Discord, Telegram, or similar apps. The agent holds persistent memory, loads specialized skills, and can act proactively on a schedule rather than waiting to be prompted.

Key examples: OpenClaw, Hermes Agent, and Claude Code Channels. All three can run on infrastructure a team controls; the first two are fully open-source.

Cloud async agents

These are task-based services with no persistent conversation. An engineer files an issue or describes a task, the agent spins up a fresh sandboxed environment, does the work, and delivers a pull request. Each task starts a clean execution with no memory of the last one.

Key examples: Devin, Cursor Background Agents, GitHub Copilot Coding Agent, OpenAI Codex, and Jules. All five run exclusively on vendor infrastructure.

Which tools are message-driven agents?

OpenClaw

OpenClaw is the largest project in this category by community size. Originally shipped as "clawdbot," it went open-source under Apache 2.0 and grew into one of the most-starred coding-agent projects on GitHub, reporting millions of active users at its peak growth.

The architecture centers on a single long-running process called the Gateway, which bridges messaging channels (Slack, Discord, Telegram, WhatsApp, iMessage, Signal, Teams, Matrix) to LLM backends including Anthropic, OpenAI, Google, and open-weight models served via Ollama. A heartbeat scheduler wakes the agent at configurable intervals, enabling proactive behavior without a triggering message.

The feature most relevant to engineering leaders is the Agent Client Protocol (ACP). It lets OpenClaw dispatch external coding harnesses (Claude Code, Codex CLI, Cursor) as sub-tasks, collect their results, and coordinate across them. That turns OpenClaw into a meta-orchestrator rather than a single-model tool, and its community skill marketplace adds thousands of task-specific extensions covering code review, deployment, and more.

Strengths

• Fully self-hosted; code stays on the team's infrastructure unless an external LLM provider is configured.
• Channel-agnostic: engineers interact from whatever messaging app they already use.
• Model-agnostic: swapping providers doesn't require changing workflows.
• Sub-agent orchestration via ACP lets it dispatch tasks to specialized coding tools.

Considerations

• Community-driven with no single corporate backer; long-term governance depends on community health.
• Self-hosting means the team owns operations: updates, security patches, scaling.
• Skill-marketplace quality varies; vetting third-party skills is the adopting team's responsibility.

OpenClaw's scale has also produced an ecosystem of managed and hardened variants. See the OpenClaw ecosystem guide for a breakdown of managed hosting and security-focused forks.

Hermes Agent (Nous Research)

Hermes Agent shipped from Nous Research, the team behind the Nous-Hermes model fine-tunes. Where OpenClaw emphasizes breadth and orchestration, Hermes focuses on depth: self-improving skills and persistent cross-session memory.

The self-improvement loop is the differentiator. When Hermes solves a difficult problem, it generates a reusable skill document describing the solution pattern. The next time it hits a similar task, it loads that skill instead of reasoning from scratch. Over weeks of use, the agent accumulates domain-specific expertise tuned to a team's own codebase and conventions.

Hermes connects to Telegram, Discord, Slack, and other chat platforms, and runs on multiple terminal backends: local, Docker, SSH, and several serverless options. The serverless backends let the execution environment hibernate when idle and wake on demand, keeping infrastructure cost near zero during quiet periods.

Strengths

• Self-improving skill library builds institutional knowledge automatically.
• Persistent memory across sessions without manual context management.
• Model-agnostic: works with Claude, GPT, Gemini, or open-weight models.
• Serverless backends enable cost-efficient always-on operation.

Considerations

• Younger project than OpenClaw, with a smaller community and fewer third-party integrations.
• Self-generated skills need periodic human review. The agent optimizes for what worked before, not necessarily what is still correct.

For a direct comparison of the two self-hosted leaders, see OpenClaw vs. Hermes Agent.

Claude Code Channels (Anthropic)

Claude Code Channels is Anthropic's plugin connecting a running Claude Code session to Telegram or Discord. An engineer texts a message from a phone, and Claude Code executes it on the local development machine using the project's full context, tools, and skill system.

The key architectural difference from OpenClaw and Hermes is that Channels is not a standalone runtime: it extends Claude Code. That means it inherits the full Claude Code feature set (multi-session dispatch, persistent task loops, MCP server integrations, the skill library), but it also depends on a running Claude Code session and an active Anthropic subscription.

For teams already invested in Claude Code, Channels is the fastest path to async messaging: there is no new infrastructure to deploy. For teams evaluating from scratch, the subscription requirement and single-model lock-in are real constraints.

Strengths

• Code executes locally: source never leaves the developer's machine.
• Inherits all Claude Code capabilities: skills, multi-session agents, MCP tools, long context.
• Zero infrastructure to deploy beyond a running Claude Code session.
• Native mobile notifications via Telegram and Discord apps.

Considerations

• Requires an Anthropic subscription tier priced for heavy usage.
• Claude models only, no model switching.
• Session-bound: if the Claude Code process stops, Channels stops with it.

See OpenClaw vs. Claude Code for a side-by-side on the self-hosted-vs-local-execution tradeoff.

Which tools are cloud async agents?

These tools take a different approach: describe a task, the agent spins up a sandboxed environment, does the work, and delivers a pull request. There is no persistent daemon and no messaging bridge. Each task is a fresh execution.

Devin (Cognition)

Devin is the most autonomous option in this category, running in a full cloud VM with browser, terminal, and editor access. Tasks are assigned through a web UI or Slack integration; Devin plans, codes, tests, and opens a pull request. Cognition has publicized enterprise deployments running Devin alongside large human engineering teams in a hybrid-workforce model.

Entry pricing starts with a low-cost tier, with compute billed per unit of active work. Heavier team plans include a bundle of compute credits, and usage beyond that bundle is billed incrementally. Costs scale with actual usage, so Devin fits defined, delegable tasks better than open-ended exploration.

For a head-to-head with the local-execution alternative, see Devin vs. Claude Code and Devin vs. Cursor Background Agents.

Cursor Background Agents (now Cloud Agents)

Cursor's async agents, originally launched as Background Agents and now branded Cloud Agents, spin up an isolated cloud VM, clone the target repository, and work on a dedicated branch. Each agent gets a full Linux environment with terminal, browser, and desktop access, letting it perform GUI-level testing rather than code-only edits.

Multiple agents run in parallel, each able to use a different model. The tight coupling to the Cursor IDE means this option fits teams already standardized on Cursor as their editor.

GitHub Copilot Coding Agent

GitHub's approach integrates most tightly with existing developer workflows: an engineer assigns a GitHub issue to the Copilot agent, and it creates a branch, implements the change, runs tests, and opens a pull request. No context switching, no new tool to learn. The agent operates inside the project-management system a team already uses.

GitHub moved this product to usage-based billing alongside its existing seat tiers in 2026. The agent handles well-scoped issues best: bug fixes with a clear reproduction path, test additions, and documentation updates.

OpenAI Codex (Cloud Agents)

OpenAI's Codex cloud agents run in sandboxed environments accessible through ChatGPT or the API. An engineer describes a task, the agent executes it, and returns diffs or a pull request. Pricing moved to a token-based model tied to the underlying Codex-family models.

The ChatGPT integration means non-engineers can also dispatch coding tasks, which has implications for cross-functional teams handling well-defined technical requests. Multi-agent runs support parallelizing independent work items, and a dedicated desktop app pairs the cloud backend with a native macOS and Windows UI.

Jules (Google)

Jules is Google's entry, built on the Gemini model family. It integrates with GitHub, cloning repositories into Google Cloud VMs to work on assigned tasks. It targets the same issue-to-pull-request workflow as Copilot Coding Agent, backed by Google's infrastructure and Gemini's extended-thinking capabilities. As of this writing Google has not published enterprise pricing or SLA terms for Jules, so teams evaluating it for anything beyond experimentation should confirm current terms directly with Google before committing.

How do the eight always-on agents compare?

The table below compares all eight tools across architecture, async capabilities, and enterprise readiness. Message-driven harnesses (OpenClaw, Hermes, Channels) and cloud agents (Devin through Jules) serve different workflows. Choose the paradigm first, then the specific tool.

What does this shift mean for engineering orgs?

The shift to review-first culture

When agents produce pull requests at volume, the engineering workflow inverts. Most teams today spend the majority of engineering time writing code and a fraction reviewing it. With async agents handling implementation, that ratio flips. The bottleneck moves from "who writes this" to "who reviews this, and how fast."

This is not a hypothetical shift. Organizations running Devin and similar tools at scale describe the resulting structure as a hybrid workforce: human engineers set direction, define tasks, review output, and handle what the agents cannot solve, while the agents absorb the volume of well-specified work.

Security and governance

The architecture choice determines the security posture. Self-hosted tools (OpenClaw, Hermes) keep code on infrastructure a team controls. Claude Code Channels runs on the developer's local machine. Cloud agents (Devin, Cursor Background Agents, Copilot Coding Agent, Codex, Jules) send code to a vendor VM for every task.

For regulated industries, the self-hosted path removes the "code in a third-party VM" question entirely. For teams with SOC 2 requirements but less restrictive data policies, the cloud agents' enterprise tiers provide the compliance documentation an audit will ask for. A middle ground is a self-hosted harness like OpenClaw paired with a commercial LLM provider's enterprise API: infrastructure control with vendor-grade model quality.

Two governance points deserve specific attention. IP indemnification: some vendors in this space offer indemnity for legal exposure from AI-generated code, and most do not. For legal teams, this is frequently a hard requirement rather than a preference. Data loss prevention: message-driven agents that operate through Slack, Discord, or Telegram route proprietary code excerpts through third-party messaging infrastructure. Enterprise DLP policy may prohibit this regardless of the agent's own security posture, so evaluate the messaging channel itself as a data boundary, not just the agent runtime behind it.

Cost models

Three pricing patterns compete in this category. Seat-based subscriptions offer predictable monthly budgets. Compute-based pricing (Devin's usage model, Cursor Background Agents' billing) scales with actual usage but can surprise a team that runs agents heavily. Open-source self-hosting (OpenClaw, Hermes) carries zero licensing cost but real operational cost in engineer time for deployment and maintenance. A reasonable planning estimate is 10-20% of one SRE's time for updates, monitoring, and incident response.

Team structure implications

Async agents compress the time to produce working code but expand the time needed for review, testing, and architectural guidance. Teams that adopt these tools well tend to shift toward more senior composition: fewer engineers writing boilerplate, more engineers reviewing output, defining system boundaries, and handling the edge cases agents miss.

Headcount doesn't necessarily drop. The work changes: the volume of code a team can ship increases, so a backlog of migrations and technical debt that was previously too expensive to address becomes tractable. The constraint moves from production capacity to review capacity.

When does self-hosting beat a managed always-on agent?

The build-vs-buy decision in this category maps cleanly onto organizational priorities.

Self-hosted wins when: a team has strict data-residency requirements, wants model flexibility to swap providers as pricing shifts, needs deep customization of agent behavior, or has SRE capacity to own the operational burden. OpenClaw is the stronger choice for breadth: more channels, more integrations. Hermes is stronger for depth: self-improving skills, persistent memory.

Managed wins when: a team wants zero operational overhead, needs compliance certification out of the box, values simplicity over configurability, or is already embedded in a specific vendor ecosystem: GitHub for Copilot, Anthropic for Channels, Google for Jules.

The hybrid pattern is worth considering for teams that want both: an open-source harness like OpenClaw as the routing and session-management layer, with a commercial LLM provider behind it via API. That combination gives infrastructure control with vendor-grade model quality, at the cost of API billing on top of the harness itself.

Self-hosting also raises a hardware question: where does the harness actually run. See Mac Mini as AI Agent Server for the dedicated-hardware case, current pricing, and when a small VPS beats owning the box.

Which always-on agent fits your team profile?