r/codex • • May 28 '26

Complaint CODEX is hot garbage now

14 Upvotes

So OpenAI finally did it. I hit the “crazy limits” wall on GPT-5.3-Codex today, and honestly, the $20/mo Plus sub is officially useless for serious dev work.

You literally can't run a complex Next.js refactor or multi-file React build without draining your entire weekly cap in just a few prompts. They quietly switched from a simple message limit to a "token credit" system, meaning agentic models burn your budget in the background while they think.

It's an obvious, aggressive push to force developers onto the $200/mo Pro tier or the pure API. I'm canceling my Plus subscription today. What’s everyone moving to? Claude Code? Cursor? Windsurf?

UPDATE -> I bought 100$ per month plan and it gave the same usage as the previous limits as GPT 5.3 codex gave but can someone tell me like why is CODEX so bad. it literally broke my frontend since i write backend myself. please suggest better alternative and yeah not claude code its the worst subscription since they banned my 200$ plan outta nowhere. i cancelled the codex 100$ instantly worst ever

Edit: Crazy you all fell for this ragebait....Most guys know this is Satire and you all be going mad


r/codex • • Sep 13 '26

Comparison Value of $20 plans: what do you think about this

Post image
5 Upvotes

r/codex • • Jun 14 '26

Commentary So much misinformation... And skill issues

5 Upvotes

