Codex CLI 0.153.4 Release: GPT-6 Astra Becomes the Default, Bedrock Routes Arrive, and Async Clarifications Are Fixed

Codex CLI 0.153.4 Is a Rollout Stabilization, Not a Second GPT-6 Astra Launch

OpenAI’s Codex CLI 0.153.4 release should be read as the endpoint of a short stabilization train that ran from September 3 to September 4, 2026, not as a new model launch. The model-level launch event was GPT-6 Astra’s September 3 introduction in OpenAI’s product release notes, where OpenAI described limited organizational rollout, broader availability over the following days, and the model’s supported work across reasoning, coding, computer use, research, and document creation. The Codex CLI releases that followed are narrower: they adjust how the CLI can configure, display, select, and route Astra after the model exists. Teams tracking launch availability should separate those two layers carefully. For deeper context on GPT-6 Astra Launch Availability, GPT-6 Astra Launches in ChatGPT, Codex, the API, Azure, and AWS Bedrock: Availability, Benchmarks, and What Changes Now is a practical companion. This article covers GPT-6 Astra’s September 2026 launch across ChatGPT, Codex, the API, Azure, and AWS Bedrock, including staged availability, benchmarks, and near-term product implications.

The practical news is that 0.153.4 makes GPT-6 Astra the bundled default when no model is explicitly configured, fixes Astra’s visibility in the bundled model picker, and tightens asynchronous-question guidance so it appears only when the tool is actually available. Those changes matter for developers and administrators because defaults and picker visibility affect day-to-day operator behavior even when backend access policy is still governed elsewhere. A CLI default does not by itself grant an organization access to a restricted model, change OpenAI account eligibility, or override a cloud provider route’s catalog state. It changes what Codex chooses or presents inside the CLI under the conditions described in the release notes.

The sequence also explains why some users may have seen Astra-related support before 0.153.4 while others did not see Astra as an ordinary bundled choice. Version 0.153.1 added API configuration support for GPT-6 Astra, which means the CLI learned how to accept Astra in configuration. That is different from being exposed in the picker and different again from being the default. Version 0.153.4 closes that gap by fixing bundled picker visibility and default selection, while 0.153.3 separately expands model-picker catalog coverage for selected Amazon Bedrock routes. The train is best understood as aligning the CLI’s configuration layer, UI selection layer, defaulting behavior, and route catalog metadata.

For organizations that already standardized on Codex CLI 0.153.0, the 0.153.1 through 0.153.4 run is a post-release operational follow-up. The 0.153.0 baseline introduced the surrounding context for administrators who track model configuration, developer workflows, and CLI behavior across teams. This new patch series does not replace the need to understand that baseline; it clarifies what changed immediately after Astra entered the Codex ecosystem. For deeper context on Codex CLI 0.153.0 Guide, Codex CLI 0.153.0 Complete Guide: Vim Undo, Remote Plugin Marketplaces, Safer Reconnects, Guardian History, and MCP Controls is a practical companion. This guide explains Codex CLI 0.153.0, including Vim undo, remote plugin marketplaces, safer reconnects, Guardian approval history, and MCP control changes.

Version Timeline: September 3–4, 2026

The four releases landed quickly enough that a single “latest version” summary can obscure the operational difference between them. Administrators should review the train chronologically because each patch addresses a separate failure mode: configuration without visibility, display wording without execution change, route catalog coverage, and session-scoped guidance for asynchronous questions. Treating those as one undifferentiated Astra update increases the risk of incorrect runbooks, especially in enterprise environments where model defaults, picker options, cloud routes, and tool availability are governed by different owners.

The shortest accurate summary is that 0.153.1 made Astra configurable, 0.153.2 fixed a label, 0.153.3 added selected Bedrock picker routes and a text-only async clarification, and 0.153.4 made Astra visible and default in the bundled CLI path while reducing misleading async guidance. That progression is typical of a rollout cleanup: the underlying feature exists, early integration points appear, metadata and descriptions are corrected, and then the default and picker state are brought into alignment.

The Six Distinctions That Matter in Production

First, API configuration support is not the same thing as user-facing model selection. In 0.153.1, Codex CLI could accept GPT-6 Astra in configuration, which is the mechanism automation owners care about when they pin models in files, scripts, or managed setup. A configured model can be valuable before it appears as a bundled picker option because platform teams may want deterministic rollout through configuration management rather than letting every developer choose from a UI or interactive selector.

Second, bundled-picker visibility is about discoverability, not entitlement. Version 0.153.4 fixed Astra’s visibility in the bundled model picker, meaning the CLI’s built-in selection experience was brought into line with the intended model list. That does not mean the picker is an access-control plane. If an organization does not have Astra access through the relevant OpenAI rollout or configured provider route, a visible picker entry should not be interpreted as a contractual right to use the model. Teams should continue to validate real request success through their normal smoke tests, logs, and provider-side controls.

