Devin vs Claude Code vs Codex 2026: 8 Coding Agents Tested

Devin vs Claude Code vs Codex 2026: 8 Coding Agents Tested

Background coding agents went from research demo to commodity in twelve months. Cognition just slashed Devin's price floor from $500 to $20/mo this April, OpenAI rebuilt Codex billing on April 2, and Factory closed a $150M Series C two weeks ago. We tested all eight in production this month on internal Techsy tooling work, and the numbers below are the ones we actually paid. We don't sell any of these tools and have no affiliate links, every other top-10 result for this query is published by a vendor of one of the agents on the list.

Pricing as of 2026-04-26. Token-based and ACU-based plans bill on top of the base. Verify before purchase, see vendor links in each tool section. For greenfield generation rather than working in an existing repo, see our lovable-vs-bolt-vs-v0 comparison.

What is a background coding agent?

A background coding agent is an AI software engineer that runs asynchronously in a sandboxed cloud environment. You assign it a task, a GitHub issue, a Linear ticket, a Slack message, and it works alone for minutes or hours, then returns a pull request for review. You don't watch it type.

That's the distinguishing trait. Inline tools like Cursor and Copilot suggest as you type; background AI agents queue up, execute, and report back. The lifecycle is the same across every tool on this list: ticket → cloud sandbox → autonomous edit → PR → human review.

The category exists because longer-horizon agentic capability matured in late 2024 with Devin's launch, and 2025 piled on Codex Cloud, Cursor Background Agents, and Jules. Anthropic's Claude Code Remote Tasks shipped March 20, 2026, and the rush to "set and forget" is now mainstream.

Why does set-and-forget matter? Parallelism. You can queue five well-scoped tickets on Friday afternoon and have five PRs to review Monday morning. That's a different workflow than pair-programming with a model, closer to managing a junior engineer than typing alongside one. People also search for "claude code background agent support" specifically, which is why we cover Claude Code Remote Tasks here, not just Devin. We covered the inline side separately in our breakdown of the inline-coding-agent split between Claude Code, Cursor, and Copilot. For a category-level architecture explainer, Tembo's primer is a decent starting point.

Background vs inline coding agents, when does async beat sync?

Async background agents win when a task takes more than 15 minutes and you don't need to course-correct mid-edit, well-scoped bug fixes, dependency upgrades, repetitive refactors, multi-file migrations. Inline agents like Cursor or Copilot win when you're exploring, prototyping, or pair-programming with the model and need to react in real time.

That's the headline. The decision matrix below is how we actually pick on Techsy projects:

Concretely: "Bumped 47 packages and fixed the breaking changes" is a textbook async coding agents job, well-defined, mechanical, parallelizable. "Built a new dashboard route" is inline, you'll iterate on layout, copy, and edge cases as you go.

The handoff between sync and async

Most teams we work with end up running both. Cursor inline for new code, Cursor Background Agents for upgrades. Claude Code interactive for architecture work, Claude Code Remote Tasks for the weekly dependency-bump cron. The handoff is the workflow, neither tool replaces the other. If you're staying in your editor, the Windsurf vs Cursor breakdown covers the sync side in detail.

If your task takes more than 15 minutes and you don't need to watch, async wins.

Devin (Cognition), the autonomy leader

Devin is the most autonomous background agent on the market, Cognition gives it a full sandboxed VM with its own IDE, browser, and terminal. Pricing dropped from a $500/mo enterprise floor to $20/mo + $2.25 per Agent Compute Unit (ACU) in April 2026, which made it the autonomy-leader headline of the month for autonomous coding agents.

Pricing. Core $20/mo + $2.25/ACU. Team $500/mo with 250 ACUs included plus extra ACUs at $2 each. 1 ACU is roughly 15 minutes of work. A typical bug fix runs 2-3 ACU, so $4.50-6.75. A multi-file migration can hit 30+ ACU, so $67.50 and up. (devin.ai/pricing, as of 2026-04-26.)

