GPT-6 Astra Rollout Troubleshooting Playbook for ChatGPT Work and Codex: Plans, Allowances, Permissions, CLI, and App Updates

Start with entitlement, not with troubleshooting folklore

When a user says “I do not see Astra,” the fastest mistake is to start by reinstalling apps, clearing browser state, or buying more credits. OpenAI’s documented operating model for ChatGPT Work and Codex makes this a rollout and entitlement problem first: plan eligibility, rollout cohort, workspace model access, product surface, local/cloud controls, allowance state, client version, and app state all have to line up before a user can reliably expect GPT-6 Pro powered by GPT-6 Astra to appear where they are looking.

OpenAI says GPT-6 Pro powered by GPT-6 Astra is gradually rolling out to Pro $100, Pro $200, Business, and Enterprise. Plus includes limited Astra usage in Work and Codex as rollout reaches the account. That language matters operationally: an eligible plan is not the same thing as completed rollout for a specific account, and a visible feature on one user’s account does not prove that another user in the same company, plan family, or geography has the same entitlement at the same time.

The selected article covers GPT-6 Astra’s September 3, 2026 launch across ChatGPT, Codex, the API, Azure, and AWS Bedrock, including its staged availability and benchmarks. The full analysis in GPT-6 Astra Launches in ChatGPT, Codex, the API, Azure, and AWS Bedrock: Availability, Benchmarks, and What Changes Now extends this section’s GPT-6 Astra Availability discussion because this is the most direct background link for a troubleshooting section about whether GPT-6 Astra is actually available to a user, workspace, or organization.

The practical support posture is therefore a decision tree, not a single fix. First confirm the plan. Then confirm whether rollout has reached the account. Then, for Business and Enterprise, check whether the workspace allows the relevant model access. Then verify the product surface: Chat, Work, and Codex are not interchangeable surfaces. Then check whether Work Cloud, Work Local, or Codex Local controls allow the intended mode. Only after those gates pass should the team spend time on allowance, credits, Codex CLI version, desktop-app update state, sign-in state, and stale client behavior.

Decision rule: If the account is not yet in the rollout cohort or the workspace has not granted the required model access, upgrading the CLI, restarting the desktop app, changing a starting default, or buying credits will not make Astra available.

The opening decision tree

The first pass should be short enough for a help desk or workspace administrator to run during a live support interaction, but precise enough to avoid false escalations. A useful opening script is: “Which plan is the user on, has Astra reached that account, is the workspace allowed to use the model, which surface is the user opening, are Work or Codex local/cloud controls enabled for that user, does the user still have included allowance or applicable paid capacity, and are the CLI and desktop app current enough for Astra?”

Separate Chat, Work, and Codex before you inspect models

OpenAI distinguishes Chat, Work, and Codex by job type. Chat is for fast conversational work. Work is for longer multi-step deliverables. Codex is for software-development and repository workflows. A user who expects the same selector, history behavior, and controls across all three will misread the product state and may report a missing model when they are actually on the wrong surface.

Work is available on eligible web, mobile, and desktop surfaces. Codex remains a separate desktop view and is not selectable on web or mobile. That distinction is central to rollout triage: if a user opens mobile or web and says they cannot select Codex, the correct response is not to search for a hidden model menu; it is to explain that Codex is a separate desktop view. OpenAI also documents that supported desktop Codex chats can be accessed through the mobile Remote tab without becoming mobile or web history, which means mobile visibility of a desktop Codex chat is not the same as native mobile Codex availability.

The selected article is a tutorial on using ChatGPT Work to build websites and presentations without code after the July 2026 ChatGPT Work launch. The full analysis in How to Use ChatGPT Work to Build Websites and Presentations Without Code extends this section’s ChatGPT Work Setup Guide discussion because it provides practical ChatGPT Work usage context for readers who need a setup-oriented starting point before troubleshooting Astra access inside Work.

A clean support note should record the surface in the same line as the symptom. For example: “User sees Astra in Work desktop but not in web Chat,” “User expects Codex on mobile model selector,” or “User can access a supported desktop Codex chat through mobile Remote but cannot start a native mobile Codex session.” Those are different cases with different next steps, and combining them under “Astra missing” slows escalation.

Do not confuse starting defaults with actual access

Starting defaults are useful for shaping the first step of a workflow, but OpenAI’s guidance is explicit that starting defaults do not grant unavailable model or feature access. If an administrator or user configures a default that points toward a preferred mode, that default cannot override rollout status, plan eligibility, workspace permissions, or product-surface limitations. In a troubleshooting playbook, defaults belong near the end of the tree, after entitlement and controls have been verified.

The same principle applies to workspace controls. Work Cloud, Work Local, and Codex Local are separate controls. Enabling one should not be treated as proof that the others are enabled, and disabling one should not be treated as a global block unless the administrator has verified the relevant policy state. This matters for enterprise administrators because a developer may be allowed to perform a local Codex workflow while a business user’s Work Cloud path is governed differently, or the reverse may be true depending on workspace configuration.

