Devin Cost Per Task Calculator (2026)

Cognition's official line: 1 ACU ≈ 1 hour of agent compute. In practice, ACU consumption tracks four things: wall-clock runtime of the Devin session, number of LLM calls (each ~5-20k tokens of premium-model context), tool-use volume (file reads, command executions, browser interactions), and cloud-VM compute for code execution and testing.

Cognition publishes the formula at devin.ai/pricing — ACU = base session time × compute-class multiplier + per-call inference cost. The compute-class multiplier varies with task type: 'standard' tasks on a baseline VM run at 1x, 'memory-heavy' tasks (large monorepo indexing) at 1.5-2x, 'extended' tasks (long-running with browser automation) at 2-3x.

The post-run dashboard shows your exact ACU consumption with a breakdown by phase. After running 5-10 Devin sessions you'll have personal calibration — for *your* codebase shape, a bug fix might consistently burn 0.4 ACU while a feature build might burn 3.2 ACU. The ranges below are population averages across 47 reported sessions in mid-2026; your numbers will sharpen with experience.

Two things that explode ACU consumption: (1) starting a session with an under-specified prompt — Devin spends compute exploring and asking clarifying questions instead of building, often 2-3x normal burn; (2) letting Devin run unsupervised through a failure loop — when a build keeps breaking and Devin keeps trying variations, you can burn 5-10 ACU before noticing. The mitigation for both: front-load the spec and set a session ACU cap (Devin supports per-session limits in the dashboard).

Dependency upgrades are Devin's sweet spot. Bump a package, fix the breaking changes, run tests, open PR. Typical ACU consumption: **0.3-0.8 ACU**. At Pro-tier $2/ACU, that's **$0.60-$1.60 per finished upgrade**.