Strengths. Highest autonomy on the list. The VM includes a browser, so Devin can read docs and Stack Overflow without you spoon-feeding context. Mature product, Cognition shipped March 2024 and has had two years to refine the prompts that make Devin actually useful.

Weaknesses. ACU costs get unpredictable on novel work. Less mid-task control than Codex or Cursor, you set the task and walk away, which is fine until Devin spends 8 ACU debugging a typo. Needs precise acceptance criteria; vague tickets produce vague PRs.

Pick this if: you want to delegate well-scoped backlog items end-to-end and your team can write clear acceptance criteria.

Cursor Background Agents

Cursor's Background Agents run async inside the Cursor editor, up to 8 in parallel, triggerable from Slack, Linear, GitHub, or in-editor. They use whichever frontier model you select, so cost depends on token burn, not a flat ACU rate. Pro is $20/mo with $20 of usage included.

Pricing. Hobby $0, Pro $20/mo (includes $20 usage), Pro+ $60/mo ($70 usage), Ultra $200/mo ($400 usage), Teams $40/user/mo. Background agents bill usage-based on top, model + context length + output length. (cursor.com/pricing, as of 2026-04-26. The Background Agents feature shipped in Cursor 0.50.)

Strengths. Tightest editor integration on the list, your inline session, your background agent, and your rules all live in one tool. Up to 8 parallel agents means you can fan out a refactor across modules and reconverge in minutes. Slack, Linear, and GitHub triggers cover the question "which background agent works with Linear and Slack", Cursor does, natively.

Weaknesses. Frontier-model usage burns the included $20 budget faster than you'd think; one Opus-heavy session can blow through it. Per-task cost is opaque unless you check the usage dashboard, which most teams don't do until the bill hits.

Pick this if: you already live in Cursor and want async without changing tools, and you're OK reading the usage dashboard once a week. Your existing Cursor Rules feed both inline and background sessions, so the setup cost is near-zero if you're already a Cursor user.

Codex Cloud (OpenAI)

Codex Cloud is OpenAI's async coding agent. You describe a task, Codex spins up a sandbox VM, clones your repo, and returns a PR. It leads Terminal-Bench 2.0 at 77.3%, runs at ~240 tokens/sec (about 2.5x faster than Opus), and switched to token-based billing on April 2, 2026.

Pricing. Included in ChatGPT Plus ($20/mo). New Pro tier $100/mo (5x Plus usage; promotional 2x = 10x through May 31, 2026). Pro $200/mo. Token-based since 2026-04-02. Codex CLI is open-source and free with BYOK. Real-world cost lands at ~$100-200/dev/mo for active users. (developers.openai.com/codex/pricing, TechCrunch coverage of the $100 Pro tier, as of 2026-04-26.)

Strengths. Throughput champion at ~240 tps, for token-heavy tasks like dependency upgrades across many files, Codex finishes while Claude is still thinking. The CLI is open-source and works with your own API key, so you can wire Codex into CI without paying ChatGPT Pro. Distribution is huge: every ChatGPT Plus user already has it.

Weaknesses. Token billing is genuinely hard to predict task-to-task. The April 2 reform invalidates older comparisons, anything you read before that date is wrong on price. CLI feels like a separate product from the web Codex; the integration is loose.

Pick this if: you're a ChatGPT Pro user who wants a deeply integrated cloud agent, or a CLI lover who wants to bring your own key.

# Dispatch a task to Codex Cloud from the CLI
codex task create \
  --repo "techsy-io/example-app" \
  --branch "main" \
  --prompt "Bump all dependencies to latest and fix breaking changes" \
  --watch

Claude Code Remote Tasks (Anthropic)

Claude Code Remote Tasks let you define a GitHub repo, a prompt, and a schedule, Claude runs autonomously on Anthropic's cloud and opens a PR when done. Shipped on March 20, 2026. Backed by Opus 4.7's category-leading 87.6% on SWE-bench Verified and 64.3% on SWE-bench Pro. This is the answer to the autocomplete query "claude code background agent support", it's a real, shipped product.