Local mode also needs precise language. OpenAI notes that local work can still involve cloud storage of messages and task context. Therefore, “local” should not be described to users, auditors, or security reviewers as fully offline operation. A safe internal explanation is: “Local controls affect where and how the workflow runs, but they do not eliminate all cloud service involvement or cloud-stored task context.” That wording prevents a permissions ticket from becoming an inaccurate data-handling assurance.

Credits are not an early-access mechanism

The most important billing clarification in this playbook is simple: buying credits does not provide early rollout access. Credits may matter after a user already has access and is consuming paid capacity, but credits do not move an account into an earlier rollout cohort, override workspace model access, or make Astra appear on an unsupported surface. If a user has purchased credits and still cannot see Astra, the correct next step is to return to the entitlement tree rather than to purchase more credits.

Allowance questions should be handled only after access is confirmed. OpenAI states that Astra can consume an allowance faster than GPT-5.6 Sol depending on task size, reasoning, and Fast mode. That means a user may have access and still hit usage friction sooner than expected when running large, multi-step, high-reasoning Work or Codex tasks. The symptom in that case is not “Astra never rolled out”; it is “Astra is available, but usage capacity is constrained or depleted.”

A practical support classification is to separate three states: “not entitled,” “entitled but blocked by workspace or client conditions,” and “entitled and available but constrained by allowance.” The first state is solved by waiting for rollout or changing plan where appropriate. The second is solved by administrator configuration, correct surface selection, or client update. The third is solved through usage planning, task sizing, mode selection, and billing governance. Mixing these states leads to bad advice, especially when a support team tells a not-yet-rolled-out user to buy credits.

Version checks matter after eligibility is established

OpenAI documents that Astra requires Codex CLI 0.153.0 or newer and the latest desktop app. That requirement is concrete enough to belong in every troubleshooting runbook, but it should be sequenced correctly. If the account is not in the rollout cohort, a CLI update will not unlock access. If the workspace does not allow the model, the latest desktop app will not override the policy. If the user is looking for Codex on web or mobile, a CLI update does not change the product-surface model.

Once eligibility, rollout, permissions, and surface are confirmed, the client check becomes straightforward. Ask the user or administrator to verify the Codex CLI version and update to at least 0.153.0 where Codex workflows are involved. Then verify that the desktop app is current. If a user has multiple machines, check the machine that actually runs the workflow; a current laptop does not prove that a workstation, CI-adjacent development host, or shared desktop environment has the required version.

The Codex 0.153.0 release is also operationally relevant because it documented broader reliability and workflow behaviors, including complete patch, terminal, and command history; automatic reconnection after app-server drops with uncertain or queued submissions paused; and persistence of Guardian review history across compaction, restarts, and forks. Those details should not be inflated into new Astra capabilities, but they help explain why version hygiene matters for serious Codex usage: an outdated client can make troubleshooting harder even when entitlement is correct.

Use a written case record from the first interaction

A rollout issue can involve product, billing, administration, client state, and user expectation at the same time. The support record should therefore capture facts in a structured order: account plan, workspace name or administrative context, rollout observation, model-access setting if known, product surface, intended mode, Work Cloud or Work Local state, Codex Local state, allowance symptom, credit-purchase history if relevant, Codex CLI version, desktop-app version state, and whether the issue reproduces after sign-out, restart, or update.

A concise opening record might read: “Business workspace user cannot see Astra in Work desktop. Colleague has access, but this user’s account rollout status is unconfirmed. Workspace model permission not yet checked. Work Cloud enabled; Work Local unknown. No Codex workflow involved. User bought credits yesterday; informed that credits do not grant early rollout. Desktop app update state pending.” That note prevents the next responder from repeating billing advice or treating a colleague’s access as definitive proof.

This playbook uses that structured approach throughout the remaining sections. The goal is not to guess why Astra is missing; it is to eliminate the gates in the right order, preserve the distinction between entitlement and consumption, and avoid promising that a client update, a default setting, or a credit purchase can bypass OpenAI’s documented rollout, plan, workspace, and surface requirements.

Map the surface before you escalate an Astra access issue

When a user says “Astra is missing,” the first useful question is not whether the account has enough credits; it is which product surface the user is looking at. OpenAI’s Work and Codex operating model separates ChatGPT web and mobile, ChatGPT desktop Work, desktop Codex, and the mobile Remote tab. A model may be reachable in one eligible surface and still not appear in another because plan eligibility, workspace policy, rollout state, desktop-app version, and Codex CLI version are evaluated together rather than as a single universal account flag.

For troubleshooting, treat the surface as part of the evidence. Ask the user to identify whether they are in ChatGPT Work on web or mobile, Work in the desktop app, the Codex view in the desktop app, or the Remote tab on mobile. A screenshot of a model picker without the surrounding surface is not enough, because Codex is not a selectable native web or mobile experience. If a user is looking for Codex directly in the ChatGPT web interface or ordinary mobile chat history, the fix is not a model permission change; the expectation is wrong for the documented operating model.

