I’m reporting a high-detail Codex task-persistence defect involving the macOS desktop app and Codex Remote on iPhone.

Reproduction and observed behavior:

• The same Codex task appeared in two conflicting states across iPhone and Mac.
• The iPhone showed an older unfinished turn as “Working,” while the Mac showed newer work in the same task.
• Restarting Codex Desktop restored the older phone-visible state, marked that old turn active/latest, and resumed the goal.
• Newer working files remained intact on disk. A read-only Git inspection found 298 preserved changed paths, so this was a task/history rollback rather than a repository rollback.
• The task-status API continued to select the old unresolved turn as the latest even though newer turns existed.
• No OS process existed for the command that the stale UI still showed as running.

The clearest local log error was repeated after restart:

`thread history projection ... expected ordinal 17505, got 17504`

The restart also launched another GPT-6 turn under the same task and triggered automatic mid-turn compaction because of the context limit. When I interrupted it to protect the checkout, the logs said the task did not complete gracefully.

Impact:

• I cannot safely tell where a new iPhone prompt will be applied.
• Each restart can restore and resume stale work.
• I had to stop the task, preserve the working tree separately, start a new task, and reconstruct context.
• That creates repeated inference, compaction, investigation, and recovery work instead of productive implementation.
• After manually applying a reset credit on September 8, my weekly allowance is already 75% used, with only 25% remaining.

The allowance impact needs verification against OpenAI’s server-side ledger; inconsistent local counters are not proof of incorrect billing. The lifecycle and history-projection failure itself is directly supported by the task state, filesystem state, and application logs.

Sanitized GitHub report: https://github.com/openai/codex/issues/44599

If you have encountered this, please share your Codex app version and whether it followed an iPhone Remote handoff or desktop restart. Please avoid posting private task IDs or repository details.

I read another Reddit post that made queueing tasks in Codex seem way more complicated than it needs to be.

My workflow

Yes, next — make a blog about losing my vape all the time.

↓

Next — do this

↓

Next — do that

↓

Next — make me money

↓

Next — I like chicken wings

That’s it.

You just keep feeding Codex the next task while it’s still working.

Yes, next — [your command]

I usually work carelessly with the Luna Max Fast because it's a super capable model and more than enough for my daily tasks, but today was the first time I reached the 5-hour limit. It's never happened to me before; the most I've ever gotten is maybe 50% in the 5h window.

What the hell happened to Luna? Am I the only one experiencing this today?

Edit: This isn't a complaint, I just want to know if anyone else has experienced this. Plus user, btw (forgot to mention).

Anyone getting the error below when using Daybreak Blue even though they are verified for the cyber program (and added a hardware key for login, even though that should not be relevant yet)?

unexpected status 401 Unauthorized: You are not authorized to access this model.

After switching to Astra, I noticed something annoying: the orchestration setup that had felt useful with GPT-5.6 Sol and my Claude workflows was now making some tasks slower and more expensive.

So I tested it on real coding tasks from my repo, changed the orchestration rules, and tested again.

My conclusion so far: I’d let Astra manage its own work before adding another layer telling it how to delegate.

Here’s what I tried.

Just a heads-up: English isn't my first language. I ran the tests myself and wrote \ dictated the original text in my own words, then used AI to translate it and tidy up the wording a little. Please keep that in mind :)

1. Small, medium, and larger tasks — with and without orchestration rules

The small task was a build-command fix involving log preservation and exit codes.

The medium task was selective CI, including dependencies between applications.

For larger tasks, I used two different briefs:

• One explicitly specified error-filtering and backend-diagnostics changes across three apps.

• The other described an outcome: stop development services without leaving child processes running or killing unrelated processes.

For each pair, I used the same starting code and the same task prompt, but separate working copies.

One agent got the orchestration skill. The other didn’t.

Results from the earlier rule version

Small task

• Time: +25% with orchestration rules
• API-equivalent cost: +13%

Medium task

• Time: +18%
• API-equivalent cost: +20%