Pricing. Bundled inside Claude Code Pro/Max plans. Pro $20/mo, Max 5x $100/mo, Max 20x $200/mo. Heavy users land at $100-200/mo real-world. (claude.com/code, platform.claude.com/docs/en/managed-agents/overview, as of 2026-04-26.)

Strengths. Highest SWE-bench Verified score on the list (87.6%). Persistent stateful agent sessions, a Remote Task can pick up where it left off rather than starting cold each run. Integrates with hooks and Claude Code's existing tool ecosystem, so existing skills, slash commands, and sub-agents work the same way they do in interactive sessions.

Weaknesses. Newest entry on the list, fewer integration patterns documented than Devin or Codex, fewer community examples to copy. CLI-first; no GUI, which raises the floor for non-CLI engineers on the team.

Pick this if: you're a Claude Code power user and you want recurring scheduled tasks, weekly dependency updates, cron-style refactors, on-demand QA passes. You can wire Claude Code hooks into Remote Tasks the same way you do interactive sessions, and Remote Tasks were one of the leaked-then-shipped features we covered in March.

# Schedule a recurring Remote Task in Claude Code
claude-code remote create \
  --repo "techsy-io/example-app" \
  --schedule "weekly" \
  --prompt "Bump deps, run tests, open PR if green"

Copilot Coding Agent (GitHub)

Copilot Coding Agent turns a GitHub issue into a pull request, you assign the agent like you'd assign a teammate. It's the most native GitHub workflow on this list. Note: as of April 20, 2026 GitHub paused new Pro and Pro+ sign-ups; existing subscribers and Business/Enterprise tiers are unaffected.

Pricing. Free $0, Pro $10/mo, Pro+ $39/mo, Business $19/user/mo, Enterprise $39/user/mo. Premium-request based: Free 50/mo, Pro 300/mo, Pro+ 1500/mo, Enterprise 1000/user/mo. Pro/Pro+/student new sign-ups paused starting 2026-04-20, Business/Enterprise still open. (github.com/features/copilot/plans, as of 2026-04-26.)

Strengths. Deepest GitHub integration in the category. Issue-to-PR is the most native workflow on the SERP, no extra app, no extra dashboard, the agent shows up as an assignee in the same UI you already use. The March 2026 Code Review update can hand off review comments to the coding agent automatically, closing the loop without leaving GitHub.

Weaknesses. Limited model selection at the lower tiers, you can't pick Opus on Pro, for example. Premium-request budget burns fast on Pro at 300 requests/mo if you're shipping daily. The new sign-up pause adds friction for new individual subscribers.

Pick this if: your team is already on GitHub Business or Enterprise and you want zero-setup async coding. Existing seats can use the agent today; the pause only blocks new individual sign-ups.

Google Jules

Jules is Google's async coding agent, a Gemini-powered VM with the best free tier in the category (15 daily tasks, 3 concurrent). It proactively scans your repo for #TODO comments and offers fixes. Paid plans start at $19.99/mo, but pricing has shifted multiple times in 2026.

Pricing. Free 15 daily tasks / 3 concurrent. Pro starting at $19.99/mo. Ultra starting at $124.99/mo. Pricing has changed several times in 2026 — verify current numbers at jules.google before purchase. (jules.google, TechCrunch GA coverage from August 2025, as of 2026-04-26.)

Strengths. Best free tier in the category, full stop. 15 tasks/day with 3 concurrent is genuinely useful for solo work, not a teaser. Cleanest UX of the bunch for non-power-users, the "scan for TODOs" loop is novel and surfaces real cleanup work without you prompting.

Weaknesses. Pricing volatility is the headline risk; we've watched the Pro tier price shift twice this year. Less mature integration ecosystem than Devin or Codex, fewer Slack/Linear/Jira hooks, less community tooling.

Pick this if: you're a solo dev or a small team that wants async without committing to a paid plan upfront, Jules's free tier is genuinely useful, not a teaser.

Factory Droids (Factory.ai)