OpenAI describes Chat as the fast conversational mode, Work as the environment for longer multi-step deliverables, and Codex as the separate software-development and repository workflow surface. That distinction matters operationally because the same organization can allow Work while separately controlling Codex Local, or allow one kind of local task while blocking another. Do not close a ticket as “Astra unavailable” until you have recorded the surface, plan, workspace, model permission state, local/cloud control state, and client version.

The four surfaces administrators should name explicitly

Use this map to prevent circular troubleshooting. A founder on Plus may be testing Work on mobile, a developer on Business may be testing desktop Codex, and an Enterprise administrator may be testing desktop Work under a managed configuration profile. Those are different access paths. If the support case merges them into one “Astra not visible” symptom, the team can waste time reinstalling apps when the real issue is workspace model access, or changing workspace settings when the real issue is an outdated CLI.

The selected article explains the unified ChatGPT desktop app experience that brings Work, Codex, and Atlas together in one application. The full analysis in The Complete Guide to the New ChatGPT Desktop App: Work, Codex, and Atlas Unified extends this section’s Codex Desktop App Guide discussion because it is the best general desktop-app reference for a playbook that troubleshoots Codex and ChatGPT Work behavior inside the unified app.

Codex is desktop-first; Remote is not mobile Codex

The most important surface correction is that Codex remains a separate desktop view and is not selectable on web or mobile as a native experience. A user who opens ChatGPT mobile and expects Codex to appear beside ordinary chat or Work is looking in the wrong place. The mobile Remote tab exposes supported desktop Codex chats, but OpenAI’s documentation distinguishes that from turning those sessions into mobile or web history.

That distinction is not cosmetic. Desktop Codex workflows can involve repository state, local permissions, CLI behavior, approvals, patch history, terminal or command history, and workspace controls that do not map to a normal mobile chat thread. Remote access is therefore best understood as a way to follow or continue supported desktop Codex activity from mobile, not as a new mobile-native Codex surface with independent availability.

When a user reports, “I can see Astra in desktop Codex but not on my phone,” the response should separate two tests. First, confirm whether the user expects to start a fresh Codex workflow natively on mobile; if so, document that Codex is not selectable on web or mobile. Second, if the user expects to access an existing supported desktop Codex chat through Remote, verify that the chat was created in the supported desktop Codex surface, that the same account is signed in, and that workspace controls still allow the underlying Codex workflow.

Operational rule: do not use the mobile Remote tab as evidence that Codex is generally available on mobile. Remote access can be part of a supported desktop Codex workflow, but it does not erase the boundary between desktop Codex and mobile ChatGPT history.

Plan, surface, and workspace-control access matrix

The matrix below is a troubleshooting tool, not an entitlement guarantee. OpenAI says GPT-6 Pro powered by GPT-6 Astra is gradually rolling out to documented eligible plans, Plus includes limited Astra usage in Work and Codex as rollout reaches the account, and Enterprise access also depends on model-access permissions. Therefore, a “Yes, check controls” cell means the surface is in the documented path for that plan category when rollout and permissions align; it does not promise that a specific user will see Astra today.

The matrix deliberately avoids an “available now” column because the documented rollout is gradual. For a support leader, the correct response is to classify the account as eligible path, blocked by policy, blocked by client version, blocked by wrong surface, or not yet reached by rollout. Those statuses are actionable. “It should be there because the plan is paid” is not actionable and can be wrong for Plus, Pro, Business, and Enterprise accounts if rollout, permissions, or software requirements are not satisfied.

Workspace controls are separate: Work Cloud, Work Local, and Codex Local

OpenAI’s Work and Codex documentation separates Work Cloud, Work Local, and Codex Local controls. Administrators should mirror that separation in their ticket forms and runbooks. A user may be permitted to run cloud-backed Work tasks but blocked from local Work operations, or allowed to use Work while Codex Local remains disabled. A developer’s report that “Astra works in Work but not in Codex” can therefore be a correctly enforced workspace policy rather than a failed model rollout.

Local mode should not be described as fully offline. OpenAI notes that local work can still involve cloud storage of messages and task context. This matters for regulated teams, internal security review, and incident response because a “local” label may refer to where the task can interact with files or tools, not a guarantee that no task context is stored in the cloud. Administrators should use the vendor’s control names in policy documents instead of inventing shorthand such as “offline Astra.”

Starting defaults also do not grant unavailable model or feature access. If a workspace default points users toward a Work or local experience, that default does not override plan eligibility, gradual rollout, model-access permissions, app support, CLI requirements, or approval requirements. When an administrator changes a default, validate the result with a test user who has the intended role and surface rather than assuming the default has changed entitlements.

Enterprise model permissions can be the decisive difference

