What changed
OpenAI released Codex 0.149.0 on August 20 with the three repository changes behind asynchronous user messaging: PR #39319 adds `send_user_message_async`, PR #39312 adds machine-readable async delivery metadata, and PR #39452 removes the local feature gate. That changes the release status materially from BTN's August 20 dossier: the implementation is no longer only merged on main while stable 0.148.0 predates it. A stable Codex client now contains the non-terminal messaging path. The tool can send a concise user-visible acknowledgment, update or question, return an accepted result immediately, and allow the same model turn to continue. Tool registration still depends on whether the selected model advertises support.
Why it matters
The stable release removes one rollout uncertainty for coding-agent workflows that want humans and agents to work in parallel. A Codex integration can now target a released client that understands non-terminal user messaging instead of depending on an unreleased main-branch implementation. The harder workflow problem is unchanged: a developer's answer can arrive after the agent has already advanced, so builders still need to distinguish late-answer-safe questions from decisions that must stop execution. Stable client support also does not establish universal availability because the selected model must advertise the capability before the tool is registered.
The stable client now contains the async-message path
Codex 0.149.0's changelog contains the implementation series BTN previously tracked only on main. PR #39319 adds `send_user_message_async`; PR #39312 adds `delivery: "async"` metadata through the event and app-server paths; and PR #39452 removes the local feature gate. That means builders no longer need to equate this capability with unreleased repository state: the relevant client code is in a stable Codex release.
A message still does not have to end the turn
The root-agent tool sends a user-visible acknowledgment, update or question and returns an accepted result immediately, allowing the same model turn to continue. OpenAI's integration test verifies that the agent can emit the async message and later continue to a subsequent response in the same turn. This creates a distinct interaction primitive from a blocking request for input.
Codex keeps the outbound message out of model input context
The implementation deliberately does not inject the user-visible async update back into the model's input as a synthetic assistant message. Codex records and surfaces the event for the user while the model continues from its existing turn context. A developer reply, if one arrives, enters later as a new user message.
The protocol distinguishes non-terminal delivery
Companion protocol changes preserve optional async delivery metadata through Codex history, replay, schemas and app-server items. Integrations therefore have a machine-readable signal that a user-visible agent message is non-terminal instead of having to infer turn completion from the appearance of text.
Stable shipping does not remove the late-reply problem
The productivity upside is clearest when the agent can continue independent work while a developer answers a side question. A reply to an architectural, destructive or otherwise consequential question may instead arrive after the agent has already acted on an assumption. Teams therefore need an explicit policy for which questions may be asynchronous and which decisions must create a blocking boundary.
Model capability remains the final exposure gate
Removing the local feature flag simplified the client-side rollout path, but Codex still registers `send_user_message_async` only when the selected model advertises support. BTN has confirmed the client implementation is now stable, but has not found an official statement establishing that every currently served Codex model or surface exposes the capability. Stable client support should therefore be treated separately from universal model availability.