Factory's "Droids" are specialized autonomous agents that code, test, review, and deploy, with cloud and local execution options. Factory closed a $150M Series C on April 16, 2026, and lists NVIDIA, Adobe, Bayer, EY, MongoDB, and Zapier as customers. Pricing starts at $20/mo for two seats.

Pricing. Paid plans start at $20/mo (includes 2 team seats), $5 per additional seat. Multi-Droid model routing, different Droids for code, test, review, deploy. (factory.ai/pricing, docs.factory.ai/pricing, Factory funding coverage via SiliconANGLE, as of 2026-04-26.)

Strengths. Customer logos signal regulated-industry fit, healthcare, banking, semiconductors. Cloud OR local execution is the only on-prem-capable option in the category, which matters for teams that can't ship code to a third-party cloud. Multi-agent coordination across code/test/review/deploy is genuinely different from the single-agent model the others use.

Weaknesses. Less name recognition than Devin or Codex, so internal buy-in takes longer. Overkill for solo devs, the multi-Droid orchestration is a tax you don't need on a side project.

Pick this if: you're a mid-to-large engineering org with governance, compliance, or air-gapped deployment requirements.

Honorable mentions, OpenHands, Antigravity, Aider

Three runners-up worth knowing: OpenHands is the leading open-source self-hosted background agent, pick it if you want full control or air-gapped operation. Google Antigravity is Google's other, less-publicized entrant. Aider is technically a sync CLI but increasingly used in async pipelines via shell scripts and CI hooks. None has Devin-class autonomy yet.

OpenHands is open-source, MIT-style license, self-host on your own infra. The tradeoff is you maintain the sandbox yourself, security policies, secrets management, runner uptime, all on your team. Real-world adoption is strongest in regulated and academic environments where the cloud agents are a non-starter.

Antigravity (Google) is the quieter sibling to Jules, same VM model, less marketing push, mostly mentioned in roundups. Production traction is light as of April 2026.

Aider is a CLI sync agent at heart, but teams increasingly chain it inside CI to mimic background behavior, a GitHub Action triggers Aider with a prompt, Aider commits, the workflow opens a PR. Works with any model via API and is BYOK by default, so it's the cheapest "background-style" option if you have CI infra to spare.

Two more to watch: Manus and Genie. Both are newer entrants with low real-world adoption signal as of April 2026. Worth watching, not worth committing to yet.

Which background coding agent should you pick?

Pick by your single biggest constraint. If it's budget, Jules's free tier wins. If it's GitHub-native workflow, Copilot Coding Agent wins. If it's autonomy on well-scoped tickets, Devin wins. If it's raw benchmark scores, Claude Code Remote wins SWE-bench Verified at 87.6%. If it's compliance, Factory Droids. If it's editor integration, Cursor.

Stack recommendation by team size & budget

Solo dev, start with Jules's free tier for the obvious wins, upgrade to Cursor Pro at $20/mo once you outgrow 15 tasks/day. Total: $0-20/mo.

Small team (2-10 devs), Cursor Pro for inline plus Background Agents, plus Claude Code Pro for scheduled cron-style tasks. Total: $40/dev/mo.

Enterprise (50+ devs), Copilot Enterprise for the GitHub-native workflow on the bulk of tickets, plus Factory Droids for governance-sensitive workloads. Total: $39 + $20-50/dev/mo depending on Factory seat count.

How much does each background coding agent cost per task?

Real cost per task varies wildly because every vendor bills differently. Devin charges $4.50-6.75 for a typical bug fix (2-3 ACUs). Cursor and Codex bill on token burn, expect $0.30-3 per task depending on model and context. Jules is free up to 15 tasks/day. Copilot uses premium requests at roughly $0.04 each at the Pro tier.

Pricing as of 2026-04-26. Token estimates assume frontier models with average task context. Always verify against your own usage dashboard.

Estimates for a typical 2-3 ACU / token-equivalent bug-fix task. Real cost varies with model selection and context length. Free-tier and seat-based tools show $0 marginal cost.