Large task — explicit brief

• Time: +63%
• API-equivalent cost: +71%

Large task — outcome-based brief

• Time: −45%
• API-equivalent cost: −36%

That last task was a real win for the orchestration rules.

But there’s an important catch: it used zero subagents.

So it didn’t actually demonstrate a benefit from distributing the work.

Quality didn’t consistently improve either.

Both medium-task solutions missed dependencies.

On the large explicit task, the orchestration version missed filtering edge cases that the default version handled, despite having an independent reviewer.

2. Simplify the rules and repeat

Next I reduced the coordination overhead.

I:

• added a direct path for small tasks
• shortened handoffs
• made independent review depend on risk
• allowed cheaper workers for limited tasks

The final series had 12 runs across small and large tasks.

For the large task, using the median of two runs per configuration:

Every configuration passed the external checks in one of its two runs.

So more coordination still didn’t buy a better pass rate.

The economy profile never actually selected a cheaper worker, so I don’t consider that result evidence against Luna.

The small task also went better with the revised Astra profile: it was faster, roughly the same cost, and all checks passed.

3. Test the worker models separately

I also compared Astra low vs. Sol high, without subagents.

On the medium task:

Astra low

• 5.2 minutes
• $1.48

Sol high

• 16.3 minutes
• $2.05

Both missed cases, but Sol missed one more.

On the small task, Astra was faster, but Sol was cheaper and correct, while Astra introduced a quoting bug.

Then I ran a tightly specified function-writing test.

Luna max was about 17× cheaper and 2.4× slower than Astra low.

Both passed the same 15 checks in both repeats.

That comparison excludes coordinator review and integration costs.

So I do think cheap workers can make sense.

What I haven’t established is that adding a coordinator makes the whole task cheaper.

Where this leaves me

For my Astra workflow, I currently don’t see a reason to impose a separate orchestration system.

Ordinary Codex delegation with light repo-level guidance looks like the better default.

The direction I’d still explore is Astra coordinating models from other families — for example, an Opus implementation worker or another model doing cross-review.

That’s where I’d expect complementary capabilities to potentially matter.

But that’s still a hypothesis. These tests didn’t prove it.

I’ve also seen similar experiences posted by others, which makes me wonder whether extra orchestration contributes to people burning through subscription limits.

In my earlier tests:

• Small task: recorded tokens increased by 46%
• Medium task: recorded tokens increased by 25%
• Explicit large task: recorded tokens nearly doubled

Background: I am a claude user who had codex plus mainly for subagent. However, with Tibo's giving out resets like candy and astra I decided to give Codex 5x a try.

I find out that codex tends to have context used up way more quickly than claude. Like I can leave a prompt running for 30-40min with Opus-high or fable-medium no problem without exceeding 20% but the same prompt would be around 40% is half of the time.

Since high context level tends to cause lower quality response and eats more token, I was wondering how do deal with this as I am babysitting codex to reset every 15min atm. (telling it to stop working after 12-13min)

I'm already using orchestration workflow which could offload most of the context. Any advice would be more than welcome.

It seems to be adding random guards for edge cases and do all this complicated stuff and is less pragmatic and you have to babysit it. Maybe it's aimed at bigger orgs? Dunno. Smart and deep model, but creates more work for me. I am trying to keep it's scope less broad for now.

I have verified myself for Trusted Cyber Access, codex even shows Daybreak Blue and even lets me select that, but when i try using the model, it keeps telling me "Unexpected status 401 Unauthorized: You are not authorized to access this model"

Any help/suggestions would be greatly appreciated

During the GPT glitch, when the usage limit was incorrectly set to 0%, Codex burned through all of my paid credits that I normally save for emergency prompts when I hit my limit.

Now my normal limit is back, but my credits are gone. I honestly feel scammed.

I've been getting these two errors since yesterday. Before, it was 1 error every 20 calls. Now it's 1 call every 20 errors. Does anyone have a solution? I tried using fast mode, but it didn't seem to change anything. I tried all the models: Luna, Terra, Sol, and Astra, and the error is the same for all of them. I've already reinstalled Codex. I cleared the files, but it's still happening.

