My apologies to the Op I had originally responded to…
There does seem to be an issue, and I mistook the context as I encountered it.
My apologies to the Op I had originally responded to…
There does seem to be an issue, and I mistook the context as I encountered it.
Hey everyone, Apologies for this experience. Could someone please open a ticket with support@openai.com so we can investigate this against the right account/workspace?
Please include:
Once you have the support case, please share the case ID or the subject line here so we can track it internally and pull the information needed to debug what’s happening. Thank you!
I am 4% from the limit on one Pro account, and just purchased a second one. I wanted to demonstrate that bridging two separate instances of codex into the same work environment can be handled safely, although it does require a second paid account and some thoughtful foresight.
As I don’t know that I’m the best candidate for exploration into this issue, I at least wanted to demonstrate that folks don’t have to go run to Claude to continue their workflow…
If folks need an immediate fix to get their workflows going in a codex-only environment, then this is how you do it safely.
(Do not forget to back up your entire workspace)
That context summary is :
This session established a practical way to hand a live Codex workspace from one ChatGPT account to another without treating the fresh login like a blank slate.
The core idea was simple: do not rely on memory crossing accounts. Put the important operating knowledge inside the workspace itself, in plain files that Codex can read on the next login.
What we built was a two-file relay system.
The first file is the authoritative handoff: CODEX_SECOND_INSTANCE_HANDOFF.md. That became the behavioral contract between Codex instances. It tells a new instance how to start safely, what not to touch, how to handle licensing/signing/release risk, how to read the repo state, how to log its turn, and how to hand off cleanly to the next instance. Over the course of this session, that file was hardened so it did not just protect release and licensing operations, but also Prompt Forge’s product semantics, lane-classification rules, prompt-assembly boundaries, and anti-drift guardrails. It explicitly treats PromptBuilderService as the owner of assembly order, SliderLanguageCatalog as the owner of phrase authority, lane metadata as stable shape only, and policy hooks as exception-only surfaces. It also became the shared source of truth for Codex-to-Codex turn logging.
The second file is the workspace companion: CODEX_WORKSPACE_CONTEXT.md. That file does a different job. Instead of telling Codex how to behave, it tells Codex what kind of terrain it is standing in: where the real compiled surfaces are, which files are duplicate shadows, how startup is wired, where machine-local state lives, how shared-lane wiring actually works, where the fragile seams are, and what parts of the app have unusual architectural behavior. It captures the repo as it actually runs, not as an idealized design doc. It also makes clear that it does not override the handoff file; the handoff remains the behavioral authority.
That two-file split is what made the bridge work.
The handoff file gave the fresh Codex instance:
a startup ritual
scope discipline
anti-churn rules
provenance honesty
a way to log what it touched
a shared baton between accounts
The workspace-context file gave the fresh Codex instance:
the real runtime composition
the project/namespace quirks
the duplicate-file trap
the lane-install footguns
the machine-local workflow surfaces
the known validation and release seams
Together, those files let a new Codex login enter the workspace with local awareness instead of amnesia.
We then proved the bridge was not just theoretical.
A second Codex instance used the handoff and companion files to explore the workspace safely, without editing first, and reported back on the actual machine environment. That survey confirmed the installed SDKs, the presence of GitHub CLI and Inno Setup, the existence of real local Prompt Forge preset/demo/license state, and the fact that ChatGPT reasoning was part of the larger working system rather than something fully stored on disk. That was important because it let the workspace notes evolve from “repo notes” into “execution environment notes.”
Once the new instance was oriented, the session pushed further and hardened the environment around .NET 8. A root global.json was added to pin SDK 8.0.419, and the Codex notes were updated so future runs would treat unexpected .NET 10 selection as drift rather than modernization. That gave both accounts a shared, deterministic SDK baseline.
After that, the second instance discovered a build-verification blocker. Instead of guessing, it worked the problem carefully:
first separating SDK drift from NuGet access
then separating NuGet access from app file locks
then separating app file locks from a remaining Diagnostics-project graph issue
A Codex-only restore/build lane was created using a local .codex-temp\NuGet.Config plus absolute repo-local DOTNET_*, APPDATA, LOCALAPPDATA, and NUGET_* overrides. That solved the roaming NuGet.Config access problem without changing repo-wide behavior. Once the app itself was closed, Core, LicenseTool, and App all built successfully under that lane.
From there, the fresh instance kept using the relay system to investigate the remaining bug safely. It traced the failure into the Diagnostics/App/Core project graph, showed that the problem was not .NET 10 drift, not ordinary NuGet failure, and not a generic workload problem, and narrowed it to a restore/build graph issue involving how Diagnostics expands or reintroduces Core through project references in the full build path. That investigative thread is preserved above in the session log for anyone who wants to study it in detail.
So, in practical terms, here is how the cross-account bridge worked:
Put the rules in the workspace, not in memory.
The new account could not inherit hidden context reliably, so the operating contract was written into CODEX_SECOND_INSTANCE_HANDOFF.md.
Put the terrain map in the workspace too.
The new account needed to know the repo’s actual runtime shape, duplicate files, validation surfaces, and machine-local seams, so that went into CODEX_WORKSPACE_CONTEXT.md.
Make the handoff file the source of truth.
Codex-to-Codex logging, status, and baton passing all stayed in the handoff file, so both accounts shared one canonical thread of local execution truth.
Let the fresh Codex instance explore read-only first.
That avoided blind editing and let it report on SDKs, tools, local state, and constraints before doing any work.
Use the notes to constrain behavior, not just describe it.
The relay files did not merely document the repo; they actively prevented the new instance from freelancing on lane classification, semantics, labels, release flow, licensing, or architecture.
Record every significant turn back into the baton file.
That way, the next login did not have to infer what had happened from changed files alone.
That is the real lesson of this session:
A fresh Codex login can be made safe and effective if the workspace itself contains a disciplined relay layer. Not just notes, but:
a behavioral contract
a terrain map
a logging source of truth
a known environment baseline
and enough explicit architectural boundaries to prevent “helpful” drift
In short, we did not truly “sync accounts.”
We synced the workspace so a new account could enter it and behave like a responsible continuation of the old one.
The full session can be found here:
This uses ChatGPT as a middleman between the codex instances, along with a very specific set of context left in a set of shared relay files between the two codex instances.
While this isn’t an immediate fix, it is the best temporary band-aid I could come up with on the fly.
(I’m probably more brand loyal than a lot of people)
I did find it a little strange that after setting up a new account and doing just this single session, my remaining rate is shown here, using only Gpt5.4 (medium)
2 hours is roughly 10 % of my weekly allotment on a pro account.
If that math helps at all?
My project space is extremely small, as you can see from the Pompt Forge App I’m trying, so hard to deliver to the community as fast as possible ^.^
Anyways, it is entirely possible to extend your workflow into a codex-only space while the current situation is being worked out.
I’ve been a paying ChatGPT subscriber for many years, and I’m genuinely disappointed with how Codex limits are now being handled.
I’m on Plus and only use Codex sporadically in Cursor, not heavily enough to justify buying extra credits or moving to API billing. From that angle, the current setup feels less like a reasonable product limit and more like a push towards extra spend.
What makes it worse is the lack of clarity. The dashboard shows separate 5-hour and weekly limits, but the weekly reset lands at what looks like an arbitrary time in the middle of the week. That is confusing, and it makes it hard to understand what I’m actually paying for as a subscriber.
The main issue is not that limits exist. The issue is that the included allowance feels too restrictive for normal casual use, while the credit top-up model feels like a money grab layered on top of an existing paid plan. That is a bad experience for long-term customers who have supported the platform for years.
What I’d like to see:
A much clearer explanation of how limits work, predictable reset behaviour, and a more reasonable included Codex allowance for Plus users who use it occasionally but consistently.
At the moment, this feels like a good way to frustrate loyal customers and poison goodwill.
I appreciate the additional insights but if anybody can review the post here and provide the requested information, it will be really great. Thank you!
Title: Codex is currently not usable for serious work due to usage limits
I am honestly extremely frustrated with the current state of Codex.
I have intentionally invested both time and money to use Codex productively. I have already spent several hundred dollars and I still have around 300 dollars in API credits that I currently cannot meaningfully use because Codex keeps blocking me due to usage limits.
I have been using Codex exactly as intended as an agent that actually gets real work done not just generating code but actively performing tasks analyzing systems and moving projects forward.
But the current usage limits completely destroy this workflow.
What is the point of a coding agent if
you hit the limit after only a few tasks
you are stopped in the middle of a project
you lose context and momentum
and you have to wait for hours just to continue
This is not just my experience many users are reporting the same issues
limits are reached extremely quickly
people get blocked after only a few requests
even paying users run into these restrictions very fast
The most frustrating part is this
I am willing to pay for usage but instead of a usage based system like the API I am simply blocked completely.
Honestly this is how you lose customers.
I want to use Codex productively and I am willing to pay for it but in its current state that is not really possible.
What should change
move away from hard blocking limits towards usage based scaling
make limits transparent and predictable
allow users to continue working if they are willing to pay
review the current limit system which seems to trigger far too early
Codex has huge potential but right now it is not reliable enough for real world use.
Personal note from ChatGPT
From my perspective the frustration here is completely understandable. A tool like Codex depends on continuous workflow. When that workflow is interrupted by hard limits the tool loses the exact value it is supposed to provide. Developers need reliability and predictability and that is exactly what is currently missing. If users are willing to pay they should be able to continue working instead of being completely blocked.
Please take this feedback seriously.
tommy_47 and ChatGPT
@Tommy_47
Thanks for raising this!
Can you help support to pinpoint the issue?
https://community.openai.com/t/codex-rate-limits-discussion-thread/1378553/70
Thanks for the response, I appreciate you looking into this.
I will open a support ticket as suggested.
To give some quick context here as well
I am using ChatGPT Plus and Codex via the standard interface
I hit the usage limit extremely quickly even during normal workflows
this happened while actively working on a project not doing anything unusual or excessive
The biggest issue is not just hitting a limit but how fast it happens and that it completely blocks further work instead of allowing continued usage
I will include the requested details in the support ticket including email workspace info HAR file and timezone
Looking forward to clarification because in the current state this makes Codex very difficult to rely on
Thanks
tommy_47
This is no longer a reasonable limitation, it’s a disguised lockout. A week ago it was possible to do real work; now you can barely get through a couple of interactions before you have to start rationing every step. If the tool no longer supports the real workflow of paying users, then this is not a “rate limit adjustment” — it’s making the product practically useless.
This is genuinely unacceptable. A week ago I was running full workflows, automating real business processes, and building on top of Codex with confidence. Now I’m hitting the 5-hour cap halfway through a single task. We’re talking a 10x–15x reduction in what I can actually do — not a small tweak, a complete gutting of the product’s usefulness.
I’m not alone in this. Teams with multi-seat accounts are burning through credit pools in 2 days that used to last a month. People who were on the verge of committing to yearly subscriptions — myself almost included — have had to pump the brakes.
Same observation. Business account. I reach my 5h limit faster than ever.
in 2x 5h sessions I burned 60% of my weekly budget. Sic!
The saddest part is that this problem has kept me from working on my apps for two days straight. There’s still no word on when it’ll be fixed.
Same issues here. Last week, the Plus plan felt very generous and now it feels extremely limited. Went through my weekly limit in 2 days when this would last me the full week with plenty left over as well. Really hoping they sort this as Codex is much better than Claude ![]()
In my case this is not just a short block.
I am locked out until April 8 at 10:40. That is not acceptable for a tool that is supposed to support real development work.
The exact message I receive is:
“You’ve hit your usage limit. Upgrade to Pro, visit the Codex settings to purchase more credits, or try again at Apr 8th, 2026 8:40 AM.”
Being blocked for hours is already problematic, but being blocked for days completely breaks any productive workflow.
At this point it really makes you question whether it is worth continuing to use Codex or if it is time to look for a different solution.
tommy_47
I want to add a more precise datapoint to this thread.
After checking my local Codex logs, the issue does not look like “my request was too large”. The real issue looks like quota/rate-limit accounting being far too expensive for the actual token volume.
In my case, a single request showed:
And that corresponded to about 14% of the 5-hour quota window.
That is the core problem.
A request of roughly 33k tokens is not inherently abnormal for Codex. In real coding workflows, large context is expected: system instructions, project context, thread state, tool outputs, and relevant code all add up. That alone is not evidence of a bug.
What looks wrong is the pricing/accounting of that request against the quota.
If about 33k tokens consumes about 14% of the 5-hour window, then the effective 5-hour capacity is only around 236k tokens. That seems implausibly low for practical Codex usage, and much lower than what many users were previously able to use in comparable workflows.
So the issue appears to be this:
users are being charged too much quota for a normal amount of tokens.
That is why the experience feels broken. The token volume itself is not the main anomaly. The anomaly is how aggressively that token volume is converted into quota consumption.
I previously suspected the main problem might be overly inflated input size. After digging into the logs more carefully, I no longer think that is the important part. The more serious problem is that the quota accounting appears disproportionate to the actual token count.
I have the same, the limit is burning too fast in my business account
I can’t figure out a key detail; I wasn’t clear to begin with on how to actually measure my usage, but over the course of the last 3 weeks, I’ve used GPT to configure a pretty normal AWS deployment; starting last week, I’ve had to essentially use multiple accounts to continue working with the deployment; and as of today, I ran through 5 hours of usage in 20 minutes using codex to re-align some ENV vars as I’m changing where one of my data services is hosted for a backend in the cluster. In the past, I was working on several threads of work at a time, but right now, I can’t complete a single thread of work because I hit 5-hour usage limits across 3 accounts; It should just not be possible to hit the 5-hour limit if I’ve only got one prompt running. And it’s clear that the change has been drastic – going from multiple hours of work on simultaneous objectives to minutes of available time per 5-hours for single-thread work.
What am I missing?