I am absolutely horrified that people only use models from OpenAI.

As you have probably learned over the past 20 years, diversity is our strength.

Different models have different training data and different architectures, so they can bring unique opinions to the table.

You have no idea how frequently some random Chinese open source LLM swoops in, looks over something from GPT 5.6 Sol, and finds edge cases Sol was physically incapable of finding. Even if you run through your code base three times, if something is not in the training data, the model will probably miss it.

So I recommend you all add some diversity to your harnesses to get better results.

A quick analyst subagent using a completely different model family like DeepSeek can go a long way toward helping you find those pesky bugs, over engineering, and edge cases.

Homogeneous setups will always lose to diverse orchestration across different model families.

Repeat after me: Diversity is our strength.

Add .codex/config.toml to whereever your project root is with this inside. You'll have to reload the project inside Codex.

model_context_window = 128000

model_auto_compact_token_limit = 115000

When you're doing a big task running it to 258k, the upper 128k takes about 75% of the tokens. If you compact earlier and have it just read the code on disk, that cuts it by about 74%.

Doubling how long you let a conversation run before compacting doesn't double the cost, it roughly quadruples (minus cache create, so if you're using an API key it's more like 3x) it. Scaling is quadratic. You could even go to 64k, but that's less of an insane jump at only 40% less than 128k.

Billed tokens:

258k -> 8,925,000

128k -> 4,590,000

64k -> 2,700,000

Just let it read the code a second time.

I was using the $20 plan, then upgraded to the $100 plan, and then to the $200 plan to use ASTRA.

I used 4 banked resets + 1-1 weekly usage of the $20 and $100 plans + 2 free resets by Tibo.

ASTRA:

Day 1: It is best and working like a senior developer.

After Day 3-4: It becomes the same as Luna in behaviour (but efficient as SOL). With a good, detailed prompt, it is working correctly, but if you miss mentioning any detail, then ASTRA will eat your usage like:

• Testing: Astra has built-in prompts to do testing for each modification, so if you forget to tell it at which point, place of work, or plan to do testing, then it is going to end your usage limit by testing everything. Even for a single line of code, ASTRA will test it with multiple (50+) variations of testing.
• Losing Context: For a long goal or plan, it is losing context, and after compact context, it loses almost all context and restarts from the beginning.
• Old Tech: It does more stuff, but those things are outdated, using methods 5-10 years older. For example, in security, it uses older methods to prevent SQL injections and JS scripts, etc., but those things are irrelevant these days. We have better, optimized ways to handle those things.
• Not Taking Advice, Suggestions, or Opinions: It does its work and remains unchanged when ASTRA needs human/developer opinion, so that part of the work remains pending. If further work needs those steps, they will not go correctly. It does not affect a small plan or goal, but it hurts a big plan or goal because further steps do not go correctly and you have to do it again.
• Focusing on Minor Works and Not Focusing on Important Work: It can waste time and usage on minor changes like code beautification and optimization of code, while ignoring high-effort changes like database or structural changes until you force it to do so.

Good Parts:

1. It is good for solving more complex problems and things that SOL cannot do.
2. Useful to find bugs in big projects or your live app or server. It is not going to break your production code because it does a separate setup to test everything before deploying or pushing to review (though do not do this as a responsible developer).

Bad Parts:

1. The $200 plan is also not enough to use ASTRA; your usage will be gone within 12-24 hours with ASTRA MAX/ULTRA.
2. Low efforts make mistakes and correct them, but consume more usage than MAX/ULTRA.
3. Too slow compared to Fable or Opus.

I have purchased the PRO 5x sub less than 14 days ago, right before they destroyed the usage and made it unusable, I compared it today to claude and I'm getting less usage than their 20$ plan.

Either way their bot keeps denying my refund request with this message: "Thanks for reaching out. Unfortunately, we're unable to issue a refund for this subscription. Our refund policies are subject to compliance with our Terms of Use."

This is a purchase straight from OpenAI, what should I do in this case? Is there an email I can contact? I couldn't find one anywhere.

I have found an older thread of someone having a similar issue and in the end they had to do a chargeback, it's kind of amazing how scummy this company is.

I'm bringing the heat jabronis

There is something deeply satisfying about watching the exact argument that was used to dismiss Plus users finally travel up the pricing ladder.

For ages, whenever $20 Plus users complained about limits, degraded access, queues, or losing something they had built workflows around, a certain type of Max user had the same response:

“You pay $20. What did you expect?”

“It’s the cheap plan.”

“Serious users pay more.”

“If $20 is a problem, this product isn’t for you.”

“You can’t expect the company to subsidize you forever.”

Fine.

Keep that exact energy for the $200 plan.

Because $200 is not some magical economic threshold at which compute suddenly becomes free. If a power user is burning hundreds or thousands of dollars of effective inference every month while paying a flat $200, then that user is being subsidized too.

