Devin AI Limits: API Rate Limits, Session Quotas, and ACU Policies

Devin AI limits restrict the Analytics API v2 to 10 requests per hour per team, while session idle triggers sleep after approximately 0.1 Agent Compute Units (ACUs) of inactivity according to official Cognition documentation verified on 2026-09-04.

Devin AI limits encompass API request rate limits, plan-based session quotas, and enterprise ACU consumption policies that regulate agent execution across cloud and local environments.

Engineering leaders often confuse commercial pricing contracts with runtime execution boundaries. Pricing defines contract commitments and credit pricing, but operational boundaries determine devin rate limits across Cognition infrastructure. If your team exceeds these boundaries, Devin halts execution, returns HTTP 429 status codes, or blocks new coding sessions across desktop and web clients.

Operational boundaries fall into three distinct layers across the product architecture:

Core differences between API limits, session quotas, and compute units

API limits apply directly to administrative and consumption endpoints documented in the Devin Analytics API v2 OpenAPI specification. The Devin Analytics API exposes credit and ACU consumption metrics, active user statistics, and billing event logs. Because these endpoints calculate aggregations across historical sessions, Cognition restricts queries to 10 requests per hour per team. Automated reporting tools that poll these endpoints every minute will hit an immediate HTTP 429 block.

Session quotas govern developer interactions inside the Devin Desktop client. In March 2026, Devin Desktop shifted away from per-action credit subtraction toward a calendar-aligned daily and weekly quota model. These devin ai quotas track input and output tokens consumed across models. When a developer runs out of included quota on a Pro or Teams seat, execution pauses unless the account administrator enables extra usage billed at model list rates.

Agent Compute Units (ACUs) represent the primary compute metric of Devin enterprise agreements. An ACU measures execution work performed inside a virtual environment, factoring in model inferences, tool executions, browser actions, and runtime environment seconds. Unlike Desktop token quotas, ACUs apply to autonomous cloud sessions.

How pagination interacts with API rate limits

A common misconception is that iterating through multi-page analytics exports exhausts hourly API limits. Cognition documentation confirms that pagination requests following a next_page_cursor parameter do not count against the 10 requests per hour cap. Only the initial query establishing the report draws down your quota. This architectural allowance lets data engineering pipelines retrieve thousands of event rows in a single batch without triggering rate-limiting alarms.

Devin meters resource consumption based on concrete work delivered inside its sandbox environments. Every action Devin takes, whether analyzing codebases, issuing terminal commands, executing unit tests, or controlling headless web browsers, contributes to session compute.

Windows sessions consume approximately 9% more usage than equivalent Linux (Ubuntu) sessions.

Understanding this variance helps teams configure their repository runtimes efficiently. Devin provisions isolated virtual machines for every cloud session. The base operating system overhead of Windows containerization incurs higher background processor and memory allocation, translating into additional meter burn compared to standard Ubuntu containers. Detailed metrics on environment consumption are published in the Devin usage and billing documentation.

Devin Session Activity Lifecycle

[ Active Execution ] ====(Task Complete / Idle)====> [ Inactivity Window ]
        |                                                     |
  Consumes ACUs                                          Burns ~0.1 ACUs
        |                                                     |
        v                                                     v
[ Continuous Tool Calls ]                             [ Automatic Sleep ]
  Code edits, shell cmds                                Zero compute burn

Metered operations versus unmetered operations

Not every second of a running session draws down an ACU balance. Cognition isolates agent compute from passive environment state:

• Metered operations: Multi-file reasoning, repository tree indexing, code modification, shell compilation commands, test execution passes, and browser automation.
• Unmetered operations: Waiting for user clarification or responses in the chat interface, awaiting long-running asynchronous test suites that do not demand agent reasoning, and preliminary repository cloning during environment setup.

Once Devin completes a sequence of tool calls and presents findings or pull requests for human review, the session enters an idle state.

Idle session sleep triggers and wake mechanisms

