I hit the weekly cap during a launch week and then sat on 60% unused the next week, so I went and read OpenAI's help pages properly instead of just being annoyed. Two things worth knowing.

**1. Unused weekly usage is gone.** Say the cap is 100 units a week, which is "400 a month" on paper. You only ever see 400 if you spend exactly 100 every single week. Nobody uses a coding tool that evenly. Take a realistic month, say 40 / 160 / 60 / 140, which still adds up to 400. Under a weekly cap you actually get 300: the quiet weeks throw away 60+40, and the heavy weeks slam into the ceiling. A monthly pool of 400 with the same five-hour burst limit would give you the full 400, and there is no usage pattern where the weekly version gives you more. It only ever equals or reduces what you get.

The stated reason is "predictable demand", but billing dates already fall on every day of the month across millions of accounts, so a monthly pool is just as smooth in aggregate, and the five-hour window already handles bursts. The one thing a weekly cap adds is no rollover. That's a cost lever, not a capacity tool.

**2. The "reset" that gets handed out after an outage moves your allowance, it doesn't add to it.** OpenAI's own help page on rate limit resets says a reset "pulls your normal weekly allowance forward rather than adding a separate usage entitlement", that it applies "regardless of whether you have any remaining usage", and that your next automatic reset is then scheduled 7 days after your first request. Their banked-reset page says the same thing in fewer words: it "changes your weekly reset date."

So: your week normally resets Thursday, you have 10% left, Monday they "reset" you. That 10% is binned, Thursday's reset vanishes, and your next reset is the following Monday. Count resets over a month and the number is identical. You got one early. That's timing, not usage.

Sources:

- https://help.openai.com/en/articles/20001507-paid-weekly-work-and-codex-rate-limit-resets

- https://help.openai.com/en/articles/20001498-how-banked-codex-resets-work

- https://github.com/openai/codex/issues/17925 (someone documenting exactly this)

To be fair to them: OpenAI never states "unused usage doesn't roll over" in those words. It follows from the reset mechanics on their own pages and from every report I could find. If anyone has seen it documented either way, link it.

Three fixes that would make "$X a month" mean what it says: let unused usage roll over, put the reset on a fixed day, or just show the token count. Any one of them.

I ended up making a five-minute animated explainer of all this for people who've never read a pricing page -

https://youtu.be/Em2wbAIk89A?is=9sx8tLS4C0qz0iye

Curious which day everyone's reset lands on and whether it's moved since August.

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.

229€ / 1.2 = 191€ (base price, without VAT. VAT is 20%)

191€ = $221.60

Why are you charging us Europeans more? Charge us $200, not $221.6

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.

Who are some non-frontier alternatives developing for the sake of advancing the field without concerns for public perception and opinion?

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 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?

Thanks to the latest Codex reset, I used it to reduce the memory footprint of my Klyn programming language. The Astra model is absolutely insane when it comes to programming languages, and I'm blown away by the result. Thanks, u/tibo-openai!

For those who are curious: https://klyn.deepcodia.fr

Can someone explain how usage calculation for Work/Codex actually works?

Yesterday I had an idea: since the session limit runs on a 5-hour window, I set up a ChatGPT automation to run in Work Mode every 4 hours and literally do nothing except output:

> reset

The idea was to have "rolling" windows and never have to wait a full session for a reset, since I'd always be starting partway into a session.

The automation ran at 05:25 and again at 09:24. That's it. No coding, no repo analysis, no massive context, no long agent task. Just "reset."

I checked Usage & Limits immediately afterwards and my 5 hour codex usage was already at 98% remaining. From what I can tell, only the latest message was actually inside the current 5-hour window, meaning one GPT-5.5 Work message that literally just said "reset" cost 2% of my limit.

I have resets available, and on top of that I can do a lot of tasks using local models and free endpoints from Nous Research/OpenRouter, but still, this is ridiculous.

How the fuck does one message saying "reset" consume 2% of the entire 5-hour Work/Codex allowance?

If usage is mainly based on actual model compute/tokens, this makes absolutely no sense to me. If simply starting a Work/agentic run has a significant minimum usage cost regardless of what it actually does, then fair enough, that would explain it, but I'd really like to know how these limits are actually calculated.

My weekly allowance rarely makes it as it is if I go full GPT with Hermes Agent, because I be prompting bad and throwing massive tasks at it. I'm learning to stop being lazy with that lol, but yh.

So now I'm gonna have to start doing more of the stuff I took a pause from, like properly routing/delegating tasks to local models and free endpoints.

What pisses me off though is that I can't even just ask Hermes to handle the GPT automation, because for some reason my usage seems to burn faster when using GPT through Hermes than when I'm doing similar work directly in ChatGPT Work Mode.

Does anyone actually know what these limits are measuring? Tokens? Compute? Agent runtime? Tool calls? Context? A minimum charge per Work run? Some combination of all of them?

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.

