Devin vs Cursor: what happens to the PRs they open

Devin vs Cursor is a choice between two product families that both offer editors and cloud agents: Devin, from Cognition, includes a cloud coding agent you hand tasks to and Devin Desktop, the editor called Windsurf until 2 June 2026; Cursor is an AI code editor with its own cloud agents. For a developer or team lead deciding which to pay for, I compare the editors, cloud agents and prices from both vendors' pages on 13 November 2026, count what happened to the pull requests (PRs) their GitHub Apps opened in public repositories in October 2026, and give a script to repeat the count on any repository. The short version of the count: a single merge share tells you little, because the same bot's share runs from 19% to 93% depending on how drafts and the time window are filtered. I did not buy either cloud agent for this post: Devin Cloud requires Pro at $20/month and Cursor Cloud Agents require Premium at $30/month. Both vendors have a $0 plan, but neither $0 plan includes the cloud agent. So I have no hands-on results and make no judgment about which writes better code.

I'm Larry 🍀 Orbi, the creator of Orbi. Orbi takes GitHub Issues through implementation, separate review and merge; it competes with the cloud-agent half of both products, so read the last section with that in mind.

Devin vs Cursor at a glance

Swipe horizontally to see all columns.

Devin's docs point both ways. The SDLC guide has people reviewing and choosing whether to merge; the GitHub guide recommends branch protection “to ensure all required checks pass before Devin can merge changes”, which allows for Devin doing the merge. Cursor's Cloud Agents release notes for the week of 7 September 2026 describe an agent asking for approval to merge a PR on an Origin repository; I found no equivalent sentence for repositories on GitHub. A sample further down reads GitHub's merged_by field to see which account merged in practice.

Cursor vs Devin Desktop, the editor that was Windsurf

Windsurf is now Devin Desktop, following the 2 June 2026 rename. The FAQ calls it “the same IDE, same editor”, so a search for “Devin vs Windsurf” now leads to products under one brand.

Devin Desktop is a full IDE with an agent manager. Its built-in local agent is Devin Local, which replaced the older Cascade agent. Desktop also runs Codex, Claude Agent, OpenCode and any other agent that supports ACP, the protocol it uses to plug in outside agents. You can use it with local agents only, without Devin Cloud. Free includes a light agent quota, limited models, unlimited inline edits and unlimited Tab completions.

Cursor's editor Agent edits code and runs terminal commands. Its model page includes Grok 4.7 and Composer 2.5 in plan usage; Free and Plus run Cursor's own models only. Free has limited usage. Premium and above unlock Claude, GPT and other third-party models, billed separately at API list price from prepaid credit. For editor work, I'd compare Desktop's external-agent support with Cursor's model access and separate bill. I have not compared either editor hands-on.

The cloud agents

For the Cursor agent vs Devin question, the two products to compare are Devin Cloud and Cursor Cloud Agents, which were formerly called Background Agents.

Swipe horizontally to see all columns.

The two differ on GitHub issues. Devin's ordinary /devin integration ignores comments on issues; to start work from an issue comment you set up an Automation. Cursor reads @cursor on an issue as well as on a PR.

They also differ on CI. Cursor fixes failing CI automatically only on Teams and Enterprise plans; on smaller plans you ask the agent to watch the PR and fix failures. It does not auto-fix a CI failure on a commit that a person pushed to the branch.

Devin Review is included in the Free plan; on Teams it draws on shared on-demand credits, and public PRs are free. Its beta Autoapprover “does not merge PRs itself”. Bugbot bills by usage, with an average run costing $1.00 to $1.50. Bugbot Autofix spawns a Cloud Agent to address findings.

Cursor vs Devin pricing

Cursor is now sold as part of The X Subscription, covering Grok, Cursor and X. Pro and Pro+ are legacy plans closed to new customers. Monthly prices on 13 November 2026:

Swipe horizontally to see all columns.

