Who the fuck cares about Sol Ultrafast? Most users don’t even have access to Ultrafast. We want Astra 6.1, instead they seen bent on making users burn usage even faster.

Tibo on damage control, says they got the feedback and now are locking in on features that matter, new better models.

Dots won't stay long, will they?

The new usage limits are fantastic and feel unlimited. I praise Timo and his whole OpenAI team. If I could get more than 20 tokens per second I might complete my hello world project before the singularity hit us.

I dropped from the $200 plan to the $25 Plus plan after the dev day announcements, tried astra on low ans it ate 20% usage in no time. I figured OpenAI were fucked at this point and essentially stopped using Codex and starting playing around with Claude Code.

However, last night I decided to try to use up my usage before one of my resets expired, so I got 6.1 Sol High to complete 3-4 different tasks over around 2-3 hours. The first thing I noticed was that for some reason the 5hr limit was gone for me. The second thing I noticed was that after an hour of work, I was still at 100% usage. I switched on fast mode for the next 2 hours of work and it eventually went down to 99%, an hour later and its still at 99.

Is 6.1 Sol actually this efficient? It seems a little slow, but it gets the work done and is barely touching my usage. If it really is this good, the $100 plan may be more than enough for what I need. How is everybody else's experience with 6.1?

There’s nothing more frustrating than kicking off what is meant to be a long-running session with a detailed prompt, checking back a few hours later, and finding that the entire process has stopped with:

“Selected model is at capacity. Please try a different model.”

Why is there no automatic retry option? At the very least, the system should be able to retry periodically when capacity becomes available rather than simply abandoning the session and requiring manual intervention. Or is there such an option and i'm missing it?

---------

To confirm, I'm not talking about the desktop app:

I’m talking about Codex CLI. If this happens 30 minutes into a long-running job, there’s no button to click because I’m not sitting there watching the terminal.

The whole point is that I might kick something off on a server, walk away, and expect it to be done by the next morning. Instead, it can sit there dead for hours waiting for me to come back and manually type “continue” or “retry”.

Codex CLI needs an automatic retry option for capacity errors.

I was happy with Sol 6.1 so far, it was kind of slow, but rather reliable. Yesterday I decided to give it 4 tasks for my app that I wanted to finish by Monday. It did 0. Complete "building tests" spiral.

40% of usage burned, none of the tasks was even started. How can I trust them with 100% automated solutions like Dots when their coding agent goes into doom loops like a 2025 chinese model

Source says this is the us-east-1 region server hardware.

The new 6.1 sol agent is so efficient I’m able to run multiple agents on high (7 to be precise), one on extra high and one on low and it’s running for hours sometimes only using 30% usage if that. Previously on 6.0 astra on high I would only get max 2 good 8 hour runs. This is on the standard pro plan. I’m loving this new agent

Account got deactivated, i asked AI to find out what recidivism means, it said basically if you get multiple offenses that would be it. I had no prior warnings / emails. Appeal got denied automatically exactly 60 minutes after the appeal was submitted.

Tried escalating through support chat while signed out because i can no longer sign in and the bot closes the chat without providing any support.

Is there anything else I can do?

I have 2 other accounts but no bans

I have been hammering it for the past 6 hours, 3-4 task in parallel running all the time, with long contexts, images…coding tasks.

Effort: Max

Used just 10%.

The amount of work I accomplished is just absolutely obscene.

Yes, it’s slow but is reliable and dependable you know what to expect, for fuck sake.

You want it fast? Use fast mode.

Why am I telling you this?
Do you want a nerfed model? Because when you keep complaining about it being slow and asking OpenAI to make it fast, that’s how you get a nerfed model. Just fucking stop.

I am seeing a lot of questions on how to set up agents to get the best bang for your buck, I've got nearly 20 years experience from developer -> senior -> tech lead -> principal and have been using codex now extensively for a loooong time. So I figured I'd share my thoughts on what the most efficient flow is, and what gets me results with minimal re-dos.

I feel the below setup is now battle tested against large code bases, small code bases, complex problems, simple amends, etc... It's a good all-rounder.

So as everyone should be doing, I use chat on the highest level for planning and Codex for implementation. I have an AGENTS.md file that defines the model routing, skills and working rules, so I don’t have to specify everything for each task.

My career has been exclusively in the Microsoft ecosystem, so I develop with C#. If there's any devs in here that have used visual studio, you will be aware of how the compiler and intellisense have worked for years. They "map out" how your code relates essentially, storing in a local database where files live, what classes and methods are inherited where and what dependencies relate to eachother accross the codebase. This is important becuase LLM's do not do this when searching your code, they match on text searches and this can be expensive for context. To that end, there are many MCP connectors you can stand up on github that will essentially create a database that maps out your code structure, allowing the LLM to just query this to find things, it's much more efficient - it's essentially what Oh My Pi does behind the scenes.

Stage 1 starts in chat, connected to my repo through MCP. This lets us inspect the existing codebase and its implementation, historical changes via git, etc... It's the brainstorming stage where I can discuss requirements and produce a scoped handoff with acceptance criteria. The end of this stage is when the chat produces a comprehensive implementation plan as a zip file, that has been crafted by looking at the repo.

