A Devin ACU has no public price (Nov 12, 2026)

No public page prints a dollar per Devin ACU. Cognition’s billing docs, fetched November 12, 2026, bill Enterprise customers in Agent Compute Units at the rate in the order form. Self-serve Devin is a quota, then on-demand credits, and extra usage is API pricing. The pricing page lists Free at $0, Pro at $20, Max at $200, and Teams at $80 plus $40 a seat. It does not list an ACU.

Of the ten coding agents read the same morning, GitHub is the one that pins its unit to a cent. One AI credit is $0.01. A typical Copilot code review averages $0.25, $1.50, or $10, depending on the effort level GitHub names. That review is not the cloud coding agent. Codex is the one that prices a typical model task in its own unit: a GPT-5.6 Sol task may use 2–15 credits, and the page does not say what a credit costs in dollars.

Seat prices for Claude Code and Codex, without this wider unit table, are Claude Code vs Codex pricing. The Devin product row is Devin.

Ten agents, and the unit each one actually sells

A seat is not a task. The column that matters is the unit the vendor meters after you have paid the seat, and whether that unit has a public price.

The two Devin rows are one vendor. Windsurf is in the set because the name still resolves, and the resolution is a redirect.

Devin’s ACU is an Enterprise contract, not a sticker

The billing index splits the company in one paragraph. Self-serve, at app.devin.ai, is included quota and on-demand credits. Enterprise is ACUs at the rate set in the order form. The enterprise page repeats the rate, says to contact sales, and defines Enterprise ACUs as the work Devin performs for customers on that plan, “which adheres more strictly to task planning and end-to-end testing.” They are distinct from self-serve quota and on-demand credits. Session Insights can show the ACU cost of one session. The page does not show a sample session, and it does not show a dollar.

The usage page says the mechanics are the same and the unit is not. Usage accrues from the actions Devin takes, and virtual-machine time is “typically a small fraction.” Windows sessions consume approximately 9% more than equivalent Linux sessions. macOS sessions currently match Linux, and the page labels that “promotional launch pricing.” Devin does not consume usage while it waits for you, waits for a test suite, or clones a repository. It sleeps after 5 minutes of inactivity by default, or 30 minutes on some Windows and GPU sessions, and sleep is free. None of those sentences converts an ACU into a minute or a pull request.

Self-serve is the plan a person can buy without sales. The docs list Pro at $20 a month with a daily and a weekly allowance, Max at $200 with a weekly allowance and no daily cap, and Teams at an $80 a month minimum with up to 100 members. A full seat is $40 and carries a Pro-equivalent quota. A flex seat is free and draws the shared on-demand pool. With fewer than two full seats, the rest of the $80 is prepaid on-demand credit. The docs say those credits roll over and never expire. The pricing page says the allowance refreshes daily and weekly, that cost per message varies with the model, the task, and the reasoning, and that extra usage is consumed at API pricing. It also says Teams is up to 100 users. It does not print the API rate.

Cognition’s April 14, 2026 post is the change of unit. Past the included quota, self-serve usage “will be priced and billed in dollars rather than ACUs.” Enterprise billing “will continue to use ACUs.” The post’s old Team entry point is $500 a month. That figure is the post’s history. It is not on today’s pricing page.

If you are modeling cost per pull request on Enterprise, you need two numbers Cognition has not published: the dollar per ACU on your order form, and the ACUs a session of the size you care about actually burns. Session Insights is where the second number appears, after a run. A $20 Pro seat does not answer either question. The directory listing is the product note. It is not an ACU rate.

Claude Code shares a pool. Codex adds a credit table that still is not dollars.

Claude’s pricing page puts Claude Code on the Pro card. Pro is $20 a month, or $17 a month when $200 is billed up front. Max is $100. Ultra is $200. The FAQ says Claude Code is included in all paid plans and shares the limits with the rest of Claude, so the terminal and the chats draw one pool. There is no fixed message count. Pro is at least 5 times Free per five-hour session. Max is 5 times Pro every five hours and every week. Ultra is 10 times Pro’s weekly usage, with no five-hour limit for verified accounts. Past the limit, paid plans can turn on usage credits at standard API rates. Heavy sessions can switch to pay-as-you-go API credits through a Console account. Enterprise is $20 per seat per month plus usage at API rates, billed annually, and the card adds a 20-seat minimum. The page says cost scales with model and task. It does not price a task.

Codex pricing includes Codex on Free at $0, Go at $8, Plus at $20, and Pro from $100, with plans at $100, $200, and $500. Business is $20 per user a month for two or more users billed annually, or $25 billed monthly. The page says ChatGPT uses the same pricing, credits, and usage limits as Codex. An API key pays API prices. Credit-based plans pay in credits after the included limits, and “credit purchase prices and applicable discounts depend on your plan or agreement.”

