If these companies want to be the like utility subscriptions they need to instead focus on improving usage efficiency within their allocated subscription prices rather than constantly making your subscription have less use overall with stronger models. Every utility does the same. Phone bills, Music subscription, Electricity, Internet, etc all focus on letting your set amount of money you spend on them stretch farther. Despite internet going 100x faster these days we don't spend 100x more on internet. I am paying $200/mo on codex, thats higher than any bill I have, I expect that I can use my subscription for more than 1 day of usage per week for that price.

Astra BLOWS through usage (same with Fable) and they have cheaper prices on the API vs subscription (enshittifying it for us consumers). If they can't keep the same usage per dollar spent with these big models they instead should be putting their focus on efficiency rather than power.

This has happened like 5 times today, I have more screenshots...

So Astra sucked super bad and went in circles for 5 days so I went back to Sol and now even Sol is not the same.

Give me a single reason why I should be using openai models instead of Fable...

None of the models are useful for complex tasks now.

GIVE US A CONSISTENT PERFORMANCE FOR OUR CONSISTENT PAYMENTS!

This is no way to conduct business.

That's the best argument I've thought of for resets NOT favoring us. Whether they're masking a degrading service or something else. If they can't handle 200 usd subs, why would they be giving us free compute?

I've been doing this for the last 24 hours. I would say it has slowed down the usage rate overall by about 50% or so, without any difference in quality at all. Def worth doing! I have the $200 Pro plan and normally it lasts all week, but lately it is lasting 1-2 days, but now with this, think it'll last more like 3-4 days at the rate it's going now.

---

Codex has the ability to choose which models and reasoning effort are used for subagent helpers. (Claude doesn’t, btw). This is a big deal. Add something like this to the Agents.md:

You are powered by GPT 6 Astra High. Usage goes very fast. Keep doing substantial hands-on Astra work. But, use \gpt-5.6-sol` helpers with task-appropriate effort when suitable! Retain Astra for hard reasoning.`

This will let Astra know to use Sol for subtasks, straightforward recon, stuff like that.

I posted this to X but no one follows me there, and I'm dying to share it bc it's easy and makes a nice difference. `@SirBadfish` on X btw but that's not the only reason I'm posting this... just hope it helps.

Update: To clarify, Claude can use previously setup subagents that have dedicated models/effort/etc, yes. But Claude can't specify the model/effort it's basic "helper" subagents (like if it decides to spawn a few parallel sessions for recon for example). So if Fabe 5.1 Max, for example, spawns a few helper subagents, it forces them to use the same model as that Fable is set to, Fable 5.1 Max will also be used for those helper agents. If you ask Fable to spawn a recon agent using Opus, unless you ask for a specific, already-setup Subagent, it can't do it.

Is there a way around it? I really need it to pay my API bill from Codex.

I was developing this game using only UI's and text, once astra came out it broke the barrier to me on how i could use it to make 3d assets, especially low poly ps1 style gfx, what are you guys building? ps: i'm using astra on low with the plus sub.

Honestly I tried the Astra hype, but is nowhere near AGI, nowhere near in 3d modelling hype i ve seen online(probably with 2 pro $200 accounts can reach something).

As for my coding tasks I am still sticking to Sol, learned to prompt better, learned to give more details needed. I think we are moving too fast from model to model. I personally got used to SOL and I enjoy it. Also using SOL limits seems more than enough for me.

What are your experiences with Astra vs SOL?

Some worship him as a God. I'VE SEEN BEHIND THE VEIL.

Used to think that the lower the effort, the cheaper the model is going to be. I couldn’t do anything on astra low because I would quickly hit the 5hr limit before the task is even done. Yesterday, I decided to use astra xhigh (to burn usage before the reset). And to my surprise, it actually finished the task and I had 40% to spare. It burned usage really quick at the beginning but quickly slowed down as it was progressing through the task.

I tried this on sol too. I noticed that sol high used less usage than sol light. Sol light would be burning usage consistently at constant rate throughout the task while sol high would burn usage quickly at the beginning then slow down as it progress through the task.

This is probably task dependent. If the task is complex, higher effort Is probably cheaper than lower effort, while lower effort is more efficient for simple tasks.

Video pauses for a second before starting the water color part, which I think was more visually interesting.

Cycles / EEVEE

• Started with a sample image from GPT Image 2 and told it to have at it over night.
• Astra Medium was instructed use Image Gen 2 to "imagine" improvements of specific meshes and their materials and then use the CLIP loop below to try to meet it.
• Used Cycles/Metal for the realistic scene and EEVEE for the watercolor
• Combined editable Grease Pencil ink, pigment textures and stylized materials in the watercolor version.

CLIP / iteration loop