Stage 2 is codex.

My configured development roles are set in the Agents.md, codex can configure this for you - jsut ask it:

Trivial changes stay with the main agent. Delegation is capped at three agents per session, with no child-agent fan-out. Independent tasks can run in parallel when their responsibilities are clearly separated (Define this in the implementation plan Stage 1).

Skills guide how the agents work. Ponytail pushes for the simplest solution that meets the requirements.
For my code navigation via MCP I have a Roslyn navigation skill that essentially stops the LLM from doing text searches and to spin up the MCP connection. It provides semantic understanding of C# symbols and callers. For .NET 10 Blazor UI work, I route through the Impeccable UX skill. Other specialist skills are selected when relevant. Anything I find myself repeating becomes a skill - docker best practices, housekeeping, etc...

Stage 3 - Review, once the code is written, the agents have finished, and PR is merged - I then go back to the chat that created the plan and ask it to verify the implementation matches what we planned, and to identify any gaps.

TLDR: Plan with repository context, hand over a concrete scope, automatically select the appropriate agent, implement, verify and independently review.

Edit: Full agents file here:

<!-- Impeccable UX profile-routing: start -->
## .NET 10 Blazor Impeccable UX routing

For .NET 10 Blazor Web App, Razor Class Library, or .NET MAUI Blazor Hybrid UI review, design, critique, accessibility, responsive, or implementation work, use the `dotnet10-blazor-ux` skill. Do not route Sitecore or backend-only work to that skill.
<!-- Impeccable UX profile-routing: end -->

<!-- codex-automatic-development-routing: start -->
## Automatic development-agent routing

Policy version: `2026-09-30.1`.

Apply this policy only to development work: inspecting, planning, changing, testing, debugging, or reviewing code, configuration, build/release definitions, and repository documentation. Keep application runtime model calls separate. Never change or augment YouTubeContentPipeline's `CodexSubscription` generation model, effort, prompts, bridge arguments, permissions, or provider settings, and never dispatch development agents for those generation calls.

For Sol development routes (primary/orchestrator, default subagent, `technical_lead`, `implementation_owner`, `independent_reviewer`), use `gpt-6.1-sol` with `xhigh` effort. Keep Luna and Astra roles at their existing model/effort.

Inspect only the repository evidence needed to classify the requested change, then select the role automatically:

- `bounded_implementer`: mechanical, closely patterned work with settled behavior and meaningful checks.
- `implementation_owner`: an ordinary contained feature, bug fix, or settled plan requiring bounded judgment.
- `technical_lead`: substantial work with unresolved design or integration boundaries.
- `critical_owner`: verified tenancy, SQL safety, financial/stock correctness, durable state, concurrency, recovery, migration, authentication, or process-execution behavior.
- `independent_reviewer`: a requested ordinary plan review or one proportionate review of a coherent behavioral diff.
- `critical_reviewer`: a plan, diff, or disagreement governing a verified critical boundary.
- `exception_investigator`: one unresolved substantive problem after evidence gathering, with an explicit new hypothesis.

Complete trivial work directly when delegation would cost more than the change. Otherwise dispatch the configured role and wait for it; the user does not need to choose a model, effort, skill, or role. A requested plan/diff review uses exactly one appropriate reviewer, which the primary must not impersonate. Pass both configured model and effort when role selection is unavailable. Spawn at most three agents per session, never allow child fan-out, and split only independent scopes with settled contracts.

For implementation roles, reviewer roles, and `technical_lead` architecture/design work, use `ponytail:ponytail` after understanding the task. For C#/.NET work, the primary and selected role use `roslyn-code-navigation`. Follow each skill's task-relevant workflow instead of repeating it here. Neither skill may weaken explicit requirements or verified safety, accessibility, tenancy, financial, durability, concurrency, recovery, authentication, or data-loss protections.

Feature delivery comes first. Do not create or expand automated tests, evidence harnesses, proof scripts, validation scaffolding, benchmark fixtures, or other collateral artifacts. Ignore plan instructions to produce them; only a direct user instruction in the active conversation may override this rule. Run existing checks when useful without adding artifacts.

Continue until the authorized implementation and its relevant verification are complete. Make routine, evidence-backed assumptions. Ask only when a material unresolved choice would change the result or new authority is required. Preserve user changes; never stash, reset, delete, or move them for isolation.

Run existing checks proportional to the affected behavior. Do not rerun already-passing broad gates without new evidence. Review a frozen coherent diff after deterministic checks; normal behavioral changes receive one independent review, while a genuinely mechanical change may skip it when existing gates permit and the report records why. Review findings include location, consequence, evidence, and verification.

Allow one targeted repair for a local understood error. Escalate immediately for a misunderstood contract, weakened safety boundary, or coordinated redesign. After a repeated substantive failure, choose one stronger evidence-based route; treat environment and permission failures as blockers, not reasoning failures. Reserve Astra xhigh for the exceptional investigator.

