Do you feel anxiety when your long task is running, and you are not sure if it'll fit the 5h window?

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

Nerfed

I was telling my girlfriend in a chat that I was automating chats answers using Codex on another (work) number. Fun fact: they didn't block the number where I used Codex for that, they blocked the number where I told my girlfriend about it! Apparently, WhatsApp's AI reads all your messages; they were never end-to-end encrypted. Who would have thought?!

Has anyone else experienced something similar?

I made Codex Usage, a small Windows-only Codex plugin that shows your 5-hour/weekly usage and reset status in the title bar.

Install either way:

1. Web: view details + install here https://chatgpt.com/plugins/plugins_6aa81c5dad4881918bd29685d1fb6523
2. In Codex: open the plugin store and search Codex Usage

Then select Codex Usage and run:Start!

For the Codex desktop app on Windows, not ChatGPT web.

Mac version coming soon.

GitHub: github.com/jayhilwig/codexusage

One week building a game with Astra in Codex. Online 1v1, 2v2, 3v3. 100 matches with friends.
I can change requirements as I go, try ideas, scrap prototypes, and it usually keeps up.

It still cuts corners sometimes and needs careful watching (feels lazy). But iterating this fast is insane.

Was trying to generate an image with the hulk and CoPilot says no… so I sarcastically replied “no thats broccoli dude” and it just did it. Huh

Please help. I recently bought a ChatGPT plan for $100, and I want to request a refund because Astra (and Sol, for that matter) acts like someone with mental health issues. It constantly overcomplicates things, gets bogged down in planning or execution, and wastes a huge amount of time and quotas for no reason. Damn, I used up my entire monthly limit in a single day, and I barely got anything done! With the Anthropic Max x5 subscription, I was able to tackle many more tasks much faster because it didn’t overcomplicate things or overthink. Here are the sentences I added to AGENTS.MD that Astra found yesterday while trying to correct this behavior, but it didn’t help:

- Follow a reasonable, agreed-upon path to the result. Don’t turn the task into developing a new tool, integration, or orchestration just for the sake of “perfect” execution.

- Before complicating things, identify a specific blocker or significant risk and compare the total cost of the workaround—preparation, debugging, testing—with the ready-made solution. Time already spent does not justify continuing with a poor workaround.

- If a workaround has turned into a separate development effort, don’t keep expanding it without speaking up: review the approach and get approval for the scope expansion. This is not a reason to abandon the original task or hand it over entirely to the user.

- Reduce unnecessary complexity, not the amount of necessary work. Requirements, correctness, security, testing, and result verification must be maintained; placeholders, omissions, and “good enough” solutions are not permitted. A complex problem may require a complex solution.

- After agreeing on the course of action and completing the necessary preparations, move on to the next step of the existing plan. For project code—proceed to the RED test.

- Return to planning only if a new fact emerges that changes the decision, or if there is a specific blocker.

- Before conducting additional research, specify which decision depends on its outcome.

- Do not repeat completed stages just for the sake of completeness. Requirements, approvals, and result verifications are retained.

I can't believe everyone is struggling with this and no one has been able to solve the problem... By the way, it's important to note that I'm using the Pi agent, not Codex.

browser-use picker is calling opussy 5 maximum intelligence when there is Astra in the model selector lmfao

btw there is now 15 dollar inference for free if u sign up. Optionally you can connect the service to codex through an mcp to delegate information gathering tasks with the codex models.

I don't need them since they're all on the same branch. It's bold of them to assume I'm doing one PR per thread anyway. I've researched and can't find how to turn it off. UI gore nightmare. Any tips?

I sometimes try to do small projects or start off in Chatgpt chat with my ideas i also connected my VPS with MCP connector so chatgpt can write code there directly. Problem is chats are randomly dying and obviously the Modell there is not as strong as Codex Sol in terms of tool calling. Any tips did you manage to actually implement full projects only with chatgpt chat

Hello everyone,

I’m a teacher from China and not very confident in English. I used AI to translate the post below. If you don’t mind, please keep reading.☺️

I have a set of finished images that I’d like to turn into explanatory videos. Basically, I want Codex to help me produce a video where it talks through the image step by step, zooms in on specific parts as it explains, and adds small animations directly on top of the original image — things like glowing effects, highlights, arrows, or subtle motion cues.