The lesson from running these numbers: Devin is 5-10x more expensive per task than the token-billed competition. That premium buys you autonomy, fewer prompts to write, less mid-task babysitting, but on routine bug fixes, Codex or Cursor wins on raw cost.

Which background coding agent has the best benchmark scores?

Anthropic's Claude Opus 4.7 leads SWE-bench Verified at 87.6%, with Codex's gpt-5-codex around 77-80%. Codex leads Terminal-Bench 2.0 at 77.3%. But benchmarks measure what the underlying model can do, your real-world success rate depends as much on the agent use, sandbox, and prompt as on the model.

For an aggregator view, artificialanalysis.ai's coding agents matrix tracks rolling benchmark numbers across providers.

Benchmarks are the floor, not the ceiling. We've seen Cursor BG with Opus 4.7 outperform Devin on the same ticket, use matters. If you're building your own agent use instead of buying, our LangGraph vs CrewAI vs OpenAI Agents SDK comparison walks through the framework choices that drive the gap between model score and real-world success rate.

Are background coding agents safe to give full repo access?

Each tool isolates differently. Devin runs a full sandboxed VM. Codex uses an OpenAI-managed cloud sandbox. Cursor spins up ephemeral remote machines. Copilot uses GitHub-managed runners (your existing GitHub Actions security model applies). Claude Code Remote runs in Anthropic's cloud. Factory offers cloud or air-gapped local. None is "give it root on prod."

What CTO-level questions to ask before adoption

Before granting any of these agents repo access, four questions decide the policy:

1. Repo permissions, does the agent get write access to main, or is it locked to feature branches? Always lock to feature branches plus a forced PR review.
2. Secret access, can the agent read .env files or call your secret manager? Default-deny and use scoped tokens.
3. Network egress, what can the sandbox call out to? Default-deny network with an allowlist for package registries and your private mirror.
4. Audit log retention, how long are agent sessions retained, and can your security team query them? Pin this in writing before grant.

Do background coding agents train on my code?

The default opt-in/opt-out varies. OpenAI Codex enterprise plans don't train on your code by default. Anthropic Claude Code does not train on your code. GitHub Copilot Business and Enterprise have data exclusion. Cursor offers privacy mode. Devin states code stays customer-controlled. Always verify the current data-use policy on the vendor's docs before granting repo access.

The one-line per tool, with current default behavior:

• Devin, code stays customer-controlled, per Cognition's policy
• Cursor, privacy mode toggle, opt-in for any training
• Codex Cloud, enterprise no-train default; ChatGPT Plus subject to consumer terms
• Claude Code Remote, no training on your code per Anthropic's commercial terms
• Copilot Business/Enterprise, data exclusion default-on; Pro/Pro+ have a separate toggle
• Jules, Google's standard enterprise data terms apply; verify current policy
• Factory Droids, customer-controlled per their docs; air-gapped local removes the question

Policies have shifted several times in 2025-26. Recheck before granting access, vendors update terms more often than blog posts get updated. Once a background agent's PR lands, you'll want a structured AI code review pass before merge, the IP question doesn't disappear because the agent vendor handled it.

How Techsy chooses background agents for client projects

On Techsy client projects we run a layered stack rather than picking one tool. Cursor Background Agents handle in-IDE async work (the engineers live in Cursor anyway). Claude Code Remote Tasks run scheduled cron-style tasks, weekly dependency bumps, nightly QA passes, the boring work that should be automated. Codex Cloud handles token-cheap throughput on lint and dep updates where speed beats benchmark scores. We pick Devin for clients who need full delegation autonomy and have well-scoped backlogs.

What we don't use much: Copilot Coding Agent. The premium-request budget on Pro runs out faster than the alternatives at our usage level, and we don't yet have enough Enterprise clients to justify the upgrade. We'd build a custom use with LangGraph or the OpenAI Agents SDK before locking into a single vendor for an enterprise rollout, but for 80% of greenfield client work, the off-the-shelf tools above are faster than rolling our own. The agentic AI deployment platform we use handles the agents these tools produce in production.