Enterprise troubleshooting needs one additional branch: model-access permission. OpenAI states that Enterprise access depends on model-access permissions, so an Enterprise user can be on a documented eligible plan path and still fail to see Astra if the workspace has not enabled the model for that user or role. The correct escalation target is the workspace administrator or the internal AI platform team, not billing, unless the organization’s plan status itself is in dispute.

For administrators, the minimum evidence package should include the affected user or group, the tested surface, the expected workflow, whether the workflow is Work Cloud, Work Local, or Codex Local, the current model-access policy, and the approval path required by the workspace. This package prevents a common failure mode where an admin enables a model but leaves the relevant local or Codex control blocked, or enables a local control while the model itself remains unavailable to the user.

Recommended Enterprise access check record

User or group:
Workspace:
Plan type:
Surface tested: web Work / mobile Work / desktop Work / desktop Codex / mobile Remote
Expected action:
Mode or control implicated: Work Cloud / Work Local / Codex Local
Model-access permission checked: yes / no
Desktop app version checked: yes / no / not applicable
Codex CLI version checked: yes / no / not applicable
Approval requirement encountered:
Result:
Next owner: workspace admin / desktop support / user education / rollout watch

Use surface-specific symptom patterns to shorten diagnosis

If Astra appears in web or mobile Work but not desktop Codex, prioritize the desktop app and Codex CLI checks after confirming Codex Local is allowed. OpenAI documents that Astra requires Codex CLI 0.153.0 or newer and the latest desktop app. An outdated CLI can be invisible to a user who only checks the ChatGPT plan page, because the plan can be eligible while the local development surface cannot yet support the required workflow.

If Astra appears in desktop Work but not web or mobile Work, record the exact account, surface, and workspace context without promising that web or mobile will match the desktop state on a specific date. The documented rollout language supports gradual availability, not synchronized arrival across every client and account. The practical escalation is to verify the account, update state, and workspace policy, then classify the issue as rollout variance if no policy or version blocker is found.

If a user can see a desktop Codex chat from the mobile Remote tab but cannot find it in ordinary mobile history, explain the product boundary rather than treating it as missing sync. Remote exposes supported desktop Codex chats without turning them into mobile or web history. That answer is especially important for support teams because repeated reinstallations or cache-clearing steps will not make a desktop Codex thread behave like a normal mobile chat if the product model intentionally separates them.

If a user bought credits and still does not see Astra, close the billing misconception first. OpenAI states that buying credits does not provide early rollout access. Credits may be relevant to usage and billing mechanics, but they should not be used as evidence that an account should bypass the gradual rollout, workspace model permissions, or software requirements. This single clarification often prevents founders and individual power users from opening duplicate billing and technical tickets for the same root misunderstanding.

Surface mapping checklist for frontline support

1. Ask the user to name the surface: ChatGPT web Work, ChatGPT mobile Work, desktop Work, desktop Codex, or mobile Remote.
2. Confirm the plan category without promising individual timing: Plus, Pro $100, Pro $200, Business, or Enterprise.
3. For Enterprise, verify model-access permission before changing desktop software or advising the user to wait.
4. For Business and Enterprise, separate Work Cloud, Work Local, and Codex Local controls in the ticket notes.
5. For desktop Codex, confirm the latest desktop app and Codex CLI 0.153.0 or newer before escalating to model availability.
6. For mobile reports, distinguish native Work usage from Remote access to supported desktop Codex chats.
7. Record whether the user is assuming that credits accelerate rollout, because that assumption should be corrected explicitly.
8. Document whether local work is being requested and warn that local work can still involve cloud storage of messages and task context.

The best access diagnosis is narrow and reproducible: “Enterprise user in desktop Codex, model permission enabled, Codex Local allowed, latest desktop app installed, CLI below 0.153.0” is a solvable client-version issue. “Astra missing everywhere” is not a useful diagnosis until it has been decomposed by plan, surface, workspace control, and client requirement. That decomposition is the difference between a support script that generates escalations and a playbook that resolves them.

Run the missing-Astra diagnostic tree in a fixed order

Astra access problems are easiest to resolve when the first responder treats them as a sequence of gates rather than as a single “model missing” bug. OpenAI’s Work and Codex documentation separates plan eligibility, gradual account rollout, Enterprise model permissions, workspace controls, allowance behavior, Codex CLI version, and desktop app version. If you skip directly to reinstalling an app or buying credits, you can spend time on steps that cannot change entitlement or rollout state.

The diagnostic tree below is written for support desks, Enterprise administrators, Codex platform owners, and advanced users who need a repeatable way to decide whether the issue is an entitlement gap, a workspace control, a stale client, a surface mismatch, or an account-specific rollout state. Use the steps in order, and record the evidence at each gate so that escalation is based on facts rather than screenshots alone.

Decision tree overview

Step 1: verify the official rollout status before changing anything

Start by checking OpenAI’s current product release notes, ChatGPT release notes, and the ChatGPT Work and Codex help article assigned to the workflow. The relevant documented claim is that GPT-6 Pro powered by GPT-6 Astra is gradually rolling out to Pro $100, Pro $200, Business, and Enterprise, and that Plus includes limited Astra usage in Work and Codex as rollout reaches the account. That wording matters: “gradually rolling out” is not the same as “visible to every eligible user immediately.”