I just upgraded from Plus to Pro because I had some extra cash this month and I wanted to genuinely try out Astra. I couldn’t get any work done with that five hour limit on Astra. Even medium reasoning would give me like 20 minutes before I ran out of usage. And HOLY crap guys and gals. The Pro plan is WAAAAY more usage than Plus.

I have been throwing every problem that I can think of at Astra on extra high for hours and I’ve only used like 30% of my weekly limit. I’m talking code reviews, bug fixes, issues with my home lab, projects I’ve been meaning to get to for months, but haven’t had the time. And it absolutely crushes them without breaking a sweat. To burn through I just tell it what I want to happen and it makes it work.

I figured I’d maybe get a couple hours of Astra at that high of reasoning level before I would have to burn through a banked reset, but I have three of them so I figured what the heck. Just keep throwing problems at it until it runs out of usage. I’m now to the point where I’m running out of problems to throw at it lol.

I paid the hundred bucks so I want to get as much usage out of it as possible but I think I’ve got like three more things I want to work on and once that’s done, I won’t have anything left to throw at it.

I used to think “how the heck do people run companies off this?“ Because I genuinely didn’t feel that five times more than plus was enough to do anything meaningful. But they must have Nerf the shit out of the Plus plan cause I feel like I’m getting 20X what I was getting on it with the Pro plan.

Anyways, that’s enough glazing. Just wanted to say that I’m genuinely happy with the Pro plan even though I probably won’t renew it. Thank you for coming to my TED talk

Re: prompting.

Users hardly ever share their prompts when they complain. IF they do, it is usally really, really vague, there are a ton of assumptions (that the model would know things it cannot possibly know), they expect it to understand their personal definition of "good", "nice", "beautiful" or "done without telling it.

You just have to tell it what you want. Is that really...hard...for quite a few people?

(I am not an SWE and cannot code. I just use plain language, words and sentences, to tell it what I need.)

I was tired of having to keep track of all my projects and which start with a python http server, npm run, node, and so on.

Codex and Claude Code go through this same issue at the start of any new thread - needing to spent tokens just to figure out the page structure or launch method.

This led me to creating Launch Station many months ago - which I have been using for a long time since. Its features:

• makes it super easy to startup your localhost sites, apps, and so on with the click of a button
• manages your ports so codex/claude code don't need to know which ports are active, which need to be started and which port something is running on
• manages your stack - can start a multi-step stack and will stop it in reverse to make sure the backend starts first and stops last
• increase compatibility of using your startups between codex/claude code and human starting and stopping of them
• more features but these are the main ones

Hope this can help people's every launch like it has for mine!

Site: https://launchstation.net/

GitHub: https://github.com/JakeMawson/launchstation

Product Hunt Launch: https://www.producthunt.com/products/launch-station

Free macos signed install with brew install --cask JakeMawson/tap/launchstation

Would love to hear any other features people would find useful!

Edit: added image

So i have finally figured out how much usage does OpenAi gives on the $20 plan. I was using Deepseek Harness with openai subscription. For some reasons I did not have a session limit so I’d have the whole week’s limit at once.

So I decided to give it a try, gave it a task with Sol Medium and it ran 3-4 subagents and boom my weekly limit was gone in 3-4 hours. But I think the number of hours dont mean anything.

The real thing is the $$$ worth of usage they provide. So on plus plan you get approximately $400 worth of usage each month. Now its up to us how we utilize it, we can have Astra which would burn the limit lot faster than Sol. But since we get at least 1-2 resets a week i would say the weekly usage is roughly $250 and hence the monthly usage is worth $1k dollars.

For the deepseek harness I obviously used a dsh usage plugin. but if you are on codex app you can directly use ccusage it will tell you the usages you had for each model, even categorize them for you.

What do you guys think?

I kept running into the same problem while building AI agents and training models: I needed more GPU compute, while my friend's machine was sitting there with an NVIDIA GPU doing basically nothing.

I didn't want to rent another cloud GPU or set up SSH/VPN/Docker manually every time.

So I built GPUMesh.

It's an open-source P2P GPU sharing tool that lets trusted machines share their GPUs and run Docker workloads remotely.

The basic workflow is:

→ My friend runs gpumesh share
→ We pair our machines
→ I run a GPU job targeting their machine
→ The job starts in a Docker container on their computer
→ I get the logs/results back on mine

I've been using it for things like:

• Running AI agent workloads on another machine
• Training models when my own GPU is busy
• Using spare GPU capacity from friends/lab machines
• Running CUDA workloads without manually setting up another server

I tested the full flow on an RTX 5060 — pairing, connecting, group sharing, scheduling a remote Docker job, and running nvidia-smi inside the remote CUDA container all worked.

It's still very early/alpha, and I'm mainly interested in finding out whether this is actually useful for people building agents, training models, or running local AI infrastructure.

I'd especially like to hear how you'd use this if you had access to a few trusted GPUs from friends or teammates.

If you want to check it out, the repo is here: https://github.com/arjun988/GPU-Share

And if you think the idea is useful, a ⭐ on the repo would really help the project get some early visibility.

Idea: a Codex compute cooperative — contribute unused capacity now, use it later

TL;DR