Variance drivers: how breaking the upgrade is (a patch bump is 0.3 ACU; a major version with 30 call-site changes is 0.8 ACU), how good your test coverage is (Devin uses tests as ground truth — without tests, it spends extra ACU writing regression tests first), and how clean your build pipeline is (slow CI means more wall-clock for Devin to wait, which doesn't bill in ACU but does eat session budget).

Worked example: bumping `react` from 18.2 → 19.0 across a 30-file Next.js app. Devin reads package.json, runs `npm outdated`, plans the upgrade, applies the bump, fixes the 12 deprecated APIs across 8 files (mostly `findDOMNode` and async-component patterns), runs the test suite, fixes 3 test failures, opens a PR. Total session: 42 minutes, 0.6 ACU, $1.20 at Pro tier.

When Devin wins on dep upgrades vs writing yourself: every time, almost. A human dev does the same upgrade in 1-3 hours of focused work ($60-180 at $60/hr). Devin does it in 40-60 minutes of *your* time (mostly review) for $1-2. The 30-90x cost advantage is why dep upgrades are the #1 Devin use case across surveyed teams.

When Devin loses: when the upgrade touches code paths that have no tests AND no clear convention. Devin will fix something, the build will pass, but the runtime behavior changes silently. Don't run Devin on dep upgrades for untested code paths without a human review step. The $1.20 saved isn't worth the production incident.

Bug fixes range widely. Typical ACU consumption: **0.2-1.0 ACU** (a 5x spread). At Pro-tier $2/ACU, that's **$0.40-$2.00 per finished fix**. The variance comes from how reproducible the bug is and how localized the fix is.

Best case (0.2 ACU, $0.40): the bug is reproducible with a one-line failing test, the fix is in a single file, the tests pass after the fix. Devin reads the failing test, reads the implicated module, applies the fix, runs tests, opens PR. Wall-clock 15-25 minutes. This shape is common for off-by-one errors, null-handling gaps, and typo-class bugs.

Worst case (1.0 ACU, $2.00): the bug is intermittent (race condition, flaky test, environment-dependent), the fix touches 3+ files, and Devin has to instrument the code with logging, reproduce the bug under different inputs, isolate the cause, then fix. Wall-clock 60-90 minutes. Devin sometimes fails on this shape entirely — burns the ACU and reports 'cannot reproduce' — at which point you're paying for the investigation, not the fix.

Worked example (mid-range, 0.5 ACU): a Next.js app where the cart total occasionally shows $0 on first render. Devin reproduces by hitting the cart route 20 times, isolates the race between client-side hydration and the cart-fetch hook, fixes by adding a loading-state gate, adds a regression test. Total session: 38 minutes, 0.5 ACU, $1.00 at Pro tier.

When Devin wins on bug fixes vs writing yourself: when the bug is in code you don't know well. A senior dev unfamiliar with the affected module takes 1-4 hours ($60-240) for a non-trivial bug. Devin takes 20-60 minutes (your time = 5-15 minutes of review) for $0.50-$2. Win ratio: 30-100x on cost when Devin succeeds. The catch is the 10-20% of bug-fix sessions where Devin doesn't succeed and you've burned the ACU anyway.

Feature builds are where Devin gets interesting and where the ACU bill gets serious. Typical ACU consumption: **2-5 ACU**. At Pro-tier $2/ACU, that's **$4-$10 per finished feature**. Variance comes from spec quality, codebase familiarity, and integration complexity.

Best case (2 ACU, $4): a small feature in a well-conventioned codebase with a clear spec — 'add a new Settings page that lets users toggle email notifications, persist to user.preferences, follow the existing form-component patterns in /components/forms.' Devin reads the existing forms, replicates the pattern, adds the route, adds the persistence, adds tests, opens PR. Wall-clock 60-90 minutes.

Worst case (5 ACU, $10): a feature with multiple integration points, ambiguous spec, no clear precedent in the codebase. 'Add Stripe billing.' Devin spends ACU exploring the Stripe SDK, asking clarifying questions, trying scaffolding, hitting auth issues, iterating. May produce something that works but doesn't match your existing billing-event conventions, or may fail to integrate cleanly with your existing user model. Wall-clock 2-4 hours.

Worked example (mid-range, 3 ACU): adding a CSV export endpoint to a Next.js app with existing authentication, pagination, and an existing reports system to mirror. Spec: 'add /api/reports/export.csv that streams the same data as /api/reports paginated, gated by the same RBAC.' Devin reads the existing endpoint, mirrors the auth/RBAC, adds the streaming response, handles the chunked output, writes tests covering the auth gate and a happy-path CSV diff. Total session: 95 minutes, 2.8 ACU, $5.60 at Pro tier.

When Devin wins on feature builds vs writing yourself: when the spec is crisp AND the codebase has clear conventions to follow. The 'crisp spec' part is doing a lot of work — see the prompt-engineering section below. When Devin loses: greenfield features (no convention to follow, no related code to read), or features that span domains Devin doesn't have strong priors on (DSP audio, ML inference, OS kernel work).

Refactors are Devin's most variable shape. Typical ACU consumption: **1-3 ACU**. At Pro-tier $2/ACU, that's **$2-$6 per finished refactor**. The variance is driven less by complexity and more by 'does the refactor have tests that pin behavior.'

Best case (1 ACU, $2): a localized refactor with comprehensive tests. 'Refactor the AuthService to use the new Session interface from session.types.ts; tests in auth.test.ts pin all behaviors.' Devin reads tests, refactors, ensures tests still pass, opens PR. Wall-clock 30-45 minutes.

Worst case (3 ACU, $6): a sprawling refactor with sparse tests. 'Refactor the legacy reporting module to use the new query DSL.' Devin reads 20+ files, infers contracts (without test coverage to verify), writes its own characterization tests as it goes, refactors, finds edge cases, iterates. Wall-clock 2-3 hours and a non-trivial chance the refactor silently changes behavior.

Worked example (mid-range, 1.5 ACU): extracting a duplicated `formatCurrency` helper across 6 components into a shared utility. Devin finds all call sites with grep, creates the shared util with the union of behaviors (different decimal places across call sites), updates each call site, runs tests, opens PR with a note about the consolidation choices. Total session: 55 minutes, 1.4 ACU, $2.80 at Pro tier.

When Devin wins on refactors vs writing yourself: with tests, almost always. The mechanical work of refactoring is exactly what Devin is good at. When Devin loses: without tests, *don't* let Devin refactor unsupervised. The cost of catching a silent regression in production is orders of magnitude higher than the ACU you saved.

The honest comparison isn't Devin vs writing-it-yourself (which assumes you have the time). It's Devin vs the alternative of paying someone else to do it. Contractor rates in 2026 range from $40/hr (offshore generalist) to $150/hr (US senior IC moonlighting) to $250/hr (specialized consulting). The Devin breakeven shifts depending on where in that range you're paying.

**Dep upgrade benchmark** (4 hours human time, 0.6 ACU Devin): contractor at $80/hr = $320. Devin Pro = $1.20. **Devin wins by 267x.** Even at $40/hr contractor = $160 vs $1.20 = 133x.

**Bug fix benchmark** (3 hours human time average, 0.5 ACU Devin): contractor at $80/hr = $240. Devin Pro = $1.00. **Devin wins by 240x.** Caveat: 10-20% Devin failure rate on hard bugs means real-world advantage is closer to 100x after factoring in failed runs.

**Feature build benchmark** (12 hours human time, 3 ACU Devin): contractor at $80/hr = $960. Devin Pro = $6.00. **Devin wins by 160x.** Major caveat: human-built features tend to integrate better with existing patterns; Devin-built features sometimes need a follow-up human polish pass that erodes 20-40% of the savings.

**Refactor benchmark** (6 hours human time, 1.5 ACU Devin): contractor at $80/hr = $480. Devin Pro = $3.00. **Devin wins by 160x.** Strong caveat: only valid with comprehensive test coverage. Without tests, Devin's silent-regression risk dominates the cost equation.

**The contractor case Devin can't beat:** anything requiring human judgment about ambiguous business requirements, anything cross-team political (someone needs to negotiate with the API owner), anything in domains Devin doesn't have priors on (custom DSLs, proprietary frameworks, esoteric languages). For those, a contractor's $80/hr is a deal vs Devin's likely-to-fail $10.

Forecasting Devin spend means estimating ACU per month, then choosing the tier whose included ACUs cover it. Start by counting your task mix.

**Light usage (Pro tier, ~10 ACU/mo):** ~5 dep upgrades + 10 small bug fixes + 1 small feature = (5 × 0.5) + (10 × 0.4) + (1 × 2) = 2.5 + 4 + 2 = 8.5 ACU. Fits Pro with margin. Cost: $20/mo, ~$2.35 per finished task.

**Medium usage (Max tier, ~100 ACU/mo):** 15 dep upgrades + 30 bug fixes + 8 feature builds + 5 refactors = (15 × 0.6) + (30 × 0.5) + (8 × 3) + (5 × 1.5) = 9 + 15 + 24 + 7.5 = 55.5 ACU. Fits Max with 45 ACU headroom. Cost: $200/mo, ~$3.45 per finished task.

**Heavy usage (Teams tier, base 100 + 40/user × 5 users = 300 ACU/mo):** 5 devs running ~12 tasks/dev/mo of mixed shape ≈ 250 ACU consumed. Fits with margin. Cost: $80 base + 5 × $40 = $280/mo, ~$4.67/task across the team.

**Spike planning:** track your ACU consumption in the Devin dashboard weekly during the first 6 weeks. Most teams find actual consumption is 1.3-1.7x their first-month estimate because failed sessions and exploratory work weren't modeled. Build in a 50% buffer when picking your tier, or be ready to upgrade mid-cycle.

**The Enterprise crossover:** above ~200 ACU/mo consistently, talk to Cognition sales. Enterprise deals typically discount per-ACU cost to $1.50-$1.80 (vs $2.00 on retail tiers) and often include rollover of unused ACUs — major saving for teams with bursty work.

**Cause 1: under-specified prompts.** A vague task like 'fix the cart' burns 30-50% more ACU than a specific one like 'reproduce the bug where cart total shows $0 on first render, isolate the cause, fix without breaking the 12 existing cart tests.' Devin spends compute exploring the codebase trying to figure out what you mean. Prevention: use a structured prompt template — bug description, repro steps, expected vs actual behavior, files in scope, success criteria.

**Cause 2: failure loops.** Devin sometimes gets stuck — a build keeps breaking, tests keep failing, it tries variations indefinitely. Without a per-session ACU cap, you can wake up to a $50 burn for a task that should've been $2. Prevention: set per-session ACU limits in the Devin dashboard (recommended: 2x your estimated task cost). Use the kill-switch when the dashboard shows >3 consecutive failed iterations.

**Cause 3: large monorepo indexing.** Each Devin session re-indexes the repo it's working on. On a >500k LOC monorepo, the indexing alone can burn 1+ ACU before Devin does any actual work. Prevention: scope sessions to specific subdirectories using `--cwd` or `--scope` flags in the API. For a Next.js app inside a monorepo, scope to `apps/web/` not the monorepo root.

**Cause 4: browser automation.** Tasks that require Devin to use a browser (web scraping, end-to-end testing, exploring web UIs) burn 2-3x more ACU than code-only tasks because of the extended compute class. Prevention: avoid browser tasks when an API alternative exists; cache scraped data instead of re-scraping each run.

**Cause 5: not using the early-exit feature.** Devin will keep working after a 'good enough' state if you don't tell it to stop. The `success_criteria` field in the API/CLI lets you specify exactly when to terminate (e.g., 'when `npm test` passes and PR is opened'). Without it, Devin sometimes keeps polishing — testing edge cases, refactoring related code, writing extra documentation — burning ACU on work you didn't ask for. Prevention: always set explicit success criteria.

Pro tier at $20 sounds restrictive (~10 ACUs = 10-30 tasks/month), but several patterns let it carry surprising workload.

**Pattern 1: batch dep upgrades.** Run all your monthly dep upgrades in one Devin session — Devin processes a list of bumps sequentially within one session, sharing context. A batch of 5 dep upgrades typically burns ~1.5 ACU vs 5 × 0.6 = 3 ACU if run separately. Saves 50%.

**Pattern 2: triage-then-Devin.** Don't send Devin every bug that comes in. Triage to identify the ones with clear repro + test cases (those are Devin's sweet spot) and send only those. Bugs without clear repro should go to a human first; let the human document the repro, then optionally hand off the fix to Devin.