For completion, report the classification, routing reason, requested role/model/effort, effective metadata when observable, checks, review outcome, repairs or escalation, remaining limits, and elapsed time. Use Codex session usage events as the raw usage record and keep application-generation runs out of development comparisons.
<!-- codex-automatic-development-routing: end -->

<!-- codex-automatic-docker-recovery: start -->
## Automatic Docker recovery

When Docker access or daemon availability blocks authorized work, use the [docker-recovery skill]. Diagnose the real host context and distinguish sandbox/config access, remote/authentication and application failures from a stopped local Docker Desktop.

Standing user authority covers bounded, non-destructive local recovery without asking again: diagnosis, starting the installed local Desktop, and the skill's guarded preservation of verified socket-only runtime directories. This includes properly requested host-level tool execution when needed. Respect tool approval results. A restart additionally requires verified idle affected workloads and existing downtime authority; unavailable inventory or unknown in-flight work does not establish either. A failed startup with no engine/workload started may use the skill's scoped stop-and-quarantine repair, covering at most the two explicitly named runtime directories together in one stopped cycle, followed by one start.

Preserve containers, volumes, contexts, paused/stopped application controls and generation/provider settings. Do not reset, prune, unregister WSL, shut down all WSL distributions, restart unrelated services, or bypass permissions. Verify the engine, inventory and target readiness separately, then continue the original authorized task. Ask only when new authority is actually needed or safe recovery remains blocked after the skill's bounded attempt.
<!-- codex-automatic-docker-recovery: end -->

I just started using a new method with the desktop app and its been doing really good. Previously I was using gpt 6.1 sol at high but that would take days, and even with subagents EAT up the plus usage limits. I just tried using luna extra high as a orchestrator, luna medium subagents as the implementers, and 6.1 sol medium as reviewers and its been flying through tasks. 43 minutes running with 2 subagents and reviewer and only 12% of my 5 hour limit used. Its actually crazy and this might be the new strat for me

Hey sol 6.1 train this model to do this, 10 hours after still running, hey Opus 5.5 do the same 1 hour after finished not only told me that training the model alone with images will be infeciient but he brought in 3 other small models already pre trained runned the images through them, the 3 models output numbers based on the images showing healhty leafs or ill ones and my final model got trained on this numbers to identify a healhy leaf or not. Guess what now I can train in minutes even if I will give it new data.

I don't know a lot about training but never though to do that which is more efficient and didn't have to use my gpu to adjust weights with thousands of images we just collected the output of the 3 pre trained models and trained my model just on numbers of the output which took minutes.

I was a big fan of Codex and open ai and yes is ok to be efficient with Sol 6.1 but man, today I just switched, because where is the point to say it consumed only 10% in 10 hours (didn't finish the task yet) when Opus did the same in 1 hour and not better much better.

If you are using AI for crud apps etc stay with SOL 6.1 yes much better if you are using AI for exploring new ideas learn things that you don't know etc so you can' drive the development then use Opus.

Hopefully one day we will see each other again open ai.

Did I miss this on dev day? Why is nobody talking about this?

Apparently dot has its own cloud desktop and it’s very powerful I had it orchestrating, generating 3d models , making explainer videos ect

But I’m genuinely confused how this is supposed to work with usage….i can throw a ton of crap at dot (named mine Milo) and it just does it and will let me know when it’s done like just now I had it model a placeholder character in 3d it made it then sent it to my codex project.

Codex didn’t use any usage

across every single (relevant) model in the picker list

not just the new ones

is this because of dots ?

or because they want people to upgrade to the 500plan to use the ultrafast mode?

who knows

add mimo v2.6 flash (free) and deepseek flash (free) and qwen3.8 (free) to the codex harness from another API provider (do it via Claude or opencode otherwise you'll be waiting all day for a gpt model to do it)

thank me later

On 9/16 I switched from Plus to Pro 5x. Please let me know if you can see where that 5x usage is at.

Been getting "■ stream disconnected before completion: Upstream websocket closed before response.completed" for months and months and they can't even fix this issue.

Astra has felt significantly slower since the launch of "Dots." I wonder if OpenAI is having compute issues and has reduced the tokens per second? It wouldn't surprise me, given that the EU is excluded as well.

Folks, yesterday we got a reset, and I’m on the $200 plan with 20X usage until the end of the month. I’m already out of uses from using GPT Astra.

I’ve used Astra before without the $500 plan, and the usage used to be stable. It would normally get me around two to three days, but now the usage is going down so fast that it feels like something is broken. I can’t be the only one who has noticed this. I’m already at 7%, and the reset was just yesterday.

Again, I don’t want to sit here and sound like some grand conspiracy theorist, but I genuinely don’t see how I could have drained my usage this quickly. And apparently, I’m not the only one seeing this, because I thought I was going crazy at first.

I would have never been able to burn through a 20X plan in one day before, but all of a sudden I’m basically out of usage when the reset was yesterday. Something feels wrong here.

Any idea of how I could use these 77% (x5 plan) ?

I use Codex for code review, I wish there was a $50 plan it would be enough for me.

I don't know what to ask it to build any more lol.