The Best Cloud Coding Agents in 2026, Compared
Published August 25, 2026 · by the AQ team
As of August 2026, the cloud coding agents worth evaluating are Claude Code on the web (Anthropic), Codex cloud (OpenAI), Cursor cloud agents, GitHub Copilot coding agent, Google's Jules, Devin (Cognition), and AQ. All run coding work on a server instead of your laptop and end in a pull request; they differ on the three things that matter: where the code executes (vendor sandbox or your own infrastructure), which models and CLIs you can run, and whether the session is a black box that emits a PR or a live terminal your team can watch and steer. Every vendor claim below was verified on the vendor's own site in August 2026.
What counts as a cloud coding agent
A cloud coding agent executes on infrastructure that is not your workstation: it clones your repository into a VM, container, or CI runner, does the work there, and pushes the result back as a branch or pull request. The payoff: work survives your laptop closing, tasks run in parallel, and you can start or check work from a phone. The background agents vs cloud agents glossary entry untangles those overlapping terms, and the always-on coding agents guide covers the persistence side in depth.
Claude Code on the web (Anthropic)
Claude Code on the web runs Claude Code sessions on Anthropic-managed cloud infrastructure, each in an isolated VM. As of August 2026 it is in research preview for Pro, Max, and Team plans, with Enterprise access via premium seats. You start tasks at claude.ai/code or from your terminal with the claude --cloud flag, run several sessions in parallel, monitor them from the Claude mobile app, and pull any session into your local terminal with claude --teleport. An auto-fix option watches a PR and responds to CI failures and review comments. Repository cloning and PR creation require GitHub, and cloud sessions share rate limits with your other Claude usage (no separate compute charge). Team and Enterprise organizations can route sessions to a self-hosted environment on their own servers. See the AQ vs Claude Code on the web comparison for a side-by-side.
Codex cloud (OpenAI)
Codex cloud runs each task in its own isolated, OpenAI-managed container preloaded with your repository. As of August 2026 the runtime is two-phase: setup installs dependencies with network access, then the agent phase runs with internet off by default (you can enable it per environment). Start tasks from the Codex web interface, the IDE extension, or by tagging @codex on a GitHub issue or pull request; when a task finishes you can ask for revisions, open a PR, or pull the diff locally. The default-offline agent phase is the strongest security posture in this roundup; the tradeoff is that an agent cut off from the network cannot fetch a missing package mid-task.
Cursor cloud agents
Cursor's cloud agents clone your repository in an isolated cloud environment, work on their own branch, and open a pull request. As of August 2026 you can start and manage them from the editor, cursor.com/agents in any browser, a native iOS app, or by mentioning @cursor in Slack, and review and merge the resulting PRs from mobile. Self-hosted workers (announced March 2026) run the processes that touch your code on your own infrastructure, connecting outbound over HTTPS, while orchestration, planning, and model inference remain in Cursor's cloud. Cloud agents require a GitHub-hosted repository. The AQ vs Cursor cloud agents page goes deeper.
GitHub Copilot coding agent
Copilot's coding agent lives inside GitHub itself. Assign an issue to Copilot on github.com, GitHub Mobile, or the GitHub CLI, or kick off a task from the Agents panel; it works in an ephemeral environment powered by GitHub Actions. It pushes commits to a draft pull request as it goes, keeps inspectable session logs, tags you for review when it is done, and picks up your review comments as follow-up work. Its PRs require human approval before CI/CD workflows run, so branch protections keep their teeth. It is the lowest-friction option for teams living in GitHub issues, and the most constrained mid-task: issue in, draft PR out. The AQ vs Copilot coding agent comparison covers where each fits.
Jules (Google)
Jules clones your repository into a cloud VM, writes an execution plan you can review and edit before it runs, then makes the changes and opens a pull request. As of August 2026 it runs on Gemini 3 Pro, automatically detects and fixes CI failures on pull requests it created, and exposes a public API for wiring tasks into CI/CD pipelines and tools like Slack and Linear. The editable plan is Jules's distinctive move: a checkpoint between task described and code written that fire-and-forget sandboxes skip.
Devin (Cognition)
Devin is pitched as an autonomous software engineer rather than a task runner. Each session gets a dedicated cloud environment with its own shell, browser, and code editor; as of August 2026 Devin can split large tasks across parallel agents in isolated VMs, opens pull requests, responds to review comments and CI results, and takes work by @-mention in Slack. It is the most delegation-shaped tool here; the autonomy that clears backlogs also makes it the hardest to watch while it works. The Devin alternatives page looks at when that tradeoff is right.
The field at a glance
| Agent | Where it executes | Model or CLI | How you interact |
|---|---|---|---|
| Claude Code on the web | Anthropic-managed VMs, or self-hosted for Team/Enterprise | Claude | Steer from web, mobile, or your terminal |
| Codex cloud | OpenAI-managed containers, offline by default | Codex | Task in, PR out; follow-ups per task |
| Cursor cloud agents | Cursor's cloud, or self-hosted workers | Cursor's models | Editor, web, iOS app, Slack; PR out |
| Copilot coding agent | GitHub Actions environment | Copilot's models | Assign an issue; draft PR out |
| Jules | Google-managed cloud VM | Gemini | Editable plan, then PR out; API |
| Devin | Cognition-managed cloud environment | Devin's own agent | Delegate via web or Slack; parallel PRs out |
| AQ | Your own cloud VM, or a dedicated AQ-managed VM | Any CLI: Claude Code, Codex, Cursor Agent, Kimi, Grok, shells | Live shared terminals the whole team can watch and drive |
How to choose
Three questions sort the field. First, custody: if code and credentials must stay on infrastructure you control, the list shrinks to Claude Code's self-hosted environments, Cursor's self-hosted workers (execution only; inference stays with Cursor), and harnesses that run on your own VM. Second, model freedom: Claude Code on the web runs Claude, Codex cloud runs Codex, Jules runs Gemini; mixing agents on one repository, or switching when a better model ships, means another tab and another subscription per sandbox. Third, visibility: all produce a reviewable PR, but they differ on whether anyone can see the session while it runs; for long-running work teams want the live terminal. Notably, most agentic work still ends with a single person checking their own agent's output: a July 2026 LeadDev analysis of 25,264 agent-generated pull requests across 2,361 popular GitHub repositories found that in 79 percent of agentic PRs the same developer both reviewed and modified the agent's contribution, and only about one in eight workflows involved multiple humans. Cloud agents make it cheap to produce more parallel work; they do not, by themselves, get more eyes on it.
Where AQ fits
AQ is the multiplayer coding harness where engineering teams run AI coding agents like Claude Code and Codex together: shared live terminals, a code editor, and app previews, in your own cloud. Against the field above, AQ is not a task queue in one vendor's cloud: it is where the actual CLIs run, live, on a VM your team controls. Agents run as real CLIs (Claude Code, Codex, Cursor Agent, Kimi, Grok, or plain shells) in persistent tmux sessions, streamed to the browser; sessions survive a closed laptop and resume from any device; teammates open the same workspace and watch the same live session rather than waiting for a PR. Each engineer signs into the CLIs with their own Claude or OpenAI account, so there is no model markup and no single-vendor lock: the day a better CLI ships, it is another tab in the same workspace, not another platform.
Execution stays yours: agents run on VMs you connect from your own cloud or on a dedicated always-on AQ-managed VM in its own isolated network, with no shared multi-tenant execution tier. Each workspace gets an isolated git worktree and a live dev-server preview with shareable links; agents commit and open PRs with per-user GitHub auth, tracked per workspace. If you mostly fire small bounded tasks at a sandbox and review PRs, the vendor tools above do that well. AQ earns its place when the unit of work is a session rather than a task: long-running, worth watching, sometimes worth handing to a teammate mid-flight. The Free plan is a personal sandbox (AQ creates a private machine in an isolated network, nothing to install, no time limit); the Team plan is $50 per user per month in early access (standard $200), billed monthly, with your rate locked for your first 12 months.
Frequently asked questions
What is the difference between a cloud coding agent and a background agent?
Cloud describes where the agent runs (a vendor's VM or container instead of your machine); background describes how it runs (asynchronously, without you watching each step). Most of the tools in this guide are both at once, but the properties are separable: a local agent in a tmux session is a background agent on your own hardware, and a cloud session you actively steer is cloud but not background. The glossary entry covers the distinction in full.
What do cloud coding agents cost?
Most are bundled with an existing subscription rather than priced separately. As of August 2026, Claude Code on the web is included in Claude Pro, Max, and Team plans and shares rate limits with your other Claude usage, with no separate compute charge. Codex cloud comes with ChatGPT plans, Cursor cloud agents with Cursor plans, and the Copilot coding agent with paid Copilot tiers. AQ's Free plan is a no-time-limit personal sandbox, and the Team plan is $50 per user per month in early access (standard $200), with model usage on your own Claude or OpenAI accounts rather than marked up.
Can a cloud coding agent run on my own infrastructure?
Increasingly yes, with different boundaries. As of August 2026, Anthropic lets Team and Enterprise organizations route Claude Code cloud sessions to self-hosted environments on their own servers. Cursor offers self-hosted workers where execution stays in your network while orchestration and inference remain in Cursor's cloud. AQ runs agent execution on your own cloud VMs (or a dedicated AQ-managed VM) as its default design rather than an enterprise add-on. Codex cloud, Jules, Copilot, and Devin execute in their vendors' environments.
Which cloud coding agent is best for a team rather than an individual?
It depends on whether your team wants to review output or share the work itself. Copilot's coding agent is the easiest to adopt for issue-in, PR-out workflows inside GitHub. Claude Code on the web supports session sharing on Team plans. AQ is built around the team case: workspaces are visible to the whole team by default (or private and shared with specific people), everyone can watch the same live terminal, and a teammate can take the keyboard when the session owner approves a control request.
Do cloud coding agents replace running agents locally?
For most teams they complement rather than replace local runs. Quick iteration with an agent on code you are actively editing stays fastest locally; cloud agents win for parallel tasks, long runs that should survive your laptop closing, and work you start from a phone or hand to a teammate. Several tools explicitly support the hybrid: Claude Code can send a local task to the cloud with one flag and pull a cloud session back into your terminal. If you want the persistence benefits on a machine you control, see running Claude Code on a cloud VM.