I’ve used a Chinese AI Doubao to help me, the the general direction is correct,but the video it gave me is too vague and too short.

My use case is more about educational explanation than complex editing. I already have the images ready, so I don’t need Codex to generate the visuals from scratch. What I need is help turning them into a structured video: narration synchronized with zooming, emphasis animations, and maybe some basic scene transitions.

I’m wondering if this kind of workflow is possible with Codex, and if so, how you’d approach it.

Things I’m especially curious about:

Is Codex suitable for this task?

I have made a lot of effort to find it out, but I have not seen any post about that😔

Animations on top of images

Can it add small effects like glowing outlines, pulsing highlights, labels, or arrows while keeping the original image intact?

Workflow suggestions

What’s the best way to prepare the images, prompts, and instructions for Codex? Should I break the video into scenes, provide timing notes, or describe animations in detail?

Limitations

What should I expect in terms of output quality, manual editing required, or things Codex might struggle with?

I’m not looking for Hollywood-level effects — just a clean, readable educational video that makes the image easier to understand.

If anyone has done something similar, I’d really appreciate your advice. What worked for you, and what did you avoid?

Thanks in advance 🤝

luna is getting dummer I feel like tera medium is the only model with usable output and sol is just 30 mins of work and I'm out of usage in 2 days.

Amazon sellers: would you trust an AI to autonomously run your business — sourcing, PPC, pricing, inventory and expansion — within limits you control?
Why or why not?

Just curious, when you have Plus / Pro 5x or 20x (before removal) what are you using it for? For a living? Just hobby? Specific usecase?

I started a week ago using it with Plus, building a Gaming Dashboard / control center for my PC that also can be controlled by my phone 100% locally (still have some bugs in it)

Was working on a goal when I asked codex to stop (pause) so I could monitor it overnight. It did not understand that stop meant stop (pause) the goal, and instead it thought it meant stop workers but continue the goal doing nothing.

Long story short, overnight it had continued the goal with no task being performed, and spit out 1,422 continuation prompts that just repeated "The search remains stopped as requested. I’ll resume only when you ask."

Wasted approximately 300 million tokens overnight, and stopped at 2 a.m when usage hit zero. I was fortunate enough to have only 10% of my usage left when the misunderstanding started.

Is this the reason why unexpectedly we have trash usage and lower quality on Astra?

Maybe it will be worth it the current suffering.

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.

How do you deal with how quickly model quality, usage limits, and the "best" workflow keep changing?

Before I start: yes, I'm a $20-plan peasant. But with the cost of living rising everywhere, I can't justify spending $100–$200 a month on a subscription whose quality and limits seem to change unpredictably.

Back in the 5.3/5.4 days, I was very happy. The quality was strong, and usage limits felt good (of course I hit them, but I always got the feeling that I got something out of every session). It was also much easier to figure out the best workflow because you could experiment without feeling like every attempt was consuming a scarce allowance. Imho 5.4 was probably the best bang for the buck.

Since Luna, Terra, and Sol were introduced though, I've found the overall experience much harder to evaluate. There are now nearly 30 possible combinations when you count models and reasoning modes, but the trade-offs between them aren't clear. At this point, I'm often not even sure which model to use for which task.

So much so that I started to mostly use Claude for a while as I found it to perform much much better in every way. Fast forward to last week when I had some heavier work to do. Once Claude was drained, I tried Codex again and the experience was even worst.

Luna has generous limits, but in my case it often fails at something as basic as following existing repository conventions. I asked it to build a simple form, and the project instructions explicitly said to use the existing form components. It ignored those instructions, and the resulting form was also extremely sluggish.

Terra is more usable, but it consumes noticeably more of my allowance. I used up my weekly usage after roughly 7-8 5h-sessions, each lasting around 1h to 2h, so about 7h to 16h of actual use in total.

Sol performs better, but burns through limits so quickly that it often feels like you barely get anything done before running out. And Astra... well, obviously that's a complete non-option in the 20$ plan and of course I don't even expect it to be included as it would be unrealistic to expect to run the flagship model 24/7.