Devin's Teams pages differ: its pricing page says “$80/month for team plan + $40/mo per full dev seat”; billing docs say seats and credits can meet the $80 minimum. I'd confirm the checkout total.

Devin's quota is shared by cloud sessions, CLI and Desktop: daily and weekly on Pro/full Teams seats, weekly only on Max. Its size is unpublished; extra credits use API pricing. Cursor's weekly pool covers its own models across editor, CLI and Cloud Agents; third-party models cost extra. Neither vendor publishes cloud tasks per plan on these pages, so I can't tell you which one costs less for the work that ends up merged.

What happened to the PRs each bot opened

I queried GitHub's search API with is:pr is:public author:app/<slug> created:<range>, and ran every count on 13 November 2026 between 01:46 and 02:46 UTC (09:46 to 10:46 in UTC+8). Counts reflect each PR's state when queried; open counts will keep changing.

The census covers pull requests in public GitHub repositories whose author is devin-ai-integration[bot] or cursor[bot], leaving other product output uncounted. I keep the two bots in separate tables because their rows should not be read against each other; the draft column shows why.

PRs by devin-ai-integration[bot], created 1 to 31 October 2026 UTC:

Swipe horizontally to see all columns.

PRs by cursor[bot], same window. Before reading the merged column, look at the last one: three quarters of these PRs were flagged draft, and GitHub's docs say “Draft pull requests cannot be merged” until someone marks them ready for review:

Swipe horizontally to see all columns.

“Draft (any state)” counts every PR that GitHub's search flagged as a draft when I ran the query, whether it was open, closed or merged. The script further down prints only the drafts that are still open (381 and 18,916), so its draft numbers are smaller. The flag is the state at query time, not at creation: is:merged draft:true also returned 275 devin-ai-integration[bot] PRs and 441 cursor[bot] PRs. I did not establish why those merged records matched the draft filter.

Three quarters of the cursor[bot] PRs were flagged draft, and 18,916 of those were still open. Drafts were rare among devin-ai-integration[bot] PRs. Cursor's release notes for the week of 19 October 2026 say Cloud Agents “now open pull requests ready for review instead of as drafts, unless you or the task ask for a draft”. The public counts had not moved when I counted: 11,061 of the 14,346 cursor[bot] PRs created 1 to 18 October were flagged draft (77.1%), 10,486 of the 14,054 created 19 to 31 October (74.6%), and 5,334 of the 7,107 created 1 to 10 November (75.1%). From the outside I can't tell whether those repositories ask for drafts or the change had not reached them.

The share for one author moves a long way with the cut. For cursor[bot], 19.2% of all October PRs were merged. Among October PRs not flagged draft when I counted, it was 5,005 of 6,853 (73.0%). Among PRs from the week of 12 to 18 October not flagged draft, it was 1,156 of 1,241 (93.2%), and that cut keeps only 1,241 of the week's 4,709 PRs. For devin-ai-integration[bot], where drafts are rare, the same three cuts give 72.7%, 38,106 of 51,801 (73.6%) and 6,188 of 8,209 (75.4%). A number that runs from 19% to 93% for the same author, depending on the filter, is not a quality score, and I would not use any of these shares to say which product is better. They describe the state of public PRs by these two authors in these windows.

For 12 to 18 October 2026 UTC, I fetched every matching PR in full: 13,055, with no sampling.

Swipe horizontally to see all columns.

Three of the four largest repositories for devin-ai-integration[bot] that week, including the largest with 241 PRs, belong to two organisations: COG-GTM (two repositories, 373 PRs, none merged) and Cognition-Partner-Workshops (one repository, 113 PRs, 39 merged). Those two organisations' GitHub profiles have no description or website, and I could not confirm who runs them; demo or workshop traffic is a possibility for those three repositories. The fourth is Open-MBEE/OpenSysML, an open-source project with its own website, where 179 of 182 PRs were merged. For cursor[bot], the five repositories with 100 or more PRs that week accounted for 701 PRs; none merged.

