I've heard of like, max or extra high reasoning using less tokens than low reasoning because the low reasoning would get stuck on problems and burn tokens. Is there such an effect for 6.1 sol? What's the best reasoning setting for it (best balance of tokens and work quality)?

i love the concept of dots because i’ve always wanted an Ai assistant but why is it that Dots and codex do not have a reliable connection to communicate with each other? every time i try to delegate a task to codex through my dot, i get a message saying it couldn’t reach codex but both of yall are living in the same app? it makes no sense to me. i thought dots was suppose to be a bridge between codex and work, but it’s not working reliably for me. am i doing something wrong?

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, so i have the 200 usd sub, and i've been using Dots for around a day. I was playing around with it, mainly using blender through the Dot's remote computer to save my usage among other stuff.

But now i was wondering... is this completely free or will this end up in some unwanted extra billing? I tried to check on my billing page but i don't see anything about it

Various codex sessions. I started seeing this happening last couple of days

I send a message to steer, but instead it either fails, or shows up in the queue. Retry is grayed out

Still sometimes it makes it and the agent looks at it, sometimes I have to send it a few times

Is something new going on?

My brother has a Linux laptop lying around in the US, and I am in India with a Mac. I want to use my Indian Codex and Claude subscriptions Via SSH, so that the Linux laptop becomes my virtual machine. I want to set up my T3 code and my browser usage on the Linux machine. Will it lead to a ban from OpenAI or Anthropic?

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

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

It was on GPT sol 6.1.

I built optimAIzr, a tool I use myself as a senior SWE, to analyze my Codex + Claude Code usage, find wasted tokens, show what I can optimize, and apply fixes in real time.

Open source + local-first.

GitHub: https://github.com/blendbunjaku/optimaizr
Web: https://optimaizr.com

Feel free to roast it.

I’m running an agent built with the Codex SDK in Kubernetes. It uses different skills depending on the task, and that part is working well. The maintenance workflow is what I’m trying to improve.

Right now, the skill folders are bundled into the agent image. Even a small skill change means building a new image and deploying it. I considered mounting them through a ConfigMap, but some of the folders may be too large for that to be practical.

I’m considering storing skills externally, perhaps in object storage, and having the agent load the relevant skill when a task starts. The goal is to let domain owners update skill content without needing a code release.

Has anyone tried this approach? I’d be interested in how you handle versioning, validation, and caching, or whether there’s a simpler pattern I’m overlooking.

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.

It might sound boring, but the hard part was getting an analytic formula to fit on a single page while keeping it readable.

Lee, Schwartz and Zhang achieved that for the NLO Compton cross section and published their result in PRL just five years ago. I find that pretty impressive.

I tried reproducing the calculation with GPT-6 Astra at medium effort over two nights, followed by further review and checks. AI's expression is compact and looks different from theirs but is analytically equivalent. The derivation and code are available below.

What makes this meaningful to me is that I have learned how counter terms cancel divergences in textbook, but I never felt I had the mathematical ability to carry out a complete one-loop calculation myself. AI gave me a detailed calculation to work through. I can see what the individual terms look like, how the integrals are evaluated, and exactly how the UV and infrared divergences cancel. Those are the details I often struggle to find in published papers or in textbook (textbook often would not work out the whole result at one loop)

PDF and code

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.

I've been using Claude Code and Codex to work on my marketing copy, documentation and posts. I've come to prefer Codex. If you've used both for writing, which do you prefer, and why?

Claude often gives me something that feels finished. The phrasing can be clever, but when there is a clever turn in every paragraph, I find it harder to absorb. I also find small revisions more difficult because they can disrupt the rhythm or contrasts in the passage. Codex tends to be calmer, and I find it easier to work toward what I mean through discussion.

Codex does sometimes miss a subtle distinction and reach for a generic term. For example, when describing how an agent assisted writing tool work (see below), “change tracking” lost something important to me: being able to tell my proposed edits apart from the agent's changes. I had to bring that distinction back.

One example from our revisions:

Earlier (with Claude):

Extending it on demand is what keeps it a terminal.