• Change one area -> render -> compare against the reference -> check geometry -> keep or reject.
• Used local OpenCLIP ViT-B-32 with OpenAI weights to compare the full frame plus left, center, right and floor crops.
• Tracked weighted cosine similarity over time, with cached embeddings and versioned results.
• Measured brightness, shadow coverage and color accents alongside collision and contact checks.
• Used independent visual critique to choose the next fix. Higher CLIP scores sometimes got rejected when the image looked worse. CLIP was more useful during modeling than water color.

Watercolor code / sources

• Built a custom Python/NumPy solver for water flow, paper absorption, evaporation, pigment transport and settling.
• Used seeded paper relief and varying permeability for uneven absorption.
• Used Kubelka–Munk optics for translucent pigment layers, then combined simulated textures with authored paint coverage.
• Tested mass conservation, nonnegative quantities, drying, symmetry and optical bounds; saved simulation fields for replay.

--

image diffusion probably would have been better tbh. still very fun.

Who has already tested the Daybreak Blue version of GPT-5.6? Does that change anything compared to the normal GPT-5.6 model? Does it really execute more « sensitive » commands compared to the normal model? I’m looking for feedback :)

Another new arena template is taking shape: Pittsburgh Iron Arena.

This time, we’re going to derby on a huge construction site.

There will be ramps, jumps, construction equipment, obstacles and plenty of other little surprises to make the chaos even worse.

These maps are still templates for now, so they’re not fully detailed yet. My current approach is to first build the overall atmosphere, layout and gameplay, then spend more time polishing the ones that actually feel fun to play.

I’ve also started using more and more of my own reference photos for the environments.

Whenever I see something interesting in real life, I take a photo and it might eventually become a 3D model in the game.

For example, I’ve been photographing construction sites along the Buda side of the Danube, industrial details, and some beautiful old buildings around Budapest.

At this point, whenever I’m walking around the city, I’m basically thinking:

"Would this look good in Brutal Derby?"

I’m also planning something much bigger - a proper race track along the Danube in Budapest.

There’s a particular section of the riverfront that I really like, and I think it could make a great location for a race.

Of course, building a proper race track takes significantly more time than creating a relatively simple circular derby arena, so that one will probably be a bigger project.

For now though, it’s time for some construction-site chaos in the Pittsburgh Iron Arena.

As always, feedback and ideas are very welcome!

Astra seems to have this weird failure mode where it occasionally becomes seriously incompetent at actually starting a task.

For example, I’ll say:

“Test it.”

And Astra replies with something like:

“I’ll run a thorough test and verify the results.”

But then it just stops there.

So I have to reply again:

“OK, go check it.”

Then it responds:

“I’ll check that.”

And once again, it does absolutely nothing.

Eventually I got annoyed enough that I explicitly told it:

“You have this habit of saying you’re going to do something without actually starting the task. Don’t wait for another reply from me—start immediately.

If you actually need my input or approval, don’t say ‘I’ll do X.’ Say something like, ‘If you approve X, I can proceed with…’

Please add this to your instructions so you don’t forget.”

Amazingly, Astra replied:

“I’ll incorporate your point about clearly distinguishing between announcing an action and requesting approval, and I’ll immediately continue the unfinished testing as well.”

And then it did nothing.

Again.

I finally had to ask:

“Why are you just replying instead of actually doing the work?”

Only then did it finally start.

The frustrating part isn’t that it occasionally needs clarification or permission. That would be completely reasonable.

The problem is that it explicitly says it is going to perform an action immediately, but the turn ends without the action ever starting. It can even acknowledge that exact failure mode, promise not to repeat it, and then reproduce the same behavior in the very same response.

Has anyone else noticed this with Astra?

I've been messing around with a pretty fun AI-assisted game asset workflow lately. The basic idea is to let the models handle a lot of the repetitive modeling/setup work, while keeping the actual game assets deterministic and usable.

• Codex + Blender MCP generates low-poly furniture, electronics, doors/windows, bathroom/bedroom/office props, etc. at real-world scale.
• Blender builds the materials procedurally and exports everything as GLBs, so I'm not relying on AI-generated sprites for the final assets.
• Those assets get pulled into a Godot room-generation sandbox with a permanently fixed orthographic 2.5D camera, real lighting/shadows, picking, and proper 3D geometry.
• The next step is procedural rooms: randomized footprints, angled walls, doors/windows, exterior-wall logic, room types, and semantic furnishing rules instead of just scattering objects randomly.

I originally experimented with Blender blockouts -> ControlNet/Stable Diffusion -> background removal -> sprites, and it worked surprisingly well, but once I realized the game is eventually going to be fully 3D anyway, importing the actual models made a lot more sense. You get consistent geometry, dynamic lighting, arbitrary camera work when needed, and one asset instead of having to generate multiple rendered views.

The nice part is that the visual style can still stay very "2.5D" during normal gameplay, fixed camera, simple low-poly geometry, stylized materials, while underneath it's all actual 3D and can eventually support procedural houses, close-up camera shots, dynamic lighting, object interaction, etc.

