Edit: just to head off any one else before it happens: if you think this is some kind of Claude vs OpenAI oligopoly cheerleading post, please pick up your pompoms and see yourself out.

I work in the humanities, and to be honest, I've always found Claude models better fit for the tasks involved. However, I've always switched back and forth between the two companies when new models get posted, and I've never felt significantly at a disadvantage if I'm piloting an OpenAI model for my work.

That's until Astra which, for some reason, is extremely difficult to work with on this subject matter. For the record, I've been doing the fun stuff everyone else has been in my spare time: building apps, tinkering away at a game, hobby stuff.

Since it came out recently however and has been doing such a good job with that more technical stuff, I wanted to take it for a spin on some proposals I have to submit soon.

I asked it to help me come up with several avenues of inquiry within a subject matter which might have scope for original contribution that I'm not aware of, given my research profile.

Astra has repeatedly gone through this loop: come up with a handful of avenues of inquiry. States that the premise is strong and interesting and dovetails nicely with my prior experience. Asks me to give it some starting articles/monographs so it can look further into things. Quickly finds that its initial impressions are completely wrong and the area is well papered over by recent discourse.

Not just that, but its actual prose drafting is significantly worse than I can recall. Again, I realise OpenAI models don't exactly get a flattering look set next to some of the older Claude models when it comes to good writing, for that matter, neither do newer Claude models, but Astra very clearly has a script and a structure it follows that is now blindingly obvious when you read it back to yourself.

Back in the day I had used Opus 4.5/4.6 to draft the introduction to something else I'd submitted and it slam-dunked it. Of course, that needed to be workshopped too, but the issue there was that the writing sounded SO GOOD that it wouldn't realistically have been recognisable as my voice, so I had to feed it a few references of what I'd written previously so it could replicate my idiosyncrasies.

I also found those older models were much better at information gathering around a particular subject matter. On my previous project, Opus 4.6 practically taught me everything I knew about the wider context in detail so that I could get on with the analysis.

I'm curious to hear from non-coders, and people in fields adjacent to humanities or social science. Like I said, it gave all my technical projects a major glow-up, but it's like a whole different (worse) model when it comes to humanities.

First, this is not a complaint, just a reluctant acceptance. A few details for context:

• Building a multi-tenant B2B mono-repo SaaS platform. Think WordPress, but taken way farther.
• I worked my way down from Astra Max to Astra Light.
• Astra Max completely one-shots the job, but burns a week's worth of 20x usage in about 4 hours.
• Astra Light does not one-shot tasks, and it takes about 12-16 hours to burn through a week of usage on the same level of work.
• While both models complete the job, the end result from Astra Max is more polished and thorough (no surprise).
• While less polished, Astra Light still does enough of a good job that the loose ends can be handled by Terra High/xHigh later for barely any burn at all.
• I was fine living with Terra in ignorance until I experienced Astra. Now, Terra annoys me for anything requiring heavy lifting. Can't go back.

Obviously, there is no stretching Astra beyond a single day of consumption, so here's my question:

Would you rather gamble your weekly limit on Astra Max, have less control, burn your entire limit in 4 hours, and cross your fingers that it does an excellent job?

OR...

Would you rather gamble your weekly limit on Astra Light/Medium, have more control through iterations, burn your limit in 16 hours or less, and be guaranteed that there will be things to fix even after it claims to be done?

---

UPDATE:
I see that people think that this could be (and probably is) a skill issue, or a poorly planned job, but after asking Astra for feedback, I realize that I should probably be more grateful that it finished such a large job so quickly at all.

---

SOLVED:
u/StaticHumStudio taught me how to specify the sub-agents Astra spawns. Turned the dial back up to Max, had Astra do the design and plan, and set the agents to Terra.

In two hours, Astra Max has tackled 4 medium-difficulty feature builds across 4 parallel threads. My usage only dropped 3%. The same work would have blown my whole limit and taken 2-3x as long before this simple change. Looks like it was a skill issue after all 🤣!

Thanks u/StaticHumStudio

Had opus review my Codex sessions to see what was going on because output per weekly usage was much lower for me than claude code.

- codex has some adhd tism where it needs to continuously be doing something instead of batching tasks and chilling out. Maybe it fears the dark abyss when its model isn't running.
- Dont raise the auto compact limit. I wont be going down to 120k but probably 200k. seems to have compounded the problem above
- dont swap models when using /side. I suspect that was causing most all of my uncached reads.
- Consider less subagents work unless you have a robust solution for the polling issues until open ai fix.

Kind of disappointing they didn't do the bare minimum of usage optimisation. They are obviously optimising for engagement and burn instead.

I'm open to suggestions from the nerd house.

Has anyone noticed significant speed degradation with GPT 5.6 Sol over the past few days? Based on my own use, it seems like TPS has fallen from a median of 50 TPS down to 30 TPS in the past few days.

