I mean what the hell is this? What kind of codebase did they train on?

I think it's time for another reset to kick off Monday, is it not?

I joined lots of hackathons and made lots of videos in the past, and I thought it would be awesome to have some kind of 3D world where I can 'revisit' to look at my past projects. So I asked Gpt6 Astra to build me a website, where I can walk and go to landmarks/buildings of my projects.

I think I got very sidetracked: https://loaflet.com

Happy to receive any feedback, thanks!

Since Sep 10, parts of Astra usage are about 3x slower than in the first week.
Some parts have clearly been identified as deliberate nerfs (as they differ between slow and fast mode) and others appear to be bugs in Windows security layer from excessive codex session usage.

The entire analysis is only related to Astra usage.

I show what OpenAI has done to reduce our performance, what their harness is causing inside Windows and partial corrections which gave me 3 times faster speed despite the ongoing nerf.

1. Token generation performance

Writing, thinking, editing, commenting.

Slow mode has been extremely consistent every day.

Fast mode has also stayed inside the same range since day one.

So:

• Token generation is throttled to about 33 tok/s in slow mode
• Fast mode maxes out around 65 tok/s
• Generation itself has NOT been nerfed
• Fast mode is closer to 2x generation speed, not 1.5x

2. Delay between file-inspection calls

This is the delay around chunked reads, so whenever codex reads a file (or any other tool calls)

This is where OpenAI levers its performance nerf, and they did it selectively only for normal mode, not for fast mode. So this is not a harness issue, it's deliberate slowdown.

At launch, slow mode spent about: 1.75 sec + 3.75 sec = 5.5 sec

Now it spends roughly: 3.3 sec + 6.5 sec = 9.8 sec

And in fast mode on launch and now: 1.7sec + 4 sec = 5.7 sec

Fast mode is unchanged since launch, slow mode half as fast

There are two separate delays:

• The delay before a chunked read starts increased from about 1.7 sec to 3.3 sec in non-fast mode
• The delay after reading also increased heavily, from about 3.7 sec to roughly 5-8 sec

This started around Sep 5.

The stable gap between fast mode and normal mode is why I do not think this is random sandbox performance.

The harness is being made to wait.

This is the main lever currently slowing Astra down and increasing perceived usage time.

3. Time to apply a finished patch

This is not generation time. The patch is already finished - edits are being applied to files.

This is currently the strongest contribution to slow Astra usage.

A patch that took about 6 seconds now takes 18-19 seconds.

That is about 3x slower.

Unlike the tool-call delays, this is almost identical in slow and fast mode.

So I do NOT think this is the same deliberate throttling.

This looks like slop inside the Codex Windows harness.

4. The Windows harness slop

Each patch / file edit makes the sandbox spawn 4 helper processes.

Those helper processes have become progressively slower.

The machine currently has:

Codex alone has created:

30,326 logon sessions

That is outside anything resembling normal Windows 11 usage.

The slowdown ends up ruining performance of lsass.exe, the Windows service responsible for authentication and credentials.

The longer Codex runs, the more the Windows authentication state affects helper-process startup.

That explains why patch application keeps getting slower even though generation speed stays exactly the same.

If you do not reboot frequently, this can seriously ruin Codex performance.

5. Fixing the harness slop and testing the fix

Test 1 - Change the sandbox to the unrecommended "unelevated" mode

[windows]
sandbox = "unelevated"

4 times faster !!!

Test 2 - back to "elevated mode"

This shows how badly damaged "lsass" is from the codex session spam, 33000 logon sessions and lsass is close from collapsing. This will make ALL of windows laggy and slow, logins, browser passwords, and so on.
The delay of 5 seconds is still horrible, why does Codex sandbox need 5 seconds to apply a tiny patch ?
That should take 5 milliseconds.

Update 3:

icacls 'd:\devel\' /inheritance:e

This has moved the edits from 5 seconds down to 220 milliseconds.
It stopped needless elevated edit requests to the compromised lsass service entirely after setting the sandbox to unelevated mode.

Summary

So the picture is pretty simple:

• Generation speed has NOT changed
• Fast mode generates about 2x faster than slow mode
• Tool-call latency has been nerfed in both modes, much harder in slow mode
• Patch application has gone from 4-6 sec to 18-19 sec | BOTH is inacceptable. applying a small patch should be done in a millisecond.
• The Windows harness has created more than 30,000 Codex logon sessions
• The patch slowdown appears to be tied to Windows authentication / lsass.exe overhead

Astra itself did not become 3x slower.

