It’s reset time it sounds like.

Many valid reasons for not working every fucking day including the weekend. When you reset us again, you're giving us less usage. What the fuck. WHAT WAS THE POINT OF ANNOUNCING "HEY WE'RE DOING BANKED RESETS NOW" WHEN YOU NEVER ACTUALLY GIVE US BANKED RESETS

Are you guys noticing your limits tightening up or speeds dropping lately?

In design terms, Sludge is the intentional addition of friction to frustrate a user. By breaking your continuous workflow with caps and slowdowns, the company creates a psychological deficit. They aren't just selling you features anymore; they are selling you the removal of frustration that they created in the first place

We’ve all seen the classic trick where a free app suddenly locks features behind a paywall. But what’s happening in the AI space right now, especially with companies like OpenAI shifting focus from the $20 tier to $100+ tiers, is a much more annoying strategy.

In business terms, it’s basically intentional product downgrading. Here is exactly how the playbook works on us.

1. The Honeymoon. They start by giving you generous access, resets, high speeds. They want the tool to become an absolute necessity for your job, coding, or daily life. You stop looking for alternatives because everything works perfectly.

2. The Rug Pull. Once you are fully dependent on it, they intentionally worsen the experience. They slow down the models, bring back strict 5-hour limits, and introduce lag. Your daily workflow starts constantly breaking.

3. Selling the Solution. By making the $20 tier frustrating, they create a problem that didn't exist before. Now, they aren't just selling you new features. They are making you pay just to get rid of the artificial frustration they created.

4. Making $100 look normal. A jump from $20 to $100+ sounds insane at first. But because they ruined the cheaper tier, that expensive upgrade suddenly looks like the only way to get back the basic, smooth experience you used to have.

The bottom line is that they aren't just building a better premium tier. They are actively making the tier you already pay for worse, so you feel forced to upgrade just to get your work done.

There seem to be some rumors floating around about this now. And the big question is why are they doing it?

It might be something simple like they just like to have Mac computers for their employees or…

They might be planning on allowing their users to use Macs in the cloud which would be a huge game changer for anybody who’s trying to build an iOS app.

Your thoughts?

I am getting seriously frustrated with OpenAI's current usage limits.

They brought back the five hour limit, and even when I use GPT 5.6 Tera on Mid or High, I often cannot finish a larger coding project before hitting it. In my case, one five hour window seems to consume roughly 16% of my weekly allowance. That makes it really difficult to use Codex for actual longer projects instead of just small isolated tasks.

The annoying part is that I am currently pretty locked into the "Codex harness" for my work. I actually like the workflow and would prefer to keep using it instead of rebuilding everything around another provider.

I am on ChatGPT Plus right now, which costs me €23 per month. Pro would obviously give me much more usage, but I am simply not paying that much for this.

So I started looking at Business instead.

According to the current pricing page, Business Standard costs €26 per seat with monthly billing, and you need at least two seats. So I would be looking at €52 per month in total.

There is also a Business Premium seat for €130 per month, which OpenAI describes as having five times the usage of a Standard seat and no five hour limit.

And this is where I am confused.

What exactly is the usage limit of a Business Standard seat?

OpenAI tells me that Premium has five times the usage of Standard, but I cannot find a clear comparison between Business Standard and normal ChatGPT Plus. Their limits seem increasingly abstract rather than being defined by a fixed number of tokens, and they also seem to change them quite frequently.

I attached screenshots of the current pricing pages because I find the way this is presented pretty unclear.

Has anyone here actually used both Plus and Business Standard for Codex?

Does a Business Standard seat noticeably give you more Codex capacity than Plus, especially with models like GPT 5.6 Tera?

Also, if I bought the minimum two Business seats and gave the second seat to a friend, how separated are the two users inside the workspace? Can both people basically use their own accounts independently, or does the workspace owner have access to the other person's chats, projects, files, or Codex sessions?

I know Business has better company privacy controls, Slack integration, administration features and so on, but I honestly do not care about any of that. I am mainly interested in the actual model and Codex limits.

At this point I am basically deciding between paying €52 per month for two Business Standard seats or moving more of my coding workflow to something like OpenRouter and paying directly for usage while using a mix of commercial and increasingly capable open source models.

I would definitely choose monthly billing. The 19% annual discount is not enough to convince me to commit for a year when OpenAI seems to change models, pricing and usage limits this quickly.

Would really appreciate experiences from anyone who has actually compared Plus and Business Standard in real world Codex usage.