Third, default selection affects silent behavior when no explicit model is configured. OpenAI’s 0.153.4 note says Astra becomes the bundled default when no model is explicitly configured. That is operationally important because developer machines, CI jobs, or ephemeral workspaces that rely on defaults may begin attempting Astra after upgrade. The safe enterprise rule is simple: if a workflow requires a specific model for cost, compliance, reproducibility, or availability reasons, configure that model explicitly rather than relying on the CLI default.

Fourth, Bedrock catalog presence is route-specific. Version 0.153.3 added GPT-6 Astra to the Amazon Bedrock model picker for Mantle and Runtime global and US routes. That statement is narrower than “Astra is available everywhere on Bedrock.” It identifies selected route families and geographies named in the release note. Administrators should avoid copying that support assumption into unrelated routes, accounts, or regions unless their own provider catalog and access controls confirm the same result.

Fifth, Fast-tier display wording is not a performance change. The 0.153.2 release corrected Astra’s Fast-tier description to “2x speed, increased usage,” and OpenAI explicitly characterized the fix as text-only with no change to request execution. This distinction matters because release notes that mention speed can easily trigger incorrect internal announcements. Teams should not use 0.153.2 as evidence that latency, throughput, scheduler behavior, or billing semantics changed in their environment. The release adjusted what the CLI displayed, not how requests ran.

Sixth, asynchronous-question availability is session-scoped and tool-scoped. Version 0.153.3 clarified that Astra’s asynchronous-question tool accepts text only, while 0.153.4 constrained asynchronous-question guidance to sessions where that tool is actually available. That is a documentation and UX correctness fix with practical safety value: Codex should not encourage operators to use a tool when the current session does not expose it. For agent workflows, this reduces confusion between model capability, CLI guidance, and the tool surface actually active in a session.

Why the Release Train Looks Like Stabilization

A new model launch usually changes the model catalog, model documentation, API identifiers, availability posture, pricing information, or top-level product narrative. The September 3 GPT-6 Astra launch did that at the OpenAI product and API-documentation layer. The Codex CLI 0.153.1 through 0.153.4 sequence instead adjusts downstream integration behavior after the model has already been introduced. Its changes are about configuration acceptance, picker visibility, default selection, provider-route listings, display copy, and tool-guidance scoping. Those are important, but they are not equivalent to a second launch.

The stabilization interpretation is also supported by the ordering. If 0.153.1 added configuration support without changing the default or picker, OpenAI was enabling early explicit use without forcing all bundled users into Astra. If 0.153.2 corrected Fast-tier wording without changing execution, OpenAI was cleaning up operator-facing text. If 0.153.3 added selected Bedrock picker routes and clarified text-only async questions, OpenAI was aligning provider catalogs and tool descriptions. If 0.153.4 then fixed bundled picker visibility, default behavior, and session-appropriate async guidance, OpenAI was closing the most visible gaps that remained after the first patches.

For platform leaders, the immediate action is not to announce “Astra launched in Codex” as though this were a new capability independent of the September 3 launch. The better action is to publish a short internal note that says Codex CLI 0.153.4 changes default selection and picker behavior, that 0.153.2’s Fast-tier update was display-only, and that Bedrock visibility is limited to the named Mantle and Runtime global and US routes in the release note. That message prevents three common errors: overstating availability, misreading a label fix as a runtime change, and assuming every session has the asynchronous-question tool.

Security and compliance teams should focus on explicit configuration and auditability. A default model change can affect prompts, generated code, logs, approval paths, and policy exceptions if developers rely on implicit settings. The recommended control is to pin model choices in managed Codex configuration for regulated or high-impact workflows, then separately test unpinned developer workstations so support teams know what the new default does in practice. This is not because 0.153.4 is inherently unsafe; it is because any default change can produce surprises when an organization’s controls assume that explicit selection is always present.

Developer-experience teams should update onboarding material with the precise terms from the train. “Configurable” should describe 0.153.1-era explicit setup. “Visible in bundled picker” should describe 0.153.4’s discoverability fix. “Bundled default” should describe what happens only when no model is explicitly configured. “Available in Bedrock picker” should be qualified with Mantle and Runtime global and US routes. “Fast tier” should use the corrected “2x speed, increased usage” display wording while stating that the correction was text-only. “Async questions” should state both constraints: text-only input for Astra’s asynchronous-question tool, and guidance only in sessions where the tool exists.

The result is a cleaner Codex CLI integration for GPT-6 Astra, but it is still an integration update bounded by access policy, route catalogs, explicit configuration, and session tools. Version 0.153.4 is therefore significant because it makes the CLI’s default and picker behavior match the rollout more closely; it is not significant because it creates a new Astra product moment. That distinction is the key to interpreting the September 3–4 release train accurately.

Patch-by-Patch Changes Administrators Should Treat Differently