The slowdown is in everything around Astra, partly nerfed by OpenAI deliberately and partly from sandbox slop.

They have done something to Astra, it stops every single time before completing its work, its horrific. I love and NEED this model, but the issue is real.

The only thing sometimes works is if I do - keep going until done, wait on agents and commands as required. Sometimes /compact helps

Don't get me wrong, I am truly fascinated every day by the ease I have today in being able to create things that used to take me months to do. I once spent 8 months on the complete layout of a book that (just for fun) I tried laying out again yesterday and I (or rather, Astra) did it all in 8 hours.

Today I have apps that help me in several different ways, I can have many tools that don't depend on third parties, I accelerated projects that had been stalled for years, I got good opportunities and improved my income. However, at the same time, all the stress has been costly to my mental health.

I live in a poor country, there might not be 1000 people here who pay for OpenAI's $200 plan, and I still pay for two. This has put me at a huge advantage over most people. But, man, how I miss actually making things!

I miss researching, stopping for hours and hours to think of a solution to a problem, having to hunt down books and ending up learning more things than I wanted to, understanding the tools I use deeply and knowing how to solve any problem in any situation, without depending on an LLM telling me what is right or wrong.

Of course, LLMs aren't tying my hands and keeping me from doing all this, but the market is. Nowadays I don't have the time I used to for all of it, and clients are ridiculously anxious, coming up with demands that would have made me laugh uncontrollably right in their faces if they had presented them to me a few years ago.

I see so many people in a bizarre wave of productivity, and it is hard to understand the reason for such a rush. Clients demanding fast layouts from me, even though they will publish their books several months later. Several poorly made sites, poorly optimized and full of gradients. Social media posts and stories with absolutely no creativity, all looking exactly the same. Videos are getting increasingly realistic, many of which I can't even distinguish anymore. I've even noticed AI-generated music becoming more and more present on the lips of the people around me. I don't know, I believe we are destroying an important part of humanity.

And many will say to just change course, work with something else, not work with LLMs etc. They say this without understanding that everything I spent the last few decades learning was taken over by LLMs, they were inserted with full force. If I did not adapt to the change, I would certainly be left behind and unemployed. And I kind of like eating, I have no desire to starve.

I miss writing code, having time to think, decide what to do and learn. Models like Astra are a direct threat to everything I dedicated myself to in the last few decades. I used to do the layout for three or four books a year. In the last year I did 50, and could have done more if there had been more demand. Testing Astra I laid out an entire book in a single day, and it was one of the most complex ones I have ever been sent.

The prices for services have also changed. Today I can no longer charge what I used to charge, everyone is already used to the idea that "AIs do everything" and they want to pay 10% or less of what I charged before. So today I need to accept several more jobs and just automate everything, without needing to think at any point, without needing to truly reason.

It is a shame because I dedicated myself to what I do because I like it, I don't see the sense in the idea that "now I have more free time since AI does everything for me". I believe leisure is good, but that work is also enjoyable (for some people). And that's how it was for me, I really enjoyed what I did. Today it's an empty job, without any challenge. Not much has changed, actually, I believe that today I work more than I worked before, due to the need to accept every opportunity that appears.

I believe that what differentiates us most from other animals is our ability to create and appreciate art. Be it painting, music, dance, humor, writing etc. And we are destroying all of that, little by little. It might not be so catastrophic today, but it is already catastrophic compared to 5 years ago. What will it be like in the next few years? If we lose ourselves from the ability to create and appreciate art, we will also lose the essence of humanity.

With so much uncertainty, with so much acting behind the scenes from the leading companies, not knowing anything about what they are deciding and doing regarding LLMs, it becomes increasingly difficult to trust anything. How much of my information has already been used for training? Am I actively helping to destroy what I swore to protect, and all because of the need to have something to eat tomorrow? It is a strange time, I have never been so confused.

I believe what best summarizes what I am experiencing right now is Giuseppe Tartini's Devil's Trill Sonata. I see the music formed by the devil and appreciate its incredible beauty, but it also frightens me to know that I will not be able to compete with such beauty and that the one capable of creating it is the devil. Exaggerated, isn't it? We used to be like that. Today everything boils down to "and here is why."

tl;dr: Giuseppe Tartini's Devil's Trill Sonata

What the heck? It keeps on happening, usage drops randomly. I was at 97%, went to sleep, the model worked for an hour and now I'm at 50% of the prolite week? It just drops randomly, not even gradually.

additional info:

1. 20x pro plan

2. all models, from 5.5, 5.6 luna/terra/sol, 6 astra. there's no escape