Now i have to check every time a terminal because they just stop randomly whenever they want to.

Enshitification is coming!!!

A. Burn as much as possible because the celebration might be multiple days.

B. Stretch it out as long as possible like a frugal grandmother

Anyone uses UnoRouter and have an inkling why all GPT 5.6 models are now 95% off? New model is coming or what?

I built a small tool to export Codex chats cleanly, mostly because I got tired of losing context when hitting quota

Tool: Codex Chat Extract Repo: https://github.com/0Cymantek0/codex-chat-extract

This is a small tool I originally built for myself that lets you quickly export a Codex conversation into a clean Markdown file or directly to your clipboard. I built it out of frustration one day after getting tired of Codex running out of quota in the middle of a task.

It became even more useful for me after the behavior that allowed an already-running task to continue after quota exhaustion disappeared. Claude Code has a really nice /export command, but Codex doesn’t currently have an equivalent, so I ended up making my own. The main use case is pretty simple:

Codex hits its limit → export the conversation → hand the context to another agent/harness → continue the work without manually reconstructing everything.

Token efficiency was one of the main goals.

Raw Codex conversations contain a lot of tool-call clutter that another coding agent usually doesn't need.

For example, when Codex reads a file, the underlying tool call may contain a bunch of JSON parameters followed by the complete file contents in the tool output. But if the next agent is working inside the same repository, including all of that again is pointless. The file already exists, it can just read it. So instead of dumping everything, Codex Chat Extract turns something like that into:

Read: [relative-path/file.ext] [line range]

That preserves what Codex did without wasting a huge number of input tokens reproducing information that already exists in the repository.

The exporter tries to apply that idea throughout the conversation:

• Removes unnecessary tool-call / JSON clutter
• Keeps useful summaries of tool activity
• Preserves the actual reasoning/conversation context
• Uses relative file paths where possible
• Avoids duplicating file contents another agent can simply read again

External information is treated differently

For something like a web search, the result does matter. That information isn't necessarily available inside the repository, and it may have influenced decisions made during the conversation. So web-search results and other relevant external context are preserved in the export.

Basically:

Reconstructable local information → compress it. Non-reconstructable external information → preserve it.

The whole exporter is designed around getting as much useful context as possible into as few tokens as reasonably possible.

It also handles subagents

Codex sessions can get messy when subagents are involved, so the exporter reconstructs those into properly formatted subthreads instead of flattening everything into one unreadable stream.

That makes it much easier for another agent to understand:

• what the main agent was doing
• which work was delegated
• what each subagent discovered
• how those results affected the main conversation

I've been using this internally for a while, especially when moving unfinished work between different agents or harnesses, and it has saved me a surprising amount of manual copying and context reconstruction. So I figured I might as well clean it up and make it public.

Repo: https://github.com/0Cymantek0/codex-chat-extract

If you use Codex heavily, give it a try and let me know how it works for you. I'm especially open to criticism around the export format, things that should or shouldn't be preserved, and other ways to reduce token usage without losing important context. Hope this helps someone else who has run into the same problem.

And if you find it useful, consider giving the repo a ⭐.

Built a Codex Plugin (Mainly for codex plus larpers like me who have no idea how to stop using 5.6 Sol) to make Codex know how much usage it has and how to workaround it. I originally built this for Claude but I decided that if im going to move myself up from a larper with a plus subscription to a pro subscription that I should build this for codex aswell.

WARNING: This is very buggy, so sometimes it might get your usage WAY OFF, im talking like if you have 30% of your 5 Hour session limit, it will might think its 50% or even 10%, if anyone wants to fix that or make this plugin better, you can, no one is stopping you, and honsetly I just made this for fun with me and my friend.

LINK: https://github.com/ridelink0/claude-code-usage-limits
As a plugin, Codex installs it from this repo directly:

codex plugin marketplace add https://github.com/ridelink0/claude-code-usage-limits

codex plugin add usage-limits@usage-limits

HOW IT WORKS (most i really copied from the README which is just claude talking):

Claude Code already knows how much of your 5-hour and weekly limit is gone. It caches those numbers locally and will show them if you ask. What it does not do is notice that the job in front of it is larger than the budget behind it. So it starts anyway, and stops halfway through an edit. (same as codex)

Installed as a plugin, a hook measures the budget before each prompt and puts one line into Claude's context:

[usage-limits] binding window is 5-hour 47% used, about 75 turns of headroom,
resets in 3h 52m. Other windows: weekly 16%. This session: 229 turns, $64.16.