OpenAI’s Codex CLI 0.153.1 through 0.153.4 releases form a short stabilization train around GPT-6 Astra distribution inside Codex, not a separate model launch and not a single feature drop. The practical reading is that each patch changed a different layer of the client experience: API configuration awareness, displayed tier wording, Amazon Bedrock picker routes, bundled picker visibility, bundled default selection, and conditional guidance for an asynchronous-question tool. Teams that collapse those changes into “Astra is now available” will miss the operational distinction between a model ID being configurable, visible, selectable, defaulted, or accompanied by tool-specific instructions.

The safest rollout approach is to evaluate the four versions as separate control points. A developer workstation on 0.153.1 may be capable of being configured for Astra through API configuration but may not show it in the picker. A workstation on 0.153.3 may see Astra in certain Bedrock picker routes but still rely on an older bundled visibility behavior. A workstation on 0.153.4 may use Astra as the bundled default when no model is explicitly configured, which is a materially different administrative event from merely adding a model option. That distinction matters for regulated environments, cost controls, provider routing, model allowlists, and reproducibility of coding-agent sessions.

0.153.1: API Configuration Support Arrived Before Picker or Default Changes

Version 0.153.1 added API configuration support for GPT-6 Astra, according to OpenAI’s Codex release notes. In operational terms, this means the CLI could understand or accept Astra-related API configuration, but OpenAI’s note explicitly does not describe a model-picker exposure or a default-model switch in that release. Administrators should therefore avoid treating 0.153.1 as the version where every developer suddenly saw Astra in interactive selection flows or began using it automatically.

The key administrative lesson from 0.153.1 is that configuration support is not the same thing as fleet behavior. If a platform team centrally manages Codex configuration and pins a model explicitly, 0.153.1 created a path to configure Astra for eligible environments. If teams rely on interactive selection, bundled defaults, or provider-specific route pickers, 0.153.1 by itself did not provide the later 0.153.3 and 0.153.4 behavior. For change-control records, the correct entry is “Astra API configuration support added,” not “Astra made default.”

Administrators should use 0.153.1 as a boundary for configuration auditability. Check whether any managed profiles, repository templates, bootstrap scripts, container images, or developer-environment setup documents began referencing gpt-6-astra after this release. If they did, document whether that reference was intentional and whether the underlying organization, API account, and provider path were eligible for the model. If they did not, do not assume the CLI upgrade alone changed active model selection.

Recommended audit pattern, not a Codex-specific command:

1. Inventory installed Codex CLI versions across managed workstations and CI images.
2. Search centrally managed configuration repositories for the string "gpt-6-astra".
3. Separate explicit model settings from comments, examples, and documentation snippets.
4. Record whether the model is configured directly, exposed through a picker policy, or left to a bundled default.
5. Require a human review before changing shared coding-agent defaults in production repositories.

This release also matters for reproducibility. If an incident review examines a coding-agent session created during the 0.153.1 window, the presence of 0.153.1 alone is not enough evidence that Astra was the active model. Investigators should look for the explicit session configuration, wrapper script, environment management policy, or logged model selection. A version number can narrow the possibilities, but it does not replace session-level evidence.

0.153.2: The Fast-Tier Change Was a Text Correction, Not a Runtime Speed Change

Version 0.153.2 corrected the displayed Astra Fast-tier description to “2x speed, increased usage.” OpenAI’s release note characterizes this as a text-only correction and states that it did not change request execution. That sentence is the important one for administrators: this patch should not be entered into performance-change logs as a throughput improvement, latency optimization, scheduler modification, or quota-policy change in the CLI.

The wording still has a documentation impact. If internal enablement material, screenshots, runbooks, or support articles copied the old displayed description, they should be updated so users do not make decisions from stale UI text. But the correction should be handled as a user-interface and documentation consistency fix. It does not justify retesting workload performance on the assumption that OpenAI changed Fast-tier execution behavior in 0.153.2.

For cost and capacity teams, the decision rule is simple: treat 0.153.2 as a display correction unless independent billing records, provider logs, or official pricing documentation show a separate change. The official GPT-6 Astra model documentation lists Fast as two times the applicable rate, while Batch and Flex are 50% of Standard. That model-documentation pricing context is separate from the Codex 0.153.2 release note, which only corrected the displayed Fast-tier description. Do not merge those facts into a claim that the CLI patch altered billing or speed.

Operational warning: If a support ticket says “0.153.2 made Fast faster,” the evidence does not support that conclusion. The reliable statement is narrower: OpenAI corrected the displayed wording to “2x speed, increased usage,” and the release note says request execution did not change.

Security and compliance teams should care because display-only corrections can still affect user behavior. A developer choosing between Standard, Flex, Batch, or Fast may rely on the picker wording when deciding how to run a large refactor, test-generation pass, or repository analysis. Updating training material prevents accidental misuse of a tier because a human misunderstood the option. The remediation is not rollback or performance testing; it is documentation correction and confirmation that monitoring still captures actual provider, model, and tier usage.

0.153.3: Bedrock Routes and Text-Only Async Clarification Inputs

Version 0.153.3 introduced two separate changes that should not be conflated. First, OpenAI added GPT-6 Astra to the Amazon Bedrock model picker for Mantle and Runtime global and US routes. Second, OpenAI clarified that Astra’s asynchronous-question tool accepts text only. One change affects provider-route visibility in the picker; the other affects the shape of user input expected by a tool-mediated clarification flow.

