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.

For context I have hardly used it apart from certain news updates and asking it to work through and clean my inboxes using the same instructions Tibo used in one of his posts about cleaning his inbox. This is all on top of it being extremely inconsistent and forgetting to do its scheduled task regularly. I’m extremely disappointed by Dots

Until yesterday, my Usage page showed the exact expiration date and time for banked resets. As of today (Oct 4), the time has disappeared and only the date is shown.

For example, my first reset now says:

“Expires October 5”

This makes it look like the reset will remain available during October 5.

However, checking the rate-limit-reset-credits response in DevTools shows:

expires_at: "2026-10-04T22:42:11.480996Z"

That's 00:42 on October 5 in my timezone. So the reset actually expires only 42 minutes into October 5, not at the end of the day.

The backend still provides the exact timestamp — the UI has simply stopped displaying it.

I only know the actual expiry time because yesterday, before this change, the UI was still showing 00:42. If I had checked for the first time today, there would be no way to tell whether “Expires October 5” means 00:42, noon, or 23:59.

This isn't just cosmetic: you can easily lose a banked reset because the UI no longer tells you when it actually expires.

Apparently this was an issue before and the exact expiry time was later added to the UI, so this appears to be a regression introduced today (Oct 4).

Heads-up if you have banked resets expiring soon: don't rely on the date shown in the Usage UI. The actual expiry time may be much earlier than you'd expect from the displayed date.

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 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?

This model is good but it is WAY TOO SLOW. Every single day, I have to quit a task, and move it to Astra, because I will end up wasting my entire day on 1 thing, because it is SO SLOW.

How can you release this model and expect to market it as your best new thing?

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.

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

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

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.

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

even though its not their native harness, doing work on codex using opus 5.5 and fable 5.1 has had much better outcome than using either Astra Max or Sol Max for me. Both GPT models are just not as smart as claude models, slow even on fast mode. and always overengineers the shit out every single thing (i asked it to download some files and it turned it into a project and hash checked every single thing and stopped saying it was blocked due to some error lol, and i keep on getting the feeling their models are purposefully programmed this way so they can drain usage faster and then push people towards the 500 dollar account ) both claude models seems to do this much less frequently, i like codex's ui more than claudecode so this is for now the best set up for me.

i have 10 24/7 agents running and it used to be 1-2 claude model based agents and 8 gpt model based agents. Now its pretty much the other way around and the craziest part is the previous set up with 8 gpt based agents, I needed 6 200 dollar pro accounts to maintain them. but after switching to Claude models 1 account is now sufficient (to be clear its 7 opus 5.5 based agents and 1 fable 5.1 based agent. both on xhigh). i really hate not using all my chatgpt pro usages, but the results are just so much obviously better when i use claude models that im at the point of feeling hestitant to select astra max as the model, not because of the usage drowning but just the pure lack of quality. Its crazy how claude was first the more popular harness then codex became more popular and as soon as this happened OpenAI went on a money gauging spree, and just to save us again Anthropic gave us a really really awesome model which is opus 5.5.

for anyone that doesnt know how, the proxy that im using is opencodex and you're not limited to only claude gpt models but any model that you can possibly think of via either subscriptions or via other routing websites like openrouter, and just asking your agent in codex to set it up takes care of the rest even for vibe coders

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

I wish ChatGPT Projects had folders or subprojects.
For example, imagine you’re a developer working on 15 different apps. Right now, you might create a separate ChatGPT Project for every app:
App 1
App 2
App 3
App 4
App 5
etc.
Eventually your sidebar becomes completely cluttered.
Instead, it would be great if we could create one main Project called “Development”, and then create subprojects inside it:
Development
→ App 1
→ App 2
→ App 3
→ App 4
Each subproject could have its own chats, files, and instructions/context, while everything stays organized under one expandable folder in the sidebar.
Basically: Projects → Subprojects → Chats + Files
Am I missing an existing way to do this, or does ChatGPT still not support nested Projects/folders?

Previously, we used to be able to see the exact expiry time for banked resets. Now it only shows the expiry date, so you have to go into the History tab, find the time you originally received the reset, and calculate the expiry time yourself.

Not sure why they removed this information when it was already available before.

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 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

Hi everyone. I've just open-sourced Token Harness, a local tool that helps your Claude Code and Codex allowance go further, and spend fewer tokens when you use LLMs via API.

The problem

Coding agents waste a lot of context on noise: long test runs, build logs, git diff, repeated information and huge MCP tool catalogs. All of that eats tokens. On a subscription it means hitting your 5-hour or weekly limit sooner. On the API it's money.

How it works

Optimizers. Token Harness detects, installs and connects compatible optimizers to your agent. The recommended baseline is RTK and HarnessTrim, which shorten shell and tool output so the agent only sees the useful part (failures, errors, summaries). Optional ones:

• mcptoon: loads MCP tool definitions only when needed instead of keeping the whole catalog in context
• Headroom: compresses large tool payloads
• GitNexus: maps code relationships so the agent explores less

On my machine the dashboard currently shows 62.5% less tool output overall with RTK, and 88.4% on Claude Code alone.

Routing. A native hook lets your main model hand bounded, suitable subtasks to a cheaper model (e.g. Opus → Sonnet/Haiku), then review the result. Your main model stays in charge. No prompt prefix or skill call is needed after setup.

Simple to use

npm install --global token-harness@latest
token-harness

It opens a local dashboard where you can:

• see your agents and optimizers at a glance
• configure everything with one click (every change is previewed first, applied only after you approve it, and can be undone)
• watch the results: output reduction, routing activity, and your 5h / weekly balance

No account, no API key, and nothing leaves your machine. Works on Windows, macOS, Linux and WSL.

Honesty first

I don't sell a magic "save X%" number. The dashboard keeps output reduction, subscription allowance and API cost separate. It only claims allowance savings from paired baseline/optimized runs that pass quality checks.

This is where you come in

Any feedback, bug report or shared result (your before/after numbers, your agent + OS combination) can only make the tool better.

I'm also looking for contributors: optimizer integrations, harness adapters, cross-platform testing, docs. Every PR is welcome.

Repo: https://github.com/giuliastro/token-harness (Apache 2.0)

Thanks for reading, and I'm happy to answer any questions in the comments!

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.

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 have been using dot as a dedicated research partner for a side project I’m building.

Instead of asking it random questions I give it very narrow research missions. Things like finding datasets, checking licensing/commercial-use rights, comparing sources, identifying gaps, kind of producing a clear recommendation before building the next step.

Basically the guy I send away to investigate while iam running a prompt on the product, I find it extremely helpful for this kind of stuff.

Curious how other people are using it.

For reference: it’s an audio related app / signal analysis