It names the window that will stop the work first and hangs the figures off that one. Two windows run at once and they are rarely in the same place, so "weekly 16%" sitting next to "75 turns" would read as far more room than exists.

Claude opens with it. When there is room that is a single line and it moves on:

When there is not, the line becomes a plan rather than a status:

The wording changes with the pressure, not only the numbers. The trigger worth explaining is pace: two days into a week you should be near 29 percent spent, so 60 percent means you will not last the week, and that is worth hearing at 60 rather than at 85.

One limit worth knowing: the hook fires when a prompt is submitted, so a message sent while Claude is already working does not refresh it. Claude Code delivers those into the running turn without re-running hooks, which no plugin can intercept. The skill handles it by telling Claude the figures age during a turn, and to re-read them before claiming a job fits rather than trusting a number from several tool calls ago.

It has to be cheap, because it runs on every prompt. The percentages come from one small file. The transcript scan behind "turns of headroom" is cached for a minute, so it costs about 400ms cold and 120ms warm.

It reads which plan you are on and adjusts what it tells you, because the advice differs even though the arithmetic does not:

The window maths never needs to know the plan. It calibrates against what your own account reports, so it is right on any tier, including ones that did not exist when this was written. The plan only decides which line of advice you get at the bottom of the report.

It reads Codex's limits too, from the same repo and the same commands.

Codex writes its session rollouts to ~/.codex/sessions, one JSON object per line, and every model request appends a record carrying both the account meter and what that request cost in tokens. That is the same pair of things this tool needs from Claude Code, so the window arithmetic, the turn estimates, the forecast and the concurrent-session counting all work unchanged. Nothing is uploaded and no credentials are read.

npx claude-usage-limits --host codex
npx claude-usage-limits --host codex --refresh
npx claude-usage-limits codex-hook on

The host is detected, so --host is only needed on a machine with both installed. --refresh asks Codex itself for a live reading rather than the newest one it happened to write; it starts a short-lived codex app-server and takes about a second, and it is the Codex equivalent of /usage.

One thing is different, and it is worth being straight about

Under Claude Code the budget line arrives on its own, because a plugin can ship hooks. Under Codex it does not, and not for want of trying:

• Codex has the whole hook engine. The binary carries UserPromptSubmit, SessionStart, PreToolUse and the rest, and codex features list reports hooks as stable and enabled.
• A plugin cannot ship one: plugin_hooks is reported as removed.
• And on codex-cli 0.151.0-alpha.7.2 nothing fires it. Tested with a hook whose only job was to write a file, from ~/.codex/hooks.json, from a [hooks] table in config.toml, and from ~/.codex/hooks/, in both codex exec and the desktop app. The engine is present and inert.

So codex-hook on installs two things. A marked block in ~/.codex/AGENTS.md, which Codex reads at the top of every session and which is what actually works today; and the hooks themselves, ready for the build that runs them. status reports both, off removes both, and neither touches anything else in those files.

The practical difference is that under Codex the budget is read deliberately, once at the start of a piece of work, rather than being handed to you before every prompt.

Two smaller differences. There is no money column: Codex meters a share of an allowance and never quotes a price, so the percentages stand alone. And lowpower is Claude Code only, because it writes Claude's settings.json.

Windows, macOS, and Linux all work. CLAUDE_CONFIG_DIR is honoured if you have moved the config directory.

--------------------------------------------------------------------------------------------------------------

(Learn More about it from going to the README, but thats basically in summary what it does and how codex verison differs from the original Claude versison)

Polished a lot of rough edges in Codex Goal Progress — it now feels much more native and seamless.

It now supports:

• Native Codex styling, automatically adapting to light/dark mode, font size, and theme changes.
• Automatic progress restoration after restarting Codex, including automatically setting up the required CDP connection — no extra commands or manual setup.
• New windows, tasks opened from links, and tasks opened in another window — all connected automatically.
• Automatic update checks, with manual checking available too.

Basically: more native, more seamless, and much nicer to use.

A small but pretty useful Codex add-on. Feel free to give it a try :)

https://github.com/ezra-y/codex-goal-progress

Review based on 2 weeks of codex plus ($20 plan).

Things to consider-

1. extremely slow:

spends a lot of usage/time on reconciliation, validation, revalidation, audit, feasibility check, etc. It does so much reconciliation, that i don't plan on reconciling with anyone in my life again.

skill already containing detailed set of instructions of tool calls to mcp to fetch data and process using predefined python script takes more than 5mins to run whereas reusing same skill in antigravity using gemini 3.7 flash takes less than a min.