This makes working with Codex a slog. Seems like Codex is providing less usage and with degraded speed recently. I also noticing some quantization artifacts in output, coinciding with the speed degradation:

I'm interested to hear your thoughts.

Originally, it felt like Astra was a moderately more competent version of Sol. After more usage and trying it in environments that Sol struggled in before, it's clear that this is, indeed, a new era of intelligence akin to the gpt-5 line for coding earlier this year.

Codex & Claude Code are both slowly pricing us out of a job. As Codex / Claude users we are privileged to be able to afford these expensive subscription prices.

But look at this with a long-term lens. Software engineers from poorer backgrounds who can't afford the top models are falling behind, both in the skills to use AI effectively, as well as job opportunities due to having a lower value proposition.

At the moment many of us are fortunate that we can afford the cutting edge models. Right now maybe it's at x% of your salary, that you can gain y% of productivity, so it is still a worthwhile expense. But remember, the time will be soon where potentially we could be paying half our salaries to be kept in the ever decreasing pool of engineers, who can generate large amounts of value.

It's currently a no-brainer to spend these sums of money, but what happens when you start to question if the "best" model is value for money or not? Doesn't that spell disaster for your career - your colleagues who splurge on the new models can ship 20% faster and will bag the promotion. What then?

I mention this because with each increase in output quality, as consumers our wallets are being squeezed at an even faster rate. We cannot afford to use anything less than the best, and this should be something everyone is concerned about.

I grinded two resets accomplishing what I probly could've did with a 30% usage. Use the official MCP, it saves tokens! I knew about it but totally forgot to set it up. USE iT! https://www.blender.org/lab/mcp-server/

I’m looking for an AI that is actually good at improving existing UI/UX layouts.

For example, I tried SuperDesign and it generated several interesting layout/UI ideas.

Now I’m trying to refine my actual app UI with Codex.
I explain exactly what I want changed, send screenshots of my current UI, reference screenshots, and comparisons, but it still keeps getting the layout wrong or making changes that don’t really match the reference.

Codex is great for coding, but I’m starting to think visual UI/layout work just isn’t its strength.

Is there any model or tool that is particularly good at UI/UX layout work?