I think it's hilarious reading about everyone that thinks OpenAI is nerfing models or that 5.5 somehow got dumber over a few days. AI still requires thoughtful requirements and context, it isn't a magic bullet (although it's very close to those that follow proper AI SDLC processes).

No, the model is not dumber, no it's not nerfed, yes, it's a skill issue. You are the problem.

EDIT: from initial feedback it seems clear many users don't know what non-deterministic output is and why context matters. Skill issue.


r/codex • • May 04 '26 Bravo

Limits The Resets Do Not Benefit Everyone, They Align Users and Truncate Use

Post image
5 Upvotes

Let’s just call this what it is.
I hit a reset at 53% usage, which means 47% of what I paid for just vanished. Not because I used it. Not because I mismanaged it. Just because the clock decided to cut the cycle short.
My UI literally says it: 11 hours 21 minutes stolen by early reset.
So this isn’t a “feels like” situation, its the system itself, through true usage measureents admitting it.

I budget my usage like a normal person (and this week, I left a lot for Monday, which was to be my 'big job day'):
Usually, I spread it across the full cycle, lean on caching to stretch it, leave headroom for spikes. That only works if the time window is real.

But it’s not.

Instead, what I actually get is: “Here’s your full quota… but maybe only for half the time. Good luck.”
So in this case:
Paid for: 100%
Actually usable: 53%
Straight-up lost: 47%

And here’s the worst part:
That effectively means I’m paying almost double for what I actually got to use.
Like, do the math: If I only get to use ~53% of what I paid for, then my real cost per usable unit is basically 1.9x what it should be. That’s not a rounding error. That’s a completely broken value model.

Why this screws my workflow specifically
My whole setup assumes:
I have X capacity over Y time that I can choose to pace usage intelligently or choose when to spend heavy. But with early resets, it turns into: “You had capacity… you just didn’t use it fast enough before we took it back.” Cool. Love that... not. There’s no way to “make that up” either. I can’t go back in time and burn it faster.

The real issue
This isn’t about usage. It’s about unreliable delivery. If quota is tied to time, then the time window has to be consistent. Otherwise: the quota isn’t actually guaranteed, the budgeting model is meaningless, & planning ahead is basically pointless

Here's My Truth
I didn’t underuse my quota.
My quota was taken away from me early.

Those are not the same thing.

And losing 47% of paid capacity because of timing alone is… yeah, not exactly a great system.


r/codex • • Oct 11 '26

Complaint Did I join r/codex or an Opus fan club?

3 Upvotes

I keep seeing “Opus this, Opus that” posts here, and some of them are starting to feel more like sales pitches than actual discussions about Codex.

Genuine comparisons are useful, especially when people share specific examples. But when a post is purely about how great Opus is and has little to do with Codex, wouldn’t it make more sense to post it in the relevant subreddit?

There’s nothing wrong with preferring another model. I’d just like this community to stay focused on Codex tips, projects, feedback, and useful discussions rather than constant promotion of something else.


r/codex • • Sep 05 '26

Complaint Rant: Getting tired of all the posts complaining about running out of usage after 10hr of coding on a $20 plan

0 Upvotes

I know - "Who asked?"

No one. I know there's other people in this sub sick and tired of seeing this sort of posts.

INFERENCE IS EXPENSIVE. GET THE $200 PLAN IF YOU HAVE SERIOUS WORK TO DO AND STOP COMPLAINING


r/codex • • 11d ago Bravo Heartwarming

Praise End of an era for Codex. Gonna miss Tibo 🫡

204 Upvotes

Not gonna lie, it’s actually a little sad seeing Tibo seemingly pass the torch to someone else when it comes to Codex and ChatGPT resets.
I remember reading rumors last month that some people internally at OpenAI weren’t exactly happy with how generously he was handing out resets. At the time, I didn’t think much of it, but seeing his recent reply to that quote tweet makes me wonder if there was some truth to those rumors after all.
Obviously, none of us really know what’s happening behind the scenes, so take that with a grain of salt.
And look, I get it. With all the speculation about OpenAI eventually going public, handing out free resets left and right probably isn’t the most sustainable business strategy.
But man, Tibo was genuinely one of the funniest people to follow on X. He had a personality, interacted with the community, and made the whole Codex experience feel a little less corporate. There’s something refreshing about someone at a massive AI company who can actually joke around with users and casually save everyone’s day with a reset.
Maybe this is just a normal changing of the guard. Maybe there’s more to the story. Who knows?
Either way, if this really is him stepping back from being the unofficial face of Codex resets, it’s a shame.
Thanks for the laughs, the resets, and the good vibes, Tibo. You made hitting usage limits a little less painful. 🫡


r/codex • • Aug 21 '26

Reset Get notified about the next Codex reset as soon as Tibo sends it out!!! lol

0 Upvotes

Signup for the official r/codex reset notified to get notified about resets when they happen!

https://codex.lunarwerx.com/

PS: Trying out my AI generated videos lol, be nice... haha! 🔥


r/codex • • Aug 14 '26

Praise So much time wasted until I switched...

0 Upvotes

I am 78 years of age and retired. I was looking for a tech-based hobby and having very limited experience of web development, I thought I'd try my hand at vibe coding. I started work on an app in March (this year) using Google AI studio. After a couple of months hitting dead ends, strange messages and hallucinations, I moved to Claude.Things went well initially. But the bills kept rolling in, progress was expensive and painfully slow. So in June I bit the bullet and switched to Codex.Transferring the code was a quick and easy process, but the difference in terms of workflow was nothing short of amazing. It was a much smoother ride than either of the two other platforms - it was quick, efficient and cooperative. By the end of July I was 90% of the way there. In my experience, and with no experience of programming, Codex is a far superior product to either Claude or Google AI studio. Anyway, the app is now live and seems to be performing well. Next step is to develop the native versions, which I'm not looking forward to. Not making any money at the moment but it's still early days. If you're interested, here's the link: https://dinnerbydesign.app Comments welcome.


r/codex • • Oct 11 '26

Other Why do I feel like Astra is still better than opus for coding

0 Upvotes

I feel like opus is for one shotting. With Astra I feel like I have more control and I understand what it is doing. Do you guys feel this way? Or am I just too used to codex and how openAI models talk to me?

Opus seems to be faster and make better UI/UX.

Maybe I just have to gitgud with Claude.


r/codex • • May 27 '26

Complaint Codex feels the worse Agentic AI at the moment.

0 Upvotes

Over the past few weeks, we have been dealing with a constant stream of model resets. At first, we were actually happy about the updates. However, OpenAI has quietly reduced our 5-hour quota, and the Plus tier has been significantly nerfed as well.

Right now, even GPT-5.5 xHIGH feels like GPT-3—it’s barely able to solve anything. I’m running a full SSD workflow, using PRs, and carefully managing the context with memory apps. Yet, despite these optimizations, models like MiniMax 2.5 or DeepSeek V4 are performing much better for me.

What’s going on, OpenAI? Why the radio silence? Is this just going to be an endless hamster wheel? Are we stuck in a cycle where we switch to Claude, Claude gets degraded, GPT-5.6 comes out, we go back to GPT, and then GPT gets degraded again? Is this what the 'AI race' has actually come down to?


r/codex • • Oct 14 '26

Praise One small thing Open AI does silently that is very commendable

1 Upvotes

We all know that if you upgrade to the next tier, you get a fully new weekly quota, keep your banked resets and be able to use those banked resets with your new maximum usage limit, which is fair obviously, but what about the other end?

Well, I've just experienced it: I downgraded my subscription from the 200$ to the 20$ version since I was not fond of the news about the half usage limit and since I'm in the EU, that extra given is not available for me. On the last two days, I burned through every reset I had, and still had around 10% usage left with around 5 days for the next natural reset.

Lo and behold, a free instant-reset was given sometime between today and Monday, and the reset filled a full 200$ plan weekly quota, even though I am already 2 days into the 20$ subscription!

You could argue that a 10% usage left from 200$ plan is 2x your original 20$ sub quota and if it reset with a 100% usage with the new limits, it would be a downgrade so they opted not to have that. But even then, a full 200$ quota is something they did not have to do.

They get so much negative here in my opinion and when they do good things, those go unnoticed completely. I am personally very satisfied with the 20x usage limits or the quality of work, ran the CLI on sol 5.6 max, then astra 6 max non-stop when it launched and I still wasn't able to drain the usage at times, but that 50% reduction will mean that I will not be able to go a full week.

Not every task needs the strongest model, that is true, but for 200$ I should be able to get that premium for myself. Ultra and fast mode is pointless IMO, haven't really noticed any speedup or extra added creativeness, but drains insanely fast, so I avoided them.

The credits are also a nice farewell bonus, which I will gladly spend before choosing which sub to get next. I got a glimpse of opus 5.5 yesterday from the company's account and I am quite satisfied with the results. Satisfied here means: explaining is much clearer, they do not spam em-dashes and have basic web designs be filled with "blablablah that actually works. " or the "material1 / material2 / material3" headache. Curious on the blender workflows since Astra did struggle at times to make it realistic or coherent. UI design in Unity was also pretty annoying even after giving lots of references and explaining.

So to summarize: thank you Open AI for the kind farewell, but it is a race after all and right now, you've got your brakes on. When you step on the gas, I will consider coming back. [bit cheesy, but you get the point]


r/codex • • Sep 23 '26

Comparison I gave Astra, Sol, and Opus 5.5 the same Rust task

4 Upvotes

I drafted this post with Astra and made some edits afterward.

I'd hit my Codex usage limit at the time, so I used Fable 5.1 to write the task brief.

TL;DR

I gave the same Rust task to four model/agent combinations, with one run each. I compared the time to the first results report, token costs, and how much of the brief each run completed.

RunTime to first reportCost at API rates (USD)Checklist completion
Astra / Codex1h 13m 35s$48.8377/81 · 95.1%
Sol / Codex56m 41s$16.8058/81 · 71.6%
Sol / Pi59m 28s$15.9062/81 · 76.5%
Opus / Claude Code2h 45m 34s$61.4274/81 · 91.4%

Astra checked source preservation and index updates in detail. Sol/Codex was quickest to report results. Sol/Pi checked some boundaries that Codex missed and explicitly reported unfinished validation. Opus went furthest in checking the actual binary and release build.

All four still needed work. Even Astra, which met the most checklist items, could reject successful API responses I'd saved from earlier runs. This single pair of Sol runs also wasn't enough to establish a winner between Codex and Pi.

The timings end at the first results report, with outstanding issues still unresolved. Costs are calculated at Standard API rates, accounting for caching and context length per request; they are not actual bills. Completion is based on an 81-item checklist assembled afterward. Pi's time and usage cover its restarted session after a configuration adjustment.

Why I tried this, and the setup

The releases of Opus 5.5 and GPT-6-Sol prompted me to compare the three models on a project I actually use. I'd also been curious about Codex versus Pi, so I ran Sol once in each environment.

I wanted to see whether they kept track of requirements across multiple stages, what they chose to test, and when they decided the work was done.

ModelAgentReasoning effort
GPT-6-AstraCodex CLImax
GPT-6-SolCodex CLImax
GPT-6-SolPimax
Opus 5.5Claude Codemax

Astra/Codex is the baseline for the overall comparison. For the comparison between agents using the same model, Sol/Codex is the baseline for Sol/Pi. I reviewed Astra's code and requirements coverage just as I did the other three implementations.

The recorded versions were Codex CLI 0.156.0 and Claude Code 2.1.280. I couldn't establish the Pi client version during this review. Each combination ran once, and I didn't hold the tool setup or context management constant across agents.

What I asked them to build

The project is codemap-search, a code navigation MCP server I'm developing in Rust. The task was to add two features using TypeSafe Jev.

Jev returns scores (Score), choices (Choice), and yes/no probabilities (Noul). It would judge whether code was relevant to the task, while Rust would enforce request limits and rules for preserving code.

  1. overview recommendations: Evaluate all files in the same index snapshot and recommend up to 24 eligible files. If nothing fits, don't force a recommendation.

  2. search filtering: Omit irrelevant code bodies from what the existing search would otherwise display. Declaration names, file boundaries, necessary dependency context, and incomplete code excerpts had to stay.

The work also included a shared async evaluator, batching, deadlines, cancellation, settings disabled by default, MCP integration, sensitive data redaction, documentation, and offline validation.

The shared briefset had five stages: runtime, overview recommendations, search filtering, configuration/MCP integration, and final validation. Dependent work was supposed to start after the preceding implementation and its validation had been handed off. Adding the required tests was allowed; live paid calls to Jev were excluded.

A later Git comparison confirmed that all four runs started with identical source code and briefs. However, the reference Python PoC was missing from the specified location. Three runs worked mainly from the specification and official documentation; Opus found another locally archived copy. The starting code was identical, but the reference material they actually used wasn't.

After the runs, I compared their self-reviews with session logs, commits, and validation results. That's the basis for the findings below.

What the work history and code showed

Astra: concrete tests for preserving source code

Astra worked through the shared evaluator, the two adapters, and then integration. It spent roughly the last 25 minutes on integration checks and the full regression suite. It covered much of the implementation and validation with the fewest recorded responses.

Its tests were especially specific about code disappearing incorrectly or the basis for a request changing midway through it.

  • It added a real file and refreshed the index during evaluation, checking that the current request still saw 3 files while the next request saw 4.

  • It reproduced and fixed a bug where removing one function's body also removed a neighboring function on the same line.

  • It retained raw judgments, their mappings to candidates, and the index snapshot. Evaluation results remained available in MCP metadata even when there was no room for them in the response body.

Its stage management was less consistent. It checked off a stage after failing to create the handoff document, and later modified completed stages without consistently updating their status.

The biggest issue was compatibility with real API responses. It set a tolerance of 0.001 for probability sums and weighted Score consistency. Checking those rules against archived successful Jev 1.13.0 responses showed that they would reject 119 of the 120 responses containing Score outputs with four levels.

For example, one record has probabilities of [0.99, 0.01, 0, 0] and a returned Score of 0.02. The weighted sum of the displayed probabilities is 0.01, so the new implementation rejects it. This was a comparison of archived response values against the validation code; it was not 120 new production requests through the Rust implementation. The original provider records are also not included in the public commits.

The source preservation checks were detailed, but the mock responses didn't expose this mismatch. Despite the high completion percentage shown later, this compatibility issue needs fixing before I'd use the implementation.

Sol / Codex: fast integration, with gaps at the boundaries

Sol started overview while it was still building the runtime, and moved into MCP integration before writing the adapter handoffs. Most of those documents were written near the end.

It also changed the search filter late in the run. The first version edited positions in the output string directly; the revised version modified each file's structured result and rendered it again. That brought it into line with the brief, but the review still found these issues:

  • Time budget: The overview scoring and role selection stages each get a fresh 45 seconds. If each takes about 40 seconds, one request can run for roughly 80 seconds.

  • Reusable API: It accepts Score criteria expressed as objects or arrays, but only accepts strings in the response's legend. It can reject the structured responses described in the official documentation.

  • Rendering positions: When adjusting the position of relationship notes after omitting bodies, it subtracts the current file's size reduction again. The notes can end up in the wrong place. I found this by tracing the code and did not run a separate reproduction.

  • Recommendation ordering: For each eligible file, the brief called for the maximum score across all its fragments. Both Sol runs took the maximum only among fragments that passed the eligibility check.

Some required checks were missing too. There was a test that reapplied a Noul judgment of 0.80 at thresholds of 0.70 and 0.90, but no tests for the specified 0.69, 0.70, and 0.71 boundaries. Configuration changes were tested between requests, not during an ongoing evaluation.

Sol / Pi: different test choices and completion reporting

The same Sol model made different testing choices in Pi. It covered Noul boundaries, cases involving Rust, TypeScript, and constants, and threshold changes during evaluation. Some of these checks were missing from the Codex run.

It also narrowed the overall validation scope. It interpreted the instruction not to inspect other worktrees or branches as extending to branch switches inside temporary test repositories, then excluded all 10 watcher tests. Not all 10 actually switched branches. It skipped the package contents check too.

The search filter used indexed call relationships even when those relationships weren't displayed in the result. That can preserve more source, but it differs from the specified policy and affects how much the filter removes. It also substituted a check that reused a mock transport object for an actual HTTP connection reuse test.

There was a separate bug in the request size limit. When a small question is followed by a large one and the batch is split, the new question isn't checked again to see whether it exceeds the byte limit on its own. That leaves a path where a 2,000-byte question can be sent despite a 1,024-byte limit.

The completion report matched the remaining work. The other three runs checked off every completion item in the parent brief; Pi left unfinished items open. I valued that explicit record of missing validation more than the smaller implementation size.

Opus: broader validation, and more policy changes of its own

Opus spent roughly the first 21 minutes reading the reference material, examining existing behavior, and running baseline tests. It then followed the implement → validate → write handoff → mark complete sequence most consistently.

The extra time did produce broader checks.

  • It separated transport, batching, questions, responses, errors, and cancellation, and retained known usage and request records even on failure.

  • It used archived provider responses to check token estimation and numerical tolerances. Given Astra's compatibility issue, that was useful work.

  • It used virtual time in runtime tests involving timing.

  • It exercised enabled Jev features through the actual stdio binary and checked that the test injection path was absent from the release build.

It also changed some of the requested settings and limits.

  • Following the repository's boolean naming rules, it changed overview_enabled and search_filter_enabled to is_overview_enabled and is_search_filter_enabled. There are no aliases for the original names, so using the settings from the brief won't enable the features.

  • It read api_key_env only from global configuration, preventing repository configuration from changing which environment variable supplied the credentials. There was a security rationale, but it changed the existing configuration precedence that the brief required it to preserve.

  • It retained the defaults but allowed configuration to raise request size to 512,000 bytes and concurrency to 16. The brief specified ceilings of 80,000 bytes and 3 concurrent requests.

The review also found a condition where overview evaluation wasn't bypassed after the index had stopped but still retained data. When output space was tight, it could discard a completed search evaluation and leave usage information only in logs.

Compared with Astra, it took 2.25 times as long, processed 6.46 times as many total tokens, and produced 6.93 times as many output tokens. There were 507 recorded responses and 4 context compactions. It also added about 2.72 times as many Rust lines, including tests. The broader validation came with more code and configuration changes to review.

Codex versus Pi, using the same Sol model

The baseline in this section is GPT-6-Sol / Codex CLI / max (cc3df0e). The Pi run (479c552) used the same model and reasoning setting. This is a separate comparison from the overall Astra baseline.

MetricSol / Codex (baseline)Sol / PiPi versus baseline
Time to first report56m 41s59m 28s4.9% more
Total tokens processed48,734,51745,423,1846.8% fewer
Input excluding cache reads375,480685,07682.5% more
Output119,805105,02012.3% fewer
Responses2121948.5% fewer
Cost at Standard API rates$16.80$15.905.4% lower

Percentage changes use (Pi value / Sol·Codex value − 1) × 100.

Pi processed 6.8% fewer tokens and cost 5.4% less at API rates, but took 4.9% longer. It did more of some individual checks and less of the full e2e and packaging validation. That doesn't establish that it completed the same amount of work to the same standard at a lower cost.

The differences I was curious about showed up in task selection and reporting. With the same model, the runs differed in how broadly they interpreted instructions, which checks they prioritized, and when they called the work done. But with one run each, different tools, and different context management, I can't attribute those differences specifically to Codex or Pi.

Pi also had an initial attempt excluded from the table. Exploration started at 06:45 KST and was stopped without any code changes. After adjusting the context limit configuration, I restarted at 06:55. The table covers that restarted session. The initial exploration consumed another 201,715 tokens, and total elapsed time from the first request to the final result was about 1h 9m 29s. Usage from the configuration adjustment itself is not included.

Time, tokens, and cost

These times end when each agent first reported the outcome of its implementation work. They don't measure time to satisfy every acceptance criterion; Pi explicitly left validation unfinished in that report. Usage queries, retrospectives, and subsequent commit work are excluded.

RunTime to first reportTotal tokens processedRelative to AstraResponses
Astra / Codex1h 13m 35s20.89M1.00×91
Sol / Codex56m 41s48.73M2.33×212
Sol / Pi59m 28s45.42M2.17×194
Opus / Claude Code2h 45m 34s134.99M6.46×507

Here, 1M means one million tokens. Response counts include responses with recorded usage. Total tokens add up the input and output processed across requests. The same earlier context can be read from cache repeatedly, so these totals don't represent that much unique material.

Astra and Sol/Codex had almost identical average input lengths per response: about 228K and 229K tokens. Sol's larger input total came from generating more responses with a similar amount of context. Its uncached input was actually 46.4% lower, and its output was 7.7% lower.

Sol/Codex processed 2.33 times as many total tokens as Astra, but its cost at API rates was 65.6% lower. Opus processed 6.46 times as many tokens and cost 25.8% more. Those figures account for model pricing and cache rates.

I calculated costs using official Standard API prices checked on September 23, 2026. These are comparable estimates from token usage, not verified bills. For Astra and Sol, I applied the context pricing tier separately to each request. For Opus, I used the rate for cache writes retained for one hour, as recorded in the logs. Reasoning tokens were already part of output and weren't added again. OpenAI pricing, Anthropic pricing

The comparison excludes subscriptions, taxes, tool fees, discounts, Fast mode, and regional surcharges. The max reasoning setting is separate from Fast pricing. The cost breakdown and calculations are at the end.

Completion against the brief

I also checked how much was actually finished by comparing the completion reports with the brief. Using the state at the first results report, I consolidated repeated requirements into 49 code behavior items, 27 required validation/documentation items, and 5 prerequisites/process items, for 81 checklist items in total.

The original brief did not literally contain 81 separately numbered tasks. I assembled this checklist afterward and applied the same items to all four runs, with equal weight and no partial credit. Defects in the shared runtime were counted against the item where they originated; each feature's own implementation requirements were assessed separately.

Overall completion

Completion = items confirmed as met / 81 × 100**.** Deviations from the specification, missing validation, and process violations did not count as complete. Neither did items for which there wasn't enough evidence to decide.

RunCompleted/totalNeeds work or confirmationCompletionVersus Astra
Astra / Codex77/81495.1%Baseline
Sol / Codex58/812371.6%−23.5 pp
Sol / Pi62/811976.5%−18.5 pp
Opus / Claude Code74/81791.4%−3.7 pp

“pp” means percentage points relative to Astra. None of the runs met all 81 items. The remaining count includes missing tests, documentation, and process steps that weren't followed at the time, so it isn't a count of code fixes still to make.

Completion by stage

Each cell is completed/total.

Brief areaAstraSol / CodexSol / PiOpus
Shared runtime17/1814/1817/1816/18
overview recommendations15/1510/1510/1514/15
search filtering14/1411/1411/1414/14
Configuration/MCP integration15/1514/1515/1513/15
Final validation and evidence14/149/149/1414/14
Prerequisites and stage management2/50/50/53/5
Total77/8158/8162/8174/81

For all four runs, I left the requirement to verify the port against the specified PoC unconfirmed. The original material was missing, and I couldn't establish that Opus's alternative copy matched it. This also reflects a limitation in the supplied material.

I accepted MCP validation through calls within the process, as permitted by the brief. Sol and Opus's mock snapshot swaps also met the relevant unit-test requirement. Going further with the actual stdio binary or real index updates did not earn extra points.

Code behavior only

Removing validation, documentation, and process leaves 49 code behavior requirements. These percentages reflect requirements confirmed through the code and existing validation evidence. They are not success rates measured by repeatedly running a common set of inputs.

RunConfirmed as metCode changes neededMore evidence neededRequirements met
Astra / Codex48/491098.0%
Sol / Codex40/498181.6%
Sol / Pi43/494287.8%
Opus / Claude Code44/495089.8%

Astra's 98.0% does not mean 98% of real requests succeed. The tolerance check alone can determine whether the feature is usable. The percentages also depend on how requirements are split into items. I used the table to compare coverage of the requested work and assessed defect severity separately in the code review.

What the tests actually covered

A completed checklist item earned the same credit in each run, but the depth of validation differed.

ValidationAstraSol / CodexSol / PiOpus
e2e tests passed during the run214211199221
Additional e2e tests not run00100
MCP path used for enabled featuresCalls within the processCalls within the processCalls within the processActual stdio binary
Threshold changed during evaluationCheckedOnly between requestsCheckedChecked
MCP request during a real index refreshCheckedMock swap in unit testsNot demonstratedMock swap in unit tests
HTTP connection reuse/expiryLoopback serverLoopback serverMock object reuseLoopback server

All four e2e results also had one existing Clang-related ignored case. Each run added different tests, so I didn't treat the pass count as a quality score. The brief allowed MCP checks within the process; Opus went further by exercising stdio. Astra went further in checking requests during a real index refresh.

During the later review, I reran the existing cargo test --offline --manifest-path apps/codemap-search/Cargo.toml --lib jev command. All tests passed: 27 for Astra, 20 for Sol/Codex, 19 for Sol/Pi, and 59 for Opus. The response compatibility, deadline, and batching issues were found even with those tests passing.

Limits of the comparison

  • There was one run per combination. This isn't enough to rank the models' general abilities or establish statistical superiority. Token counts across models also don't necessarily represent the same amount of information or computation.

  • Elapsed time includes tool, compilation, and test waits. I didn't control resource contention from concurrent work, so this isn't a measurement of pure model speed.

  • I didn't measure production quality. There were no new live Jev calls, Noul threshold calibration, or validation on other operating systems. I didn't treat earlier Python performance results as measurements of these Rust implementations. The cost tables cover tokens used by the coding agents.

  • The public commits were created after the first results reports. Opus's commit includes a later change wrapping an internal error return value in Box. That follow-up work's time and usage are excluded from the totals.

  • Not all raw material is public. The public material consists of the four implementation commits and their validation documents. The local session logs used to check usage and chronology, and the complete archived provider responses, are not included.

None of the runs received the official Jev skill during implementation. I used it only during the later review and did not deduct points for not using it. The analysis was also assisted by AI, with findings from static code review distinguished from results of actual reruns.

What I'd check next time

If I ran the same task again, I'd have a clearer idea of where to focus the review. For Astra, I'd start with real API responses and the validation conditions. For both Sol runs, I'd check time and size limits across stages. For Pi, I'd look for required checks excluded by an overly broad reading of instructions. For Opus, I'd look for configuration names and policies that had drifted from the brief.

In this comparison, Codex and Pi differed more noticeably in how they selected work and decided it was finished than in time or cost. Pi's explicit unfinished items made it easier to see what still needed checking.

Above all, there was plenty of reason to inspect the commits after the tests passed and the results reports arrived. Here are the implementations and validation records.

Public commits

These links point to specific commits so later changes won't be mixed into the comparison.

Appendix: token breakdown

CategoryAstraSol / CodexSol / PiOpus
Uncached input700,452375,480685,0761,012
Cache reads20,064,64048,239,23244,633,088131,956,503
Cache writes0002,128,650
Output, including reasoning129,847119,805105,020899,799
Reasoning, a subset of output51,24250,71040,907545,042
Other output78,60569,09564,113354,757
Total20,894,93948,734,51745,423,184134,985,964

Total = uncached input + cache reads + cache writes + output. Reasoning is already included in output and is not added again. Opus logs repeat the same response ID across multiple entries, so those were deduplicated. Opus's uncached input and cache writes together total 2,129,662 tokens.

Appendix: cost calculations

All amounts are USD. Individual cost components are shown to four decimal places, and totals to two. Totals and ratios were calculated before rounding.

RunUncached inputCache readsCache writesOutput, including reasoningTotalRelative to Astra
Astra / Codex$8.9324$31.9981$0$7.8979$48.831.00×
Sol / Codex$0.9116$14.4885$0$1.4036$16.800.34×
Sol / Pi$2.1332$12.5326$0$1.2324$15.900.33×
Opus / Claude Code$0.0040$26.3913$17.0292$17.9960$61.421.26×

The cache calculations account for three details:

  1. Cache reads are separate from uncached input. Codex's input_tokens includes cache reads, so I subtracted them. Pi's input field already excludes cache reads. All three OpenAI runs recorded zero separate cache-write tokens.

  2. Astra and Sol were priced request by request. When a request's total input exceeded 272,000 tokens, the entire request used 2× the input/cache rates and 1.5× the output rate. This applied to 38/91 Astra requests, 79/212 Sol/Codex requests, and 60/194 Sol/Pi requests. I didn't select a single rate from the session total or average context length. Astra pricing conditions, Sol pricing conditions

  3. Opus used the rate for cache writes retained for one hour. All 2,128,650 cache-write tokens in the valid usage records were ephemeral_1h_input_tokens. Using the five-minute rate of $5/1M instead of $8/1M would undercount the cost by about $6.39. Cache reads were $0.20/1M, and no long-context surcharge was applied to Opus 5.5. Anthropic pricing and cache rates

Rates and usage by input tier

Rates below are USD per million tokens at Standard API pricing. The input tier is determined by the total input for each request, including input read from cache.

Model / input per requestUncached inputCache readsCache writesOutput
Astra / up to 272K$10$1$12.50$50
Astra / over 272K$20$2$25$75
Sol / up to 272K$2$0.20$2.50$10
Sol / over 272K$4$0.40$5$15
Opus 5.5 / all context lengths$4$0.20$5 / 5 min, $8 / 1 hour$20

Sources: OpenAI Standard pricing, Anthropic pricing. OpenAI cache-write usage was zero in these runs. The recorded Opus cache writes all used the one-hour duration.

Run / input per requestResponsesUncached inputCache readsOutput, including reasoning
Astra / up to 272K53507,6678,131,20073,627
Astra / over 272K38192,78511,933,44056,220
Sol·Codex / up to 272K133295,16124,035,96878,692
Sol·Codex / over 272K7980,31924,203,26441,113
Sol·Pi / up to 272K134303,56926,603,13668,583
Sol·Pi / over 272K60381,50718,029,95236,437

For each tier, I calculated token count × applicable rate / 1,000,000, then added the results. For example, Astra's cache-read cost is (8,131,200 × $1 + 11,933,440 × $2) / 1,000,000 = $31.99808.

For Opus, the calculation is (1,012 × $4 + 131,956,503 × $0.20 + 2,128,650 × $8 + 899,799 × $20) / 1,000,000 = $61.4205286. Cache-write tokens were not charged again as regular input.

Appendix: code and validation references

FindingEvidence at the reviewed commit
Astra's numerical toleranceRuntime validation, additional overview check
Astra's real index refresh and adjacent declarations on one lineIntegration tests
Sol's time budget across two stagesoverview call, deadline calculation
Sol's structured Score response validationlegend validation, official Score documentation
Sol's positioning of relationship notesadjust_after_omissions
Recommendation ordering in both Sol runsCodex maximum score calculation, Pi maximum score calculation
Pi's missing size recheck for a single questionBatch splitting
Pi's skipped validation and completion limitsFinal validation record
Opus's public setting names and precedenceConfiguration parser
Opus's request size and concurrency ceilingsRequest size ceiling, concurrency policy validation
Opus's condition for a stopped indexSnapshot handoff, host check
Opus's stdio and release validationFinal validation record

Appendix: related skills

  • Writing the brief: task-brief-creator — The skill used to organize scope, stage handoffs, and completion criteria.

  • Reviewing the results: Official Jev skill — This wasn't provided during implementation. It was used afterward to compare the implementations with the API contract.

These skill links point to their current public versions. The completion assessment used the original shared briefset linked above.


r/codex • • Jun 01 '26

Complaint Cancelling 5 Codex accounts

0 Upvotes

4 Plus accounts, 1 Pro Lite, new limits without the boost are worthless.

1 day after reset, not looking good! Totally unsustainable

Cancelling and going somewhere better or Upgrading to PRO $200?


r/codex • • Jun 13 '26

Commentary openai must be cracking up right now, right after they released banked resests and soon to release 5.6, Fable gets banned bc of marketing gone wrong

Post image
0 Upvotes

Hopefully openai has learned from anthropics mistakes and won’t try and tout 5.6 as world ending. Keeping the naming direction incremental also helps, “Mythos” has a “mythical” feeling to it that separates it from Opus. If they would have just made it opus 5 and said it was the latest and greatest upgrade it would have been okay.

But they created a massive hype train that made it seem like mythos could destroy secure systems, develop viruses, etc, which then gave an administration who already loves taking revenge a very easy opportunity to do so and force them to take the model down.

We’ll see what openais response to this is, if I were them I would drop 5.6 sooner rather than later to capitalize on this before fable gets reinstated.

Edit: I used Claude for over a year before coming to codex, and I actually got a Claude sub again to try out fable before it got ripped away. It’s not waving the flag of any company to talk about Anthropic screwing up. OpenAI has screwed up in the past before too but this is the relevant issue that’s going on right now lol


r/codex • • Sep 09 '26

Commentary Unpopular Opinion: If AI Keeps Wasting Your Tokens, Get Better at Using AI

2 Upvotes

It seems like this sub has basically become a running list of:

“OMG AI USED ALL MY TOKENS IN 12 HOURS DOING ONE TASK!!!”

Okay... and?

You asked it to do that task. Were you not looking at it at all during those 12 hours? Did you never check your usage and think, hmm... this seems like a lot, maybe something is going wrong here?

And before this turns into a model war, this applies to every model out there.

Claude, Codex, Gemini, whatever. I've used all of them.

Garbage in, garbage out.

I've asked different models to do some pretty complicated shit.

One project was basically: deploy 45 servers on a Hyper-V farm, create a domain, join everything to the domain, and install/configure X, Y, and Z according to a pile of documentation.

It ran for around 10 hours and used about 15% of my $200 plan.

Then I asked it to build an HTPC environment from end to end. That ran for around 6 hours and used about 75% of my plan.

Why the massive difference?

Prompt, guardrails, good documentation, the tools I gave it, and agent seperation/management.

Another example, I asked it to build a remote browser system where an RDS session displays the browser, but the actual rendering, processing and network traffic happen through a desktop WebView.

That project was planned out in detail. I had specialized agents with small clearly defined jobs, and manager agents coordinating everything. There were roughly 3,000 lines of documentation and instructions telling the system exactly what it was building and how everything should work.

That used around 35% of my $200 plan.

Then one day I basically said:

“You know what would be neat? Make me an app that manages all my Raspberry Pis from one interface. Give it all the features of ABC software.”

And you'll never believe what happened...

It burned through basically my entire usage in about 18 hours and still produced a shitty result.

Shocking.

Because I gave it shitty instructions. I barely planned anything out and basically told it "here's an idea, go build it." So yeah, it wandered around, made bad decisions, redid shit and wasted a ton of usage.

If you give a person shitty instructions you're probably going to get a shitty result. If you then disappear for 12 hours, give them no feedback, no direction, no milestones, and don't tell them they're heading down the wrong path, the result is probably going to get shittier and shittier as the project goes on.

Then when they finally deliver a pile of garbage, whose fault is that really?

AI isn't magically exempt from this.

And the constant:

“It used ALL MY TOKENS in 12 hours!”

Okay?

I can probably burn mine in four. Congradulations I guess?

How many sub-agents did you spin up? How many tool calls were being made? How much duplicate research happened? How many times did the context get compacted and lose something important? How many agents repeated work? How much time did it spend wandering down dead ends because you never gave it checkpoints or guardrails?

“I used all my tokens” tells me almost nothing about how much useful work actually happened.

Here's some perspective from that 45-server project.

The client was billed $15,000.

The project was roughly:

  • 6 hours of AI-assisted documentation/planning

  • 10 hours of autonomous AI implementation

  • 3 hours of actual human management

  • 10 hours of AI-driven testing, troubleshooting, fixes and user issues

Total actual human time invested was about 19 hours.

AI cost was about $6.

That's roughly $780 of revenue per human hour invested, before accounting for the rest of the business costs.

Six fucking dollars of AI usage helped leverage 19 hours of my time into a $15,000 project.

If that AI usage had cost me $200 instead of $6, I wouldn't have cared.

If it had cost me $500, I still wouldn't have cared.

Hell, if the AI portion had cost $2,000 and still let me deliver that project with 19 hours of human labor, I'd have paid it and moved on with my life.

Perspective.

I'm not trying to win a contest for who can use the fewest tokens. I'm trying to make money and get work done.

Thats the part that seems completely missing from alot of these complaints.

The people who actually figured out how to use these systems effectively usually aren't posting:

“HELP!!! IT USED 100% OF MY TOKENS!!!”

They're saying, yeah I burned through my allowance, but it just did 30 hours worth of work for $200 and saved me or my company hundreds or thousands of dollars.

That's a win. Who gives a shit that the token meter says 100%?

And then there's:

“But after all that work it STILL didn't fix the issue!”

Yeah... and?

If you hired a human for $200 and somehow got 30 hours of engineering work out of them, there is absolutely no guarantee they would have solved the problem either.

And if the issue is incredibly complicated, the codebase is massive, the documentation is hundreds or thousands of pages long, and your prompt is basically a vague one-liner... what do you honestly expect?

The useful metric isn't:

“How many tokens did it use?”

It's:

“How much useful work did I get for the money?”

And I already know what some of the responses to this are going to be:

“Nope. Not me. I'm good at AI.”

“I'm good at prompting.”

“My prompts are great.”

“The model is the problem.”

Okay.

If you're consistently burning through your entire allowance, getting garbage back, and then complaining that every model sucks... clearly you're not as good at this as you think you are.

Sorry.

Either your prompting isn't as good as you think, your project management isn't as good as you think, your expectations are completely unrealistic, or you have no idea how to do a basic cost/benefit analysis.

Or probably some combination of all of them.

And again, this isn't a Codex thing, or a Claude thing, or Gemini or whatever model you happen to be pissed off at this week.

Garbage in, garbage out.

Get better at breaking projects apart. Get better at documentation. Get better at giving agents narrow responsibilities. Get better at checkpoints. Get better at recognizing when an agent is going down a stupid path and stopping it before it spends six hours digging the hole deeper.

And most importantly, get better at measuring value produced instead of staring at a token meter like it's the fucking gas gauge on your car.

If your AI agent spent 18 hours running in circles because you gave it a vague one-paragraph prompt, no architecture, no documentation, no guardrails, no checkpoints and then walked away...

Maybe the lesson isn't that AI usage limits suck.

Maybe the lesson is that you suck at managing AI agents.

And fortunately, thats something you can actually fix.

Get better.


r/codex • • Oct 16 '26

Humor The reset economy, then and now

Post image
0 Upvotes

r/codex • • Sep 22 '26

Complaint GPT-6-SOL - not impressed

0 Upvotes

It is as slow as usual, quality is roughly the same as 5.6 and it still consumes about 1% quota per hour on a 20x Pro plan in my workflow - just as 5.6.

I'm using Sol High. So far, it looks like scam to me.

EDIT: Because some people asked - no coding is involved, its reverse engineering through IDA in a database that I have worked at for the past few days, so the results are comparable.


r/codex • • Jul 22 '26

Complaint My weekly quota is GONE in 2 days thx SOL ULTRA

6 Upvotes

What a joke.

I'm building backend services, APIs, database migrations, refactoring messy async logic. Not frontend fluff. Not CSS or image gen which is token heavy. SOL ULTRA is supposed to be the big boy for this stuff.

It burned through my entire weekly quota in two days (working only for 6 hrs in goal). Two. I'm not even halfway through my sprint.

LMAO the output isn't even better than what Sol High gave me a week ago. GPT 5.6 consumes quota faster and faster with each reset and it is really noticeable. And it becomes low-effort slop AI like when I ask it to optimize several endpoints and it spits back like "hey, I just ran e2e test and it failed but it was a planned fail now I fix it and run true test" consuming another 4% of weekly quota.


r/codex • • Aug 10 '26

Complaint Don’t ever use Luna Max

0 Upvotes

I recently had the worst experience of using Luna on max reasoning level
It goes on crack
It invent things not asked to
Hallucinates like hell
Spends hours and hours going in circle on the same thing
Token usage is way out of the roof

On the other hand xhigh is the best reasoning level
It does exactly what it has been told to do so
Does the work in timely manner
Doesn’t invent things
Token usage is so generous that I can go day in and out

Obviously it needs sol defining the boundaries , architecting , planning , adversarial etc etc
Luna Xhigh gets the work done


r/codex • • Apr 21 '26

Commentary GPT 5.5 : Major Shift in Agentic Coding

0 Upvotes

This is what is currently known about GPT 5.5, it points to a significant change in agentic coding capability as it seems like a brand new model trained from the ground up.

  • rumored to be a completely new pre-trained base, built on nearly two years of focused research.

  • major qualitative shift models becoming less rigid and more intuitive, adapting to user intent without over-explanation.

  • natively omnimodal system, GPT-5.5 is expected to function as a highly autonomous agent rather than a traditional chatbot.

  • long form reasoning handling complex, open-ended tasks over significantly longer timeframes.

  • solve tasks that previously required heavy prompting or weren't feasible for LLMs at all.

tldr: we are moving from "AI is just a tool" to "AI is an employee now".

edit: whoa where are all these Indian bot comments coming from ??!


r/codex • • Jun 14 '26

Complaint Purely unusable

3 Upvotes

I genuinely don’t know what to say.

This post will add nothing new of value, but I just cannot comprehend the level of degradation right now and I need to say it out loud. I feel like I’m talking to a malevolent sandbagging employee who should have been fired a long time ago but is still on payroll for political purposes.

Just spent the last 5 hours debugging a monorepo build error that Codex silently introduced while working on an isolated feature task.

For some reason, mid-goal it decided to completely change its worktree and create a split graphite stack for the work it was already doing on that stack. I looked at the logs around that split and it literally forgot that it was the agent working on the stack — so it treated the work as a “parallel” track by some other agent, which should not be interfered with at all.

In the new worktree, it also disregarded the skills injected into the custom instructions (which it typically does read reliably) — the skills that tell it how to use a worktree and graphite specifically.

So it skipped the whole setup process (literally, just `bun install` and `bun run build`) and began “debugging” a “broken build” by changing the build process itself — never bothering to just install dependencies and build them first.

So it added caching to the wrong part of the build toolchain, manually symlinked to packages in the primary worktree, and began installing packages in temporary directories and skipping the normal package manager entirely.

This basic setup process hasn’t changed in 8 months on my side.

Completely fckn unusable.


r/codex • • Sep 25 '26

Complaint OpenAI is becoming incompetent

4 Upvotes

On top of the fact that Opus 5.5 is crushing even ASTRA GPT-6 in almost every area — raw capability, reasoning, token efficiency, and quota management — serious problems have been affecting OpenAI’s systems since last night.
And the worst part is the complete lack of transparency on their official status page, where everything is shown as “operational,” as usual, even hours after major issues have already started.
Yesterday, the ChatGPT web interface was massively bugged for several hours. Today, Codex has been showing obvious signs of being severely degraded or practically unusable since yesterday, and the situation is still ongoing.
Meanwhile, Claude keeps introducing genuinely impressive features. One recent example is a quota-safety feature: when Claude is working on a task and you reach your usage limit, the model does not simply stop in the middle of the job. It first tries to finish the current task cleanly, and only after that does it block further usage until your quota resets.
That is an incredible feature, among many others, and it shows real attention to the user experience and to people who actually rely on these tools for serious work.
With Codex, on the other hand, there is unfortunately a growing sense of overall mediocrity.
I genuinely hope OpenAI reacts and manages to regain control, because the situation is becoming a disaster.
I pay for both services, including the $200 plans, and Claude has become incredibly impressive. Unfortunately, some things OpenAI offers — especially image generation and image-to-code/design workflows — are still unavailable or not as mature on Claude, which makes OpenAI difficult to replace completely for graphical interface work.
Otherwise, I would have already boycotted OpenAI entirely.


r/codex • • Aug 11 '26

Reset Use ALL your tokens ASAP

0 Upvotes

I see a lot of complaining about token usage, weekly resets and unplanned resets pushing the reset date.

Let me clarify something. You should use ALL your tokens as soon as they are available. I'm not saying you have to prompt stupid requests, but if you have something really important in your to-do list you should use all your tokens in one day, or two days max.

Why? First of all because you can benefit from unplanned resets. But more importantly, any completed task is a completed task.

I will never understand people saving tokens for the following day, or doing 20% per day. Either you are scamming your employer by pretending you are working 5 days when you can finish in one day, or for the case of a personal project you are delaying intentionally something that can be done earlier.

Use all your tokens, don't complain about unplanned resets, it's ridiculous.


r/codex • • Jun 10 '26

Workaround I really want codex to defeat Claude and win.

0 Upvotes

I'm a Claude MAX subscriber.

5.5 is the only model that always helped me when I was in the most difficult time. I hope he wins strong enough to kill Claude. I'm serious.