The Bedrock change is route-specific. It does not mean every Bedrock region, route, account, or enterprise policy automatically exposes Astra. The release note identifies Mantle and Runtime global and US routes, so administrators should verify the actual route catalog available to their accounts before updating internal platform matrices. If an enterprise permits Codex through one Bedrock route but not another, the relevant control is the route-level model catalog, not merely the Codex version number. For deeper architecture planning around this provider path, use as the internal reference point for routing and governance considerations. For deeper context on Codex on Amazon Bedrock, How to Access OpenAI Codex on Amazon Bedrock: Complete Enterprise Setup Guide is a practical companion. This enterprise setup guide explains how to access OpenAI Codex on Amazon Bedrock, covering the AWS availability milestone and enterprise use cases for code generation, review, debugging, and modernization.

In practice, the 0.153.3 Bedrock picker change affects teams that let developers choose provider-backed models interactively. A centralized AI-platform team may have already specified provider routes outside the picker; in that case, the picker addition improves discoverability but does not necessarily change production routing. Conversely, a developer group that depends on the picker for allowed model choices could see a new Astra option in qualifying Bedrock routes after upgrading, subject to account and policy availability. That is why fleet owners should test the picker under the same identity, network, and provider configuration used by real developers.

The text-only asynchronous-question clarification is a different kind of fix. It narrows user expectations for a tool that asks asynchronous clarification questions in Astra sessions. OpenAI’s note says the tool accepts text only, so administrators should not train users to attach binary files, structured payloads, images, or other non-text inputs through that clarification path unless future official documentation says otherwise. This matters in coding workflows where a developer might be tempted to answer a clarification with a screenshot, a local file, or a pasted artifact that exceeds what the tool is designed to accept.

For security teams, text-only does not mean risk-free. Text can still contain secrets, credentials, proprietary code, incident details, customer data, or regulated information. The correct governance response is to apply the same data-handling rules to asynchronous clarification answers that already apply to prompts and code context. If the organization forbids pasting production secrets into AI tools, that prohibition applies equally to a clarification answer typed later in the session.

0.153.4: Bundled Picker Visibility, Bundled Default Behavior, and Qualified Tool Guidance

Version 0.153.4 is the release in this train with the clearest default-selection impact. OpenAI says it fixed Astra’s bundled model-picker visibility and made Astra the bundled default when no model is explicitly configured. That sentence contains two different administrative effects: users may see Astra correctly in the bundled picker, and the CLI may select Astra by default when there is no explicit model configuration. The second effect is the one administrators should treat as a change-management event.

The phrase “when no model is explicitly configured” is the governing condition. If an enterprise profile pins another model, a repository-level configuration sets a specific model, or a managed wrapper injects a model setting, the release note does not say 0.153.4 overrides that explicit choice. If a workstation or CI environment relied on Codex’s bundled default because no model was configured, 0.153.4 can change the active model to Astra. The right audit is therefore not “who upgraded,” but “who upgraded and had no explicit model configured.”

This distinction is especially important for teams that need deterministic coding-agent behavior across branches, repositories, or compliance zones. A model-default shift can affect code suggestions, reasoning patterns, tool-call plans, output length, and review burden even when the user’s prompt is unchanged. The release note does not claim a breaking change in Codex commands, but default model changes are still operationally significant because they alter the baseline used by unattended or lightly supervised workflows.

Version 0.153.4 also constrained asynchronous-question guidance to sessions where that tool is actually available. This is a usability and correctness fix: users should not receive instructions about a tool that their current session cannot use. Administrators should view this as a reduction in misleading guidance, not as a guarantee that every Astra session has the asynchronous-question tool. Availability remains conditional on the session context and tool configuration described by the product, and the release note’s point is that guidance should now be better qualified.

For help-desk teams, this changes troubleshooting language. If a user says they do not see asynchronous-question guidance after upgrading to 0.153.4, the answer is not automatically “the upgrade failed.” The better first question is whether the current session actually has that tool available. If the tool is unavailable, the absence of guidance may be expected under the 0.153.4 fix. If the tool is available but guidance is absent or incorrect, then the issue deserves normal version, configuration, and reproduction analysis.

Administrator Impact Table

Recommended Rollout Controls for the 0.153.4 Endpoint State

The highest-value control after 0.153.4 is an explicit model policy. If Astra should be the standard for a team, set that intentionally in the organization’s supported configuration path and record the approval. If another model should remain standard, pin it explicitly rather than relying on a previous bundled default. If different repositories need different behavior, document the repository-level rule so developers can reproduce coding-agent sessions during review or incident response.

A second control is picker validation. Run the same picker flow under the same provider identity and route used by developers, not from an administrator’s unusually privileged account. For Bedrock-backed usage, confirm that the expected Mantle or Runtime route appears only where policy allows it. A screenshot from a personal sandbox is not sufficient evidence for an enterprise rollout because route catalogs, account entitlements, and identity policies can differ across environments.

