# Background coding agents in 2026: cloud agents that open pull requests

> Codex cloud, Copilot cloud agent, Cursor, Jules, Devin, Amp, Tembo, Warp, OpenHands and SHIP compared on triggers, machines, pull requests and price.

- URL: https://letsship.ai/compare/background-coding-agents
- Author: Önder Ceylan
- Published: 2026-10-16
- Last reviewed: 2026-10-16

Background coding agents that return a pull request from a cloud machine include Codex cloud, GitHub Copilot cloud agent, Cursor cloud agents and Jules. Devin, Amp, Tembo, Warp, OpenHands and SHIP are the others. This page compares the machine each agent uses, what starts a run, what the agent returns, and the price. Each card below starts with the team that the agent fits, from the product's own pages.

## Compare ten background agents on their own documentation

The table, the prices and the cards use only each product's own docs, pricing page or repository, and each card links its sources. Third-party lists for "background coding agents" were read only to see which products appear for that search, and none is cited.

| Product                                            |     Schedules     | Starts from an issue |  Choice of agent  |       Video       |    Self-hosted    |
| -------------------------------------------------- | :---------------: | :------------------: | :---------------: | :---------------: | :---------------: |
| [Codex cloud](#codex-cloud)                        | Not documented |        Yes       | Not documented | Not documented | Not documented |
| [Copilot cloud agent](#github-copilot-cloud-agent) |      Yes      |        Yes       |    Pro+ and Max   | Not documented | Not documented |
| [Cursor cloud agents](#cursor-cloud-agents)        |      Yes      |        Yes       | Not documented |      Yes      |      Yes      |
| [Jules](#jules)                                    |      Yes      |        Yes       | Not documented | Not documented | Not documented |
| [Devin](#devin)                                    |      Yes      |        Yes       | Not documented |      Yes      | Not documented |
| [Amp](#amp)                                        |      Yes      |   Not documented  | Not documented | Not documented | Not documented |
| [Tembo](#tembo)                                    |      Yes      |        Yes       |      Yes      | Not documented |      Yes      |
| [Warp](#warp)                                      |      Yes      |        Yes       |      Yes      | Not documented |     Enterprise    |
| [OpenHands](#openhands)                            |      Yes      |        Yes       |      Yes      | Not documented |     Enterprise    |
| [SHIP](#ship)                                      |      Yes      |        Yes       |      Yes      |      Yes      | Not documented |

A check means the product's own pages describe it. A dash means none of those pages states it, which is a statement about the pages, not about the product.

Each product is paid for in one of three ways. Prices are in US dollars a month, from each vendor's own pricing page, and they change often.

Pay a monthly plan

The plan covers the agent and its model use, up to the plan's limits.

**Codex cloud:** $20 ChatGPT Plus, from $100 ChatGPT Pro, $25 a user Business.
ChatGPT Free and Go do not include it, and an API key has no cloud features. Plus and Pro can buy more credits.

**Copilot cloud agent:** $10 Pro, $39 Pro+, $100 Max, $19 a seat Business, $39 a seat Enterprise.
Copilot Free does not include it. Runs draw GitHub AI Credits from the plan, and you can buy more.

**Devin:** $20 Pro, $200 Max, from $80 Teams.
The Free plan does not include the cloud agent. Past the plan's quota, extra usage bills at API prices.

**Jules:** $0 Jules, $19.99 Google AI Pro.
The free tier allows 15 tasks a day, Google AI Pro 100 and Google AI Ultra 300.

Pay a plan, then pay for usage

Model use or machine time bills on top of the plan, or draws down its allowance.

**Cursor cloud agents:** from $30 Premium.
Runs bill at API prices for the model, under a spend limit that you set.

**Warp:** $20 Build, $200 Max, $50 a user Business.
Build includes $20 of usage at API rates. Pay as you go bills 20% above API rates, and cloud runs also bill agent time.

**Tembo:** $60 Pro, $200 Max.
A free trial comes first. Model use and VM time draw from the plan's allowance, and VM time still bills when you bring your own key.

**Amp:** $0 Hobby, from $20 Individual.
Orbs bill by the minute. Model use bills at the providers' API prices, or on your own keys.

Bring your own model keys

Your model provider bills you for inference, and the plan pays for the platform.

**OpenHands:** $0 Cloud Individual.
Up to 10 conversations a day. The open-source version is free, and models run on your own key or the OpenHands provider at cost.

**SHIP:** $170 Starter, $480 Scale.
Free credits to start. Inference bills to your own model keys.

## Read each agent on its own terms

### Codex cloud

Fits a team that uses ChatGPT plans and wants a task to continue while the laptop sleeps.

**Works on:**
A VM for each task, with internet access off until you allow it

**Triggers:**
`@codex` on a GitHub pull request, a Linear assignment or mention, Slack

**Returns:**
Changes and test results. You commit or open a pull request when ready.

**Price:**
It starts at ChatGPT Plus, $20 a month. Pro is $100, $200 or $500, and Business $25 a user. ChatGPT Free and Go do not include it.

OpenAI runs each Codex cloud task in its own VM, and the task continues while your computer sleeps. Internet access stays off until you allow it, and then only for the domains you list. A `@codex review` comment on GitHub flags P0 and P1 issues. Codex cloud needs a ChatGPT sign-in on Plus or above, and an API key has no cloud features.

**Sources:**
* [Cloud](https://learn.chatgpt.com/docs/cloud)
* [Cloud environments](https://learn.chatgpt.com/docs/environments/cloud-environments)
* [Pricing](https://learn.chatgpt.com/docs/pricing)
* [Code review](https://learn.chatgpt.com/docs/code-review)
* [Linear](https://learn.chatgpt.com/docs/third-party/linear)

### GitHub Copilot cloud agent

Fits a team that wants an issue assignment on GitHub to start the work.

**Works on:**
A temporary cloud environment on GitHub

**Triggers:**
An issue assignment, schedules and events such as a new issue, Slack, Jira, Linear

**Returns:**
One pull request per task. A mention on any pull request changes it.

**Price:**
From Pro ($10). Pro+ $39, Max $100, Business $19 a seat, Enterprise $39 a seat. Copilot Free does not include it.

GitHub's cloud agent researches a repository, plans a change and implements it in the background. Automations start it on a schedule or on events such as a new issue. By default, GitHub Actions workflows wait for a person to approve them before they run on the agent's push.

**Sources:**
* [About Copilot cloud agent](https://docs.github.com/en/copilot/concepts/agents/coding-agent/about-coding-agent)
* [Start Copilot sessions](https://docs.github.com/en/copilot/how-tos/use-copilot-agents/cloud-agent/start-copilot-sessions)
* [About third-party agents](https://docs.github.com/en/copilot/concepts/agents/about-third-party-agents)
* [Copilot plans](https://github.com/features/copilot/plans)

### Cursor cloud agents

Fits a team that works in Cursor and wants a video and screenshots of each change.

**Works on:**
Isolated cloud VMs, or your own machines with the self-hosted option

**Triggers:**
Schedules, GitHub, GitLab and Bitbucket events, Slack, Linear, PagerDuty, webhooks

**Returns:**
A pull request with screenshots, videos and logs of the change

**Price:**
From Premium ($30 a month). Runs bill at API prices for the model.

Cursor's cloud agents run in VMs with full development environments, and they control a desktop and a browser to test the change. Automations start them from schedules, repository events, Slack, Linear, PagerDuty and webhooks. Each run produces screenshots, videos and logs. Runs bill at API prices for the selected model.

**Sources:**
* [Cloud agents](https://cursor.com/docs/cloud-agent)
* [Automations](https://cursor.com/docs/cloud-agent/automations)
* [Pricing](https://cursor.com/pricing)

### Jules

Fits a team that uses Google AI plans and wants an agent that fixes CI on its own pull requests.

**Works on:**
A short-lived Ubuntu VM with internet access

**Triggers:**
A `jules` label on a GitHub issue, schedules, the REST API

**Returns:**
A branch or a pull request. It fixes CI failures on its own pull requests.

**Price:**
Free for 15 tasks a day. Jules in Pro comes with Google AI Pro, $19.99 a month, for 100 a day, and Jules in Ultra with Google AI Ultra for 300.

Jules is Google's coding agent. It works in a short-lived VM, and a `jules` label on a GitHub issue starts a task. You approve its plan before it changes code, unless you turn on auto-approval. Jules detects and fixes CI failures on the pull requests it creates.

**Sources:**
* [Jules docs](https://jules.google/docs)
* [Tasks](https://jules.google/docs/running-tasks/)
* [Usage limits](https://jules.google/docs/usage-limits/)
* [Scheduled tasks](https://jules.google/docs/scheduled-tasks/)
* [Environment](https://jules.google/docs/environment/)
* [Changelog](https://jules.google/docs/changelog/)
* [Google AI plans](https://gemini.google/subscriptions/)

### Devin

Fits a team that wants runs to start from schedules, webhooks and incident tools.

**Works on:**
An isolated cloud machine for each session

**Triggers:**
Linear, Jira, Slack, GitHub and PagerDuty events, schedules, webhooks

**Returns:**
A pull request, and a video of its end-to-end test

**Price:**
The cloud agent starts at Pro, $20 a month, and Max is $200. Teams starts at $80 a month. The Free plan does not include the cloud agent.

Devin's automations start sessions from GitHub, GitLab and PagerDuty events, from schedules and from webhooks. After a pull request, Devin tests the app end to end and records the screen. Devin Review then reviews the pull request.

**Sources:**
* [Automations](https://docs.devin.ai/product-guides/automations)
* [Testing and recordings](https://docs.devin.ai/work-with-devin/testing-and-recordings)
* [Devin pricing](https://devin.ai/pricing)
* [ChatGPT plans in Devin](https://docs.devin.ai/admin/billing/chatgpt)
* [Self-serve plans](https://docs.devin.ai/admin/billing/self-serve)

### Amp

Fits a team that sends work to a remote machine from the terminal.

**Works on:**
Orbs, remote machines that Amp bills by the minute

**Triggers:**
Schedules, webhooks, an `@Amp` mention in Slack

**Returns:**
A pushed feature branch and the pull request URL

**Price:**
Hobby is free, with orbs paid as you go or your own keys. Individual starts at $20 a month.

Amp sends work to orbs, remote machines where agents work without your computer. You start one from the CLI with `amp -ox`, from a schedule, a webhook or a Slack mention. The agent pushes a feature branch and reports the pull request URL. Orbs bill by the minute.

**Sources:**
* [Manual](https://ampcode.com/manual)
* [Orbs](https://ampcode.com/docs/markdown/orbs)
* [Event-driven orbs](https://ampcode.com/orbs/event-driven)
* [Pricing](https://ampcode.com/pricing)
* [Orb sizes and costs](https://ampcode.com/docs/markdown/orbs/sizes-and-costs)

### Tembo

Fits a team that wants to choose the coding agent that a background run uses.

**Works on:**
A dedicated Linux VM for each session, billed by the second

**Triggers:**
Issue assignments in Linear, Jira or GitHub, Sentry errors, schedules, webhooks

**Returns:**
A pull request, with a review agent's inline comments

**Price:**
A free trial, then Pro $60 and Max $200 a month. Model use and VM time draw from the plan's allowance.

Tembo runs Claude Code, Codex, OpenCode or Pi in a dedicated VM and opens a pull request when the session completes.

**Sources:**
* [Models](https://docs.tembo.io/features/models)
* [Pull requests](https://docs.tembo.io/features/pull-requests)
* [tembo.io/pricing](https://tembo.io/pricing)

### Warp

Fits a team that wants to choose the coding agent for each agent in its pipeline.

**Works on:**
Warp-hosted compute or your own infrastructure

**Triggers:**
Slack, Linear, Jira, GitHub, GitLab, webhooks, schedules

**Returns:**
A reviewed pull request back in the thread or issue. It never merges for you.

**Price:**
Cloud runs start at Build, $20 a month with $20 of usage at API rates. Pay as you go bills 20% above API rates.

Warp runs Warp Agent, Claude Code or Codex for each agent in a factory.

**Sources:**
* [Warp Factories](https://docs.warp.dev/factories/)
* [warp.dev/pricing](https://warp.dev/pricing)

### OpenHands

**License:** MIT

Fits a team that wants to choose the coding agent and run it on its own infrastructure.

**Works on:**
OpenHands Cloud, or your own VPC on Enterprise

**Triggers:**
An `openhands` label or mention on GitHub or Slack, schedules

**Returns:**
A pull request when it decides the issue is resolved

**Price:**
Cloud Individual is free for up to 10 conversations a day

OpenHands Cloud runs its own agent, or Claude Code, Codex and Gemini CLI.

**Sources:**
* [OpenHands Cloud](https://docs.openhands.dev/openhands/usage/cloud/openhands-cloud)
* [ACP agents](https://docs.openhands.dev/openhands/usage/agent-canvas/acp-agents)
* [openhands.dev/pricing](https://openhands.dev/pricing)

### SHIP

Fits a team that wants each change through its own CI, a review and a test before a person sees the pull request.

**Works on:**
A separate sandbox for each agent

**Triggers:**
An issue assigned to SHIP in Linear or Jira, `@SHIP` on a GitHub issue, scheduled tasks

**Returns:**
A pull request that passed your CI, a Reviewer and a Tester against a preview

**Price:**
Free credits to start. Starter $170 and Scale $480 a month. Inference bills to your own keys.

SHIP runs a Planner, a Builder, a Reviewer and a Tester on each issue, with your own CI between them. Any gate that fails sends the work back to the Builder. Each role's harness and model is set in `ship.yml` ([schema](https://letsship.ai/docs/configuration/schema)), and inference bills to your own provider keys. A [scheduled task](https://letsship.ai/platform/auto-maintenance) files an issue on a schedule, and SHIP takes it to a pull request.

**Sources:**
* [ship.yml schema](https://letsship.ai/docs/configuration/schema)
* [Automated codebase maintenance](https://letsship.ai/platform/auto-maintenance)
* [Artifacts](https://letsship.ai/docs/api/artifacts)
* [Pricing](https://letsship.ai/pricing)

## Choose by how your team works

Work should start on a schedule

* [Copilot cloud agent](#github-copilot-cloud-agent)
* [Cursor](#cursor-cloud-agents)
* [Jules](#jules)
* [Devin](#devin)
* [Amp](#amp)
* [Tembo](#tembo)
* [Warp](#warp)
* [OpenHands](#openhands)
* [SHIP](#ship)

Errors or incidents should start work

* [Tembo](#tembo)
* [Cursor](#cursor-cloud-agents)
* [Devin](#devin)

Tembo starts from Sentry errors, and Cursor and Devin from PagerDuty.

You want a video of each change

* [Cursor cloud agents](#cursor-cloud-agents)
* [Devin](#devin)
* [SHIP](#ship)

SHIP's Tester attaches screenshots, videos or a trace of its test as proof.

You want to choose the coding agent

* [Tembo](#tembo)
* [Warp](#warp)
* [OpenHands](#openhands)
* [SHIP](#ship)

The agent must run on your own infrastructure

* [Cursor](#cursor-cloud-agents)
* [Tembo](#tembo)
* [Warp](#warp)
* [OpenHands](#openhands)

Cursor and Tembo through a self-hosted option, Warp and OpenHands on Enterprise.

Each change passes your CI, a review and a test before a person reviews it

* [SHIP](#ship)

## Questions

### What is a background coding agent?

A background coding agent takes a task and works on it in a cloud machine, not on your laptop. Then it returns a branch or a pull request. It can start from an issue, a chat message, a schedule or a webhook, so nobody has to watch it work.

### What are the best background coding agents?

Ten products document a cloud agent that works on its own machine and returns a branch or a pull request. They are Codex cloud, Copilot cloud agent, Cursor cloud agents, Jules, Devin, Amp, Tembo, Warp, OpenHands and SHIP. Each fact comes from the product's own pages.

### Which background coding agents run on a schedule?

Copilot cloud agent, Cursor cloud agents, Jules, Devin, Amp, Tembo, Warp and OpenHands each document scheduled runs. SHIP runs scheduled maintenance missions that file an issue and take it to a pull request.

### Which background coding agent fixes its own CI failures?

Jules documents that it detects and fixes CI failures on the pull requests it creates. In SHIP, a failed CI run sends the work back to the Builder with the failure, before any review.

### Can a background coding agent run on my Claude or ChatGPT subscription?

Tembo connects Claude and ChatGPT subscriptions, and Devin links a ChatGPT plan on Pro, Max and Teams. In SHIP, claude-code runs on your Claude subscription and codex on your ChatGPT subscription, or both run on API keys.

### Do background coding agents merge their own pull requests?

Check each product's own docs for its merge rules. Warp's docs say the factory never merges for you. In SHIP, a person accepts each pull request.