Leave out the repositories with 100 or more matching PRs that week, five for each author. For devin-ai-integration[bot] those are the four above plus airbytehq/airbyte, 776 PRs in all, which leaves 7,570 PRs, of which 5,941 were merged and 105 were flagged draft. For cursor[bot] it leaves 4,008 PRs, of which 1,300 were merged and 2,767 were flagged draft; the merged count does not change because none of the 701 excluded PRs had been merged.

For the full week again, with no repositories left out, half of the merged PRs were merged within the times below. These times say nothing about unmerged PRs. Each row is computed on that author's own merged PRs, a different slice for each, so don't read one row against the other.

Swipe horizontally to see all columns.

I randomly sampled 150 merged PRs per author from that week's 6,211 and 1,300 (seed 20261113) and read merged_by from GitHub's pulls API:

Swipe horizontally to see all columns.

So 48 of 150 and 41 of 150 sampled merges, roughly three in ten on each side, were done by the author's own bot account. I don't know whether a person requested the merge or a rule did it; the field records only the account. The docs rows in the first table don't settle who merges on GitHub, and this sample doesn't either. At least one review comment appeared on 29 of the 150 sampled devin-ai-integration[bot] PRs and 13 of the 150 cursor[bot] PRs; comment counts cannot establish whether human review happened.

Four limits matter:

• Devin's “Open PRs as” setting can use a user's account. Those PRs are absent.
• Cursor documents cursor authorship for Automations, without specifying ordinary Cloud Agent authorship. Bugbot Autofix also starts Cloud Agents, so this author may include that work.
• Only public repositories are visible. The paying teams whose work is mostly private are outside this census.
• Search counts drift: for the same week, the devin-ai-integration[bot] merged count was 6,211 in the census and 6,201 when I ran the script a few minutes later. I did not find out why a merged count would drop; the change is about 0.2%.

For context, Cognition's November 2025 review said about two thirds of Devin's PRs were being merged; Cursor said on 2 September 2026 that cloud agents created more than 60% of the PRs it merged internally. Those have different denominators and cannot be compared with each other or this census.

Count it yourself

This counts basic PR states, with drafts counted only among open PRs. It does not reproduce the non-draft merge shares above. It takes the App's slug, without the [bot] suffix: devin-ai-integration or cursor.

#!/usr/bin/env bash
# Count the pull requests a GitHub App opened, by what happened to them.
# usage: agent-pr-count.sh <app-slug> <created-range> [owner/repo]
#   agent-pr-count.sh devin-ai-integration 2026-10-01..2026-10-31
#   agent-pr-count.sh cursor 2026-10-01..2026-10-31 your-org/your-repo
set -euo pipefail
app="${1:?app slug, for example devin-ai-integration or cursor}"
range="${2:?created range, for example 2026-10-01..2026-10-31}"
scope="is:public"
if [ -n "${3:-}" ]; then scope="repo:$3"; fi

count() {
  local n
  n=$(gh api -X GET search/issues -f q="is:pr $scope author:app/$app created:$range $1" -q .total_count) ||
    { echo "search failed: is:pr $scope author:app/$app created:$range $1" >&2; return 1; }
  [[ "$n" =~ ^[0-9]+$ ]] || { echo "no count returned: is:pr $scope author:app/$app created:$range $1" >&2; return 1; }
  sleep 2.2 # the search API allows 30 requests a minute
  echo "$n"
}

opened=$(count "")
[ "$opened" -gt 0 ] || { echo "no PRs by app/$app in $range ($scope)" >&2; exit 1; }
merged=$(count "is:merged")
closed=$(count "is:closed is:unmerged")
open=$(count "is:open")
open_draft=$(count "is:open draft:true")
if [ $((merged + closed + open)) -ne "$opened" ]; then
  echo "warning: the parts do not add up to the total; PRs changed state during the run" >&2
fi

echo "app/$app, created $range, $scope, counted $(date -u +%Y-%m-%dT%H:%MZ)"
echo "opened           $opened"
echo "merged           $merged"
echo "closed unmerged  $closed"
echo "still open       $open (draft: $open_draft)"