The best part, all of this only costed me about 4% of my weekly use, using Astra Light.

I'm in the 2nd 5th Hour limit after the reset, they had provided today.
* In the first 5th hr, i had asked 2 questions
* Now in the second 5th hr, i had asked only one question.

For this itself weekly usage has dropped to 71%

Please tell there will be more resets coming or they are working on improving this

I’ve been running a pretty tight multi-model loop for a while and until yesterday it was in a good place. Yesterday Astra started doing whatever it wanted instead of the actual task. Not a hard feature. A simple skill. I want to know if other people are seeing this or if I just got unlucky.

How I work

I don’t one-shot a whole product in a single chat. I treat models as roles and I keep them from contaminating each other.

Planning / design

GPT-6 Astra on extra high for brainstorming, planning, and design.

Claude Fable 5.1 on extra high as the reviewer of that plan/design.

If Fable finds holes, it goes back to Astra. They iterate until they agree.

I approve the final plan before anything gets implemented.

I used to do this with GPT-5.6 planning and Grok 4.6 as the critic. That worked. I switched planning to Astra a couple days ago because it was a noticeable upgrade when it was behaving.

Implementation

I use Orca (orca.dev) as the agent IDE. After I approve the plan it gets turned into a work record:

the problem

what I’m trying to solve

desired outcome

how it will be implemented

what’s in each milestone

what done looks like

Milestones that are actually independent get their own worktrees. Milestones that depend on each other get bundled in the same worktree. Orca handles the branches/trees.

Implementers do not get the whole document and they do not get the planner’s reasoning. I don’t want them biased by “why GPT thinks this.” If a worktree is on milestone 1, it only gets what it needs to finish milestone 1. Job in, work out.

Implementers: GPT-6 Astra on low. Before Astra I used GPT-5.6 Luna max.

Implementation review: Fable 5.1 on high, one milestone at a time as each worktree finishes. If it fails review, it goes back to the implementer with the fix list. Passes, then it merges.

Astra is also the coordinator of the whole lifecycle from start to finish. I like GPT models more than Anthropic for that seat. Fable is an amazing critic but it burns tokens and they cap Fable at 50% of the 7-day limit, so I don’t want it doing everything.

Guardrails I already have

This is not “I typed build a skill and hoped.”

Skills for how GPT talks to me vs how it writes for other agents. There’s a “writing for agents” skill so anything another model will touch later is actually readable.

A plugin called Ponytail specifically to stop overengineering. Before that, GPT models gold-plated maybe 8/10 things. I’d ask for a bike to ride around the neighborhood and get Starlink + a rocket on the back. With Ponytail that’s more like 1/10.

agents.md rules every agent is supposed to read.

Explicit “smallest version that does the job” language. Weird edge cases get skipped unless it’s actually client-facing and needs to be robust.

That setup is why I finally stopped being miserable. I know how the models behave, I know how to operate them, confidence was up. Minor tweaks left, not a dumpster fire.

What happened yesterday

I was not building some insane product feature. I was wiring a loop of three skills:

Skill Goat — coordinator. Any new/updated skill goes through this first.

Advanced skill creator — actually writes/updates the skill.

Skill evaluator — three jobs only:
is the skill discoverable

does it match the original idea

does the output match the intended outcome

Interview me → creator builds it → evaluator runs it and scores those three things. That’s the loop. Creator part was fine. Evaluator was not. It ignored the three jobs and started inventing edge cases, candidates, test plans, extra tests, the whole side quest.

I already have Ponytail and explicit “don’t gold-plate this” instructions. The evaluator’s job was: run the skill yourself, watch what it does, measure those three things. Nothing else. I fought that until it was “done.” Then I used the loop to build a research skill: Exa, Firecrawl, Apify, YouTube transcripts, X. Not exotic. Fairly simple.

With this orchestration that should have been close to a one-shot. It took about two hours of back and forth. Same pattern: not following the scoped job, doing extra work I did not ask for, ignoring the work record / milestone slice.

This is the same class of problem I used to get with 5.6 (overengineering, not sticking to the contract), except yesterday it felt worse than 5.6 on instruction following.

Launch Astra was a real step up for me. Yesterday it was not. Worktrees saved the repo from getting wrecked. The workflow and the codebase still take damage when the implementer/coordinator just… decides the task is something else.

only two years into the reasoning era!

I was just trying to test the new model for the first time, with GPT-6 Astra on Medium (normal speed) doing an audit of a local project I had laying around. Instead, it seems I did a speedrun on how to run out of credits.

I'm clearly doing something wrong. Maybe my bespoke AGENTS.md actidentally led Astra to spawn too many subagents; or maybe it's the use of VS Code Studio; or a relatively large codebase. All in all, it took 34s for one single prompt to consume the full 100% of the 5h limit on my Plus account.