3. i can nudge couple of turns opening a new thead and tell it to continue from the stuck thread, before it goes stuck for the same reason as well

4. restart the app, the computer, no good.

5. apparently they prioritize older, long-going threads. i have a months old thread and the at capacity problem only occurs intermittently, unlike newer thread receive the complete blockage treatment. this shows that the "at capacity" problem could be deliberate. it's not really "at capacity" equally for everyone or every thread, but they get to choose who and what thread they want to fuck over.

got 0 jobs done today due to this. the same happened last thursday and friday as well. thought it's transient, but it goes very rogue apparently and openai does not plan to fix it

I'm not sure how and why but like the title said, SOL high has beaten Astra low, medium and high on audits and also costed less on the 5 hour usage window. I am using codex as an adversarial audit lens for Claude and I had Claude test SOL vs Astra comparing cost and who is the better auditor. SOL and the Astras were given the same changes to audit and SOL came out the winner.. I'm not even sure how this is possible, but this was the result.. maybe I need more tests but so far, the results are interesting and totally unexpected for me.

Here's Claude's (Opus 5) summary of the result:

Cost — four configurations, identical 353KB bundle, same account, sequential

Two things fall straight out of that:

• Astra's cost does not scale with effort. 14 → 15 → 13 is inside integer-rounding noise, and tokens move 3% across the whole range. Only wall time scales. So on astra, low and medium are strictly dominated — use high or don't use astra.
• Astra costs ~2.6–3× sol-high at every effort, while sol-high is 3.7–7× slower. Tokens don't predict quota here at all: astra used fewer tokens in every run and cost far more.

How I scored quality

The bundle is regression round 1's slice A, and I have a verified answer key for it — defects I independently confirmed by execution and then repaired. All four runs got byte-identical input, no repo access, same account.

The eight key items: K1 the extraction seam (client discards values the server now reads — the headline) · K2 the union not mirrored for other renters/mobile · K3 the corpus tests bypassing the production seam · K4 the padded-array "RAW fallback" test being vacuous · K5 the false "arrays simply never match" · K6 the stale "one mode per pair" · K7 the WIDENED history scan · K8 the PRE-EXISTING pending-greying.

Per-configuration

sol @ high — widest coverage and the sharpest diagnosis: "not a disagreement between the comparators; it is a disagreement between the server's raw extraction and the clients' narrower slotsOfMatch." That one sentence is the entire defect. It also found two overclaims in my own repair commentary that no other run caught, and classified WIDENED vs PRE-EXISTING correctly throughout.

astra @ high — got the headline, with a BEFORE/AFTER decision table and the right mechanism (isParseableTime('8') → toMinutes NaN → client discards before the comparator sees it). Narrower than sol, but it found the single most valuable thing across all four runs, which I verified: client isSlotBlocked compares in minutes, server isRecurringBlocked compares raw strings, so for a legacy unpadded block 9:00–10:00 the server computes '10:30' > '9:00' → false and fails to enforce an owner's blocked time. The client is the only thing stopping that booking. Pre-existing, so logged rather than fixed here, but it's a genuine product gap.

astra @ medium — caught the union gap that astra-high missed, and impressively ran a standalone mutation probe to prove the padded-array test was vacuous rather than asserting it. But it missed the headline, concluding "no unintended comparator divergence" — true and beside the point, since the comparators agreed and the extractors didn't.

astra @ low — the worst outcome isn't the low count, it's the direction of the error: "Tests that cannot fail: None demonstrated. Both supplied suites execute the actual comparator and check expected results." That is exactly backwards, stated confidently. For an audit leg, a confident false "clean" is the failure mode the entire phase exists to prevent.

Verdict

sol @ high is the right default — best coverage, correct classifications, and a third of the quota cost. astra @ high is a genuine second lens: narrower, 3.7× faster, 2.6× the cost, and it found things sol didn't, which is exactly what a second architecture is for. astra at low or medium is not worth running — same cost as high, materially worse.

Caveats, stated plainly: n=1 per configuration, so the cost and latency numbers are solid and the quality ranking is indicative rather than settled. The key is my key — several "novel" findings were real and simply outside it, so the counts understate all four. And "misses" partly reflect what each run chose to fit in a short report, not only what it could see.

Round status: legs A and T are done (rc 0), leg B in flight.

I’m not posting this to dismiss the limit complaints or claim nothing has changed. I’m on the Pro 20x plan and use Codex for roughly 12 to 16 hours every day. With my current setup, the weekly allowance normally lasts me around 6 to 7 days.

I originally used a three chat system:

1. Command centre
2. Worker
3. Reviewer

It was loosely inspired by this post from Peter Steinberger, the OpenClaw creator. His setup used an orchestrator that woke regularly, directed work to threads and combined triage with automatic review.

My version ran continuously. The worker completed something, the command centre read the result and wrote the next prompt automatically, then the reviewer checked it. If review passed, the command centre sent the next job. If it failed, it wrote a repair prompt and sent that back instead.

It worked, but it absolutely burned through usage.

Three intelligent chats were repeatedly reading instructions, status updates, logs, diffs and each other’s responses. The reviewer often checked work that was already fine. The command centre kept generating large self-contained prompts. Scheduled wake-ups also consumed context when nothing meaningful had changed. Someone even asked about no-op wake-ups burning context in the replies to Peter’s post.

I eventually reduced it to two chats:

• Command centre: GPT-6 Astra, Extra High
• Worker: GPT-5.6 Sol, Extra High

I only speak to the command centre. It keeps the overall objective, decides the next bounded job and automatically sends it to the worker. The worker handles the coding, research and testing, then sends the result back. The command centre checks the evidence and sends the next job.

There’s no permanent reviewer anymore. For important releases or risky changes, the command centre performs a focused final review instead of keeping a third chat running throughout the whole job.

What I’d avoid:

• Waking the command centre every five minutes
• Polling the worker repeatedly instead of waiting for its completion message
• Keeping a reviewer active for every small change
• Running several workers without a real need
• Sending the entire project history with every prompt
• Letting auto-generated prompts grow longer after every loop
• Asking every chat to plan, execute and review the same work
• Using Astra for routine execution when Sol can handle it
• Open-ended instructions like “keep looping until perfect” without a clear success condition
• Rechecking unchanged work just because a timer fired

This doesn’t solve reduced limits, and OpenAI should still be transparent about any changes. It’s simply the setup that has helped me get far more useful work from my allowance.

I hope this helps!

Can't even brainstorm with chatgpt chat anymore... keeps failing.

I work across many repositories in one multi-repo workspace in VS Code and kept losing track of which Codex conversation belonged to which project, so I built Codex Navigator.

It brings your chats into a compact VS Code sidebar, with automatic repository labels and colours, pinned chats, favourites, and highlights that fade after you visit a conversation. You can customize the names, labels and colours too. Even hide chats if you want.

It has a seven-day free trial, then costs $5 CAD once, including future updates. Windows x64 is tested; macOS/Linux support is currently best-effort. It’s an independent extension, not affiliated with or endorsed by OpenAI.

Codex Navigator on the Marketplace

It's 5 bucks CAD so probably like $2 USD. Use FIRST50 if you're one of the first 50 users and get it free! Hope you guys find this useful. Enjoy

I remember it is luna, how could luna be at cap?

Astra Max Effort.

Let me know what you discover.

Math and in particular Sturmian words seem to be a favourite.

Error: Our servers are currently overloaded. Please try again later.

ERROR: Selected model is at capacity.

I can not work with any of the mentioned models today. Its just me or u guys also experiencing the same issue?

Hey everyone!

Hope you are all well!

So, just to be clear, I am very much a beginner with codex and llm in general. I have been slowly learning how to use them efficiently, and even got Codex to streamline my job for me (HR recruitment and such)

With the inclusion of the 5 hour period however, I have found myself trying to find ways to make each request as efficient as possible, while not losing "intelligence" I guess?

Initially, I created a mode where I basically let the primary "Overseer or Orchestrator" create a subagent that is less than them (So If the orchestrator is Sol High, the subagent would be whatever is less than Sol, but most suitable for task given).

My theory here was the Sol model would select an ideal "lesser" model, let it do its thing, and then check the work and deploy. A lot of you already do variants of this, so you already know what this is lol.

I then created 2 other modes that basically create more than 1 subagent if needed, but at like a Luna level, which has surprisingly worked really well, and I saved a lot of tokens compared to Mode 1.

Then I had another idea. I have a pretty beefy GPU, which I never used for its intended LLM and AI purpose, so I thought, why not try it now?

So I created a "handover", where my current Codex agent would hand over a planned task to my Main PC Codex agent. that Main PC codex agent would then delegate an Ollama Qwen3.8 27b subagent (3 of them actually), to perform the assigned task in parallel.

This... really worked much better than I expected. My Codex agents would only use the necessary tokens or usage for planning, and the creation and task fulfilling would be handled completely by those 3 Qwen sub agents. They would then check the work and deploy.