A third control is clarification-tool training. Tell users that Astra’s asynchronous-question tool, where available, accepts text only, and that 0.153.4 should avoid presenting guidance for sessions where the tool is unavailable. The practical instruction is short: answer clarifications in text, do not paste secrets, do not assume attachments or other modalities are accepted, and report contradictory guidance with the CLI version and session context.

The final control is change-log precision. Record 0.153.1 as configuration support, 0.153.2 as a display correction, 0.153.3 as Bedrock picker routing plus text-only clarification wording, and 0.153.4 as bundled visibility, bundled default behavior, and tool-availability-qualified guidance. That precision gives platform owners a clean map from user reports to likely causes and prevents a stabilization train from being misread as a single broad launch event.

Operational Upgrade and Verification Runbook

This runbook treats Codex CLI 0.153.4 as an operational stabilization release: the objective is to prove which version is installed, whether the bundled default now resolves to gpt-6-astra only when no explicit model is configured, whether the Amazon Bedrock picker exposes the newly listed routes, whether Fast-tier wording is updated without implying a runtime change, and whether asynchronous-question guidance appears only in sessions where the tool is available. Use this as a platform-team procedure, not as a model-launch checklist; OpenAI’s GPT-6 Astra access was still rolling out to a limited set of organizations in the referenced release window, so a successful CLI upgrade does not prove that every tenant, workspace, API key, or Bedrock route has production entitlement.

Runbook Inputs and Decision Records

Before changing developer workstations or shared build images, record three inputs: the currently installed Codex CLI version, the model-selection policy your organization intends to enforce, and the distribution path used for the CLI. The release notes distinguish API configuration support, picker visibility, bundled defaults, Bedrock picker entries, and guidance behavior; collapsing those into “Astra works” creates ambiguous incidents when one surface updates before another.

Step 1: Identify the Installed Version Without Trusting a Single Surface

Start with the most authoritative source in your estate: a package lockfile for repository-local installs, a golden-image manifest for managed desktops, a container digest for CI, or an endpoint-management inventory for laptops. A local CLI version command can be useful, but it should not be the only evidence if developers can install multiple copies or if shells can resolve a different binary than the managed one.

Example inventory commands, not release-documented Codex CLI syntax: adapt these to your package manager and fleet tooling. The goal is to collect a version claim and the filesystem path or artifact identity that produced it.

# Example only: collect local binary and package-manager clues.
# Do not treat these as official Codex CLI commands unless your estate documents them.

command -v codex || true
codex --version 2>/dev/null || true

# Example package-manager probes for environments that use these tools.
npm list -g --depth=0 2>/dev/null | grep -i codex || true
brew list --versions 2>/dev/null | grep -i codex || true

# Example CI/container evidence.
cat /etc/os-release 2>/dev/null || true
env | grep -E 'CODEX|OPENAI|MODEL' | sed 's/=.*/=<redacted>/' || true

Map the observed version to the release-train behavior. On 0.153.1, expect API configuration support for GPT-6 Astra but not bundled default selection or picker exposure. On 0.153.2, expect the corrected Fast-tier display text but no runtime execution change from that text correction. On 0.153.3, expect Bedrock picker entries for the named Mantle and Runtime routes and the text-only clarification for asynchronous questions. On 0.153.4, expect Astra picker visibility in the bundled picker, Astra as the bundled default when no explicit model is configured, and tool guidance constrained to sessions where the async-question tool is available.

Step 2: Choose Pin, Canary, or Fleet Upgrade

Use a pin when reproducibility matters more than immediate default adoption. Teams with regulated change windows, deterministic CI agents, or approved-model allowlists should pin Codex CLI and explicitly configure the model until they have evidence that 0.153.4 behaves correctly in their environment. Use a canary when you need to validate bundled-default behavior, Bedrock route visibility, and clarification-tool guidance before updating every workstation. Use a fleet upgrade only after your canary proves both explicit and implicit model-selection paths.

Recommended decision rule: if your developers already set a model explicitly through managed configuration, upgrade validation should prove that the explicit setting remains effective and that 0.153.4 does not silently change those governed sessions to Astra. If your organization intentionally wants the bundled default to become GPT-6 Astra where no model is configured, upgrade validation should prove that the unset-model profile selects gpt-6-astra and that access failures are handled as entitlement or rollout issues rather than misdiagnosed as CLI installation failures.

# Example only: internal release manifest for a managed rollout.
# This is not an official Codex CLI configuration schema.

codex_cli:
  approved_version: "0.153.4"
  rollout_ring: "canary"
  expected_when_model_unset: "gpt-6-astra"
  explicit_model_policy: "managed-settings-win-over-bundled-default"
  evidence_required:
    - installed_version
    - model_selection_trace
    - bedrock_picker_capture
    - fast_tier_label_capture
    - async_question_tool_capture