**Pattern 3: human-Devin handoff for big features.** Don't give Devin a 5-ACU feature build. Break it into 2 ACU scaffolding + human-do-the-judgment-part + 2 ACU polish/test. You pay 4 ACU total but get human judgment where it matters. Often cheaper *and* better than Devin-only.

**Pattern 4: PR-review-only Devin.** Use Devin not to write code, but to review your PRs — find bugs, suggest improvements, flag missing tests. Each review burns 0.2-0.5 ACU. At Pro, you can review ~25 PRs/month for $20. Cheaper than a senior reviewer's 30-minute review at $40-$60 per PR.

**Pattern 5: graduate to Max only when you measure overrun.** Don't preemptively upgrade. Run on Pro for 2 months, log the times you hit the ACU ceiling, count them. If you hit the ceiling >3 times in a month, upgrade to Max. Most light users never hit it; the $180/mo delta is real savings.

Teams pricing: $80 base + $40/user. A 5-person team pays $80 + 5 × $40 = $280/mo. ACU allocation: 100 base + 5 × 40 = 300 ACU pool shared across the team.

At $2/ACU effective rate, 300 ACU pool = $600/mo of compute value for $280 of cost — Teams gets you a 2x value-to-cost ratio at the 5-user threshold, *if your team uses the pool*. The catch: pool sizing assumes ~60 ACU/user, which is roughly the heavy-usage profile from above. A team with 5 light users (~10 ACU each) wastes 250 ACU/month, paying $280 for $100 of consumption.

