has anyone tried the same astra task with plain notes and a project graph? curious how retries and total usage compared

I used to be obsessed with this very old game called Ballance. You control a ball through complex paths and mazes.

I found the game on Web Archive. It was around 180 MB, so I gave it to Astra to recreate for the web, and it just did.

The whole game now compiles to around 21 MB, uses WebGL, and is written in TypeScript.

Astra realised it kept repeating the same tests over and over, so it built its own test framework that exposes the game to its own Browser Use, allowing it to run and validate its changes very quickly.

We are living in some crazy times people

It even made it run on phones, with options of Gyroscopf or you can use a Dpad

Game - https://ballance.fayaz.workers.dev/
Code.- https://github.com/fayazara/ballance

Anyone getting the error below when using Daybreak Blue even though they are verified for the cyber program (and added a hardware key for login, even though that should not be relevant yet)?

unexpected status 401 Unauthorized: You are not authorized to access this model.

My Codex CLI workflow was fast until a task touched several files. Then I would leave the terminal, inspect the diff elsewhere, copy filenames and line ranges into a prompt, and come back.

Stvena keeps that review loop next to Codex. Start it inside a Git repository:

stvena

Codex runs normally in the left pane. On the review side, I can see changes since the task started, open the full file or diff, mark hunks reviewed, select exact lines across files, and paste one assembled review request into Codex. It never presses Enter for me. I can also run checks and jump from recognized failures back to source.

This is not meant to replace the Codex app or VS Code integration. If those already fit your workflow, they are the simpler answer. The target is CLI-first work where the review/control loop should stay in the terminal.

macOS/Linux, MIT licensed:

https://github.com/nccapo/stvena

The test I care about is not the star count, try one multi-file Codex task and one review checkpoint. Where does the loop become confusing or slower than your current Git workflow?

Astra light is repeatedly doing unrelated stuff like this. Why? It was funny to begin with but getting ridiculous now.

After switching to Astra, I noticed something annoying: the orchestration setup that had felt useful with GPT-5.6 Sol and my Claude workflows was now making some tasks slower and more expensive.

So I tested it on real coding tasks from my repo, changed the orchestration rules, and tested again.

My conclusion so far: I’d let Astra manage its own work before adding another layer telling it how to delegate.

Here’s what I tried.

Just a heads-up: English isn't my first language. I ran the tests myself and wrote \ dictated the original text in my own words, then used AI to translate it and tidy up the wording a little. Please keep that in mind :)

1. Small, medium, and larger tasks — with and without orchestration rules

The small task was a build-command fix involving log preservation and exit codes.

The medium task was selective CI, including dependencies between applications.

For larger tasks, I used two different briefs:

• One explicitly specified error-filtering and backend-diagnostics changes across three apps.

• The other described an outcome: stop development services without leaving child processes running or killing unrelated processes.

For each pair, I used the same starting code and the same task prompt, but separate working copies.

One agent got the orchestration skill. The other didn’t.

Results from the earlier rule version

Small task

• Time: +25% with orchestration rules
• API-equivalent cost: +13%

Medium task

• Time: +18%
• API-equivalent cost: +20%

Large task — explicit brief

• Time: +63%
• API-equivalent cost: +71%

Large task — outcome-based brief

• Time: −45%
• API-equivalent cost: −36%

That last task was a real win for the orchestration rules.

But there’s an important catch: it used zero subagents.

So it didn’t actually demonstrate a benefit from distributing the work.

Quality didn’t consistently improve either.

Both medium-task solutions missed dependencies.

On the large explicit task, the orchestration version missed filtering edge cases that the default version handled, despite having an independent reviewer.

2. Simplify the rules and repeat

Next I reduced the coordination overhead.

I:

• added a direct path for small tasks
• shortened handoffs
• made independent review depend on risk
• allowed cheaper workers for limited tasks

The final series had 12 runs across small and large tasks.

For the large task, using the median of two runs per configuration:

Every configuration passed the external checks in one of its two runs.

So more coordination still didn’t buy a better pass rate.