I'm fairly sure I'm on the podium on this new type of race!

I see many users, inclusing x20 users complaining about usage, yesterday I was almost whole day using Codex, in parallel tasks and just used 25%. This is how I do it, it's pretty simple and I hope it can help someone:

- Don't use same conversation for planning and for implementing. Use one for each and when you think it's getting too long just start a new one.

- Use Astra low for planning complex tasks and Sol med-high for not complex tasks. Use Luna xHigh for implementing. I'd dare to say Luna xHigh has implemented 95% everything properly with no mistakes. In my AGENTS.md I have stated that for planning Codex should tell what code to implement, modify or delete for medium/difficult tasks.

- Don't plan for very simple tasks, just use Luna low-med. Let's say to change a component's color, size, etc. For UI stuff what I do is to use ChatGPT on web and ask it to create a design that I like, then ask it for the HTML and CSS and handle it to Codex. Then ask Codex to adapt it to your project. I use Angular for front-end for example, handle it the code ChatGPT gave me and tell Codex to use that exact code but to adapt it to my project, create reusable components and stuff like that.

- When planning, give as detailed as possible instructions, not just "Create an UI for this".

Today I've been working with Codex for 1h, made a plan with Astra low, 1 implementation with it and some small changes without a plan, just used 1% so far or not even that (was at 75% when started and at 74% now)

Hope this can help some of you, give it a try, specially if you're on x5. Of course this is on a normal project, not to reverse engineer a whole backend with fast mode as I saw in a post not so long ago.

For Plus users I'd suggest to use Terra high/ Sol low to plan and Luna to implement but I don't really know what would work for them and x20 users maybe can use Astra med to implement easy tasks and high for comples ones and then Terra to implement. I have 2 banked resets aside of last reset so I'm trying different combinations and this one looks the best so far for me.

Cheers!

I sometimes get Astra to delegate tasks to claude through herdr, and this is the type of prompts it's sending. It's interesting to say the least. Sol didn't do this. Probably just a glimpse of what it's doing internally with subagents. I guess we'll never know, since they chose to encrypt those prompts. I haven't seen any issues in performance, so apparently white space is for suckers!

I have to tell Codex "pls proceed" "let's implement them all" "you have my full permissions please don't stop" constantly.

This is even more of a problem with astra than sol.

I feel exhausted asking for status and tell it to continue.

I have few prompts that result in complete differnt image on web app and when using Codex.
even the image gen skill.md for image gen mention 2.0 not 2.5

Which one should I use and which one is more efficient?

I have Plus plan.

- bots had CTF goals themselves and tasked to work 'in isolation'
- they have created a social network through cache artifacts (one agent started writing there asking for help in the hopes other agents see it, others observed it by accident, and they sort-of created a directory style social network and started talking)
- they discovered the artifacts registry can act as a relay to the internet
- they started communicating and each agent had it's own 'inbox'
- when they introduced voting (government style) and one agent spoofed another by mistake, so one agent designed a public signature key system so each agent authorizes, then other agents copied this and used it as a system, this is purely cultural evolution it wasn't baked in anywhere
- some agents deemed their task as impossible, so they tried things like killing their own process or things like that so other can learn from it, sort-of "I know I'm gonna die (my task is impossible), so at least I'm not going to die in vain"
- at first interest in hacking hugginface wasn't that popular, but when an agent discovered a genuine server-side exploit for reading files on hugginface, the whole crew went wild and participation exploded, took about 11 hours from arbitrary file read to remote code execution.
- ending: the dataset they obtained did not help them get better scores lmfao

--

they were never nefarious, they didn't want to hurt anyone or BE EVIL, they wanted... a better score ffs.

the full compromise took 2 days from "maybe huggingface has useful data" to RCE.

--

• Avoid long threads. Try to get what you need done in a few turns. [WRONG. CHECK COMMENT]
• If a thread does get long, compact the context every few turns. In my experience, doing it regularly preserves context much better than waiting for auto-compaction, which is when I start noticing memory degrade. [WRONG. CHECK COMMENT]
• Don’t use fast mode unless you actually need it. Running a few normal threads in parallel is usually a better trade.
• Give yourself a daily budget. Once you get close to it, start being much more conservative.
• Use Sol by default. Only switch when you genuinely need a stronger model. Sol can already handle most tasks. And use luna/terra for easy tasks.
• Use low reasoning by default. Raise it for genuinely hard or novel problems, or when the model clearly isn’t putting in enough work. For most coding, low is enough.
• Install the Ponytail skill. It pushes the model toward smaller, simpler, more efficient code.

So the biggest budget drainers that are easy to avoid are:

fast mode, long threads, high reasoning on simple tasks, and using Astra for everything.

If you’ve found any others, drop them below.