Leaving an agent session open in a browser tab does not result in unbounded billing. When Devin finishes executing tasks and waits for instructions, an inactivity timer activates. The agent automatically transitions into sleep mode after consuming approximately 0.1 ACUs of idle time.

While sleeping, the session consumes zero ACUs. The virtual machine state, file edits, and terminal outputs remain preserved in memory snapshots. Sending a follow-up prompt immediately wakes the instance, restoring context without re-running initialization routines.

Enterprise administrators manage organizational compute distribution through Usage Policies. Documented in the Devin usage policies guide and accessed via Enterprise Settings, usage policies establish explicit devin acu limits on individual team members.

A single per-user allocation governs both cloud web sessions and local client sessions, including Devin Desktop and Devin CLI. When an engineer reaches their assigned limit, Devin blocks new session creation across all surfaces until the monthly cycle resets or an administrator grants an override.

Structuring usage tiers across engineering teams

A usage tier is a configuration profile defining monthly ACU allocations for assigned members. Tiers do not pool compute across teams. Instead, a tier establishes an individual budget applied to each assigned engineer.

Enterprise teams configure tiers to match functional responsibilities:

• Platform & Core Engineering: Higher ACU allocations monthly for heavy refactoring, continuous agent delegation, and repository migrations.
• Product Developers: Standard allocations monthly for typical feature development, test authoring, and bug investigations.
• Casual Contributors & QA: Conservative allocations monthly for reproducing field issues and validating pull requests.
• Default Tier: Baseline limit automatically applied to new accounts joining the enterprise workspace.

Admins can define tiers manually or use guided setup recommendations. In guided setup, Devin reviews the previous three billing cycles of member activity, models projected consumption, and estimates request volume before changes take effect.

Identity provider group mappings and resolution hierarchy

Enterprises integrating Okta, Microsoft Entra ID, or Google Workspace can map directory groups directly to usage tiers. When an engineer belongs to multiple directory groups, Devin resolves their active tier according to a strict hierarchy:

1. Explicit Member Assignment: A direct tier assignment applied by an admin in the console overrides all directory group rules.
2. Highest-Priority IdP Group Mapping: If an engineer belongs to multiple mapped groups, Devin applies the tier with the highest ranking in the priority list.
3. Default Organization Tier: Fallback applied when no specific mappings or assignments exist.

Tier priority governs precedence, not allocation size. An admin can rank a restrictive tier higher in priority than a permissive tier to safeguard quarterly compute budgets.

Managing temporary overrides and additional usage requests

When developers hit their allocation mid-cycle, they encounter a blocking modal with an integrated request form. Users select their required ACU increase, provide justification, and submit the request directly to workspace admins.

Approval policies define how requests resolve:

• Manual Approval: Every request pauses in an administrative queue for human review.
• Always Approve: Requests auto-approve instantly up to a defined ceiling, keeping developers unblocked.
• Efficiency-Based Approval: Devin evaluates the user's historical session efficiency score. If their score registers as Healthy or Satisfactory, the system grants incremental usage increases automatically.

Approved increases apply as temporary overrides, which expire when the monthly contract billing cycle resets.

Decouple Devin AI artifacts into persistent shared workspaces

Give your engineering team and autonomous agents a centralized environment for build outputs, logs, and datasets with per-file version history and remote MCP access. Every organization starts with a 14-day free trial requiring a credit card.

Start 14-Day Trial

Integrating custom developer tooling with the Devin Analytics API v2 requires proactive HTTP error handling. When an automation pipeline exceeds the 10 requests per hour limit, the API returns an HTTP 429 response with a JSON payload:

{
  "error": "rate limit exceeded"
}

Responses include a standard Retry-After header indicating the number of seconds the client must pause before retrying.

Caching and conditional HTTP requests

The Analytics API v2 aggregates historical consumption data in one-hour buckets. Querying the exact same time range multiple times within an hour wastes API quota on identical datasets.