Use this rule for triage: if the official notes do not document Astra for the requested surface or account category, do not open an engineering incident that assumes a broken selector. If the notes do document it but use gradual-rollout language, continue the tree and avoid promising a date. A support reply should say that the account must satisfy plan, permission, policy, version, and rollout conditions before Astra appears.

Operational warning: Do not use social posts, screenshots from another workspace, or a teammate’s access as proof that the current user should have Astra. OpenAI’s documentation is the boundary for support decisions, and staged rollout can make two otherwise similar accounts differ for a period of time.

Step 2: confirm the exact account, organization, and workspace

Many false positives come from users switching between personal accounts, Business workspaces, Enterprise workspaces, and test identities. Ask the user to confirm which account is signed in and which workspace is active before you inspect permissions. A Plus user may be eligible for limited Astra usage only when rollout reaches that account; a Business or Enterprise user may be in the wrong workspace; a Codex user may have a desktop session authenticated to a different identity than the browser session where the administrator checked policy.

Record the account category, the workspace name or identifier available to the administrator, the surface being tested, and whether the user can reproduce the issue after signing out and back in. Do not ask users to send credentials or tokens. The useful evidence is the relationship between the identity, workspace, plan, and surface, not secret material.

Recommended case note template:
- User identity checked by support: yes/no
- Intended workspace confirmed by user: yes/no
- Product surface: Work web, Work desktop, Codex desktop, mobile Remote for a desktop Codex chat, or other
- Reported symptom: Astra absent, Astra visible but unavailable, allowance warning, policy block, or version prompt
- Last successful refresh: app restart, browser reload, sign-out/sign-in, or none
- Admin policy checked by: name or team, not secret values

Step 3: separate plan eligibility from account rollout

After the identity is confirmed, determine whether the account is on a plan OpenAI lists for Astra rollout. OpenAI’s Work and Codex article names Pro $100, Pro $200, Business, and Enterprise for gradual rollout, and says Plus includes limited Astra usage in Work and Codex as rollout reaches the account. That means an eligible plan is necessary but not always sufficient at a specific moment. If a user says, “My teammate on the same plan sees it,” the next question is whether both accounts are in the same rollout state and workspace policy state.

Do not treat purchased credits as an entitlement fix. OpenAI states that buying credits does not provide early rollout access. Credits can be relevant to paid usage mechanics in other contexts, but they are not a bypass around account rollout, Enterprise model permissions, or client requirements. If the account has not received the rollout, a credit purchase should not be recommended as a troubleshooting action.

Step 4: for Enterprise, inspect model access before device troubleshooting

Enterprise environments add a second administrative gate: model access permissions. OpenAI states that Enterprise Astra access depends on model-access permissions in addition to rollout and plan eligibility. This is the point where the support path should move from the end user’s device to the workspace administrator who can verify whether the model is allowed for the relevant users, groups, or roles.

The selected article guides IT administrators through ChatGPT Enterprise setup, including the admin console, SSO, data controls, and model access management. The full analysis in How to Set Up ChatGPT Enterprise for Your Team: Admin Console, SSO, Data Controls, and Model Access Management extends this section’s ChatGPT Enterprise Model Permissions discussion because model permissions and access management are exactly the Enterprise admin concepts readers need when Astra is missing due to workspace-level controls.

A practical decision rule is simple: if a non-Enterprise user on an eligible plan is missing Astra, proceed to rollout, allowance, and client checks; if an Enterprise user is missing Astra, require an admin permission check before reinstalling software. The same user might see different options in a personal account and an Enterprise workspace because those accounts are governed by different plan, policy, and permission layers.

Administrators should avoid broad policy changes just to test one user. Instead, verify the intended permission assignment for a known affected identity, confirm the product surface, and check whether the same policy should apply to Work, Codex, or both. If policy is changed, instruct the user to refresh the session after the change; a stale desktop process may not immediately present the updated state.

Step 5: verify Work Cloud, Work Local, and Codex Local separately

OpenAI’s Work and Codex operating model distinguishes Work Cloud, Work Local, and Codex Local as separate workspace controls. Treat them as three different switches in your diagnostic notes. A user may be allowed to use Work Cloud but not Work Local, or Codex Local but not a Work mode, depending on workspace policy. A generic statement such as “Work is enabled” is not precise enough for Astra troubleshooting.

The local-mode warning is especially important for regulated teams. “Local” in this context should not be described as fully offline unless OpenAI documentation explicitly says so for the specific workflow. The Work and Codex help article says local work can still involve cloud storage of messages and task context. If a policy or data-handling review depends on offline operation, do not approve the workflow based on the word “local” alone.

Step 6: check included allowance before assuming the model is broken