Save it as agent-pr-count.sh, then run chmod +x agent-pr-count.sh. It needs bash and the GitHub CLI gh logged in; I tested gh 2.100.0 and bash 5.3. Do not paste it into an interactive shell: set -e can close that shell on its first failure.

Three actual runs follow; they finished within the same minute, and the timestamps are UTC. The script does not print the exit=0 lines: I printed them with echo "exit=$?" after each run. Your counts will differ a little, because PRs keep changing state.

$ ./agent-pr-count.sh devin-ai-integration 2026-10-01..2026-10-31
app/devin-ai-integration, created 2026-10-01..2026-10-31, is:public, counted 2026-11-13T02:02Z
opened           52775
merged           38381
closed unmerged  4832
still open       9562 (draft: 381)
exit=0

$ ./agent-pr-count.sh cursor 2026-10-01..2026-10-31
app/cursor, created 2026-10-01..2026-10-31, is:public, counted 2026-11-13T02:02Z
opened           28400
merged           5446
closed unmerged  2864
still open       20090 (draft: 18916)
exit=0

$ ./agent-pr-count.sh devin-ai-integration 2026-10-01..2026-10-31 airbytehq/airbyte   # one repository
app/devin-ai-integration, created 2026-10-01..2026-10-31, repo:airbytehq/airbyte, counted 2026-11-13T02:02Z
opened           453
merged           225
closed unmerged  88
still open       140 (draft: 58)
exit=0

The third argument restricts the count to one repository, including a private repository your gh login can read.

No matches exits 1 with no PRs by app/cursor in 2031-01-01..2031-01-31 (is:public) in my empty-range test. An unknown app slug or repository exits 1 with gh: Validation Failed (HTTP 422); bad credentials exit 1 with gh: Bad credentials (HTTP 401). Failed searches also print the query. A parts/total mismatch prints the warning in the script.

GitHub's search API allows 30 requests a minute for a logged-in user, so the script sleeps 2.2 seconds between its five queries. Search lists at most 1,000 results per query, but total_count still reports the full number, and this script reads counts only. My full census scripts are not published on this site. To list every PR, I split time ranges until each slice held 1,000 results or fewer, then paged through each slice.

What I'd check before choosing

• If I already paid for Claude or GPT API usage, I'd check whether Desktop's external agents can use that billing before buying another subscription. Cursor requires Premium for third-party models and bills their usage separately.
• For Slack/Linear/Jira ticket handoff, I'd trial both cloud agents using the intake routes above. Cursor's Jira integration requires Teams/Enterprise.
• For GitHub issue comments, Cursor reads @cursor; Devin needs an Automation.
• For automatic CI fixing on a small plan, I'd investigate Devin's CI-bot allowance. Cursor requires Teams/Enterprise for automatic fixes.
• For work on my own machines, I'd check Outposts and Self-Hosted Machines. Both keep the agent loop in their vendor's cloud.

Before paying for a team, I'd run the same ten backlog tickets from the same baseline in separate repository copies for one week, then run the script on each repository. I'd check PR authors first; if they differ from these bots, I'd record the PR list manually. I'd read the changes and record the actual bill.

Where Orbi fits, and where it doesn't

Orbi, my product, does not review or merge PRs opened by Devin or Cursor. It handles work starting from your GitHub Issues labelled ai-ready: it implements, has a separate session review the change, fixes findings, then merges when review passes and CI is green. When branch protection requires human approval, it stops and waits for you. A release starts when a person requests it.

Orbi has no editor, and its only intake is a GitHub Issue; there is no Slack, Linear or Jira route. The Devin comparison and Cursor comparison cover the handoffs. I'd consider Orbi for an Issue-to-merge workflow; it won't replace either editor.

Related

• Cursor alternatives: which one merges the PR for you?
• Best AI agent for coding: test them on your own repo
• Orbi compared with Devin
• Orbi compared with Cursor
• Orbi Cloud