Devin AI Pricing 2026: Plans and Real Cost per Task
Oct 28, 202616 min read
Devin, Cognition's autonomous AI software engineer, costs $0 to $200 a month per Devin's pricing. The monthly fee only buys entry, and the compute units your tasks burn set the real bill, which means even the $0 plan costs money.
Devin AI pricing is the usage-based cost of running Devin, made up of a monthly plan fee that includes an allowance of compute units and a metered charge for any units your tasks consume beyond it.
Activepieces, whose Free plan includes unlimited flows, can screen what reaches Devin, but the number to start from is still cost per finished job, not the fee.
Every current plan, price and limit
Count the blank columns in the table below, which lists each plan on the pricing page. The fee is public, but most of the numbers needed to cost a task aren't.
| Plan | Monthly price | Included ACUs | Extra-ACU price | Concurrent sessions | Seats | Key features |
|---|---|---|---|---|---|---|
| Free | $0 | not published | not published | not published | not published | not published |
| Pro | $20 | not published | not published | not published | not published | not published |
| Teams | $80 minimum | not published | not published | not published | not published | not published |
| Max | $200 | not published | not published | not published | not published | not published |
According to Devin, Free is $0 a month, which is enough to try Devin but not to budget with, since no ACU allowance is published to divide by.
Pro is $20 a month, so a solo builder can start cheaply, but the fee says nothing about how many tasks it covers.
Your own team size and usage decide the real Teams figure, because Devin's $80 minimum is a floor rather than a quote. Max is $200 a month, ten times Pro, so it only pays off if the extra spend buys proportionally more merged work.
Without included ACUs and an overage rate, you can't calculate a cost per task from the page alone. Measure it yourself on a trial workload.
As it stood on 28 October 2026, every price here comes from the Devin pricing page. Where the page gave no figure, the cell says "not published" instead of carrying a guess. Plans change, so recheck before you commit.
Agent compute units and metering
What Devin bills against is the agent compute unit (ACU). The monthly fee buys a quantity of work, and your real cost is whatever each merged task consumes from that quantity.
What burns compute units fastest
If you read Devin's docs, consumption comes down to four things. The list shows that every driver is about time and repetition, not about how many tasks you start, so the lever you control is how tightly each session is scoped.
- Session length: the longer a session runs, the more units it accrues.
- Task complexity: harder work means more steps, more reading of the codebase and more tool use per session.
- Idle time: a session left waiting on you still counts against the meter.
- Retries: each failed attempt at a test, build or fix is paid for again, whether or not it ends in a merge.
Retries are the one that breaks the math. A task that needs several attempts costs several times a clean one, yet it counts as one merged task in your head. Divide units spent by tasks merged, not tasks started.
What happens when Devin units run out
When the included units run out, work doesn't simply continue at the plan price. Depending on your plan, you either stop or buy more units, and the second path means your per-task cost now depends on the add-on rate.
**Divide units spent by tasks merged, not tasks started.
Read that rate before you rely on it, and set an alert well ahead of the limit rather than discovering it mid-task.
Whether leftover units carry into the next cycle is a plan term, and I'd assume they don't until the terms say so in writing. If they expire, a quiet month is money you have already spent.
A session that stalls and sits idle is still metered, so close or cancel abandoned sessions instead of leaving them open.
If you are running this arithmetic for your own team, see what the same workload costs on Activepieces.
Devin pricing for different user types
Because idle sessions burn units, the useful price is the bill divided by merged tasks, and on that measure all three workloads land near $9 to $10.50 per merged task.
I assume a task burns 2 ACUs (Devin's compute unit, about half an hour), at $2.25 per ACU on pay-as-you-go and $2.00 on the team plan, with 250 ACUs included in its $500 fee.
I also assume 43 % of tasks merge, and a month is 4.33 weeks.
Check these against Devin's current pricing page, because the plan fees and ACU rates are my working assumptions.
| Workload | Best plan | Plan fee | Overage | Total monthly bill | Merged tasks | Cost per merged task |
|---|---|---|---|---|---|---|
| Solo builder (10 tasks/week) | Core, pay as you go | $0 | about $194 usage | about $194 | 18 | about $10.50 |
| Five-person team (40/week) | Team | $500 | about $192 | about $692 | 74 | about $9.35 |
| Heavy daily user (100/week) | Team | $500 | about $1,232 | about $1,732 | 186 | about $9.31 |
The fee barely moves the per-task cost. The merge rate sets it, and the next three paragraphs show why.
For the solo builder at 43 tasks a month, the $500 team fee would cost more than all the usage, so pay-as-you-go wins.
Devin Core runs about $9 per hour, against $65.38 for a US developer. That's roughly seven times cheaper per hour, but only if the output merges.
For the five-person team, the old Teams rate was $8 per hour, so the $500 fee buys a cheaper ACU, and at 173 tasks the discount outweighs the fee.
The catch is the 43 % merge rate against 73 % for Codex, 84 % for Claude Code and 85 % for humans. At 73 %, the same team would pay about $5.50 per merged task.
For heavy daily use, past roughly 100 tasks a week, overage is most of the bill, so ask for volume pricing before you commit. Get the quote in writing and compare it with $9.31.
Limits and hidden costs that drive upgrades
Treat the $9.31 estimate as a floor, not a forecast: every limit below raises your cost per merged task before it touches the monthly fee.
Devin concurrency limits and ACU caps
When a session cap is hit, tasks queue behind each other, so a batch of ten fixes finishes at the speed of the slowest lane.
An ACU cap stops work mid-month, and the top-up you buy to resume it is billed at whatever rate your plan sets. Both are cheap to ignore on a trial and expensive to discover on a deadline.
A seat minimum means a solo builder pays for seats nobody sits in. SSO, VPC deployment and faster support sit behind the upper tiers. If your client's security review demands any of them, the upgrade stops being optional, and your per-task cost absorbs the difference.
Costs that never appear on the Devin invoice
Someone reads every pull request, and that salary is a cost per task. A failed session still burned compute units. Your CI runs on every attempt, passed or not. The table sets each limit beside the plan that removes it.
| Limit | How it bites | Plan that removes it | That plan's price |
|---|---|---|---|
| Session cap | Tasks queue | Next tier up | That tier's quoted fee |
| ACU cap | Work halts mid-month | Next tier up, or a top-up | Tier fee, or the top-up rate |
| Seat minimum | Unused seats billed | Lower-minimum plan | Whatever that plan lists |
| SSO | Blocks security review | Enterprise-level tier | Quoted by the vendor |
| VPC deployment | Blocks data-residency rules | Enterprise-level tier | Quoted by the vendor |
| Support | Slow answers when stuck | Higher support tier | That tier's quoted fee |
| PR review time | Your hours, per task | No plan removes it | Your hourly rate |
| Failed sessions | Spent units, nothing merged | No plan removes it | Units spent per failure |
| CI | Runs on every attempt | No plan removes it | Your CI provider's bill |
Add the last three rows to your own ledger before you divide by merged tasks, because no tier on any price page will do it for you.
Worth checking against a plan that does not meter every step: one credit covers a whole run on Activepieces.
Devin pricing compared to competitors
Of these four, Devin is the one whose bill follows the work a task consumes, not the number of prompts you send. Its monthly fee therefore tells you the least about what you'll pay.
Price and metering side by side
Compare the metering unit and the heavy-month column, because those decide your cost per merged task. All four tools lead with a flat fee and then meter something else.
| Tool | Entry monthly price | Metering unit | Background or in-editor | Cost of a heavy month |
|---|---|---|---|---|
| Devin | Small flat fee | Compute units | Background | Grows with units burned, so long or failed tasks cost the most |
| Cursor | Flat seat fee | Usage against an included allowance | Mainly in-editor | Grows once usage passes the allowance |
| GitHub Copilot coding agent | Flat seat fee | Premium requests | Background | Grows with requests past the included amount |
| Windsurf | Flat seat fee | Credits | In-editor | Grows once credits run out |
A request or credit is a fixed, countable event. A compute unit tracks how long the agent works, so a task that loops costs more than one that doesn't. Only Devin's meter punishes a stuck task directly.
Devin versus Copilot, Cursor and Windsurf
These tools do different jobs, so a price comparison alone misleads.
Devin and the Copilot coding agent take a ticket and work without you, which means you pay for output you didn't watch and must review afterward. Cursor and Windsurf work beside you, so you catch a wrong turn within seconds and spend less on retries.
That makes the cheapest sticker the wrong yardstick. An editor assistant with a modest allowance can look far cheaper than an agent, yet it consumes your hours where the agent consumes units.
Price each tool by the same measure, cost per merged task, and count your review time in the ledger beside the vendor's meter.
How to keep Devin spend predictable
Cap every session before it starts, then divide what you spent by what you merged. That keeps the ledger honest, because review time sits beside the meter.
The six steps below run in order, and each one limits how much a single bad session can cost:
- Scope the task to one change.
- Write a brief naming the files involved and a test that proves the work is done.
- Set an ACU (agent compute unit, Devin's billing meter) limit on the session.
- Check running sessions and stop any that have stalled.
- Record the cost of each merged pull request (PR).
- Hand the task to a human once cost passes your threshold.
If the task is vague, it is expensive, because Devin keeps exploring while the meter runs. One change per session means a failure costs you one retry, not a tangled branch.
Name the files and state the done-test, such as a failing test that should pass, so Devin knows when to stop and you know what to review.
Set limits and watch usage
Set the ACU limit per session, so the worst case is a number you chose. Then look at running sessions. A session looping on the same error is spending your money on nothing, so stop it and rewrite the brief instead of letting it grind.
Log the final cost against each merged PR. Your average per merge is the figure to compare against any other tool, and sessions that never merge belong in the total.
Pick a threshold in advance: the cost per merged PR above which a person is cheaper. Ambiguous design work, tasks with no test to check against, and changes touching many files tend to cross it.
When a task crosses the line twice, stop delegating that type of work.
Connect Devin to ticket and alert workflows with Activepieces
The cheapest task is the one you never start, and Activepieces can decide what reaches Devin and where the result goes, at 1 credit a run however many steps the flow has.
Once you've stopped delegating a type of work, the same logic applies upstream: stop sending Devin tickets that were never ready.
Filter tickets before they reach Devin
Every session Devin starts burns compute units, and a vague ticket is the surest way to burn them on work that gets rejected.
Activepieces sits between your sources and Devin. A trigger fires when a ticket is created in your tracker or an alert arrives from your monitoring feed, and a filter step then checks what came in.
The MIT-licensed core carries 746 integrations, counted from the open source monorepo under packages/integrations/community, and roughly 60% of them are community-contributed, so a tracker or monitoring feed is likely already a integration in that folder.
The integration action that runs as a step in your flow is the same one exposed as a tool on the project's MCP server, as the Integrations Framework and MCP Server documentation describe.
The filter is where the money is saved. Drop tickets with no reproduction steps, no acceptance criteria, or no linked repository, and you've removed the sessions most likely to cost units and produce nothing mergeable.
Tickets that pass go on to start a Devin session with the full ticket text as the prompt. Rejected ones can go back to the author with a request for detail, which costs you a message instead of a session.
The flow below shows the path. Tracker and alert feed in on the left, the filter discards vague items, clear ones pass to Devin, and the result card goes out to Slack and the tracker.
(illustration)
Read it as a gate placed before the meter starts running. Whatever the filter rejects never reaches Devin's billing at all.
Post results back to the team
When a Devin session finishes, a final step formats a result card: what was attempted, the pull request link, and whether the session ended in success or a stall.
Activepieces posts that card to a Slack channel and writes it back to the originating ticket, so the person who owns the work sees the outcome where they already look, and with 746 integrations in the open source monorepo that is two steps in one flow, not two systems.
That record is also what makes cost per merged task measurable. If every result lands on the ticket, you can count which tasks merged and which ended in rework, then divide your unit spend accordingly.
On price, Activepieces bills separately from Devin: the Free plan is $0 with 1,000 credits a month, and Plus is $20 a month for 10,000 credits, then $0.007 a credit over. The full list is on its pricing page. Devin's bill is unaffected by it.
Before building anything, check whether Devin's native integrations already cover your tracker and Slack. If they do, you may only need Activepieces for the filter, and its MIT-licensed core can run on your own infrastructure if tickets can't leave it.
Frequently asked questions
Is there a free plan or free trial for Devin? There is a Free plan with limited Devin usage, though free trials of paid plans are not currently offered, so the first paid plan is your entry cost once you outgrow it.
Check the pricing page for current terms. Then run one small, well-scoped task and divide what it burned by whether it merged. That's your real trial.
Can you cancel Devin or change plans mid-month?
Assume a plan change takes effect on the vendor's billing schedule, not yours, and confirm that before you commit. We have no confirmed terms on proration or refunds for a cancelled month.
The practical advice is to start on the smallest plan and upgrade only when a limit actually blocks you. Moving up is easier to justify than getting money back.
Does Devin offer discounts for startups or education?
We found no confirmed discount program for either group. If you qualify, ask support in writing and keep the reply.
Be wary of any answer that only comes after a sales call, because a price you can't read on a page is a price you can't model. A discount on the fee also matters less than a lower cost per merged task.
Is Devin cheaper than hiring a junior developer?
It depends on your merge rate, not on the fee. A junior developer is a roughly fixed monthly cost whether the week goes well or badly.
Devin's cost moves with the compute your tasks burn, so a run of failed or abandoned sessions raises your cost per merged task while a junior's salary stays flat.
Devin wins on well-defined, repetitive work that merges on the first or second try. It loses when tasks need heavy back-and-forth.
Do unused Devin compute units carry over? We couldn't confirm whether unused compute units roll over or expire.
Check the plan terms before you buy in bulk, because expiry turns a cheap-looking bundle into waste if your usage is uneven. Until you know, buy only what you expect to burn in a billing period.
Related reading
Running the numbers
See what the same workload costs here.
Free forever plan, and every paid plan self-hosts at no extra cost.
See pricing Talk to sales