If Astra was visible earlier and is now unavailable, inspect allowance behavior before escalating. OpenAI states that Astra can consume an allowance faster than GPT-5.6 Sol depending on task size, reasoning, and Fast mode. A large multi-step Work task, a repository-heavy Codex workflow, or a repeated high-reasoning attempt can deplete included usage more quickly than a short chat-style request. The symptom may look like access disappeared even though entitlement and rollout remain valid.

Use a task-size lens when interviewing the user. Ask whether the last attempts involved large repositories, long context, multiple files, repeated retries, or high-complexity deliverables. The recommended mitigation is not to buy credits for early access, because OpenAI explicitly says credits do not provide early rollout access. Instead, reduce the task scope, split the deliverable, remove unnecessary context, or wait according to the account’s normal allowance behavior if the product presents an allowance-related limitation.

Step 7: validate Codex CLI 0.153.0 or newer and the latest desktop app

Only after entitlement, permissions, controls, and allowance are plausible should you spend time on client version. OpenAI’s Work and Codex article states that Astra requires Codex CLI 0.153.0 or newer and the latest desktop app. The Codex 0.153.0 release is also operationally important because it documented changes such as improved reconnection handling, preserved draft state for Vim undo and redo, complete patch and command history, remembered MCP approvals scoped to the account, and review-history persistence across restarts, compaction, and forks. Those details do not create Astra entitlement, but they explain why outdated clients are poor evidence during rollout troubleshooting.

The selected article covers Codex CLI 0.153.4, where GPT-6 Astra becomes the default, Bedrock routes arrive, and async clarification fixes are included. The full analysis in Codex CLI 0.153.4 Release: GPT-6 Astra Becomes the Default, Bedrock Routes Arrive, and Async Clarifications Are Fixed extends this section’s Codex CLI Upgrade Guide discussion because it directly supports CLI troubleshooting by tying the relevant Codex CLI upgrade to GPT-6 Astra rollout behavior.

When checking the CLI, record the installed version and the method used to check it, but do not infer features from prerelease tags or undocumented builds. The source requirement is the minimum: 0.153.0 or newer for Astra. If a user is on an older CLI, update first and retest. If a user is on a newer stable CLI but an old desktop app, update the desktop app too; the requirement includes both the CLI minimum and the latest desktop app.

Do not present 0.153.0’s operational features as approval bypasses. For example, remembered MCP approvals being scoped to the account does not remove sensitive-action checks or other approval policies. Reconnection improvements also do not mean uncertain queued submissions are automatically completed; the release notes say uncertain or queued submissions remain paused for review. These distinctions matter when a user interprets a missing or paused action as an Astra access failure.

Step 8: refresh the session after every meaningful change

Policy changes, account switches, plan changes, and application updates should be followed by a clean session refresh. For web surfaces, that may mean a full reload and reauthentication to the correct workspace. For desktop Work or Codex, it usually means closing and reopening the supported desktop app after updates and sign-in changes. For CLI-based Codex workflows, it means starting a fresh session after confirming the supported CLI version and account identity.

This step is not superstition. Clients can retain session state, cached account information, workspace policy state, or an old view of available models. A refresh does not grant unavailable access, but it prevents stale state from hiding access that the account, policy, and client now satisfy. If the user still does not see Astra after a refresh, your case record should show that the issue survived entitlement, policy, allowance, version, and session checks.

Step 9: identify surface mismatches before calling it a rollout defect

Astra visibility can differ by surface because Work and Codex are not the same product area. OpenAI describes Chat as fast conversational work, Work as longer multi-step deliverables, and Codex as software-development and repository workflows. Work is available on eligible web, mobile, and desktop surfaces. Codex remains a separate desktop view and is not selectable on web or mobile. Supported desktop Codex chats can be accessed through the mobile Remote tab, but that does not convert Codex into a native mobile or web selectable experience.

If a user says “Astra is missing on mobile Codex,” clarify the actual path. If they mean they are using the mobile Remote tab to view a supported desktop Codex chat, troubleshoot the underlying desktop Codex session. If they mean they expect Codex itself to be selectable on mobile or web, explain that OpenAI does not document Codex as a native selectable mobile or web experience. This distinction prevents an unsupported-surface request from being misfiled as an account rollout defect.

Step 10: close with an account-specific rollout assessment

If every prior gate passes and Astra still does not appear, classify the issue as account-specific rollout or a support escalation candidate, depending on the evidence. A clean case should show that official notes document the feature, the user is in the intended account and workspace, the plan is eligible, Enterprise model access is allowed if applicable, Work Cloud or Work Local or Codex Local policy matches the requested mode, included allowance is not the apparent blocker, the CLI is 0.153.0 or newer, the desktop app is current, and the session was refreshed.

The most important communication rule is to avoid implying that starting defaults grant access. OpenAI states that starting defaults do not grant unavailable model or feature access. A default can shape the initial behavior of an eligible and permitted workflow, but it cannot override a missing rollout, an ineligible plan, a disabled Enterprise model permission, a blocked Work or Codex control, an exhausted allowance, or an outdated client requirement.

