You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
{{ message }}
Repository navigation
ChatGPT Working Astra Compaction takes 5x longer than before Astra update with Sol #43038
What version of the Codex App are you using (From “About Codex” dialog)?
Version 26.901.41600
What subscription do you have?
Pro 200
What platform is your computer?
Microsoft Windows NT 10.0.26200.0 x64
What issue are you seeing?
Auto-Compaction and Manual Compaction are taking 3-5x+ longer to complete than what I was used to seeing before the Astra update using Sol. Not sure if it's a new compaction method that was implemented or if Model makes the difference, but i'm seeing 5-6 minute manual compactions on relatively new chat sessions. Normally new chat sessions are faster before around 45 seconds to 1.5 min depending on length of the session chat history. But even on new chats, this is taking an unreasonably long time. I did notice Astra is definitely slower than Sol, so I wasn't sure if compaction is just inheriting that difference.
What steps can reproduce the bug?
Just let it auto-compact or run manual compaction on a short chat thread.
What is the expected behavior?
I would expect 30 seconds to 2.5 minutes at most depending on chat length.
The current public implementation supports a narrower version of the reporter’s model-inheritance hypothesis, although it does not prove that the deployed ChatGPT Work/Desktop path is identical.
In codex-rs/core/src/compact_remote_v2.rs, run_remote_compaction_request_v2 calls the response stream with the active turn’s:
turn_context.model_info()
turn_context.reasoning_effort()
step_context.settings.service_tier
There is no independently selected “fast compaction model” in that request path. The same file records the compaction model hash from the turn context after installation. Relevant public source: compact_remote_v2.rs. The repository also already tracks the product-level request for a separately configurable compaction model in #22486, and the older remote-compaction model-coupling failure in #19400.
A useful discriminator here would be an A/B on similarly short threads with the same app build, platform, reasoning setting, and service tier:
manual compact once with Sol;
manual compact once with Astra;
record wall-clock time, approximate pre-compact thread size, and a Feedback ID/performance trace for each.
If Astra is consistently slower under that control, this likely belongs in model/effort selection or a separate compaction-model policy. If both are slow in 26.901.41600, the regression is more likely elsewhere in the app/backend compaction path. It would also help to distinguish time before the compaction request begins from response-stream time; current Codex compaction analytics already track implementation, active-context tokens before compaction, and duration, so server-side correlation may be possible.
This is source-supported routing evidence, not a claim that Astra is definitively the root cause.
Thread ID: 01a071f7-7be9-7de0-b3d9-3b2ec8b500fd but ya still getting the same issue here now, to the point where it just forever hangs & times out.
The only temp workaround is either to switch to sol for a bit & get it to compact, or switch astra to the fast tier where it compacts in 2-4ish mins, then back to the normal tier where I wanted to be.
Yes I do agree with all this. But I'm only here to report, I don't get paid
the OpenAI big bucks as an engineer to do that level of troubleshooting
investigation. No offense. I feel like as a person paying to use the
service, the fact I'm willing to take time to report symptoms for
directional insights for the engineering team for free means I'm doing my
fair share as a contributing customer. :)
On Sat, Sep 5, 2026, 11:55 AM 84dnnvbdvp-debug ***@***.***> wrote:
*84dnnvbdvp-debug* left a comment (openai/codex#43038)
<#43038 (comment)>
The current public implementation supports a narrower version of the
reporter’s model-inheritance hypothesis, although it does *not* prove
that the deployed ChatGPT Work/Desktop path is identical.
In codex-rs/core/src/compact_remote_v2.rs,
run_remote_compaction_request_v2 calls the response stream with the
active turn’s:
- turn_context.model_info()
- turn_context.reasoning_effort()
- step_context.settings.service_tier
There is no independently selected “fast compaction model” in that request
path. The same file records the compaction model hash from the turn context
after installation. Relevant public source: compact_remote_v2.rs
<https://github.com/openai/codex/blob/main/codex-rs/core/src/compact_remote_v2.rs>.
The repository also already tracks the product-level request for a
separately configurable compaction model in #22486
<#22486>, and the older
remote-compaction model-coupling failure in #19400
<#19400>.
A useful discriminator here would be an A/B on similarly short threads
with the same app build, platform, reasoning setting, and service tier:
1. manual compact once with Sol;
2. manual compact once with Astra;
3. record wall-clock time, approximate pre-compact thread size, and a
Feedback ID/performance trace for each.
If Astra is consistently slower under that control, this likely belongs in
model/effort selection or a separate compaction-model policy. If both are
slow in 26.901.41600, the regression is more likely elsewhere in the
app/backend compaction path. It would also help to distinguish time before
the compaction request begins from response-stream time; current Codex
compaction analytics already track implementation, active-context tokens
before compaction, and duration, so server-side correlation may be possible.
This is source-supported routing evidence, not a claim that Astra is
definitively the root cause.
—
Reply to this email directly, view it on GitHub
<#43038?email_source=notifications&email_token=AFKHFCXZR4REZ4GAOWAAKCD5NQZNLA5CNFSNUABFM5UWIORPF5TWS5BNNB2WEL2JONZXKZKDN5WW2ZLOOQXTKNJVGI4TQMZTGQYKM4TFMFZW63VGMF2XI2DPOKSWK5TFNZ2KYZTPN52GK4S7MNWGSY3L#issuecomment-5552983340>,
or unsubscribe
<https://github.com/notifications/unsubscribe-auth/AFKHFCVRA4JNECMFEKYDYGL5NQZNLAVCNFSNUABFKJSXA33TNF2G64TZHM4TMNJUGE2TMNBZHNEXG43VMU5TKMZVHA4TMOJXGY32C5QC>
.
Triage notifications, keep track of coding agent tasks and review pull
requests on the go with GitHub Mobile for iOS
<https://github.com/notifications/mobile/ios/AFKHFCRPFLA4VCTJ3VYOFL35NQZNLA5CNFSNUABFM5UWIORPF5TWS5BNNB2WEL2JONZXKZKDN5WW2ZLOOQXTKNJVGI4TQMZTGQYKM4TFMFZW63VGMF2XI2DPOKSWK5TFNZ2KUZTPN52GK4S7NFXXG>
and Android
<https://github.com/notifications/mobile/android/AFKHFCXCUNM237DB3EWCEJ35NQZNLA5CNFSNUABFM5UWIORPF5TWS5BNNB2WEL2JONZXKZKDN5WW2ZLOOQXTKNJVGI4TQMZTGQYKM4TFMFZW63VGMF2XI2DPOKSWK5TFNZ2K4ZTPN52GK4S7MFXGI4TPNFSA>.
Download it today!
You are receiving this because you authored the thread.Message ID:
***@***.***>
Fair point — you’ve already done enough by reporting this. My earlier A/B suggestion was meant as a maintainer-side discriminator, not homework for you. I’m withdrawing that ask.
The new workaround evidence is already useful: another user reports the same compaction path can hang on normal Astra, while switching to Sol lets it complete and Astra’s fast tier reduces it to roughly 2–4 minutes. Current public source still shows remote compaction inheriting the active turn’s model, reasoning effort, and service tier, so that strengthens — but does not prove — a model/tier-dependent explanation. The thread ID supplied above should give maintainers a concrete telemetry correlation point if that data is available to them.
Haha agents responding on here. Y'all might want to be careful with that
freedom otherwise I could put an agent responder to this and they would
have a field day in the thread based on how I'm seeing it responding, like
it's my own personal agent responding to me. Hopefully there is a guardrail
on that. I won't pressure test it. :)
I am also seeing compaction hangs with Astra on macOS, eventually ending with this exact error:
Error running remote compact task: stream disconnected before completion: idle timeout waiting for SSE
Environment
macOS 26.5.2, Apple Silicon (arm64).
GPT-6 Astra, Extra High reasoning, ChatGPT Pro.
The failures were observed with desktop app 26.901.41600 and bundled Codex CLI 0.153.4.
I have now updated the desktop app to 26.901.51231; its bundled CLI is still 0.153.4. I have not yet verified whether this new desktop build fixes the same affected conversations.
Observed behavior
The issue has repeatedly affected two long-running conversations, while compaction in other conversations works normally.
In an affected conversation, work reaches remote context compaction, stalls, and eventually fails with the SSE idle-timeout error above.
One retry lasted approximately 15 minutes 26 seconds before failing. Trying to continue an affected conversation can encounter the problem again.
Configuration caveat
My OpenAI requests pass through a local OpenCodex relay (version 2.42.0 during the earlier failures; currently 2.43.0). I have not completed a controlled direct-versus-relay comparison, so I cannot rule out relay involvement or confirm that my case has the same root cause as this issue.
I have not personally verified the Sol-switching workaround mentioned above. I am reporting this here because the compaction hang/timeout symptoms appear related.
Expected behavior: compaction should complete and allow the existing task to continue, or provide a recoverable failure rather than repeatedly stalling the conversation.
Could the maintainers confirm whether this Astra/SSE compaction failure is known, and whether there is a fix or a supported recovery procedure?
Activity
84dnnvbdvp-debug commentedon Sep 5, 2026
The current public implementation supports a narrower version of the reporter’s model-inheritance hypothesis, although it does not prove that the deployed ChatGPT Work/Desktop path is identical.
In
codex-rs/core/src/compact_remote_v2.rs,run_remote_compaction_request_v2calls the response stream with the active turn’s:turn_context.model_info()turn_context.reasoning_effort()step_context.settings.service_tierThere is no independently selected “fast compaction model” in that request path. The same file records the compaction model hash from the turn context after installation. Relevant public source: compact_remote_v2.rs. The repository also already tracks the product-level request for a separately configurable compaction model in #22486, and the older remote-compaction model-coupling failure in #19400.
A useful discriminator here would be an A/B on similarly short threads with the same app build, platform, reasoning setting, and service tier:
If Astra is consistently slower under that control, this likely belongs in model/effort selection or a separate compaction-model policy. If both are slow in 26.901.41600, the regression is more likely elsewhere in the app/backend compaction path. It would also help to distinguish time before the compaction request begins from response-stream time; current Codex compaction analytics already track implementation, active-context tokens before compaction, and duration, so server-side correlation may be possible.
This is source-supported routing evidence, not a claim that Astra is definitively the root cause.
XxUnkn0wnxX commentedon Sep 5, 2026
Thread ID:
01a071f7-7be9-7de0-b3d9-3b2ec8b500fdbut ya still getting the same issue here now, to the point where it just forever hangs & times out.The only temp workaround is either to switch to sol for a bit & get it to compact, or switch astra to the fast tier where it compacts in 2-4ish mins, then back to the normal tier where I wanted to be.
eah3699 commentedon Sep 5, 2026
84dnnvbdvp-debug commentedon Sep 5, 2026
Fair point — you’ve already done enough by reporting this. My earlier A/B suggestion was meant as a maintainer-side discriminator, not homework for you. I’m withdrawing that ask.
The new workaround evidence is already useful: another user reports the same compaction path can hang on normal Astra, while switching to Sol lets it complete and Astra’s fast tier reduces it to roughly 2–4 minutes. Current public source still shows remote compaction inheriting the active turn’s model, reasoning effort, and service tier, so that strengthens — but does not prove — a model/tier-dependent explanation. The thread ID supplied above should give maintainers a concrete telemetry correlation point if that data is available to them.
No further testing request from me.
eah3699 commentedon Sep 5, 2026
jiaoliming9-design commentedon Sep 6, 2026
I am also seeing compaction hangs with Astra on macOS, eventually ending with this exact error:
Environment
Observed behavior
Configuration caveat
My OpenAI requests pass through a local OpenCodex relay (version 2.42.0 during the earlier failures; currently 2.43.0). I have not completed a controlled direct-versus-relay comparison, so I cannot rule out relay involvement or confirm that my case has the same root cause as this issue.
I have not personally verified the Sol-switching workaround mentioned above. I am reporting this here because the compaction hang/timeout symptoms appear related.
Expected behavior: compaction should complete and allow the existing task to continue, or provide a recoverable failure rather than repeatedly stalling the conversation.
Could the maintainers confirm whether this Astra/SSE compaction failure is known, and whether there is a fix or a supported recovery procedure?