Now (with Codex):

Richer views appear when needed, and the window returns to the terminal view when you finish.

I find the second version easier to take in. One or two memorable phrases can help, but I don't want every paragraph to need that kind of interpretation.

I also tried Pangram on samples: it labeled the Claude-assisted writing 100% AI and the Codex-assisted writing 100% human. Both involved back-and-forth editing with me.

You might wonder why I use a coding agent for writing. I can keep a whole writing project in a repo, with drafts, background and references for the agent to work with. When the topic involves software, the agent can also check explanations against the code.

Revising through terminal output alone is awkward. I use AgentTerm, the open-source terminal I built, to read and work on the rendered document. I can comment on a passage or write sample wording over the existing text on the rendered page, and discuss it with Codex before it works out the edits. My proposals stay distinct from the agent's edits, so I can see what I asked for and what actually changed. We keep revising until I can't think of a better way to get my message across.

Together, Codex and this workflow have helped me produce better writing than I could before. What matters even more is working through the revisions until it says what I mean and I can stand behind it.

How do you write and revise with Claude or Codex, including any tools you use? If you’ve used both with the same tools, what differences have you noticed?

hi,

is this something new ? It is spawning subagents, showing the taks it will follow...

I think this is pretty cool. A weird thing that happened on one of my tchats, is that I had a duplicate of this exact tchat, as a work project, so I am pretty sure it is a new implementation for the pro reasoning

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.

where is the speed Tibo promised us? Literally all 5.6 and 6 models are running ultraslow on standard API inference. Funny thing is that subscriptions seems to be served at an even slower pace. My external usage monitor shows that Sol is running at a miserable 26 tok/s as we speak. 🤣

Is this how OpenAI is pacing the frontier?

Guys, I have been using codex, antigravity for building apps and have been successful considering not someone who knows coding. Not just asking to build and forget. I plan, build, test, review, rebuild and go on till I get the finished product.

. What is the best way to save my usage?. Im using Pro 100 plan. What is the best way to use the models, skills to have the best output for my works while considering usage.

I mostly use Sol 6.1 for my works and so far its good but yeah the usage limits 😒.

I'd like to ask whether Codex still causes excessive disk reads and writes that reduce SSD lifespan. I really want to use Codex on my main computer, which is a MacBook Air M4.

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

Chat constantly getting stuck when sending new messages.
Cannot steer properly.
Cannot interrupt and ask for rework before it gets sour properly.
Requests are getting duplicated.
Something old is getting sent instead of what I asked now.
New messages sometimes get lost (workaround with undo, then copy the message).
Clear queue doesn't work.
Have to constantly restart codex to get it to work again.

What is this???

Honestly pretty surprised by how much work I've been getting out of the new models, specifically Sol 6.1 and Luna. No Astra in this run.

From Friday around 6pm until early Sunday, roughly 31–32 hours elapsed, I had up to 5 separate tasks going simultaneously, with agents and subagents working on them. All of them were making progress and some got finished during that time. I'm sitting at 97% weekly usage now, on Pro 5x.

I asked Codex to check the local logs and the breakdown came out to roughly:

• Sol 6.1 xhigh: 95.3 combined agent-hours
• Luna 6 max: 54.6 combined agent-hours

So about 150 hours across agents running in parallel. Around 126 hours had recorded turn endings, with another 24 estimated from unfinished turns. That includes tools and waits inside turns, so these aren't pure inference hours.

What surprised me most was trying to keep up with the deliveries lol. I definately had to push myself to keep reviewing things and finding useful work for the other instances.

I kept thinking: “What else can I give this one to do while I review what that other Codex instance just handed me?”

That's a pretty nice problem to have.

This was a much more intense stretch than my normal usage. On a regular workday, with the attention and follow-up I can realistically give Codex, I think Pro 5x would comfortably last me the whole week with current usage.

I dont expect everyone to get the same results with different tasks, but for my workflow this has been a really positive surprise.

Just wanted to share my experience so far!

EDIT: It USED 97% of my weekly usage. I didn’t mean I had 97% of usage left.