Use the following closure language as a recommended support pattern: “We verified the account, workspace, plan, Enterprise permission state, Work/Codex control state, allowance symptom, client versions, and session refresh. Because OpenAI describes Astra as a gradual account rollout, the remaining explanation may be account-specific rollout timing unless OpenAI Support identifies a separate account issue.” This phrasing is precise, avoids overpromising, and leaves room for official support review without inventing a hidden activation mechanism.

Operational evidence packets for administrators and end users

When an Astra case reaches workspace support, the first operational mistake is treating every symptom as “missing rollout.” Build two evidence packets instead: one from the affected user and one from the administrator. The user packet proves the account, surface, version, and symptom. The administrator packet proves plan eligibility, model permissions, workspace controls, and policy decisions. Keeping those packets separate prevents an administrator-only permission failure from being misreported as a global rollout problem.

End-user evidence packet

• Account and workspace identity: capture the signed-in account, the workspace selected at the time of the attempt, and whether the user was operating in Chat, Work, desktop Codex, or mobile Remote. Do not rely on screenshots without confirming the workspace context, because a user may belong to more than one organization.
• Surface and device: record whether the attempt occurred on web, mobile, desktop Work, desktop Codex, or the mobile Remote tab. OpenAI states that Codex is a separate desktop view and is not selectable on web or mobile; Remote can access supported desktop Codex chats without making Codex a native mobile or web model selector.
• Codex version evidence: for Codex incidents, capture the installed CLI version and desktop app update state. OpenAI says Astra requires Codex CLI 0.153.0 or newer and the latest desktop app, so a case without version evidence is incomplete.
• Exact failure class: ask the user to label the symptom as “model not visible,” “model visible but task refused,” “task starts then allowance is exhausted,” “available in Work but not Codex,” or “available on desktop but not mobile/web.” This wording separates access failure, usage exhaustion, and product-surface mismatch.
• Recent task characteristics: collect whether the task used long reasoning, large repository context, multi-step Work deliverables, or Fast mode. OpenAI says Astra can consume allowance faster than GPT-5.6 Sol depending on task size, reasoning, and Fast mode, so the task shape belongs in the case file.

Administrator evidence packet

• Plan and rollout status: document whether the account is on a documented eligible plan and whether the rollout has reached that account. OpenAI says GPT-6 Pro powered by GPT-6 Astra is gradually rolling out to eligible Pro, Business, and Enterprise customers, and Plus receives limited Astra usage in Work and Codex as rollout reaches the account.
• Enterprise model access: for Enterprise, record the model-access setting or policy decision that applies to the affected user or group. OpenAI states Enterprise access also depends on model-access permissions, so plan eligibility alone is not evidence of usable access.
• Work and Codex controls: record the separate states of Work Cloud, Work Local, and Codex Local. OpenAI’s operating model treats these as distinct workspace controls; enabling one does not prove that the others are available.
• Managed configuration evidence: where managed configuration is used, attach the relevant enforced requirements and managed defaults that apply to the signed-in identity. Managed defaults are not the same as enforced requirements, and neither replaces role-based access control or grants unavailable model access.
• Allowance review: record whether the user appears to have included allowance remaining or whether the symptom follows heavy usage. Buying credits does not provide early rollout access, and a depleted allowance is operationally different from missing entitlement.

The selected article explains ChatGPT’s 2026 usage limits, including rate limits, token budgets, metered credits, and ways to maximize an allowance. The full analysis in Understanding ChatGPT’s 2026 Usage Limits: Rate Limits, Token Budgets, and How to Maximize Your Allowance extends this section’s AI Usage Credits and Allowances discussion because it is the most semantically relevant link for diagnosing whether an Astra issue is caused by usage caps, credits, token budgets, or allowance exhaustion.

Pilot cohorts and rollout communications that reduce false tickets

A reliable Astra rollout should start with cohorts that exercise different failure modes rather than only enthusiastic early adopters. Include one Business or Enterprise knowledge-work group using Work Cloud, one engineering group using desktop Codex, one user who regularly switches between Work and Codex, one mobile-heavy user who must understand the Remote distinction, and one administrator who can validate model-access permissions. This cohort design exposes plan, permission, allowance, version, and surface issues before a broad announcement creates duplicate support tickets.

Recommended rollout communications should avoid promising that Astra will appear everywhere at the same time. State that OpenAI describes the rollout as gradual, that Enterprise availability depends on model permissions, that Codex requires CLI 0.153.0 or newer plus the latest desktop app, and that mobile Remote is not the same as selecting Codex on mobile. Also state that credits are not an early-access mechanism, because users often interpret credit purchase as a way to force availability.

Recommended internal wording: “Astra access depends on account rollout, plan eligibility, workspace permissions, product surface, remaining allowance, and Codex version. If Astra appears in one place but not another, report the exact surface and workspace before reinstalling software or changing settings.”

Decision table: access failure, usage exhaustion, or surface mismatch