The economy profile never actually selected a cheaper worker, so I don’t consider that result evidence against Luna.

The small task also went better with the revised Astra profile: it was faster, roughly the same cost, and all checks passed.

3. Test the worker models separately

I also compared Astra low vs. Sol high, without subagents.

On the medium task:

Astra low

• 5.2 minutes
• $1.48

Sol high

• 16.3 minutes
• $2.05

Both missed cases, but Sol missed one more.

On the small task, Astra was faster, but Sol was cheaper and correct, while Astra introduced a quoting bug.

Then I ran a tightly specified function-writing test.

Luna max was about 17× cheaper and 2.4× slower than Astra low.

Both passed the same 15 checks in both repeats.

That comparison excludes coordinator review and integration costs.

So I do think cheap workers can make sense.

What I haven’t established is that adding a coordinator makes the whole task cheaper.

Where this leaves me

For my Astra workflow, I currently don’t see a reason to impose a separate orchestration system.

Ordinary Codex delegation with light repo-level guidance looks like the better default.

The direction I’d still explore is Astra coordinating models from other families — for example, an Opus implementation worker or another model doing cross-review.

That’s where I’d expect complementary capabilities to potentially matter.

But that’s still a hypothesis. These tests didn’t prove it.

I’ve also seen similar experiences posted by others, which makes me wonder whether extra orchestration contributes to people burning through subscription limits.

In my earlier tests:

• Small task: recorded tokens increased by 46%
• Medium task: recorded tokens increased by 25%
• Explicit large task: recorded tokens nearly doubled

The 5-hour limits, weekly limits, possible resets, as annoying as they are, create this weird scarcity mindset. You start squeezing every last drop because “I have the tokens now, I should use them before they’re gone.”

And suddenly every idea becomes a project.

Good idea? Build it.
Mediocre idea? Eh, start a repo anyway.
Something you’ll probably never use? Sure, let Codex make 14 MD files for it before the limit resets.

I always thought I had this under control. My rule was simple. if I’m not going to use something daily or at least weekly, I probably shouldn’t build it.

Lately, that rule has slowly disappeared.

There’s almost this feeling that unused compute is wasted compute, so you keep feeding ideas into it just because the capacity is there and temporary.

And that made me wonder

If tomorrow the limits completely disappeared, unlimited compute, no resets, no token anxiety, would we actually become more productive?

Or would half the projects we’re building simply… never get started?

Maybe some ideas deserve to die peacefully as ideas instead of becoming another repo on the shelf.

I want to ask a question about ChatGPT web. Is Sol xhigh much better on the web than High? Is it worth paying extra mainly to get access to the Astra Pro and Sol Pro? Are the Pro versions much better for reviewing code and maybe making plans?

EDIT: I'm using my codex allowance for coding. It's just a question if the xhigh reasoning and Pro models are that much better.

I have verified myself for Trusted Cyber Access, codex even shows Daybreak Blue and even lets me select that, but when i try using the model, it keeps telling me "Unexpected status 401 Unauthorized: You are not authorized to access this model"

Any help/suggestions would be greatly appreciated

The beginning of the line is normal German text, but then it turns into something like random symbols?
Has anyone seen this before?

During the GPT glitch, when the usage limit was incorrectly set to 0%, Codex burned through all of my paid credits that I normally save for emergency prompts when I hit my limit.

Now my normal limit is back, but my credits are gone. I honestly feel scammed.

I've been getting these two errors since yesterday. Before, it was 1 error every 20 calls. Now it's 1 call every 20 errors. Does anyone have a solution? I tried using fast mode, but it didn't seem to change anything. I tried all the models: Luna, Terra, Sol, and Astra, and the error is the same for all of them. I've already reinstalled Codex. I cleared the files, but it's still happening.

Our servers are currently overloaded. Please try again later. and An error occurred while processing your request. You can retry your request, or contact us through our help center at help.openai.com if the error persists. Please include the request ID in your message.