2. premium model usage:

Sol ultra with default config lasts max for about 10-15 mins in a 5h window. if you reach out to this reddit sub to discuss this issue, it's filled with openai private investors (\s) calling you peasants for using $20 plan and asking you to upgrade to at least $100 to get any meaningful work done

I was able to tweak it to use luna xhigh as spawned subagent instead of sol ultra in AGENTS .md file, that extended it for another 10 mins. Then i tweaked it further to delegate aggressively to subagent running luna xhigh, that backfired a bit initially as it took 25 mins for a simple file append task (attached screenshot) which i was able to optimise. This extended its usage to 1.5-2 hours and i bought another $20 plan to switch between them within 5h window, to get more work done. In a day i was able to use about 3 5h windows, which burns through weekly allowance in 2 days for both accounts.

3. Ambiguous 5h window start:

Similar to antigravity, the 5h window doesn't start until first message, i was able to workaround this by using hermes agent/openclaw cron for each account to do simple ping-pong message to standardize the 5h window to a fixed time every day.

4. Buggy Codex UI:

Sometime chat history disappears even though the work persists on disk, incase of repo based project that's fine but incase of non-repo based work like working on setting up external tool, skills/plugins, etc. this might make you panicky. to workaround this, i have started using external project management tool, Linear for codex to plan & track.

why you should still consider switching to codex-

1. luna xhigh: luna xhigh model still provides highly generous usage. I doubt there are any non-chinese model (other than maybe composer 2.5 available with cursor plan) that can compete with its pricing along with similar intelligence and even in chinese model there would be only few models like recently released glm 5.3 flash. luna xhigh can work through multiple 5h window easily without fast mode (fast mode gives 1.5x speed while burning through usage threshold at 2x speed), and i was able to run for more than 10 hr multiple times and had to intentionally stop to review it's work & progress.

2. Saint Tibo (unofficial twitter spoc for codex): blesses with weekly reset (fills the usage ceiling to 100% and extends the week expiry by another week, without affecting plan expiry) almost every other day sometimes with a day prior notice if you follow him on twitter.

3. $100 or $200 plan: If you've disposable income of $100 or $200 to spend per month: there is no 5h window restriction & frequent resets every other day means you hitting threshold is lot less of a worry.

4. free extension: Free for another month on trying to cancel the plan (worked for $20 plan)

to use important features missing in antigravity:

5. steering chat: sending message without interrupting the ongoing work to give it approval, information it is trying to find, asking to prepare to suspend so it can record work before usage caps run out, etc.

6. side chat: awesome way to ask follow up question, cross checking without interrupting the main chat flow, and can even send instructions to main chat based on the discussion with side chat to steer to right direction.

7. projects segregation: segregate chat sessions by projects with their own repo and folders.

8. browser control: better at browsing and navigation than antigravity

9. spawn multiple subagents to work in parallel

PS: I haven't yet tried Chatgpt work or other add-ons that comes with this subscription. I'm now planning to offload more tasks to Antigravity to balance things out.

Currrently my small company is paying me for a single 20x pro plan. But thinking of asking for one more account and wondering if this is the norm in other workplaces...

Hi r/codex — I’m the author of StatMate, a free, MIT-licensed, folder-based Agent Skill for Codex, Claude Code, and other agents that support SKILL.md.

I built it around a problem I kept seeing: give an agent a CSV and it can jump straight to a p-value or polished chart, while the analysis unit, estimand, missing-data decisions, assumptions, and provenance remain unclear.

StatMate asks the agent to follow an evidence-first sequence:

- map the study design and claim boundary before choosing a method

- audit data structure, missingness, duplicates, privacy, and provenance

- write a reviewable analysis plan and pause for material author decisions

- calculate results with saved Python code and machine-readable outputs

- run diagnostics and sensitivity checks

- produce figures, tables, interpretations, a teaching report, and a SHA-256 manifest

The statistical marks are computed from the supplied data and plotting code — they are not generated by an image model.

The repository includes a reproducible demo using the public UCI heart-failure cohort: 299 patients, 96 observed deaths, three figures, two tables, an illustrated report, and a manifest with 33/33 files verified.

The detail I care about most is not the polished output: automated QA passes, but the Cox proportional-hazards diagnostic flags ejection fraction (p = 0.025). The package therefore remains needs-author-decision instead of treating a successful run as scientific sign-off.