Allowance monitoring and model fallback plans

Allowance monitoring should be framed as a capacity-management process, not a blame exercise. OpenAI says Astra can consume allowance faster than GPT-5.6 Sol depending on task size, reasoning, and Fast mode. A support team should therefore ask whether the user is running multi-step deliverables, repository-wide software work, or repeated long-running attempts after uncertain outcomes. Those patterns can exhaust included usage even when access and permissions are correct.

A practical fallback plan names which work should wait for Astra and which work can move to another available model. Reserve Astra for tasks that need its reasoning profile in Work or Codex, such as complex multi-file planning, difficult repository analysis, or long multi-step deliverables. Route routine summarization, short drafting, and low-risk transformations to another model that is available to the user under the workspace’s policy. Do not describe fallback as equivalent capability; describe it as a continuity option when allowance, rollout, or surface constraints block Astra.

Administrators should also define a retry rule. If a task fails because the model is unavailable, do not repeatedly resubmit large jobs until the failure class is known. If a Codex submission is uncertain after a connection problem, OpenAI’s Codex 0.153.0 release notes indicate the app can reconnect after app-server drops while uncertain or queued submissions remain paused for review. Treat that as a review checkpoint, not as proof that the task completed or safely resubmitted.

Audit evidence for policy, local work, and Codex operations

Audit evidence should prove both intent and enforcement. For workspace controls, store the change request, approver, affected groups, effective date, and whether the change applied to Work Cloud, Work Local, Codex Local, or model access. Because these controls are separate, an audit entry saying “Astra enabled” is too vague to explain a later incident. Use the control names that match the operational decision.

Local work requires careful wording in audit records. OpenAI states that local work can still involve cloud storage of messages and task context. Do not record Work Local or Codex Local as “fully offline” unless a separate official source supports that claim for the exact configuration. The safer audit statement is that the work used a local mode control while still being subject to the product’s documented storage and task-context behavior.

Codex 0.153.0 also matters for operational reconstruction because the release documented complete patch, terminal, and command history; Guardian review-history persistence across compaction, restarts, and forks; account-scoped remembered MCP approvals; rollout compression and resume improvements; and app-server thread metadata. These are useful evidence sources when investigating what a developer attempted, what was reviewed, and whether a remembered approval belonged to the signed-in account. They should not be treated as bypasses for sensitive-action checks or workspace approval policies.

Known non-fixes that waste time

• Buying credits to force rollout: OpenAI says buying credits does not provide early rollout access. Credits may matter for usage, but they do not move an account ahead in a gradual rollout.
• Changing a starting default: starting defaults do not grant unavailable model or feature access. They only affect default behavior where access already exists.
• Assuming one surface proves all surfaces: Astra appearing in Work does not prove Codex readiness, and a desktop Codex chat visible through mobile Remote does not mean Codex is selectable on mobile or web.
• Calling local mode offline: local work can still involve cloud storage of messages and task context, so “offline mode” is an unsafe support label.
• Ignoring CLI version after eligibility is proven: Codex requires CLI 0.153.0 or newer for Astra, plus the latest desktop app. Eligibility does not compensate for an outdated client.
• Retesting with larger tasks after allowance pressure: if allowance exhaustion is plausible, repeated large attempts can make the incident harder to diagnose and may consume more included usage.

Concise runbook for escalation and closure

1. Classify the incident: mark it as access failure, usage exhaustion, or product-surface mismatch before assigning the ticket.
2. Confirm identity: verify account, organization, workspace, plan, and Enterprise model-access permissions where applicable.
3. Name the surface: record Chat, Work web, Work desktop, desktop Codex, mobile, or mobile Remote. Do not accept “ChatGPT” as a complete surface description.
4. Check workspace controls: inspect Work Cloud, Work Local, and Codex Local separately, and record the effective policy for the affected user or group.
5. Verify client requirements: for Codex, confirm CLI 0.153.0 or newer and the latest desktop app before escalating as a product defect.
6. Review allowance state: compare the symptom against recent task size, reasoning intensity, Fast mode usage, and repeated retries.
7. Apply fallback: route urgent work to an approved available model or surface when the task does not strictly require Astra.
8. Escalate with packets: attach the user evidence packet, administrator evidence packet, timestamps, screenshots if useful, and the exact failure class.
9. Close with a reason code: use one of four closure labels: rollout not reached, permission corrected, allowance exhausted, or surface/client mismatch.

The most effective Astra operations teams do not treat rollout troubleshooting as a single yes-or-no entitlement check. They maintain evidence packets, communicate the limits of gradual availability, separate allowance exhaustion from permissions, and document which surface was actually used. That discipline gives administrators a defensible audit trail and gives users a faster answer: wait for rollout, request permission, update Codex, reduce workload, or use an approved fallback.

Useful Links

• OpenAI Help: ChatGPT Work and Codex
• OpenAI Help: ChatGPT release notes
• OpenAI product release notes
• OpenAI Codex GitHub release: rust-v0.153.0