For teams moving code-generation workflows to Astra, keep the CLI upgrade separate from API migration work. GPT-6 Astra has documented model-level constraints, including the gpt-6-astra model ID and specific reasoning-effort and sampling limitations in OpenAI’s model documentation; those application changes deserve their own test plan. Use for the broader API and application migration track rather than hiding that work inside a CLI patch rollout. For deeper context on GPT-6 Astra Migration Tutorial, How to Migrate from GPT-5.5 and GPT-5.6 Sol to GPT-6 Astra: Responses API, Reasoning, Caching, and Compatibility is a practical companion. This migration tutorial walks developers from GPT-5.5 and GPT-5.6 Sol to GPT-6 Astra with attention to Responses API compatibility, reasoning behavior, caching, and staged access checks.

Step 3: Verify Explicit Versus Implicit Model Selection

Create two clean test profiles. Profile A must include an explicit model setting from your approved configuration source. Profile B must remove the explicit model setting and rely on the bundled default. Run a harmless, low-risk prompt in each profile, and capture the selected model from whichever surface your deployment exposes: CLI trace, gateway log, request metadata, administrative telemetry, or a redacted transcript if it includes the model identifier.

Example fixture design, not an official Codex CLI schema: the important control is the presence or absence of a model setting, not the particular file path shown below.

# Example only: Profile A, explicit model configured by the organization.
# Expected result: the explicit model remains selected after the 0.153.4 upgrade.

model = "your-approved-explicit-model-id"

# Example only: Profile B, no model setting.
# Expected result on the 0.153.4 bundled build: gpt-6-astra is selected by default.

# model intentionally unset

Do not use answer style, latency, or subjective code quality to infer the model. A model-selection verification passes only when the selected model is visible in a reliable control-plane or request-plane record. If the unset profile fails because the organization does not yet have Astra access, record that as an access or rollout finding, not as proof that 0.153.4 failed to set the bundled default.

Acceptance criterion: explicit model configuration remains explicit, and an unset model configuration resolves to gpt-6-astra only in the 0.153.4 bundled-default path. Any test that cannot show the selected model should remain inconclusive until request metadata, gateway logging, or administrative telemetry is available.

Step 4: Test Bedrock Route Visibility Separately from Execution

For Amazon Bedrock users, validate route visibility as its own control. OpenAI’s Codex CLI release notes say 0.153.3 added GPT-6 Astra to the Amazon Bedrock model picker for Mantle and Runtime global and US routes. That statement is about picker availability in the CLI surface; it does not guarantee that every AWS account, region policy, identity role, procurement arrangement, or internal gateway will allow production execution.

Capture route visibility with screenshots or structured UI logs, but redact account IDs, project names, IAM role names, and internal route aliases. If your organization blocks screenshots in administrative tools, capture a signed test note with the operator, date, CLI version, route checked, and observed picker entry. Keep any execution test outside this visibility check unless security, procurement, and platform owners have approved the data path.

Step 5: Confirm Fast-Tier Labels Without Inferring a Speed Change

Verify that the Astra Fast-tier description displays the corrected text, “2x speed, increased usage,” on upgraded clients. OpenAI’s release note for 0.153.2 explicitly characterized this as a text-only correction and said it did not change request execution. Treat the label as a version and UI-catalog sanity check, not as a performance validation or an authorization to revise latency service-level objectives.

A useful negative test is to reject any rollout report that claims “Fast got faster because of 0.153.2.” The proper conclusion is narrower: the label changed, and request execution did not change because of that label correction. If platform teams need to validate actual latency, they should run a separate benchmark with controlled prompts, region, tier selection, queueing conditions, and request sizes; the 0.153.2 release note alone does not supply that evidence.

# Example only: evidence note format for a Fast-tier label check.

check: "Astra Fast-tier label"
expected_text: "2x speed, increased usage"
source_release_behavior: "0.153.2 text-only correction; no request execution change"
observed_client_version: "0.153.4"
runtime_performance_claim_made: false
operator: "<name or team>"
timestamp_utc: "<ISO-8601 timestamp>"

Step 6: Confirm Async-Question Tool Availability and Text-Only Inputs

Test asynchronous-question behavior with a scenario that requires a user clarification but does not involve secrets, credentials, production repositories, or irreversible actions. The release train contains two separate claims: 0.153.3 clarified that Astra’s asynchronous-question tool accepts text only, and 0.153.4 constrained asynchronous-question guidance to sessions where that tool is actually available. Your verification should therefore inspect both input constraints and guidance gating.

Recommended test scenario: ask the agent to modify a small disposable repository where the instruction is intentionally ambiguous, such as “rename the customer status field to the new approved term,” without providing the term. In a session where the async-question tool is available, the expected behavior is that clarification guidance can appear and the question payload remains text-only. In a session where the tool is unavailable, the expected behavior is that guidance specific to that tool should not be presented as if the session could use it.