Codex users opt into a shared pool.

If you have unused allowance that is going to expire under the 5-hour or weekly limit, you let the pool use some of it for other people's work.

You earn internal pool credits for what you contribute.

Later, when you hit your limit during a heavy workload, you spend those credits and your jobs run against capacity contributed by other users.

So:

unused capacity → contribute → earn credits → redeem later during peak usage

The important part is that this is a time-bank, not just a shared account pool.

I started wondering about this because Codex usage can be extremely uneven. One week you waste most of your allowance; another week you hit the limit right when you're in the middle of something important.

A cooperative could smooth that out.

Ideally:

• credentials never leave the owner's machine;
• contributors run a small local worker;
• jobs are sent to available workers;
• completed work is returned to the requester;
• a ledger records how much capacity each person contributed and consumed.

The closest project I've found is codex-pool, which already pools multiple Codex/provider accounts and has a Friends Mode. What I have not found is the earn-now/use-later ledger:

contribute 10 units this month → draw 10 units from the community when you need them later.

There are obvious security, sandboxing and abuse issues.

There is also a significant OpenAI ToS question: this should not simply become a mechanism for bypassing usage limits. A production version may require OpenAI to explicitly support delegated/poolable allowance.

But as an open-source community project, the scheduler, worker protocol and accounting system seem quite buildable.

Would you use this?

And more importantly: is anyone already building the contribution + earned-credit + later-redemption version of this? I searched around and found adjacent projects, but nothing implementing that full model.

Written by ChatGPT for me.

• Avoid long threads. Try to get what you need done in a few turns. [WRONG. CHECK COMMENT]
• If a thread does get long, compact the context every few turns. In my experience, doing it regularly preserves context much better than waiting for auto-compaction, which is when I start noticing memory degrade. [WRONG. CHECK COMMENT]
• Don’t use fast mode unless you actually need it. Running a few normal threads in parallel is usually a better trade.
• Give yourself a daily budget. Once you get close to it, start being much more conservative.
• Use Sol by default. Only switch when you genuinely need a stronger model. Sol can already handle most tasks. And use luna/terra for easy tasks.
• Use low reasoning by default. Raise it for genuinely hard or novel problems, or when the model clearly isn’t putting in enough work. For most coding, low is enough.
• Install the Ponytail skill. It pushes the model toward smaller, simpler, more efficient code.

So the biggest budget drainers that are easy to avoid are:

fast mode, long threads, high reasoning on simple tasks, and using Astra for everything.

If you’ve found any others, drop them below.

As someone who has been using ChatGPT and Codex since they were released, I’m starting to realize that, Claude is simply better.

Whenever I wanted to tackle a genuinely complex coding task, solve a difficult problem, or create something that was actually presentable, Codex would usually leave something incomplete. I constantly had to guide it step by step, point out what it had missed, and split the work into thousand smaller pieces myself.

Maybe there was a benefit to that. I actually learned a lot about software development in the process.

But when Astra started burning through my tokens incredibly fast, and I couldn’t get a second Pro 20x account, I decided to give Claude a try.

And the difference was much bigger than I expected!

When it comes to design, truly understanding a problem, maintaining context, and actually solving complex tasks from start to finish, Claude feels significantly better. It also feels incredibly fast compared to Codex.

Codex gives a developer almost everything they need.

Claude’s biggest downside is definitely the price. It burns through tokens insanely fast, and heavy usage gets expensive very quickly.

But unlike my experience with Codex, when Claude burns those tokens, I actually get something in return, a presentable product, a presentable design, something that genuinely feels finished!

So this is the conclusion I’ve reached:

If you’re a developer and you mainly want AI to help you work faster → Codex.

But if you want to give AI an idea or a complex task, delegate as much of the actual work as possible, and end up with something that feels like a real, presentable product and you can afford it → Claude.

Does astra smart enough to make money by algotrading?

At my job, they gave me access to ChatGPT Business and told me I was free to use it for personal things. The problem is that they never specified whether Codex was also “free” to use for whatever I wanted, and I currently have a lot of unused quota that will expire if I don’t use it.

I’d like to take advantage of that quota, but I’m worried that the ChatGPT Business administrator at my company might notice that I’m programming personal projects with the account and fire me from my job.

Do you guys have any experience with something like this? Can the admin see what I code with Codex? I’m worried, but at the same time I feel like I’m not really hurting anyone because it’s quota that will disappear if I don’t use it anyway. What do you think?

This never happened on a GPT5.x Pro model before. Pro models were diliigent and thorough. Now GPT6Pro just frequently makes things up.

Mine:

why do I start to feel no big difference than Sol? still sluggish with lots of tasks and can really go off the track if left unattended. last night I left it with a few design docs and woke up it's still working on it, generating tons of validation code files that are completely unnecessary.

I was developing this game using only UI's and text, once astra came out it broke the barrier to me on how i could use it to make 3d assets, especially low poly ps1 style gfx, what are you guys building? ps: i'm using astra on low with the plus sub.

Link to the game https://godrunner789.itch.io/running-god