The credit table is credits per million tokens, not dollars. GPT-5.6 Sol is 100 credits of input, 10 of cached input, and 500 of output, per million tokens. GPT-6 Astra is 250, 25, and 1,250. GPT-6 Luna is 2.5, 0.25, and 12.5. The line under the table is the closest thing in this census to a published coding-task size: “A typical GPT-5.6 Sol task may use 2–15 credits.” There is no cache-write charge on Codex credit billing. Fast mode is 2.5 times included usage and 2 times purchased credits. Ultrafast on GPT-6 Astra and GPT-6.1 Sol is 8 times included usage and 6 times purchased credits. The page says GPT-5.6 Sol’s promotional pricing runs at least through November 21, 2026, and it does not print the later credit rate. None of that is a dollar until the plan’s credit price is known. This page does not invent one.

The same FAQ prints local-message estimates per five hours for Plus and Standard Business. They are estimates, shared with cloud chats, and they are not fixed limits. Pro has no five-hour limit.

A wide range is the point. The page says tasks that look similar can consume different amounts, because model, context, reasoning, tool use, retrieval, and caching all count. Prompt length is not the bill. Desktop voice is a second meter on the same page: $0.05 a minute of the Codex usage budget, with the task model billed separately, or 1.25 credits a minute on credit-based Business, Edu, and Enterprise workspaces. That is a voice minute inside a coding product. It is not the 2–15 credit task.

Cursor sells a week of its own models, then a token rate

Cursor’s pricing docs sell Cursor inside The X Subscription, shared with Grok. Paid plans include one weekly pool for Cursor’s models: Grok 4.7, Grok 4.6, Grok 4.5, and Composer 2.5. The pool covers the editor agent, the CLI, Cloud Agents, and the Grok apps. Plus is $8 a month, or $80 a year, and it does not include third-party models, Auto, Cloud Agents, or your own API keys. Premium is $30, or $300 a year, at 4 times Plus, and third-party models start there at API list price from prepaid credit. Super is $100, 15 times Plus. Ultra is $200, 50 times Plus. Annual stickers are $1,000 and $2,000. Prices exclude tax. Teams is $30, $100, or $200 a seat, matching the tier.

On Teams and Enterprise, eligible third-party requests add a Cursor Token Rate of $0.25 per million tokens, on top of the model’s API price, including when you bring a key. Individual plans do not pay it. Cursor’s own models do not pay it. A third-party model whose cache-read price is strictly below $0.10 per million tokens, on every tier, does not pay it. The third-party table is explicitly per million tokens. Claude Fable 5.2 on that table is $8 input, $10 cache write, $0.20 cache read, and $40 output. The Cursor-model table, above that sentence, prints Composer 2.5 as $0.50, a dash, $0.20, and $2.50 under Input, Cache Write, Cache Read, and Output, and says those rates apply past the weekly pool. This note does not copy the “per million tokens” sentence backward onto that table, because the page attaches the sentence to the third-party section.

No row prices a finished task. A week of pool is not a pull request. The Cursor listing has the seat card. The cost calculator can price a token count you already have. It cannot tell you how many tokens the agent will spend.

GitHub is the vendor that prices the unit

GitHub’s individual billing doc says Copilot usage is measured in AI credits, and 1 AI credit = $0.01. The interaction is tokens. The tokens are priced by the model. The total becomes credits. Copilot cloud agent is on the list of features that consume credits, with chat, the CLI, Spaces, Spark, and third-party coding agents. Code completions and next-edit suggestions are not billed in credits on paid plans.

The face-value column is this note’s multiplication. GitHub says base credits match the subscription price and never change, and that flex is an extra monthly amount. Pro’s 1,000 base credits are $10 at a cent each, which matches the $10 seat. The 500 flex credits are another $5 of face value on top of the seat. Business, from the plans page, is 1,900 credits against a $19 seat, with no flex split in that table. Unused included credits do not carry over. They reset at 00:00 UTC on the first of the month. Extra budget spends at the same cent: a $10 budget is 1,000 credits.

Two discounts are in force on the page. Through November 30, 2026, paid plans get 30% off model costs on Copilot Fusion. Paid plans also get 10% off while using auto model selection in Copilot Chat, or Copilot cloud agent. The 10% note has no end date in the text that was read.

The published “typical” dollar is not the cloud agent. The models page says code review picks the model for you, so you cannot price it from the token table. GitHub then prints estimates, and says they are estimates, that they rise with pull-request size and custom instructions, that actual costs can fall outside the ranges, and that they exclude GitHub Actions minutes.

A balanced review at the average is $1.50, which is 150 credits at the published cent. That division is this note’s. GitHub did not print the review in credits. The billing doc’s only sentence on a cloud-agent session is that a long one, on a frontier model, across many files, costs more credits than a quick chat question, because it does more work. There is no average. The Copilot listing has the seat summary.

Jules counts tasks. Amp, Factory, and Replit count something else.