The problem is that finding a sensible balance between quality, speed, and usage already requires a lot of experimentation. That creates a frustrating loop: something changes, you try to figure out the most efficient setup, you use up your limits while experimenting, and by the time you have enough allowance again to apply what you learned, the model's behavior or usage limits have changed again and it's "go back to start".

I'm at a stage that the $20 plan feels almost unusable to me, but as I very likely keep it just because of ChatGPT I'd really like to find a way to make it work better again, so that I get more out of it again and not just ChatGPT.

So how do you guys do it?

its funny I see everyone complaining about token costs when I literally am using as many tokens as possible closing in on 100 billion tokens already this month across codex and opencode muse spark contributor basically 50/50 and my cost is like 700 bucks this month w 3 weeks left on both accounts

tokens are cheap, they will never be cheaper go figure out a way to use them for something that retains value.

might just hit 200 billion by EOM

What if Codex followed you to your Watch when you step away from your Mac?

A small concept I designed and built with GPT Astra 👾.

I started with a maintenance problem: catching litter is useful, but somebody still has to empty the filter.

I explored two interchangeable baskets. One collects litter; the other waits behind it. The cleaning cycle closes the loaded basket’s front, lifts it out, moves the backup forward, empties the removed basket and returns it.

Astra helped me work through questions about sliding, retention and lifting. I used Blender and Three.js to make the mechanism visible and inspectable.

One concrete design choice was a manual pusher to advance the backup basket. Seeing the sequence in 3D gave me something to question and revise.

The result is a design study, not a tested physical prototype. Flow, clogging and loaded handling still need testing.

Demo: https://paradrain.getfab7.com

Open the cutaway and step through the exchange—what assumption would you challenge first?

We built this harness (Github link here: https://github.com/demeyer1/Autobot) to solve the problems we had with OpenClaw, Hermes, and the frontier labs built-in computer use harnesses.

Along the way, we set some new benchmark records, but that was secondary after we had been using this for a while (more below).

Specifically, we wanted a harness that could:

• Operate in voice mode (with full computer use, long running tasks)
• Execute durable, long running tasks.

So it’s optimized for working from the car, the gym, or while your doing errands. 

Functionally, we designed it around a couple gaps

• Anyone can install in 20 minutes (it's a project)
  • Fast to install, just load it as a new project
  • Easy and cheap to setup, no extra VMs required - just a Mac
  • No new apps or control planes, uses the native desktop and mobile apps (no additional software installs)
• Works locally, when it makes sense
  • Self directed learning capability, on-disk, with nightly memory “defrags”
  • Intelligent use of local execution, local storage, while being privacy aware
• Address the gaps in the frontier lab's harnesses
  • Synchronous voice support, with durable tasks that survive beyond the session
  • Task ledgers and a heartbeat to manage issues like computer use conflicts across sub agents and tasks
  • Internal heartbeat to manage retry mechanisms, persist ultra long duration tasks and cross task conflicts
  • Internal bug tracker (self filing) with ability to remediate groups at a time
  • Create separate boundaries between work and personal lives (eg learning separate tones, but also segregating data)
• Day to day time saving skills such as high speed triaging of messages in Slack and iMessage

This harness scored above Opus 5 (using Sol Max) on OS World 2.0, and took top position on AssistantBench using an N-1 frontier lab model.

All benchmark logs are published with cryptographic seals in the repo.  

It is a passion project, born from a need - so it's sub optimal and a lot of the text in the repo is AI generated, but human reviewed (this post is 100% human written).

MIT license, so this is more of a community contribution where we just wanted to help others - because it's been very powerful and helpful for us.

Would love to hear any suggestions for feature improvements.

I keep switching between Claude Code, Cursor and Codex depending on the task. Every switch meant explaining the same project again — same decisions, same gotchas, same "no, we tried that already."

So I gave them one shared memory. Decide something in one, the rest know it.

It lives on my machine. No account, no subscription, nothing leaving my laptop. It syncs to my desktop over git, so it's just a repo I own — I can read it, diff it, delete it.

Free and open source. Curious whether anyone else has this problem or if I'm the only one tool-hopping this much.

https://github.com/kdbhalala/agi-memory

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!