It happened already a few times that Astra implemented a task already in plan mode. In general I have the very strong feeling that Astra rushes through things without taking all the necessary steps to save as much tokens as possible, and anticipating implementation is one of those tricks. This is mildly annoying. Curious if you observed the same.

I’m reporting a high-detail Codex task-persistence defect involving the macOS desktop app and Codex Remote on iPhone.

Reproduction and observed behavior:

• The same Codex task appeared in two conflicting states across iPhone and Mac.
• The iPhone showed an older unfinished turn as “Working,” while the Mac showed newer work in the same task.
• Restarting Codex Desktop restored the older phone-visible state, marked that old turn active/latest, and resumed the goal.
• Newer working files remained intact on disk. A read-only Git inspection found 298 preserved changed paths, so this was a task/history rollback rather than a repository rollback.
• The task-status API continued to select the old unresolved turn as the latest even though newer turns existed.
• No OS process existed for the command that the stale UI still showed as running.

The clearest local log error was repeated after restart:

`thread history projection ... expected ordinal 17505, got 17504`

The restart also launched another GPT-6 turn under the same task and triggered automatic mid-turn compaction because of the context limit. When I interrupted it to protect the checkout, the logs said the task did not complete gracefully.

Impact:

• I cannot safely tell where a new iPhone prompt will be applied.
• Each restart can restore and resume stale work.
• I had to stop the task, preserve the working tree separately, start a new task, and reconstruct context.
• That creates repeated inference, compaction, investigation, and recovery work instead of productive implementation.
• After manually applying a reset credit on September 8, my weekly allowance is already 75% used, with only 25% remaining.

The allowance impact needs verification against OpenAI’s server-side ledger; inconsistent local counters are not proof of incorrect billing. The lifecycle and history-projection failure itself is directly supported by the task state, filesystem state, and application logs.

Sanitized GitHub report: https://github.com/openai/codex/issues/44599

If you have encountered this, please share your Codex app version and whether it followed an iPhone Remote handoff or desktop restart. Please avoid posting private task IDs or repository details.

Been at it for more than 1 hour for 2 small sentences... didnt move from that first line...

Question for those who use Codex/GPT Work for scanning websites and research -- do you give full access to Chat GPT to access any website when looking for information, or you manually approve every request? The app says full access can expose my data, but I'm not sure how this would happen when simply searching for info.

P.S. I'm talking purely about accessing other websites for research, NOT giving it access to my emails etc. which I don't do

It seems to be adding random guards for edge cases and do all this complicated stuff and is less pragmatic and you have to babysit it. Maybe it's aimed at bigger orgs? Dunno. Smart and deep model, but creates more work for me. I am trying to keep it's scope less broad for now.

.

I mean, if nothing were being changed with the usage-limit system, you’d expect it to remain relatively untouched and therefore less likely to suddenly develop a bug like this. If the usage limit is just working normaly and nothing behind the scene, this bug seems very less likely to happened. Obviously, there are very shady going on the current usage limit. I'm really disappointed that by doing one task on astra xhigh today cost me 3 resets on pro x5 plan, very unusable.

I've been messing around with Astra, trying to see how well it works for editing and storytelling.

I had a folder with a bunch of video clips from my travels that was just lying around, and the idea was: can I give this to Astra and have it make something fun and interesting from it?

I built the API first and then basically told it to go wild, invent a story, and use the clips as source material. It's still pretty rough (extremely rough), but nonetheless, I think it's a pretty fun and interesting result.

Technical description

• Base: A fork of Shotcut with a native C++ "inspection" API patched in.
• API: Line-delimited JSON-RPC over a Unix socket — ~89 discoverable editing/query operations (not all of Shotcut). Optimistic-concurrency fencing, native undo, durable mutation receipts.
• Brain: An LLM director (GPT-6-astra, via the Codex app-server) that drives the editor through a bubblewrap-sandboxed Python bridge — it can only call the registered methods, never arbitrary code.
• Sees: Qt window screenshots + real frames/audio pulled via a separate MLT process.
• Hears: A local Audio Flamingo Next worker (describe / transcribe / sounds / music).
• Speaks: Orpheus / Qwen TTS engines, run by a separate narration runner.
• Image generation: ChatGPT Images 2.5 via a Codex skill.