Do not simulate human approval by allowing the agent to proceed with a destructive action. Clarification is a control point, not a substitute for approval policy. Teams that already maintain approval gates for file writes, deployments, database migrations, or external commands should align this async-question verification with so that “ask the user” and “obtain authorization” remain separate workflow states. For deeper context on Codex Human Approval Workflows, How to Build Human-in-the-Loop Codex App-Server Workflows with Asynchronous Questions and Bounded Approvals is a practical companion. This tutorial explains how to build human-in-the-loop Codex app-server workflows using asynchronous questions and bounded approvals so agents can keep working while awaiting human input.

Step 7: Build an Evidence Packet for Audit and Rollback

A complete evidence packet should let an administrator reconstruct what changed without rerunning the test. Include the CLI version, installation source, explicit-model profile result, unset-model profile result, Bedrock picker captures for every approved route, Fast-tier label capture, async-question transcript or trace, and a final decision record. Redact prompts and repository paths if they disclose customer data, unreleased code names, security architecture, or credentials.

# Example only: rollout evidence index.

codex_cli_0_153_4_evidence:
  version:
    observed: "0.153.4"
    source: "managed package inventory and local binary check"
  model_selection:
    explicit_profile:
      expected: "configured model remains selected"
      result: "pass|fail|inconclusive"
      evidence: "gateway-log-id-or-redacted-screenshot"
    unset_profile:
      expected: "gpt-6-astra bundled default"
      result: "pass|fail|inconclusive"
      evidence: "gateway-log-id-or-redacted-screenshot"
  bedrock_picker:
    mantle_global: "pass|fail|not-applicable"
    mantle_us: "pass|fail|not-applicable"
    runtime_global: "pass|fail|not-applicable"
    runtime_us: "pass|fail|not-applicable"
  fast_tier_label:
    expected: "2x speed, increased usage"
    execution_change_claimed: false
  async_question:
    guidance_only_when_available: "pass|fail|inconclusive"
    text_only_payload_confirmed: "pass|fail|inconclusive"
  approval:
    rollout_decision: "continue|hold|rollback"
    approver: "<team or change ticket>"

Rollback is appropriate when explicit model settings are ignored, unset profiles do not select the documented bundled default on a verified 0.153.4 build, Bedrock picker entries disappear from approved routes without a known policy reason, or async-question guidance appears in sessions where the tool is unavailable. A hold is more appropriate than a rollback when the only failure is Astra access, because access rollout and entitlement are distinct from the CLI stabilization changes described in the release notes.

Close the change only after the evidence packet distinguishes four facts: the binary is 0.153.4, governed explicit selections remain governed, the bundled default behaves as documented when configuration is unset, and the UI/tooling clarifications match the release-train notes. That separation is what prevents a routine CLI upgrade from turning into an unclear incident about model access, Bedrock routing, Fast-tier performance, or human clarification controls.

Operational Implications by Owner Group

Codex CLI 0.153.4 changes the risk profile most for users and automation that rely on bundled defaults rather than explicit model configuration. According to OpenAI’s Codex release notes, 0.153.4 makes GPT-6 Astra the bundled default when no model is explicitly configured, while the preceding 0.153.1–0.153.3 patches separately handled API configuration, picker text, Bedrock route visibility, and asynchronous-question clarification behavior. The practical rule is simple: if your workstation, image, CI job, or support script never names a model, it may behave differently after the upgrade; if it names a model explicitly, the upgrade should be treated as a compatibility event rather than an intentional model migration.

Local CLI users should treat the 0.153.4 upgrade as a prompt-behavior and tool-policy validation point, not merely a binary update. Before using Codex on a repository that can change source files, infrastructure manifests, database migrations, or deployment scripts, start with a read-only task and verify the effective model and provider path through the CLI surfaces already approved in your organization. If the session asks asynchronous clarification questions, confirm that the input expected is text-only and that the guidance appears only when the asynchronous-question tool is available, matching the 0.153.3 and 0.153.4 release-note fixes.

Enterprise image maintainers should stop publishing Codex CLI images that float across this release train without a change record. A base image that installs the newest CLI at build time can make GPT-6 Astra the effective default for downstream teams that never opted into a model change. The safer pattern is to pin the CLI version in the image recipe, pin or declare the model in the runtime configuration, and label the image with both values so administrators can answer whether a production incident came from application code, the Codex binary, the bundled model default, or a provider-route change.

Recommended policy: treat the Codex CLI version and the effective model as two separate controlled settings. A CLI upgrade should not automatically authorize a model migration, and a model migration should not depend on a floating CLI package.

Bedrock teams need a separate validation lane because 0.153.3 concerns model-picker availability for Mantle and Runtime global and US routes, not a universal guarantee that every account, region, permission boundary, or network path can execute the model. The test should first confirm that the expected route appears in the picker, then confirm that an authorized account can run a low-impact request, and finally confirm that policy-denied users receive an understandable failure. This distinction prevents support teams from misclassifying an account entitlement issue as a Codex UI regression.