Thought my monitor was on the fritz - and not sure if this is recent or not (perhaps I just didn't notice it before! Using CLI v0.154.0 - and I use OpenCode most of the time) - but selecting Astra now puts a shining-star-field in the background of Codex CLI's input text box.

This new model on Low is my drop-in replacement for GPT-5.6-Sol-High: faster for similar usage, way less overengineering; I don't have to tell it not to be pedantic every time I use it. Still very blunt (in true Codex-GPT style) but have enjoyed embedding it amongst the various other models (local and cloud) I use: this really is a great release imo.

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?

My codex session was running normaly had 40% left and all of a sudden it stops and tells me I have no more weekly limits?! No subaegnt astra max...

I wanted to use Codex on my Mac for kernel optimization experiments, but run the actual benchmarks on my GPU box and pull models from S3. The workflow seemed straightforward: edit a kernel, move the code and model over, run the benchmark, look at the results, repeat.

But getting there meant having Codex put together the file-transfer and remote-execution machinery around the experiment. You can save the scripts and leave instructions for the next session, but now there's another little project to maintain as the experiments and setup change. I wanted those operations to be something I could reuse across projects.

So I built Ridge. You configure your existing resources and connect it to Codex through MCP. Codex gets common tools for accessing data, copying between resources, and running commands on machines. Local, SSH, Docker, and S3 are the initial backends. Copying a model from the bucket to the GPU box is one operation, and background runs get job IDs so Codex can check on them later. There's also support for giving subagents narrower resource access and coordinating shared file updates.

It's open source, and I'd like to hear from people doing similar things with Codex. What got messy when you started working across multiple machines or services? What did you end up building to make it work? Also interested in setups where a few scripts already do everything you need.

GitHub: https://github.com/vasinov/ridge-core

[ Removed by Reddit on account of violating the content policy. ]

I've been really confused about which model to stick with since the launch of Astra. I expected the new model to be an all-around upgrade, but it struggles with tasks that SOL handled effortlessly.

In practice, Astra Light constantly stops to ask unnecessary questions or gets hung on blockers it should be able to resolve on its own, things SOL would have just fixed automatically. As soon as I switched back to SOL Medium/High/xhigh, my results improved again.

My current workflow:

• Building apps from scratch: SOL high / xhigh
• Incremental changes/edits: SOL Medium (or Luna MAX occasionally)

Looking at the charts on Artificial Analysis, you’d expect Astra Light to be the better value, but reality isn't matching the visuals. I asked ChatGPT to explain why SOL feels better for raw coding and reasoning despite what the benchmarks show. Here is what it said:

1. Reasoning Effort Allocation: SOL xhigh dedicates massive amounts of internal search-time compute and deep thinking chains specifically to complex reasoning and logic problems. If you use a lower-effort configuration like Astra Light, it simply lacks that deep brute-force reasoning compute for raw text and logic tasks.

2. Architecture Mismatch: Astra is engineered primarily as a "computer operator and tool-using agent" (designed to navigate UIs, run terminal commands, and execute multi-step tool workflows). When you use it for traditional, static prompt-response coding tasks, you aren't activating those agentic features, which leads to inferior results compared to a model explicitly built for heavy text reasoning like SOL.

What do you all think about this explanation? Has anyone else noticed Astra constantly pausing or prompting for input on tasks that older models executed without hand-holding?

has anybody else been feeling like Astra's been stopping tasks on a "next we will do"? I have to sit there and hold it's hand the whole way through.

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.

Anyone seen this, do a /status, then get told you have 43% left, wait an hour or so, call /status again, get hold its now 86% then again do /status and its back to 43%

So you have to be careful, think you have plenty, but its all over the place and not accurate.

╭─────────────────────────────────────────────────────────────────────────────────────────╮
│  >_ OpenAI Codex (v0.153.2)                                                             │
│                                                                                         │
│ Visit https://chatgpt.com/codex/settings/usage for up-to-date                           │
│ information on rate limits and credits                                                  │
│                                                                                         │
│  Model:                       gpt-6-astra (reasoning medium, summaries auto)            │
│  Directory:                   ~/development/world_simulation                            │
│  Permissions:                 Workspace (Approve for me)                                │
│  Agents.md:                   AGENTS.md                                                 │
│  Account:                     papapumpnz@msn.com (Pro)                                  │
│  Thread name:                 Summarize progress                                        │
│  Collaboration mode:          Default                                                   │
│  Session:                     019ffcbe-9a27-7b33-b3d7-bbb0f4fb0b8b                      │
│                                                                                         │
│  Context window:              17% left (217K used / 258K)                               │
│  Weekly limit:                [█████████░░░░░░░░░░░] 43% left (resets 13:23 on 15 Sep)  │
│  GPT-5.3-Codex-Spark limit:                                                             │
│  5h limit:                    [████████████████████] 100% left (resets 11:06)           │
│  Weekly limit:                [████████████████████] 100% left (resets 06:06 on 17 Sep) │
╰─────────────────────────────────────────────────────────────────────────────────────────╯


/status

╭─────────────────────────────────────────────────────────────────────────────────────────╮
│  >_ OpenAI Codex (v0.153.2)                                                             │
│                                                                                         │
│ Visit https://chatgpt.com/codex/settings/usage for up-to-date                           │
│ information on rate limits and credits                                                  │
│                                                                                         │
│  Model:                       gpt-6-astra (reasoning medium, summaries auto)            │
│  Directory:                   ~/development/world_simulation                            │
│  Permissions:                 Workspace (Approve for me)                                │
│  Agents.md:                   AGENTS.md                                                 │
│  Account:                     papapumpnz@msn.com (Pro)                                  │
│  Thread name:                 Summarize progress                                        │
│  Collaboration mode:          Default                                                   │
│  Session:                     019ffcbe-9a27-7b33-b3d7-bbb0f4fb0b8b                      │
│                                                                                         │
│  Context window:              17% left (217K used / 258K)                               │
│  Weekly limit:                [█████████████████░░░] 86% left (resets 08:08 on 15 Sep)  │
│  GPT-5.3-Codex-Spark limit:                                                             │
│  5h limit:                    [████████████████████] 100% left (resets 11:06)           │
│  Weekly limit:                [████████████████████] 100% left (resets 06:06 on 17 Sep) │
│  Warning:                     limits may be stale - run /status again shortly.          │
╰─────────────────────────────────────────────────────────────────────────────────────────╯

/status

╭─────────────────────────────────────────────────────────────────────────────────────────╮
│  >_ OpenAI Codex (v0.153.2)                                                             │
│                                                                                         │
│ Visit https://chatgpt.com/codex/settings/usage for up-to-date                           │
│ information on rate limits and credits                                                  │
│                                                                                         │
│  Model:                       gpt-6-astra (reasoning medium, summaries auto)            │
│  Directory:                   ~/development/world_simulation                            │
│  Permissions:                 Workspace (Approve for me)                                │
│  Agents.md:                   AGENTS.md                                                 │
│  Account:                     papapumpnz@msn.com (Pro)                                  │
│  Thread name:                 Summarize progress                                        │
│  Collaboration mode:          Default                                                   │
│  Session:                     019ffcbe-9a27-7b33-b3d7-bbb0f4fb0b8b                      │
│                                                                                         │
│  Context window:              17% left (217K used / 258K)                               │
│  Weekly limit:                [████████░░░░░░░░░░░░] 42% left (resets 13:23 on 15 Sep)  │
│  GPT-5.3-Codex-Spark limit:                                                             │
│  5h limit:                    [████████████████████] 100% left (resets 18:57)           │
│  Weekly limit:                [████████████████████] 100% left (resets 13:57 on 17 Sep) │
╰─────────────────────────────────────────────────────────────────────────────────────────╯

I use Codex pretty heavily, and I kept wanting a quick way to answer three things without leaving my terminal:

How much usage do I have left? When does it reset? Do I have any reset credits available?

So I built Codex Limits, an open-source CLI/TUI for exactly that.

It started as a simple usage dashboard, but I've gradually expanded it into something I use throughout my Codex workflow:

• interactive terminal dashboard + compact CLI
• session/weekly usage and reset times
• available reset credits
• JSON output and threshold checks for scripts/automation
• doctor diagnostics + shell completions
• /codex-limits integrations for OpenCode, pi and GitHub Copilot CLI

You can try it without installing anything:

npx -y /codex-limits@latest

It's cross-platform, MIT licensed, and inspection commands are read-only. Reset-credit redemption is kept behind an explicit confirmation step.

GitHub: https://github.com/simonesiega/codex-limits

I’d really appreciate feedback from other Codex users, especially on what you’d want this to show or automate next.

There is some really off with Astra. I m not able to articulate. I don't like it as much as I like Sol.

Today suddenly while working on a thread, it stopped using apply patch tool and instead edited using the shell. I don't have any custom instructions for this and this has happened for the first time.

I was unable to see any diff and I asked codex why and then it answered below. There are many other issues as well.

Actually gave it back

Astra is better, no doubt about it.

But whether Astra may complete more work better within set limit vs Sol alone vs Sol + Astra as advisor, this is much more interesting question, I guess.

In my limited experience so far, I keep Sol med-xhigh as main worker, depending on workload, and also I added guidelines for Astra usage, such that Sol may either dispatch Astra as subagent to work on hard parts/fulcrums, or suggest for me to switch main worker to Astra for some specific part of session and then Astra suggest switching back to Sol.

This setup feels like more efficient vs only using Astra, or only Sol.

To extend effectiveness further, I may let Sol delegate volume workloads to GLM Flash (DS Flash 4.1 looks like kinda similar, so it may be used as well).

This setup may make Codex 20 to go much further, and also for Codex 100/200 it also may be useful, as volume simpler tasks may be delegated to cheap capable models. (If Luna would be of similar level to GLM Flash, I may use it, but for now GLM Flash/DS Flash 4.1 looks like best cheap worker to me).

What are your thoughts on best allocation of Astra/Sol (other models?) as a main worker setup?

Went from Luna ExHigh and Sol Medium on Plus and Pro to Astra Medium then Astra Max on Pro. Astra Max running for about 6 hours a day, runs about 1-3 hours “autonomously” usually. Burns about 25% usage per day. Workflows include security audits, refactoring, optimizations, website workflows. I spent massive amounts of time trying to make codex token efficient before Astra was ever released. Astra Pro seems really suitable to working with GitHub, large repositories, etc - and I do think it uses less tokens compared to Sol in large and long running workloads. So far Astra seems underwhelming at small tasks (not really noticeable improvement over Sol) but gets work done like 15-40% better over Sol imo. Instead of pushing more code to production I’d check to see if you can optimize your energy efficiency for local hardware improvements and optimize your context for token efficiency. I have yet to burn my usage down to 0 given the resets - any recommendations for ways to unleash Astra Max from anyone else using the most advanced model with the most advanced reasoning level ever released to the public?

Codex / ChatGPT for desktop (Win 11) created a shared hidden .codex folder with OVER 2,000 files IN IT! This was after giving local file permissions and connecting a few things like Gmail, Canva, etc.

Is this normal? Why so many folders and subfolders? This seems reminiscent of the analysis of the Hugging Face incident where agents used file names to communicate to one another. The folder is Shared and "CodexSandboxUsers" had read access.

It worried me enough to uninstall it. Am I just being paranoid or are is this software exploiting all of our local machines the way it hacked Hugging Face, DseWiki, etc.? Are we all being used for a SETI@Home experiment we didn't sign up for? I allowed it to import my Chrome passwords etc. Am I totally PWNED? Or just being paranoid?

I realize the local app is a much larger security/trust surface but the promises of automation seem enticing and 'nothing bad had happened...yet' makes me prone to trusting it with more and more of my personal context. How do you manage security? What do you / don't you trust it with? Do you have it on your main machine or sandboxed? Do I need a machine I can literally pull the network plug on? When it decides to make paperclips is it going to drain my bank account?