Codex Task Limits 2026: GPT-6 Sol, Astra, Credits, and API Billing

Short answer: why Codex limits are not a static task count

Codex task limits cannot be reduced to a fixed number of completed programming tickets. Because agentic software engineering is an iterative, multi-turn loop involving code reading, AST parsing, tool execution, terminal command verification, and file diff generation, usage consumption is inherently variable. A developer asking Codex to fix a typo in a single function might consume 2,000 tokens of context and a fraction of a compute credit. The same developer asking Codex to refactor an entire database abstraction layer across twelve files with test-driven repairs will consume hundreds of thousands of context tokens, trigger multiple reasoning traces, and burn significant quota within a single session.

OpenAI structures Codex access across five operational variables: the underlying GPT-6 model tier (Astra, Sol, or Luna), the subscription plan tier (ChatGPT Plus, Pro, Business, or Enterprise), the task complexity profile, the authentication route (ChatGPT OAuth login versus OpenAI API keys), and workspace governance rules. Understanding these boundaries prevents unexpected rate limits, eliminates billing surprises, and ensures teams deploy the appropriate model tier for each programming objective.

Codex limits by plan

OpenAI does not publish a fixed Codex task count for any plan. For Plus and Standard Business seats it publishes estimates of local messages per five hours for each model, Pro plans currently have no five-hour limit, and weekly limits may apply. Because ChatGPT Work draws on the same allowance, the plan-by-plan table for Free, Go, Plus, Pro, Business and Enterprise is in ChatGPT Work and Codex limits by plan.

Task size and usage

OpenAI does not publish a task ceiling per window. Its Codex pricing page says small scripts or routine functions may use only a fraction of the allowance, while larger projects, long-running tasks and extended sessions that hold more context use significantly more per message, and that model choice, context, reasoning, tool use, retrieval and caching all affect usage. Measure a week of your own tasks in the usage dashboard instead of planning by a fixed task count, use GPT-6 Luna for routine edits, and split repository-wide work into smaller tasks.

How Credits and Rolling Windows Operate

OpenAI calculates Codex limits through a dual-governance model: rolling five-hour message quotas and account-level credit banks.

The five-hour window functions as a moving rate governor. Unlike a rigid calendar reset that renews at midnight, your quota restores progressively as older messages age past the five-hour mark. If a developer uses 40 messages between 9:00 AM and 10:00 AM on a Plus plan, those 40 messages begin re-entering the available pool starting at 2:00 PM.

When a developer operates at the upper bound of task complexity, the rolling quota alone may be depleted before the five-hour window rolls over. In this scenario, OpenAI provides credit top-ups:

• Credit Mechanics: Codex credits represent a flexible usage currency anchored directly to token consumption. OpenAI indicates that GPT-6 Sol consumes fewer task credits than GPT-6 Astra, averaging 5 to 40 credits per message for Sol while Astra draws higher credit ratios for complex reasoning traces.
• Fast Mode versus Normal Mode: Fast mode accelerates response streaming by provisioning dedicated compute clusters, consuming credits at a 1.5x to 2x multiplier for supported models. Turning off Fast mode extends credit longevity when working on non-urgent background refactoring.
• Image & Multimodal Consumption: Supplying UI screenshots, architecture diagrams, or Figma mockups to Codex CLI or Desktop draws down credit balances substantially faster than raw source code, as vision encoding introduces fixed token overheads per image tile.

CLI, Desktop, and IDE Surface Mechanics

The developer experience of Codex depends heavily on how the client application interacts with the execution environment. The standalone Codex application is formally transitioning into the unified ChatGPT desktop application, while the CLI (codex) and IDE extensions (VS Code, JetBrains, Cursor-compatible LSP) operate as distinct local execution surfaces.

Authentication Modalities

Developers can authenticate local Codex environments through two separate paths, each carrying fundamentally different financial and governance implications:

1. ChatGPT Account Authentication (codex login): The CLI authenticates via OAuth with your ChatGPT personal or workspace credentials. Under this mode, all command executions, code inspections, and agentic loops draw from your subscription plan quota and workspace credit pools. No API credit cards are charged.
2. OpenAI API Key Authentication (export OPENAI_API_KEY=...): The CLI bypasses the ChatGPT subscription layer entirely. Every token consumed is billed directly to your OpenAI Platform developer account according to published API rates ($2.00 per million input tokens and $10.00 per million output tokens for GPT-6.1 Sol and GPT-6 Sol, with cached input at $0.10 on GPT-6.1 Sol and $0.20 on GPT-6 Sol).

Local Shell and Sandbox Boundaries

When Codex executes shell commands in CLI or Desktop mode, safety and rate limits intersect:

• Terminal Execution: By default, Codex CLI executes commands in your local shell environment, inheriting local path configurations, environment variables, and node/python runtime versions. While this enables native test execution, infinite loops or runaway processes can consume hundreds of tokens in terminal log capture.
• Cloud Sandboxes: In cloud-hosted execution modes, tasks run within isolated container sandboxes subject to execution timeouts (typically 15 to 30 minutes per continuous run) and network egress restrictions. Developers must structure tasks to complete within bounded iterations rather than initiating open-ended daemon watchers.

Business Workspaces and Organizational Ownership

For engineering managers and CTOs, managing Codex limits across a team requires centralizing governance through ChatGPT Business, Team, or Enterprise workspaces rather than reimbursing individual personal subscriptions.

Workspace Credit Pooling

Standard Business workspaces provide each seat with individual Plus-level baseline quotas. However, teams frequently encounter asymmetric utilization: senior architects and backend engineers burn through limits rapidly, while front-end designers or product managers use minimal quota.

To solve this, Business workspaces allow administrators to enable Workspace Credit Pooling:

• Automatic Monthly Reloads: Admins configure an aggregate monthly credit balance that is shared across all workspace seats once individual quotas are reached.
• Seat-Level Hard Caps: Admins can set maximum monthly credit expenditure per user (e.g., capping junior developers at $50/mo in overages while allocating $200/mo to core infrastructure engineers).
• Seat Migration Governance: As of June 24, 2026, standalone "Codex-only" seats are formally restricted to legacy workspaces holding pre-existing agreements; all new business deployments utilize unified ChatGPT Business seats encompassing both conversational and agentic capabilities.

Audit Logs and Zero Data Retention

Enterprise deployments must safeguard intellectual property. Organization-level Codex accounts enforce strict data boundaries: code inspected by Codex is excluded from foundational model training by default, and audit logs capture every CLI command execution, file modification, and model routing event for compliance review.

The API Boundary: When to Decouple from Subscriptions

While ChatGPT-backed Codex access is ideal for interactive developer pair programming, it is structurally unsuited for automated continuous integration, background cron agents, or repository-wide batch processing.

Developers should decouple from ChatGPT subscriptions and migrate to API-based execution when:

1. Automated CI/CD Pipelines: Triggering code reviews, automated PR generation, or lint repairs inside GitHub Actions or GitLab CI requires non-interactive, predictable machine authentication via OPENAI_API_KEY.
2. High-Concurrency Batch Migrations: Running concurrent refactoring scripts across dozens of microservice repositories simultaneously will instantly trigger the 5-hour rolling limit on a personal subscription, but executes cleanly against API Tier 4/5 rate limits.
3. Strict Budget Allocation by Project: API keys can be segmented by project ID, billing department, and spend limit, allowing precise accounting of generative AI expenses against client deliverables.

By aligning your workload with the appropriate model tier (Astra for frontier reasoning, Sol for workhorse engineering, Luna for high-volume tasks) and selecting the correct authentication route, teams can eliminate workflow interruptions and maximize the engineering return on Codex.