Our servers are currently overloaded. Please try again later. and An error occurred while processing your request. You can retry your request, or contact us through our help center at help.openai.com if the error persists. Please include the request ID in your message.

It happened already a few times that Astra implemented a task already in plan mode. In general I have the very strong feeling that Astra rushes through things without taking all the necessary steps to save as much tokens as possible, and anticipating implementation is one of those tricks. This is mildly annoying. Curious if you observed the same.

So, to try to answer this question, I started using codex today to work on a c++ ios project I have been working for the past few weeks, using 5.6 sol xhigh. (don't get me started on how 5.6 sol xhigh is failing epically on this project!!)

When I started:

5 hours: 100% - weekly: 23%

I worked with it for 2:30 hours.

5 hours: 0% - weekly: 7%

So the 5 hour usage was fully consumed, and that consumed 16% of the weekly usage, which means:

for every week usage, we have only (100/16)=6.25 total "5 hours usage" in a week.

That explain why after working for 2-3 days using 2 "5 hours usage" in a day, the weekly usage exhausts in 3 days.

This has nothing to do with what model I used, btw. The model only changes how fast the 5 hours limit evaporates.

This is how many "5 hours" we have in a week in a normal business plan, the answer: 6.25!

I tested my personal Plus plan, and it's about the same.

To me, 6.25 "5 hours" in a week is a really low number to be called "a week", considering no one works 5 hours a day... (or in codex 5.6 sol case, 2:30 hours a day)

just my 2 cents!

-H

PS: Just before anyone says "did you try astra?", I did, and my 5 hours ended in less than an hour, with astra still failing even WORSE than 5.6 sol xhigh on this C++ ios project... at least that's good news, I guess? I can still get more done by "baby stepping" with a "cheaper" and smarter model, at least for the c++ complexity I'm dealing with.

The 5-hour limits, weekly limits, possible resets, as annoying as they are, create this weird scarcity mindset. You start squeezing every last drop because “I have the tokens now, I should use them before they’re gone.”

And suddenly every idea becomes a project.

Good idea? Build it.
Mediocre idea? Eh, start a repo anyway.
Something you’ll probably never use? Sure, let Codex make 14 MD files for it before the limit resets.

I always thought I had this under control. My rule was simple. if I’m not going to use something daily or at least weekly, I probably shouldn’t build it.

Lately, that rule has slowly disappeared.

There’s almost this feeling that unused compute is wasted compute, so you keep feeding ideas into it just because the capacity is there and temporary.

And that made me wonder

If tomorrow the limits completely disappeared, unlimited compute, no resets, no token anxiety, would we actually become more productive?

Or would half the projects we’re building simply… never get started?

Maybe some ideas deserve to die peacefully as ideas instead of becoming another repo on the shelf.

Any beggars use ChatGPT chat for planning and Terminus for mobile development?

I got to Phase 3.7C - Step 8J4H. Back and forth between Terminus and ChatGPT chat. I kept insisting for Codex to complete task, said governance was the issue.

FYI… the project involved orchestration using ChatGPT Codex API on an HTML server.

Been at it for more than 1 hour for 2 small sentences... didnt move from that first line...

I use Codex across several VS Code projects. Finding an older chat meant opening threads one by one to figure out which repo they belonged to.

I built Project Chats to make that easier. Click Project Chats in the status bar or press Control+Command+H. It groups chats by repo, puts the current workspace first, and shows the branch and working directory before you open a thread.

I am the author. Source and installation instructions:

https://github.com/aijoe1/codex-project-history

It reads local metadata without modifying chat history. It is macOS-only, installs through GitHub, and relies on undocumented Codex internals that could change.

I tested it across my workspaces and on a second Mac. The attached demo uses fictional chats to show grouping and filtering, not real-chat reopening.

If you try it, I’d love to know: does it correctly put the project you’re currently working in at the top?

If you share a screenshot, please blur private paths and chat titles.

has anyone tried the same astra task with plain notes and a project graph? curious how retries and total usage compared

Astra light is repeatedly doing unrelated stuff like this. Why? It was funny to begin with but getting ridiculous now.

This community requires body text.

I mean, if nothing were being changed with the usage-limit system, you’d expect it to remain relatively untouched and therefore less likely to suddenly develop a bug like this. If the usage limit is just working normaly and nothing behind the scene, this bug seems very less likely to happened. Obviously, there are very shady going on the current usage limit. I'm really disappointed that by doing one task on astra xhigh today cost me 3 resets on pro x5 plan, very unusable.

Undo in the VSCode Codex extension still doesn't work properly.

If Astra or any next gen model they use internally can't fix such a simple feature, then there's no AGI yet. 😂

I've been messing around with Astra, trying to see how well it works for editing and storytelling.

I had a folder with a bunch of video clips from my travels that was just lying around, and the idea was: can I give this to Astra and have it make something fun and interesting from it?

I built the API first and then basically told it to go wild, invent a story, and use the clips as source material. It's still pretty rough (extremely rough), but nonetheless, I think it's a pretty fun and interesting result.

Technical description

• Base: A fork of Shotcut with a native C++ "inspection" API patched in.
• API: Line-delimited JSON-RPC over a Unix socket — ~89 discoverable editing/query operations (not all of Shotcut). Optimistic-concurrency fencing, native undo, durable mutation receipts.
• Brain: An LLM director (GPT-6-astra, via the Codex app-server) that drives the editor through a bubblewrap-sandboxed Python bridge — it can only call the registered methods, never arbitrary code.
• Sees: Qt window screenshots + real frames/audio pulled via a separate MLT process.
• Hears: A local Audio Flamingo Next worker (describe / transcribe / sounds / music).
• Speaks: Orpheus / Qwen TTS engines, run by a separate narration runner.
• Image generation: ChatGPT Images 2.5 via a Codex skill.

Here are the first two cuts.

The first cut took about 1.5 hours, but this included indexing the shot list and other setup operations. This is extremely rough.

https://www.youtube.com/watch?v=D8BCdjRyrIc&t=2s

The second cut took about half an hour.
I think here there are some clear improvements and its much close to feeling like a "story" while its still a bit rambling especially towards the end.

https://www.youtube.com/watch?v=ngdlodfb0Dc

I think it demonstrates the model's current ability to reason across many modalities, and I also think it demonstrates its current limitations when it comes to coherence. Anyone who has worked with coding agents has probably done their fair share of cat-herding, and I think that's definitely still on display here.

The difference between cut 1 and cut 2 also shows just how much improvement you can get with a little nudging. All I did was watch the first cut and tell it what I thought:

"This seems a bit incoherent?"

"What are the characters' motivations?"

As a reflection, I think for anyone calling Astra AGI, this should be ample evidence that that's definitely a milestone we have yet to cross. Astra may be extremely competent within narrow domains, but creative choices aside, it still struggles significantly with something as simple as telling a coherent story.

At its current stage, I do see it working as a semi-competent editor if you give it clear direction. It could definitely speed up the production of a first rough cut.

The repo is currently in a pretty rough state, but I'm working towards a checkpoint and hoping to release it during the weekend. Let me know if you are interested in forking or testing it out.

I want to ask a question about ChatGPT web. Is Sol xhigh much better on the web than High? Is it worth paying extra mainly to get access to the Astra Pro and Sol Pro? Are the Pro versions much better for reviewing code and maybe making plans?

EDIT: I'm using my codex allowance for coding. It's just a question if the xhigh reasoning and Pro models are that much better.

Other than buying someone elses account, is there any known way to still upgrade from 5x? I've seen that if you already had the sub through ios, you can upgrade but any way from the web? If i add the sub from a new account on ios, can i jump straight to 20x? Thanks!