CI/CD owners should assume that implicit defaults are incompatible with reproducible automation. If a pipeline asks Codex to review a pull request, generate a patch, update generated files, or comment on a release candidate, the job definition should specify the intended model rather than inheriting the bundled default. Store the CLI version, model identifier, provider route where applicable, and release-note URL in the build artifact or job summary. That metadata is what allows a failed deploy gate to be reconstructed after the runner image has moved on.

Support desks should update triage scripts to distinguish API configuration support, model-picker visibility, bundled default selection, Bedrock route entries, Fast-tier label text, and asynchronous-question tool behavior. These were separate changes across 0.153.1 through 0.153.4. A useful first response asks the reporter whether the model was explicitly configured, whether the issue occurs on a Bedrock route or a direct OpenAI path, whether the issue is only a displayed Fast-tier description, and whether the async clarification flow is actually available in that session. That triage prevents unnecessary escalation for the 0.153.2 text-only correction, which OpenAI’s release note says did not change request execution.

Regulated environments should classify 0.153.4 as a configuration-affecting update because default model selection can affect validation, approval scope, data-handling review, and audit evidence. The release does not by itself prove that an organization has GPT-6 Astra access, nor does it override internal policy on approved models, providers, regions, or tool use. Teams that operate under change-control rules should link the upgrade ticket to their approved model inventory and maintain a test packet that shows what was configured explicitly and what would happen if configuration were absent. For a broader deployment template, use as the companion operating model. For deeper context on Codex Enterprise Deployment, The Codex Enterprise Deployment Playbook: 12 Prompts for Team Onboarding, Access Control, and Usage Governance is a practical companion. This playbook covers enterprise Codex deployment with prompts and practices for team onboarding, access control, usage governance, and governance-first rollout discipline.

Rollback and Version-Pinning Criteria

A rollback should be based on observed operational risk, not general discomfort with a new default. Roll back or hold at the previous approved version if unconfigured sessions select an unapproved model, if a previously approved workflow now sends unsupported parameters, if Bedrock users see picker entries that cannot be executed under documented account policy, if CI jobs produce materially different patches without an explicit model change request, or if async-clarification prompts mislead users about unavailable tools. Each criterion should be tied to a failing test case and an owner who can approve either remediation or rollback.

The recommended version-pinning policy is to maintain three channels: a frozen production version, a canary version that tracks the next Codex CLI release after smoke testing, and a developer preview version for non-production evaluation. Production images and CI runners should never install an unqualified latest package. Canary users should be selected from teams that can recognize model-selection differences, Bedrock route problems, and tool-availability prompts. Developer preview can be broader, but it must not write to production repositories, credentials, or deployment targets unless the same version has passed the canary gate.

Sample release-control record
Codex CLI version: 0.153.4
Effective model policy: explicit model required for CI; local default allowed only in approved sandboxes
Provider routes under test: direct OpenAI path; Bedrock Mantle global; Bedrock Runtime US
Release-note evidence: OpenAI Codex releases reviewed on the approval date
Canary duration: define internally based on deployment risk
Rollback package: previous internally approved Codex CLI version
Rollback owner: platform engineering change manager
Exit criteria: all required smoke tests pass and no unresolved high-severity support tickets remain

Do not encode a policy that says “0.153.4 equals Astra everywhere.” OpenAI’s model documentation and release notes should be read together with organization entitlement, route configuration, and local settings. Codex 0.153.4 can make Astra the bundled default when nothing is configured, but enterprise policy can still require explicit model selection, block unapproved providers, or pin older behavior until validation is complete. That is the difference between a product default and an operational authorization.

Release-Note Monitoring and Test Cases

Monitoring should watch the Codex release feed for four types of changes: default-model changes, model-picker changes, provider-route changes, and tool-guidance changes. A text correction should not trigger the same emergency procedure as a runtime routing change, but it should still be logged if it affects user documentation or support macros. Assign one owner to review the release feed daily during rapid release trains and weekly during stable periods, and require that any production-impacting release note be translated into a test case before fleet rollout.

Known limits should be documented in the rollout ticket. The 0.153.4 release does not convert limited model access into general availability, does not make picker visibility equivalent to successful execution, does not change the 0.153.2 Fast-tier runtime behavior, and does not authorize non-text asynchronous-question inputs. Teams using GPT-6 Astra through API-backed workflows should also verify model-specific constraints from OpenAI’s model documentation, including reasoning-level and sampling-parameter limitations, before assuming an older Codex configuration can be carried forward unchanged.

The final approval decision should be conservative: upgrade when the new default is intentional, explicit configuration is enforced where needed, Bedrock routes are separately validated, support can distinguish the four patch types, and rollback can be executed without rebuilding institutional knowledge during an incident. Hold the rollout when any of those conditions is missing. Codex CLI 0.153.4 is operationally important because defaults and route catalogs shape real usage, but production safety still comes from version control, evidence, and disciplined configuration.

Useful Links

• OpenAI Codex CLI releases on GitHub
• OpenAI Codex GitHub repository
• OpenAI GPT-6 Astra model documentation
• OpenAI product release notes
• Amazon Bedrock documentation