Devin endpoints support HTTP caching headers. When querying consumption or active user metrics, store the returned ETag header. Subsequent requests should pass this value in the If-None-Match request header:

curl -X GET "https://server.codeium.com/api/v2alpha/analytics/consumption" \
  -H "Authorization: Bearer devin_sk_live_sample" \
  -H "If-None-Match: \"w/3f82a9bc71\""

If the underlying billing aggregation has not changed, the server responds with an HTTP 304 Not Modified status code. This avoids re-transmitting duplicate payloads and conserves processing overhead.

Python retry client with exponential backoff

The following implementation demonstrates how to query the Devin Analytics API v2 using the Python requests library. It validates HTTP status codes, respects Retry-After headers, and implements exponential backoff with jitter:

import random
import time
import requests

def fetch_devin_consumption(api_token: str, start_date: str, end_date: str, max_retries: int = 5):
    url = "https://server.codeium.com/api/v2alpha/analytics/consumption"
    headers = {"Authorization": f"Bearer {api_token}", "Accept": "application/json"}
    params = {"start_date": start_date, "end_date": end_date, "granularity": "daily"}
    retries = 0
    while retries <= max_retries:
        response = requests.get(url, headers=headers, params=params, timeout=30)
        if response.status_code == 200:
            return response.json()
        if response.status_code == 429:
            retry_after = response.headers.get("Retry-After")
            if retry_after and retry_after.isdigit():
                wait_seconds = int(retry_after)
            else:
                wait_seconds = (2 ** retries) + random.uniform(0.5, 1.5)
            time.sleep(wait_seconds)
            retries += 1
            continue
        response.raise_for_status()
    raise RuntimeError("Exceeded maximum retry attempts for Devin Analytics API")

This pattern ensures that scheduled reporting jobs do not fail abruptly during temporary quota spikes.

A major driver of premature ACU quota depletion is redundant agent work. When Devin runs in an isolated sandbox, it often spends considerable time downloading dependencies, cloning large repositories, analyzing documentation PDFs, and parsing architectural specifications. If multiple engineers launch Devin sessions targeting the same project, each agent duplicates that discovery work, burning ACUs on identical background tasks.

Teams typically evaluate traditional storage solutions to share context across agents:

• Local Workstation Storage: Files saved locally on an engineer's machine cannot be accessed by cloud-hosted Devin instances, creating fragmented context.
• Amazon S3 or Cloud Object Stores: S3 stores raw blobs but lacks native document indexing, file version trees, and unified human-agent collaboration interfaces.
• Google Drive: File synchronization tools built for human document editing impose strict API rate limits when accessed concurrently by high-frequency coding agents.

Intelligent workspaces solve this coordination bottleneck by serving as a persistent shared substrate for human developers and autonomous agents. Instead of forcing Devin to rebuild context from scratch inside every ephemeral VM, teams maintain a single source of truth in Fast.io shared workspaces.

Fast.io workspaces provide persistent storage for AI agents where agents and developers interact with the same files, schemas, and assets. Rather than consuming ACUs indexing gigabytes of external documentation, teams upload specifications once. With Fast.io Workspace Intelligence, uploaded project assets are automatically indexed for semantic search and retrieval without requiring separate vector database infrastructure.

Agents interact with Fast.io workspaces through the remote Model Context Protocol server over Streamable HTTP at https://mcp.fast.io/mcp (or https://mcp.fast.io/mcp/key with Bearer authentication). Coding agents read reference documentation, write generated test suites, and deposit compiled build artifacts directly into shared folders. For distributed engineering teams, Fast.io team collaboration ensures that every file change maintains an append-only audit log and per-file version history, preventing concurrent agent executions from overwriting critical work.

Every organization starts with a 14-day free trial on Fast.io pricing, which requires a credit card. Subscription tiers include Starter, Business, and Growth, where usage-based credits meter AI inference and operations, while seats and workspace storage remain bundled.