Jules meters a task on a rolling 24 hours. The free Jules plan is 15 tasks a day and 3 concurrent, on Gemini 2.5 Pro. Jules in Pro is 100 tasks and 15 concurrent, with higher access starting at Gemini 3 Pro. Jules in Ultra is 300 tasks and 60 concurrent, with priority access starting at the same model. The page prints no dollar. It says Jules in Pro is a benefit of Google AI Pro, and Jules in Ultra is a benefit of Google AI Ultra, for individual accounts ending in @gmail.com. Task limits are not pooled on a family plan. You have to be 18.

Google’s subscriptions page, fetched the same morning, prices Google AI Pro at $19.99 a month and Google AI Ultra starting at $99.99, with a $199.99 tier for the higher limit. Google AI Plus is $4.99. That page does not name Jules. The $19.99 is the price of the plan Jules points at. It is not a Jules line item, and it is not a price per task. Fifteen tasks on the free Jules plan have no dollar on either page. One hundred tasks are included with a $19.99 plan only if you accept Jules’s sentence and Google’s card as the same purchase. Dividing $19.99 by 100 is $0.1995 a task at the cap, and that quotient pretends the Google AI Pro subscription buys nothing else. This note does not use it.

Amp charges paid credits for the model and tool usage in a thread. For individuals and non-enterprise workspaces, Amp does not add a markup to provider API prices. The page’s example is the cleanest pass-through in the set: a thread that uses $2 of Anthropic and $0.50 of OpenAI deducts $2.50. Amp does not call that thread typical. You can link a ChatGPT or Claude subscription, or bring a key, and the page says there is then no Amp token fee. Purchased credits expire twelve months after purchase. Orbs are a second meter, billed by the minute, and a paused orb costs nothing. Amp pauses an orb 5 minutes after the agent stops or 20 minutes after you last interacted, whichever is later. The Individual card in the fetched HTML is $20 a month, with a Megawatt and Gigawatt control, and the feature text in that response includes 45,000 minutes of orb time. A separate Gigawatt dollar was not in the HTML. Hobby is free. Teams are “no extra charge” on top of the member’s tier.

Factory sells a seat and a usage multiple. Free is $0 and your own inference: sign in with ChatGPT, GitHub Copilot, or OpenRouter, or bring a key. Pro is $20 a month. Plus is $100 and “~5x the usage of Pro.” Max is $200 and “~10x the usage of Pro.” Teams is $60 a month plus $40 per individual, up to 10 seats. Business and Enterprise print no dollar. The tilde is Factory’s. The page does not define the usage unit those multiples share, and it does not price a task. The model bill on Free is the other vendor’s bill. Factory’s $0 is the seat.

Replit bills Agent on effort. A checkpoint is the completed work on a request. Simple requests typically cost less than complex builds. The docs do not say how much less, and they do not print a dollar. Replit asks for confirmation before a paid action. Plan Mode can bill for reasoning that does not change code. Third-party APIs, named as Claude, ChatGPT, and Gemini, are deducted from Replit credits at the provider’s public rate. The same credits also pay for published apps, storage, and databases. The pricing page lists Core at $20 a month, or $18 billed annually, with up to 30 hours of Free Mode chat, up to 60 projects, and $20 toward more powerful models. Pro is $100 a month, or $90 billed annually, with $100 toward the most powerful models. A control on the Pro card also lists $90, $215, $425, $825, and $2,000 a month. Those options are not named as plans in the text around the control, so they are not in the table above.

Windsurf is the empty row on purpose. https://windsurf.com/ returned HTTP 308 to https://devin.ai/desktop at 13:44:09 GMT. There is no Windsurf price in that response. Devin’s self-serve docs still point Devin Desktop at windsurf.com. The desktop product is Devin’s. The old name redirects.

What you can put in a budget

Put the seat in the budget. Put a task price in the budget only where the vendor printed one.

GitHub’s balanced code review, at GitHub’s own average, is $1.50, and the range around it is $0.25 to $5. That is a review of a pull request, with the model hidden, and it excludes Actions minutes. It is the only dollar in this set that is both a task and a published estimate. Codex’s 2–15 credits are a task size. They become money when you know what your plan charges for a credit. Amp’s $2.50 is an illustration of pass-through billing. It is not a median.

Everyone else sold a pool. Claude Code’s pool is the plan’s, shared with chat, with API rates after it. Cursor’s pool is a week of Cursor’s own models, with third-party tokens extra and a $0.25 per million token rate on the team plans. Factory’s pool is a multiple of Pro, and the multiple is approximate. Replit’s pool is credits that also buy the cloud around the agent, and the agent confirms before it spends them on a paid action. Jules’s pool is a count of tasks, and the dollar, if you are paying, is a Google AI subscription that Google’s own price page does not tie to Jules.

Devin is the row the search is about. Enterprise still speaks ACU, and the price is the contract. Self-serve speaks dollars and will not tell you the dollars per message. A Pro seat at $20 is a quota with a daily and a weekly reset. It is not a cost per pull request, and dividing it by a hoped-for number of tickets will not make it one. Run a session, read Session Insights, and use that ACU count against the rate on the order form. Until both numbers exist, the cost per task is not known.