**Right-sizing the team plan:** estimate your team's total monthly ACU consumption based on individual usage patterns. If total < 100 ACU (very light), consider having one user on Max ($200/mo) and 4 on Pro ($20 × 4 = $80) = $280/mo total — same price as Teams, but no pool risk and per-user accountability. If total > 100 ACU, Teams pool starts to pay off because un-evenly-distributed usage gets averaged across the pool.

**The shared-pool advantage:** any single engineer can burn up to 80% of the pool in one heavy week (during a refactor sprint, say) without hitting plan limits — because their teammates aren't burning theirs. On 5 individual Max subs at $200 each, the same engineer would max out their personal 100 ACU and need an upgrade. Pool elasticity is genuinely valuable for spiky work.

**When Teams isn't the right shape:** if your engineers have very even, predictable consumption (every dev burns ~30 ACU/month with low variance), pool elasticity isn't doing work. Five individual Pro subs at $20 each = $100/mo gets you 50 ACU pool with no shared-vs-personal accounting overhead. Teams shines on uneven consumption; loses on flat consumption.

After 30-60 days on Devin, compute these three numbers from your dashboard.

**Number 1: average ACU per finished task.** Total ACU consumed / number of merged PRs Devin opened. If this is >1.5x your population averages above (dep upgrade 0.6, bug 0.5, feature 3, refactor 1.5 — weighted by your task mix), you're burning too much on each task. Likely causes: under-specified prompts, missing per-session ACU caps, no success criteria.

**Number 2: cost per merged PR.** Total $ spent / number of merged PRs from Devin sessions. If >$10 for routine tasks (dep upgrades, small bug fixes), you're either tackling tasks too complex for Devin or hitting too many failed sessions. Devin sessions that don't produce a merged PR are pure cost.

**Number 3: human-review time per Devin PR.** Track how long humans spend reviewing and revising Devin's PRs. If >30 minutes average, Devin is producing low-quality output that erodes the cost advantage. A human review at $60/hr × 30 min = $30 — that's bigger than the Devin cost itself. Re-tune prompts or accept that this task shape isn't Devin-suitable.

**Healthy benchmarks (from teams running Devin productively):** average ACU per merged PR: 0.4-1.0. Cost per merged PR: $1-$5. Human review time per Devin PR: 5-15 minutes. If your numbers are 2-3x these benchmarks, the audit conversation is: are you using Devin on the wrong task shapes, or are your prompts wasting ACU?

**The hard exit signal:** if cost per merged PR exceeds 25% of the equivalent contractor cost ($20 vs $80 contractor), Devin is still winning but the margin is thin enough that a few bad weeks could flip it. Either improve prompt discipline or move that task class back to humans.