Repository navigation
Description
Before submitting
- I searched existing issues and did not find a duplicate.
- I included enough detail to reproduce or investigate the problem.
Area
apps/server
Steps to reproduce
- In a Codex thread, pick Speed Ultrafast and start a long
/goalrun, so Codex keeps starting its own goal continuation turns. - While the run is active, send a message with Speed set back to Default, so it is steered into the running turn (for example Send now on a queued message).
- Watch the native thread settings (
thread_settings_appliedin the Codex rollout, orthread/settings/updatedon the app server).
Expected behavior
Codex stops using the Fast or Ultrafast tier from its next turn: the next goal continuation, and any native subagent started after the change. If T3 cannot apply the change before a later point, the picker says the change is pending until Codex confirms it.
Actual behavior
T3 saves serviceTier: "default" at once and the picker shows Default. Codex never receives the change while the T3 run lives. The goal kept one T3 run alive for about 10 hours, and every native turn in it kept service_tier: ultrafast:
| Time (CET, 2026-11-11/12) | What happened |
|---|---|
| 23:52 | Ultrafast picked. T3 sends turn/start with serviceTier: "ultrafast"; Codex applies it. |
| 02:23 | Message sent with Speed Default via Send now (queued-message.promote-to-steer). T3 persists thread.model-selection-updated with serviceTier: "default". The native turn keeps running; there is no interrupt. |
| 05:19 | That native turn completes. Codex starts goal continuation turns, still ultrafast. |
| 05:59 | Two native subagents start. Their thread_settings_applied records service_tier: ultrafast (they inherit the parent's live settings). |
| 11:37 | The run fails because the account's weekly limit is used up. |
| 12:34 | The next T3 run sends serviceTier: "default" in turn/start. Codex applies Default one second later. |
After the 02:23 change, the native rollout of the parent records 3,489 requests and about 1.08 billion tokens under the applied ultrafast setting. Which tier the server actually ran and billed is not proven: Codex has no per-response tier receipt for a ChatGPT login (openai/codex#54952, openai/codex#30413). What is proven is that the setting Codex applied stayed ultrafast while T3 showed Default.
Cause
Links are pinned to c846833a6baa. The Codex adapter is unchanged on main at d8f3feff0c17.
- Codex plans every selection change as
apply_on_next_turn(CodexAdapterV2.ts#L1767-L1768). So the orchestrator steers the message into the running turn and persists the new selection right away (Orchestrator.ts#L5816-L5856). - The Codex
steerTurnsendsturn/steerwithexpectedTurnId,inputandthreadIdonly (CodexAdapterV2.ts#L7753-L7784). Codex'sTurnSteerParamshas no settings fields, and Add a turn-scoped service tier override openai/codex#40616 notes the tier override is ignored on a steer. Since fix(server): a model change sent with a Claude steer now applies to the running turn #34564 the orchestrator passes the selection with the steer effect (Orchestrator.ts#L5838,#L5878), but only the Claude adapter uses it. - T3 sends the tier only in
turn/start(CodexAdapterV2.ts#L802-L841), where Codex keeps it "for this turn and subsequent turns". - Goal continuations are turns Codex starts on its own, and they "reuse the last turn's settings" (
CodexAdapterV2.ts#L7359-L7362). T3 attaches them to the same T3 run. So for Codex, "next turn" means the next T3 run, which a goal can postpone for hours. - Nothing tells the user. The picker shows the new tier at once, and no run or contract field records the tier Codex applied. T3 reads
thread/settings/updatedonly for subagent threads (updateSubagentSelection).
Suggested fix
- When a steer carries a changed Codex selection, call Codex's
thread/settings/updatefor the native thread. It updates the next-turn settings without starting a turn (Add thread/settings/update app-server API openai/codex#23502, experimental; T3 already initializes withexperimentalApi: true). ItsserviceTierfield reads "Override the service tier for subsequent turns". This keeps the running turn and its native subagents alive, which is why the orchestrator does not restart today. I have not tested it. - Show the change as pending ("applies after the current Codex turn") until
thread/settings/updatedconfirms it for the root thread. - Keep restarting the turn as an explicit user choice only.
Whether thread/settings/update also changes requests inside the turn that is already running is open upstream (openai/codex#56581).
Impact
A user who turns Fast or Ultrafast off to save quota keeps paying the higher rate for as long as a goal runs, and native subagents spawned after the change start with the old tier. The picker says the opposite. In this case the account's weekly limit ran out before the change ever applied.
Version or commit
T3 Code desktop 0.1.9 (the code path is the same on main at d8f3feff0c17). Codex CLI 0.166.0.
Environment
macOS, desktop app, Codex provider instance logged in with ChatGPT.
Logs or stack traces
Evidence comes from the T3 state database (read-only: the thread.model-selection-updated events and run selections) and from the native Codex rollouts (thread_settings_applied).
Caution
- All native events of a shared Codex app-server session are written to the log file of the thread that opened the session.
makeCodexAppServerProtocolLoggeris created withinput.threadIdof the opening thread (CodexAdapterV2.ts#L1532-L1557,#L1653-L1657). This thread's own log file ends at 22:47. Its later events are in another thread's file. - That file rotates at 10 files of 10 MiB (
EventNdjsonLogger.ts#L30-L31). On a busy shared session, the oldest kept line was from 01:22, about 11 hours old. The 22:47 to 01:22 window, which includes the 23:52turn/startwithultrafast, is in no T3 log. The native rollout still records it. - The 05:59 subagents have events in that file, but no
thread/startedorthread/settings/updatednotice. So T3 never knew their tier.
Related
- Claude: a model change sent during a running turn is steered but never applied to that turn #34549 and fix(server): a model change sent with a Claude steer now applies to the running turn #34564 (merged 2026-11-11): the same bug for Claude, fixed for Claude only.
- [Bug]: Codex fast-mode/model change kills running turn (shared session cwd ≠ thread worktree) #34119 and its fix fix(server): Codex model changes no longer restart a shared session from another worktree #34129 (open): a Codex fast-mode or model change that restarts the running turn. That is the opposite symptom on the same path. With fix(server): Codex model changes no longer restart a shared session from another worktree #34129 merged, waiting becomes the only behavior, so this bug applies to every steer.
- Fast disabled during an active turn: UI and effective service tier may diverge openai/codex#56581 (open): "Fast disabled during an active turn: UI and effective service tier may diverge". This is the Codex Desktop version of this report.
- /goal continuation can reuse stale permission context after Full Access/custom permissions openai/codex#29693 (open):
/goalcontinuations reuse stale thread settings (permissions). - Add thread/settings/update app-server API openai/codex#23502 (
thread/settings/update) and Add a turn-scoped service tier override openai/codex#40616 (no tier override on steer).
Workaround
Stop the run, then send the next message with the new speed. That starts a new T3 run, and its turn/start carries the tier.
Note
Written with Claude Opus 5.5 on behalf of Martin.
Activity
test(server): a Codex steer that changes the service tier reaches Codex
juliusmarminge commentedon Nov 12, 2026
I tried to reproduce this on the current build and could not.
On origin/main f70e349 I added an adapter replay test to apps/server/src/orchestration-v2/Adapters/CodexAdapterV2.test.ts ('a steer that changes the service tier updates Codex's next-turn settings'). It starts a Codex turn with modelSelection serviceTier 'ultrafast' (turn/start carries serviceTier: 'ultrafast' and matches), then calls runtime.steerTurn with modelSelection serviceTier 'default' while the turn is active. The transcript expects thread/settings/update {threadId, serviceTier: 'default'} before turn/steer. On main the test fails with CodexAppServerReplayFrameMismatchError: the adapter sends turn/steer {expectedTurnId, input, threadId} right away and never sends the tier change. A throwaway fix that sends thread/settings/update (reverted, not committed) showed that the bundled effect-codex-app-server client does not define that request ('Method thread/settings/update does not accept a payload'), so the fix also needs that package regenerated from a newer Codex schema. I did not run a live Codex goal run, because Codex with ChatGPT OAuth is not available on the VMs.
Closing as not planned. If it still happens for you, reply with the exact steps and the version you are on and it will be looked at again.
genesiscz commentedon Nov 17, 2026
Note
Written with Claude Fable 5.2 on behalf of Martin.
@juliusmarminge The test you added does reproduce this. It fails on
mainbecause the adapter sendsturn/steerand never sends the tier, which is the bug in this report. So "could not reproduce" and "not planned" do not match the result in your own comment. Could you reopen it?It still happens on T3 Code 0.1.10 (release, macOS, Codex CLI 0.166.0, ChatGPT login). The same steer code is in
v0.1.11-nightly.20261117.4825and onmainat 758291c.Exact steps
/goal Do exactly 6 steps, strictly one step per turn. In each step run the shell command "sleep 40" once, then reply "step N done" and end the turn.thread_settings_applied), or T3's provider log.Result on 0.1.10 (UTC, 2026-11-17, from T3's provider log):
The Codex rollout agrees:
thread_settings_appliedispriorityat 13:15:08 and changes todefaultonly at 13:17:52. All 7 goal turns ran with Fast applied while the picker showed Standard. In the original report the goal ran for about 10 hours, so the change never applied before the weekly limit ran out.Fix: #38130. Its first commit is your test, rebased. The second sends
thread/settings/updatebeforeturn/steerand adds that request to the generated client. The same goal run on that branch:The 5 goal turns after it ran with the default tier applied.
genesiscz commentedon Nov 17, 2026
Note
Written with Claude Fable 5.2 on behalf of Martin.
@juliusmarminge Thank you for merging #38130 so fast, Martin says thanks too.
One more path of this report is still open, and it has its own PR: #38169. With #38130, the new speed reaches Codex when a message is steered into the running turn. A pick in the composer with no message still waits for the next T3 run, because the Codex adapter has no
applyModelSelection. #38169 adds it with the samethread/settings/updaterequest, a failing test first, and a live run (ChatGPT login, Fast to Standard, picker only). It is separate because that behavior is your call.The review findings of #38130 and what was done with each are listed in #38130 (comment).