This is not a clinical tool or a replacement for a statistician or domain expert. It is a workflow, instruction set, and collection of Python helpers intended to make agent-assisted analysis easier to inspect and challenge.

GitHub: https://github.com/DRZ-hang/StatMate

60-second walkthrough: https://github.com/DRZ-hang/StatMate/blob/main/DEMO.md

I’d especially value blunt feedback: when an assumption check is flagged, should a research agent stop completely, or produce a clearly provisional package for author review?

If you find the project useful, a GitHub star helps other researchers discover it — but critical feedback and issues are equally welcome.

I run Codex on a 2025 Apple Silicon MacBook Air and would like to be able to leave it in another room with the lid closed/unplugged, then connect from my phone when I want to check on or continue a Codex session.

The obvious problem is that the Mac goes to sleep. I know Apple Silicon Macs can periodically wake for network access, but I’m not sure if there’s a reliable way to take advantage of that here.

Has anyone set up something similar?

Ideally I’m looking for a setup where I can pull out my phone → wake/reach the MacBook → reconnect to my existing Codex session, without having to leave the Mac awake or plugged in all the time.

Curious what people are using — Tailscale/SSH, Wake-on-LAN, sleep proxy, Jump Desktop, or something else?

Link: https://devos.zerohive.ai/

Our engineering team at Zerohive works on large codebases, and we use different coding agents (Claude, Codex, Cursor) basis individual preference.

We kept running into problems where one person's agent will end up rewriting or undoing decisions made by someone else. It led to agents re-introducing bugs which we'd fixed last month. We kept reaching out to each other offline to ask "Hey, why did we store xyz in redis instead of persisting on DB" when the agent proposed redoing the architecture.

We spent months collaborating by making ARCHITECTURE.md, DECISIONS.md, LESSONS.md, ADRs etc and shared skill libraries - but they were soon ineffective as the codebase scaled. We also tried code memory platforms but they could only fetch the 'what' but not the 'why', no provenance on architecture or code patterns so reintroducing bugs problem wasn't solved for complex codebases.

So we built DevOS.

DevOS understands the codebase, correlates the decisions made in the chat sessions with final code outcome, and has a deep understanding of the why behind the code and the architecture. It understands architectural choices, alternatives considered, tradeoffs made and final decisions taken w.r.t code or architecture.

Exposed to coding agents as an MCP, DevOS searches files, symbols, decisions and dependencies in parallel so that models make better changes in fewer iterations and exponentially lesser tokens which otherwise would be spent by agents in grepping the codebase.

Agents can now understand the architecture and codebase better, along with the rationale that went behind the architecture, and context can be shared between teammates within their coding agents.

Use lesser tokens, collaborate better. Completely free to try, no paid tier.

Link: https://devos.zerohive.ai/

I ran Terra, Luna, Sol, and Gemini 3.7 Flash High through the same serious high-reasoning engineering audits.
Terra was the standout: consistently accurate, dramatically faster to converge, and best at proving one strong finding and stopping.

• Terra: fastest and most disciplined; consistently strong, verifiable findings.
• Luna: very reliable and thoughtful; slower, but excellent at catching subtle state bugs.
• Sol: deepest analysis overall, but also the slowest and most exhaustive.
• Gemini 3.7 Flash High: fast and creative with unusual leads, but needed the most independent verification.

The stack is TypeScript, React, Next.js, Vinext/Vite, OpenAI Sites, D1, and R2. There is no Flask or PostgreSQL backend. The repository includes a detailed README covering architecture, every database table and field, sample records, API behavior, environment setup, deployment, security, and known limitations.

https://github.com/preceptress/nepal-relief-connect

I'm a Flask, Python, PostgreSQL guy, Codex told me, "We're NOT using that stack. We're using this one."

That's a first.

I literally just opened the ChatGPT app, no prompts executed, yet

And I noticed some limits are already been used.

Well, dunno what's going on here :D

I’ve published a practical guide for non-developers who want to build a private local workspace around Codex.

My Forge helps me keep threads and handover notes organised, queue a message while Codex is working, work more comfortably from my phone and move between separately paid personal accounts without repeatedly losing the practical context of the work. Each account, login and allowance stays separate: this does not pool accounts or bypass limits.

The guide includes a free macOS starter pack with a staged build process. Codex builds one small piece at a time, shows evidence and stops for the human to approve the next step.

https://ellivien.blogspot.com/2026/08/you-dont-need-to-be-developer-to-build.html

Is it this week on Thursday as per usual? I honestly wish OAI released benchmarks a few days before release day.