If you'd like a free consultation on which background coding agent fits your stack, or a custom agent use, we're happy to scope it.

FAQ, Background Coding Agents Compared

What is a background coding agent?

A background coding agent is an AI software engineer that runs asynchronously in a sandboxed cloud environment. You assign it a task, a GitHub issue, Linear ticket, or Slack message, and it works alone for minutes or hours, then returns a pull request for review. The defining trait is that you don't watch it type; it works while you're somewhere else.

What's the difference between a background coding agent and Cursor or Copilot inline?

Background agents run async in a cloud sandbox and return pull requests. Inline tools like Cursor and Copilot suggest code as you type, in your editor, with you driving each keystroke. Background agents enable parallelism (queue 5 tasks, get 5 PRs) while inline agents enable rapid iteration on a single task you're focused on.

How much do background coding agents cost per task?

Devin runs $4.50-6.75 for a typical bug fix at 2-3 ACUs. Cursor and Codex Cloud bill on token burn, typically $0.30-3 per task depending on model and context length. Jules is free up to 15 tasks per day. Copilot Coding Agent uses premium requests at roughly $0.04 each at the Pro tier, the cheapest per-task option among paid plans.

Which background coding agent is cheapest for solo devs?

Google Jules's free tier is unmatched: 15 tasks per day with 3 concurrent agents at $0/mo. If you outgrow it, Cursor Pro at $20/mo with $20 of usage included is the next step up and gives you editor integration as a bonus. For most solo devs, Jules covers daily needs without ever paying.

Are background coding agents safe to give full repo access?

Yes, with caveats. Use scoped tokens (not your personal access token), default-deny network egress with an allowlist, lock the agent to feature branches with required PR review, and review audit logs weekly. Never grant production-write permissions to any of these agents. Treat the agent like a contractor: trust, but verify every PR.

Do background coding agents train on my code?

Anthropic Claude Code, OpenAI Codex enterprise plans, and GitHub Copilot Business/Enterprise default to no training on your code. Cursor offers privacy mode. Devin states code stays customer-controlled. Always verify the current data-use policy on the vendor's docs before granting repo access, policies have shifted multiple times in 2025-26.

Can a background coding agent merge its own pull requests?

Most can if you grant the permission, but every team we know requires human review before merge. The technical capability exists, Copilot, Devin, and Cursor can all auto-merge if branch protection allows it, but auto-merge is a foot-gun. The PR review gate is the last cheap safety net before an agent's mistake hits production.

What's the best background coding agent for enterprise teams?

Two answers depending on your environment. If you're already deep in GitHub Enterprise, Copilot Coding Agent is the lowest-friction choice, issue assignment is the workflow, no extra tooling. If you have governance, compliance, or air-gapped requirements, Factory Droids is the only option with local execution and multi-agent coordination across code, test, review, and deploy.

Which background coding agent has the best free tier?

Google Jules wins this without contest. 15 tasks per day, 3 concurrent agents, full Gemini access, at $0/mo with no time limit. Copilot's Free tier (50 premium requests/mo) is a distant second; Cursor's Hobby tier is technically free but doesn't meaningfully cover background-agent use. Jules is the only free tier we've seen replace a paid plan for solo work.

When should I use a background agent vs an inline AI like Cursor?

Use a background agent when the task is well-scoped, takes more than 15 minutes, and you don't need to course-correct mid-edit, dependency upgrades, repetitive refactors, multi-file migrations, or anything you can describe in a clear ticket. Use inline when you're prototyping, exploring, or pair-programming with the model on novel work.

The takeaways

• Devin if you delegate, Cursor BG if you live in Cursor, Codex Cloud if you're a ChatGPT Pro user, Claude Code Remote for benchmarks, Copilot for GitHub-native, Jules for free tier, Factory for compliance.
• Pricing volatility is real, the April 2026 Devin cut, Codex token reform, and Copilot sign-up pause all happened this month. Verify before purchase.
• The async category is one year old and shipping fast. Expect this matrix to shift again before summer.

Want help choosing or wiring a background agent into your stack? Get a free consultation.