The world's first fully autonomous AI software engineer capable of taking Jira tickets to production.
Devin, made by Cognition, is marketed as an autonomous AI software engineer — an agent you assign tasks to, which then plans, writes, tests, and iterates on code largely on its own, working asynchronously in its own environment rather than as an in-editor assistant. It represents the most ambitious end of AI coding: not autocomplete or a pair programmer, but a system meant to take a ticket and return a pull request.
The most important 2026 news is price. With Devin 2.0, Cognition slashed the entry price from $500/mo to a Core plan starting at $20, with pay-as-you-go billing at $2.25 per ACU (Agentic Computing Unit — roughly 15 minutes of active autonomous work). The Team plan ($500/mo) includes 250 ACUs at a slightly better $2.00 rate with unlimited concurrent sessions (Core caps at 10). Enterprise is custom. This drop made Devin accessible to individual developers for the first time.
Its strength is genuine autonomy on well-scoped tasks. For clearly defined, self-contained work — fixing a bug, implementing a small feature, writing tests, doing a migration — Devin can take the task and return working code with little supervision, running multiple sessions in parallel. For teams wanting to offload routine engineering chores, that asynchronous, fire-and-forget model is genuinely different from editor-based tools.
The honest weaknesses: autonomy is also the risk — Devin can confidently go down wrong paths on ambiguous or complex tasks, and ACU-based billing means a task that spirals costs real money with less visibility than a flat subscription. It works best on well-scoped work and still needs human review. For interactive, in-editor development most engineers still prefer Cursor or GitHub Copilot, using Devin as a complement for delegatable tasks rather than a replacement.
Who it is for: developers and teams who want to delegate well-scoped engineering tasks to an autonomous agent that works asynchronously. Who it is not for: those wanting interactive, in-editor assistance (use Cursor/Copilot), or anyone uncomfortable with usage-based costs on tasks that can occasionally run long.
Full review coming soon.
Devin's sweet spot: hand it a clearly defined, self-contained task — a bug fix, a small feature, a test suite, a migration — and it plans, codes, tests, and returns a pull request asynchronously, with little supervision. For routine, delegatable work it functions like an extra engineer.
Because Devin works in its own environment rather than your editor, you can run multiple sessions at once (unlimited on Team), assigning several tasks in parallel. Teams use this to offload a batch of routine chores simultaneously rather than doing them one by one.
Large, mechanical jobs — framework migrations, repetitive refactors across many files — suit Devin's autonomous model well, since the work is well-defined but tedious. It grinds through the repetition while engineers review the output.
After the Devin 2.0 launch, pricing dropped dramatically: Core starts at $20 with pay-as-you-go billing at $2.25 per ACU (Agentic Computing Unit ≈ 15 minutes of active autonomous work), capped at 10 concurrent sessions; Team is $500/mo including 250 ACUs at a better $2.00 rate with unlimited concurrent sessions; Enterprise is custom. The shift from a flat $500 entry to a $20 usage-based Core made Devin accessible to individuals for the first time. The trap: ACU billing means a task that spirals or runs long costs real money with less predictability than a subscription — scope tasks well and watch ACU consumption.
With Devin 2.0, Cognition cut the entry price from $500/mo to a Core plan starting at $20, with pay-as-you-go billing at $2.25 per ACU. The Team plan is $500/mo with 250 ACUs at $2.00 each and unlimited concurrent sessions. This made Devin accessible to individual developers for the first time.
An ACU (Agentic Computing Unit) is Devin's normalized measure of resources used while actively working — VM time, model inference, and bandwidth. One ACU represents roughly 15 minutes of active autonomous work. You are billed per ACU consumed, so cost scales with how much actual work a task requires.
They are different categories. Devin is an autonomous agent you delegate whole tasks to, working asynchronously; Cursor and Copilot are interactive, in-editor assistants. Most engineers still prefer in-editor tools for day-to-day coding and use Devin to offload well-scoped, delegatable tasks. They complement rather than replace each other.
On well-scoped, self-contained tasks, yes — it can plan, code, test, and return a pull request with little supervision. But autonomy is also its risk: on ambiguous or complex work it can confidently go down wrong paths, so human review remains essential. It is best treated as a capable junior engineer, not a hands-off replacement.
ACU-based billing means costs scale with actual work, so a task that spirals or runs longer than expected consumes more ACUs and costs more — with less predictability than a flat subscription. Scope tasks clearly and monitor ACU consumption to avoid surprises, especially on the pay-as-you-go Core plan.