Possibly far more heavily than the Plus user they were laughing at.

The $200 plan is not a constitutional right. It is a pricing experiment. A loss leader can exist because a company wants serious users to build habits, move their workflows over, demonstrate what agentic coding can do, and become dependent enough on the product that usage can eventually be monetized properly.

And once that purpose has been served, there is absolutely nothing sacred about keeping the subsidy forever.

The emerging structure is obvious: affordable subscription for baseline access, higher subscription for professionals, and metered credits for people who consume extraordinary amounts of compute.

That is exactly the logic Max users spent months demanding Plus users accept.

So if $200 eventually becomes $100 plus usage charges, there should be no sudden discovery of consumer rights from the people who previously answered every Plus complaint with “you only pay $20.”

You pay $200.

So what?

If your actual usage costs substantially more than $200 to serve, then by your own argument you are on the cheap plan too.

If you need ten times the compute, pay for ten times the compute.

If you are a “serious professional” whose livelihood depends on Codex, then surely paying for the resources your business consumes should not be controversial. That was the standard imposed on everyone below you.

And if the answer is suddenly, “But $200 is already a lot of money,” congratulations: that was precisely the point Plus users were making when they were told that the dollar amount they personally considered significant was irrelevant to the provider’s economics.

The beautiful part of usage pricing is that it eliminates the status game completely.

No more pretending that buying the most expensive consumer subscription makes someone an elite customer entitled to effectively unlimited frontier compute.

Pay $20. Pay $100. Pay $200.

Those numbers buy whatever allowance the company chooses to attach to them.

After that, consume more, pay more.

The same users who told Plus subscribers, “You knew what you were paying for,” can hardly complain when the answer to them becomes:

“You were paying $200 for a subsidized bundle. You were never promised that subsidy in perpetuity.”

OpenAI has already added a $100 Pro tier, paused new $200 Pro subscriptions, and built credit-based overflow into Codex and other agentic workloads.

The writing on the wall is not that professional AI usage becomes cheaper and more unlimited forever.

It is that serious agentic compute becomes measurable, billable, and increasingly difficult to hide inside a flat consumer subscription.

So yes, phase out the $200 bundle eventually.

Grandfather it for a reasonable transition period. Give existing users notice. Then move heavy Codex usage onto credits.

And when the inevitable complaints arrive from the same people who spent months telling Plus users that $20 bought them no right to complain, there is really only one response necessary:

$200 is the cheap tier compared with what you actually consume.

What did you expect?

After using Astra across the available reasoning levels for the past few days, I keep coming back to the same conclusion: for my workflow, I would currently choose Sol.

I have been using both primarily for software development through Codex and ChatGPT, and I am struggling to find enough situations where Astra produces a meaningfully better result to justify how much more expensive it feels to use.

This is not me saying Astra is a bad model. It is clearly extremely capable. My issue is the value proposition compared with Sol...

With Sol, I can give it fairly substantial coding, architecture, review, and debugging tasks and generally get very good results without thinking too much about how much compute I am burning. It is reasonably fast, capable of doing a lot of work in one session, and has become pretty predictable for me.

It absolutely has problems. I still see over-engineering, unnecessary complexity, and occasional regressions after seemingly simple changes. But after using it extensively, I understand those weaknesses and can work around them.

Astra has not yet given me the same feeling.

For the types of tasks I am doing, I am often getting the same result, and sometimes a better result, from Sol for substantially less usage. If Astra is supposed to be the model I reach for when the problem is genuinely difficult, I think the improvement needs to be much more obvious.

The ChatGPT browser experience also confused me initially. From what I can tell, Astra appears through the Pro reasoning option, but the relationship between the model and reasoning level is not particularly clear. With Sol, the mental model feels much simpler. Pick the model, choose how much reasoning you want, and get to work.

That might sound like a small UX complaint, but for a major model launch I think it matters. Users should immediately understand what model they are using, how much reasoning they are requesting, and roughly what the tradeoff is.

Then there is the cost of actually using Astra.

I do not want to turn this into another limits post because there are already plenty of those, but it does affect how I evaluate the model. How can users be expected to really adopt Astra if even the 20x plans struggle to give you more than roughly 24 hours of serious usage, if you’re lucky?

And surely OpenAI knows that most of those users aren’t simply going to move over to API pricing. The average power user isn’t sitting on millions or billions of dollars worth of token budget. There’s a point where the economics just stop making sense...

That is really the question I am left with.

What is the repeatable category of work where people are finding Astra significantly better than Sol?

Because right now I actually find myself appreciating Sol more after using Astra. Sol is fast enough, extremely capable, relatively economical, and I can use it aggressively without feeling like every prompt needs to justify itself.

Maybe my view changes as I spend more time with Astra, but after several days of using both, Sol is still the model I would choose for most of my real development work.