What Are Devin ACUs? Agent Compute Units Explained

Windows Devin sessions consume approximately 9% more usage than equivalent Linux sessions, according to Cognition's official usage documentation. That single percentage is the right place to start. An Agent Compute Unit (ACU) is not a seat license or a flat monthly package. It is Devin Enterprise's billing meter for the compute work Devin AI performs during sessions, tracked at enterprise, organization, and session levels.

Cognition's billing docs split Devin into two pricing models:

• Self-serve (Free, Pro, Max, Teams): usage is billed through included quota, then prepaid on-demand credits
• Enterprise: customers are billed in Agent Compute Units (ACUs) at the rate set in their order form

The metering mechanics are the same either way. The unit name is what changes. Enterprise draws from an ACU volume negotiated on the order form. Self-serve draws from daily or weekly plan quota first, then from on-demand credits. Legacy self-serve plans once sold ACUs directly; Cognition has since moved those customers onto quota and credit pricing, while Enterprise keeps ACUs as the contract unit.

If you only remember one definition, use this: a Devin ACU is the Enterprise unit that measures Devin's actual session work (planning, context gathering, code and browser actions, VM time, and related network use) so finance and engineering can allocate cost across orgs and sessions.

Admins and users track that consumption in a few places:

• Enterprise Settings > Consumption for enterprise-wide ACU totals
• Organization Settings > Consumption Analytics for org-level ACU totals and user breakdowns
• Session Insights for the ACU cost of a specific session (available to any user)

The people who dig into ACU docs are usually the ones holding the budget: enterprise admins, platform leads, and engineers who just watched a long session burn through a limit.

Cognition does not publish a public price-per-ACU for Enterprise. Rates live on the order form. What the docs do publish is what counts toward usage, and that is the part that matters for forecasting.

Usage accrues from the work Devin actually performs in a session, including:

• Number and complexity of actions (planning, context gathering, task execution, browser actions, code execution, and similar steps)
• Virtual machine time
• Networking bandwidth (usually a small fraction of total usage)

A few behaviors that often surprise teams:

• Windows costs more. Windows sessions use about 9% more usage than the same work on Linux (Ubuntu).
• Idle work is mostly free. Aside from the small amount needed to keep the Devin VM running, Devin does not consume usage while waiting for your response, waiting for a test suite to finish, or setting up and cloning repositories.
• Sleep stops the meter. When a session is idle, Devin goes to sleep. Sleeping sessions do not consume usage. You wake the session by sending another message. Devin typically sleeps after roughly 0.1 ACUs (or the equivalent quota or on-demand credit) of inactivity.

Variables that push ACU (or quota) higher are predictable once you treat Devin like a long-running remote developer rather than a single autocomplete call:

• Task complexity and how many files change
• Prompt quality and how much context the session carries
• Codebase size
• Session runtime and conversation length
• How often you bounce messages back and forth

Official tips for keeping consumption under control line up with good agent hygiene:

• Delegate clearly scoped tasks with a defined end goal
• Keep prompts and sessions short
• Avoid packing many unrelated tasks into one session
• Split large projects across sessions (there are no concurrent session limits called out in the usage guide)

On self-serve plans, the same metering model applies, but the unit you buy is plan quota plus on-demand credits, not Enterprise ACUs. Pro and Teams full seats refresh on a daily and weekly calendar. Max uses a weekly allowance without a daily cap. When included quota runs out, prepaid on-demand credits keep sessions running. Teams shares those credits across members. That is why pricing posts that still talk as if every Devin plan sells "ACUs by the hour" are out of date: self-serve is quota and credits; Enterprise is ACUs on an order form.

Keep Devin outputs in a workspace humans can review

Give agents and teammates the same org-owned workspace with version history, Intelligence Mode search, MCP access, and ownership transfer after the session. Start with a 14-day free trial.

Start 14-Day Trial

Enterprise is where devin enterprise acu controls become operational, not just contractual. Cognition lets Enterprise admins set per-Organization ACU limits from Enterprise Settings under Organizations. Hover an org, open Manage, then set the limit (and rename the org if needed).

Once a limit is set, that organization can only consume up to that ceiling. When the org hits its devin acu limit:

• All Devin activity in that organization stops
• Users see a message that the organization has hit its ACU limit
• Users are told to contact the Enterprise admin to raise the limit

That hard stop is the feature many marketing pages skip. Soft budgets are useful for awareness. Hard org limits are useful when one team can otherwise spend the entire enterprise pool on exploratory sessions while production work waits.

Who sees what:

• Enterprise admins review enterprise ACU consumption and can break it down by organization from Settings > Consumption
• Organization admins review org ACU consumption and can break it down by user from Settings > Consumption Analytics
• Users with Personal Analytics enabled (and the View Personal Analytics permission) can see their own ACU consumption across organizations from My analytics

Billing cadence is also contract-driven: Enterprise customers are billed for ACUs as stated in the order form. Enterprise ACUs represent work performed by Devin for Enterprise plan customers, described in the docs as adhering more strictly to task planning and end-to-end testing, and they are distinct from self-serve quota and on-demand credits.

Practical admin pattern that works in multi-team companies:

1. Put each product group or business unit in its own Devin organization when possible
2. Set org ACU limits that match quarterly engineering budgets, not peak "what if everyone runs XL sessions" imagination
3. Review Consumption Analytics weekly for the first month, then monthly once patterns stabilize
4. Raise limits only after you can point to Session Insights evidence (retry loops, missing environment setup, oversized tasks)

If finance only sees a single enterprise ACU line item without org splits, you will argue about cost after the money is gone. Org limits force the conversation earlier, while engineers still have session-level detail to fix process rather than just buy more capacity.

Session Insights is the missing bridge between "our enterprise burned a lot of ACUs" and "this specific session went wrong." Any user can open Session Insights for a completed session and see that session's ACU usage, regardless of pricing model. Analysis is free of extra charge. Short sessions with fewer than one Devin message do not produce useful insights.

At the top of the insights view, Cognition surfaces four overview metrics. The one finance cares about is ACU usage: how much compute Devin consumed in that session. Lower ACU usage for the same task class usually means a more efficient run. High ACU usage with few user messages often means Devin worked alone but struggled (retries, missing environment, vague requirements). Many user messages with low ACU usage usually means the human kept course-correcting because the first prompt was underspecified.

Session Insights also classifies session size (XS through XL) using ACU thresholds and user-message thresholds. For standard accounts:

• XS: ≤ 2 ACUs or ≤ 2 user messages
• S: ≤ 5 ACUs or ≤ 5 messages
• M: ≤ 10 ACUs or ≤ 10 messages
• L: ≤ 20 ACUs or ≤ 20 messages
• XL: > 20 ACUs or > 20 messages

For Enterprise customers, ACU thresholds are scaled by a factor of 10 (for example, XS ≤ 20 ACUs, XL > 200 ACUs). User-message thresholds stay the same. The overall size is the larger of the ACU-based size and the message-based size. Sessions classified L or XL are flagged as unhealthy: Devin likely hit serious issues, or the task scope was too broad for one session.

That mapping is how you turn ACU spend into process change:

• Repeated high-impact issues on the Issue Timeline often mean environment or dependency gaps that will tax every future session
• Actionable Feedback's improved prompt and action items give a concrete next session instead of "use Devin less"
• Knowledge Usage flags misleading knowledge items that can inflate ACU spend across the whole team until someone edits them

Teams that only watch the enterprise consumption chart without opening Session Insights end up buying more ACUs for problems that better prompts, smaller tasks, or cleaner machine setup would fix. Teams that only watch Session Insights without org limits end up with accurate postmortems and no budget guardrail. You need both.

Controlling devin acu consumption is less about micromanaging every tenth of a unit and more about removing the failure modes that turn a two-hour job into an XL session.

Scope before you spend. Ask Devin to ship one vertical slice per session: one migration, one endpoint, one failing test suite. A multi-day rewrite in a single chat is how sessions climb into L and XL size classes. The usage docs explicitly recommend splitting big projects into sub-tasks across sessions.

Front-load context. Put success criteria, constraints, and environment facts in the first message. Session Insights treats high message counts as a smell for missing upfront detail. Every clarifying loop is extra conversation length, even if each loop is small.

Prefer Linux unless you need Windows. The documented 9% Windows premium is small on a short task and painful on a fleet of long-running agents.

Let sleep do its job. If you step away, Devin will typically sleep after about 0.1 ACUs of inactivity and stop charging. Do not keep the session "warm" with empty pings unless you need continuity that justifies the cost.

Fix environment once. If Action Items keep recommending the same dependency installs or repo config, put those into machine setup and Knowledge so later sessions stop paying the same retry tax.

Separate compute cost from artifact cost. ACUs measure Devin's work inside its cloud environment. They do not solve where finished code, docs, dumps, and review packages live after the session ends. Engineers still export patches through git, download files from the agent environment, or drop artifacts into object storage such as Amazon S3 or a shared drive like Google Drive or Dropbox. Those options work, with tradeoffs: S3 is durable and API-friendly but awkward for non-developer review; consumer drives are easy for humans but weak for concurrent agent writes, versioned handoff, and semantic search across agent output.

For teams that want a durable handoff layer around Devin AI rather than another dump folder, a shared intelligent workspace helps. Fast.io is built for agentic teams: org-owned workspaces, per-file version history, an append-only audit log, and a consolidated MCP toolset agents can call over Streamable HTTP at /mcp (or legacy SSE at /sse). Enable Intelligence Mode so files are indexed for hybrid search and chat with citations. When the work product is contracts, invoices, or other structured docs, Metadata Views turn natural-language field definitions into a typed, filterable table agents and humans can query. An agent can stage the workspace, then transfer ownership to a human admin who starts the 14-day free trial (credit card required) on Starter ($29/mo), Business ($99/mo), or Growth ($299/mo). Fast.io is not a Devin billing product and does not replace ACUs. It is the persistence and collaboration layer so expensive sessions produce assets the team can still find next week.

If you are evaluating Devin AI for production engineering work, treat ACU literacy as part of onboarding. Teach leads how org limits stop runaway spend, teach engineers how Session Insights sizes sessions, and decide where session outputs live before the first enterprise invoice arrives. The compute unit is only half the system; the other half is whether humans can review, search, and reuse what the agent shipped.