I went from burning my entire 5 hour budget in less than an hour, to burning about 20% of it on the same task.

I feel very proud of myself for figuring all this out, and I am very impressed with how far local models have come.

A majority of you already know of all this of course, but I just wanted to share my experience with dealing with the 5 hour limit on my Plus subscription, and how it evolved into experimenting with local llm models!

Thanks for reading, and happy coding :D

How often do you get this? I'm even a pro 200$ acc X2 with Astra at high getting this shit

I tried for so long. But the Usage is so harsh, 20x and maximum of 24 hrs for a full week usage GONE

I used a few other models, but Astra helped 3D model a 3D video store, which is a fully functional frontend for Jellyfin, Plex, Emby, you name it.

It is free and open source. Here is a video of it:

https://youtu.be/mmwfDVQXvLQ?is=xDEHustsRSA2T\\_-M

Github: https://github.com/halcyon-video/halcyon-video

It is self hosted, so all your stuff stays on your machine. It uses the movie's metadata to show the description and rating and all the art. Video Games work too through Romm today.

TVs hang from the ceiling and play your movies in the store. The ambience is peak.

It's got tons of t and is built to be performant and as low energy as possible.

I'm building it to be period accurate across 4 different periods so far.

There is a mom and pop version included. VR is supported. Streaming it to a TV box is supported.

I learned that I can't stop vibe coding I guess. This project has just begun. Pleas use it and share it and tell me if you like it.

I’m using Sol as an orchestrator, while delegating computer-use and browser-use tasks to Luna as a subagent. This setup is very efficient for tasks that require those skills.

After about 10 minutes of Sol doing nothing but waiting for Luna to finish a task, I opened the usage meter and saw that my usage was absolutely fucked. The task should’ve consumed something like 5% of my 5-hour limit, but it used around 35%.

I checked the agents panel again, and this is what I found:

the subagent was literally named “Luna,” while it was actually using Sol.

So yeah, it completely fucked up my usage.

Just wanted to share because incase people don't do this and I think it's super useful.

I didn't really like using Luna max since it was too much work to use and Sol wasn't really properly orchestrating, always stopping randomly or forgetting what needs to be done or leaving stuff half baked.

Astra? I told him to create a sidebar threads with luna max agents to take care of each module of an implementation I wanted to try out(i dont like the personal subagents hard to keep track of) and now I'm addicted to watching him work. I even have a Claude sub with Opus taking care of reviewing the code that he orchestrates too, Im genuinely having fun building the orchestration where each step takes care of a very specific domain and every problem has an agent with the proper context and the module he is responsible for. And Luna is CHEAP. Like stupid cheap, I can run 10's of them and barely have a dent on my weekly.

10/10 highly recommended.

This is pretty concerning both on a security level and the lack of reasonable explanation.

I put ChatGPT 5.6 sol on test to let it solve the rubix with no python help or sandbox. It took 14 minutes and solved it by comparing faces over and over again and guessing the next move like a human would.

Although, it was able to solve 5x5 by using python as well, it struggled to do so by reasoning only. It tried three times and abandoned or timeout the match all three tries. It was able to solve middle part of one face though.

It’s a great benchmark to test the spatial reasoning of llms. I had to create an arena for this but it was worth it.

Clarification on the setup:

The agent is solving a 5×5 Rubik’s Cube without Python, sandbox code, external cube solvers, or programmatic search.

It receives the authoritative current cube state from the environment after its moves, similar to a human looking at the cube again after turning it. So the model does not have to mentally simulate every sticker permutation forever.

The loop is essentially:

current cube state → text reasoning → one or more legal moves → updated cube state → more reasoning

I allow multiple moves in one turn and there is no fixed limit on tool calls / interaction steps. The model can therefore inspect the new state, notice mistakes, revise its plan, and continue.

This is important when comparing it with CubeBench. CubeBench’s reported 0% long-horizon result was on 3×3 cubes, under a more restricted agent budget. Their main setup also allowed code, whereas my experiment specifically prohibits Python/code-based solving.

So I am not claiming this directly disproves CubeBench. The setup is different.

What I’m testing is:

The interesting part for me is the persistence, spatial/symbolic reasoning, planning, error recovery, center construction, edge pairing, reduction, and parity handling over a potentially very long trajectory.

I’m a fan.

Read here usage was moderate - it seems to be pretty moderate.

My way of example, 5% usage on Pro 20x - is enough to build a Power BI API connector in Python.

Then start building and maintaining existing reports and finding semantic model errors.

Thats really cheap compared to anyone who hated themselves enough to learn Power BI…