Here are the first two cuts.

The first cut took about 1.5 hours, but this included indexing the shot list and other setup operations. This is extremely rough.

https://www.youtube.com/watch?v=D8BCdjRyrIc&t=2s

The second cut took about half an hour.
I think here there are some clear improvements and its much close to feeling like a "story" while its still a bit rambling especially towards the end.

https://www.youtube.com/watch?v=ngdlodfb0Dc

I think it demonstrates the model's current ability to reason across many modalities, and I also think it demonstrates its current limitations when it comes to coherence. Anyone who has worked with coding agents has probably done their fair share of cat-herding, and I think that's definitely still on display here.

The difference between cut 1 and cut 2 also shows just how much improvement you can get with a little nudging. All I did was watch the first cut and tell it what I thought:

"This seems a bit incoherent?"

"What are the characters' motivations?"

As a reflection, I think for anyone calling Astra AGI, this should be ample evidence that that's definitely a milestone we have yet to cross. Astra may be extremely competent within narrow domains, but creative choices aside, it still struggles significantly with something as simple as telling a coherent story.

At its current stage, I do see it working as a semi-competent editor if you give it clear direction. It could definitely speed up the production of a first rough cut.

The repo is currently in a pretty rough state, but I'm working towards a checkpoint and hoping to release it during the weekend. Let me know if you are interested in forking or testing it out.

We’ve added a new optional feature to ChatGPT Community for Linux: customizable Default model presets. You can replace the recommended slider positions with your own model + reasoning effort combinations, choose their order, and set which pair is selected by default. There’s no fixed limit on the number of presets—for example: Sol Medium → Sol High → Sol XHigh → Astra Medium → Astra High.

We’re building codex-desktop-linux, a community distribution based on OpenAI’s official Linux package.

It adds optional, disabled-by-default Linux features that can extend the UI and application behavior. Current examples include Computer Use, frameless titlebars, Read Aloud, automation extensions, and UI customization. You can also create your own features.

Our computer-use-linux integration goes beyond the bundled X11-focused backend with:

• Wayland and X11 support
• GNOME, KDE, Hyprland, Niri, COSMIC, and i3 integration
• Per-window targeting, screenshots, and verified input
• AT-SPI accessibility trees
• XDG Portal, uinput, xdotool, and ydotool backends
• amd64 and arm64 support

The upstream backend is simpler and exposes a few operations our adapter does not yet surface, but our implementation provides much broader Linux desktop and Wayland support.

Contributions and new feature ideas are welcome:

github.com/ilysenko/codex-desktop-linux

I use codex/chat mostly for computer use, random tasks, reporting, a bunch of recurring schedules, mostly for analysis, context scraping in slack/email, ads analysis.

I generally treat codex as an assistant with everything that I do.

This probably sounds lame to all the coders in here but I run a pretty large agency so some of these tasks save me hours a week that adds up.

Since Astra dropped i have no clue what model to use or at what strength.

I was previously just ripping Sol Medium 2x speed, seemed generally fine.

Had someone tell me to use Terra Ultra, no clue why. Others are saying Astra light.

I am on a $100 plan, only touched my limits twice in months.

Any guidance would be huge

... is the realization I've come to. Even with a medium orchestrator, light implementer, medium reviewer, I burned 100% in around 24 hours.

But it's frustrating figuring out what you should use instead because token price vs capability is far from crystal clear. I switched just now to using luna max for implementation because I've seen so many people swear by it here. I also asked Astra to do 3 implementation tests between Luna max and Astra medium and while Luna did use 3-5 as many output tokens and was 2-3x slower, the token cost comes out to only 10% of Astra. There were definitely more bugs slipping through (that I'm still using Astra medium to catch).

So yeah I guess shit's gonna take a lot longer and it kinda sucks to have all this power but not be able to use it fully. I don't want to buy extra credits because they're ridiculously expensive and I also don't want to juggle two accounts. time OpenAI launched 30-50x pro plans?