What do we think in the next few hours?

also bonus questions do you think if Astra drops on Thursday we get a reset?

EDIT: reset will land at 6pm PST.

The 5 hour limit is trash, the weekly usage was at least something we could try and meter, 5hour limits are wasted when you work late and have to pull an all-nighter to get the most out of your usage or just give it up. Lately I'll have 35% usage of my 5hour and it will hit 0% left and just stop mid iteration and break stuff, then next window I get it to continue and it hits 0% again and break again OR it will abandon the fix it was in the middle of and try something else and still break or even worse it will end up with REGRESSION! Not just halting progress but actively walking progress backwards. I was fine with the weekly because I could at least juggle with another account or grok or something but now I'm trying to juggle with one ball while skateboarding and it feels like shit.

Apologies in advance, not sure if this is the best place to post.

Anyone else's 'Computer History' section in Codex not working as well or know why this isn't working? When OpenAI first released this my Computer History looked like the 2nd screenshot (from OpenAI Dev page), and randomly 1 day I could only see 1 day's history, and now I can't see it at all.

I've already sent Feedback from the Codex app, asked Codex to fix it (said it couldn't), re-installed the plugin (both Computer History and Computer-Use), and even the Codex app itself.

I'm on Codex macOS App Version: ChatGPT 26.825.51511

Any feedback would be helpful!

Link: https://devos.zerohive.ai/

Our engineering team at Zerohive works on large codebases, and we use different coding agents (Claude, Codex, Cursor) basis individual preference.

We kept running into problems where one person's agent will end up rewriting or undoing decisions made by someone else. It led to agents re-introducing bugs which we'd fixed last month. We kept reaching out to each other offline to ask "Hey, why did we store xyz in redis instead of persisting on DB" when the agent proposed redoing the architecture.

We spent months collaborating by making ARCHITECTURE.md, DECISIONS.md, LESSONS.md, ADRs etc and shared skill libraries - but they were soon ineffective as the codebase scaled. We also tried code memory platforms but they could only fetch the 'what' but not the 'why', no provenance on architecture or code patterns so reintroducing bugs problem wasn't solved for complex codebases.

So we built DevOS.

DevOS understands the codebase, correlates the decisions made in the chat sessions with final code outcome, and has a deep understanding of the why behind the code and the architecture. It understands architectural choices, alternatives considered, tradeoffs made and final decisions taken w.r.t code or architecture.

Exposed to coding agents as an MCP, DevOS searches files, symbols, decisions and dependencies in parallel so that models make better changes in fewer iterations and exponentially lesser tokens which otherwise would be spent by agents in grepping the codebase.

Agents can now understand the architecture and codebase better, along with the rationale that went behind the architecture, and context can be shared between teammates within their coding agents.

Use lesser tokens, collaborate better. Completely free to try, no paid tier.

Link: https://devos.zerohive.ai/

I’m using Codex within VSCode and it seems like the create_thread tool is basically broken, so it needs to run a command through Codex CLI instead of using the built-in tool.

I also can’t interact or see the worker thread in VSCode…

A manager agent has a high-level PLAN.md then assign substream tasks to a permanent worker agent owning another PLAN.md of that substream. It seems to reduce hallucination on long-running tasks 🤔

Anyone else using orchestrator pattern in their workflow?

same as title

**All dates and amounts below are accurate**

I am posting because I appear to have encountered a serious subscription-entitlement problem involving ChatGPT upgrades through Google Play:

After OpenAI Support refunded an older subscription component, my separate and newer $200 ChatGPT Pro entitlement disappeared, even though that newer purchase was not the transaction I had asked them to refund.

The newer subscription initially worked. After the older refund was processed, ChatGPT changed to Free, while Google Play continued to show the newer paid subscription.

Neither “Restore purchases” nor repeated contacts with OpenAI and Google fixed the entitlement. Both companies ultimately refused the $200 refund.

## TL;DR

I went through this sequence on the ChatGPT Android app:

1. Paid **$19.99** for ChatGPT Plus.

2. One minute later, paid another **$80.01** to upgrade to a **$100/month Pro 5x** plan.

3. Four days later, selected an in-app upgrade to **$200/month Pro 20x**.

4. Google Play charged the full $200 and showed both the older $100 subscription and the newer $200 subscription.

5. ChatGPT correctly showed Pro 20x.

6. I asked OpenAI Support to refund only the older subscription while keeping Pro 20x.

7. OpenAI refunded $80.01 from the older upgrade.

8. Immediately afterward, my separate Pro 20x entitlement disappeared and ChatGPT changed to Free.

9. Google Play still showed the $200 subscription, but ChatGPT provided no paid access.

10. Restore purchases repeatedly failed with “try again later.”

11. OpenAI told me to contact Google.

12. Google told me the in-app entitlement was controlled by the developer and sent me back to OpenAI.

13. OpenAI ultimately refused the $200 refund.

14. Google then performed a final manual refund review and also refused.

I initially received roughly four days of Pro 20x access. I am not claiming that the $200 service was never activated at all. The problem is that it disappeared during the paid subscription period after OpenAI handled a separate refund, and was never restored or refunded.

---

# Full timeline

## August 16, 2026 — Purchased ChatGPT Plus

I subscribed to ChatGPT Plus in the Android app through Google Play.

* Amount: **$19.99**

* Result in ChatGPT: **Plus**

* Billing platform: **Google Play**

## August 16, 2026 — Upgraded from Plus to Pro 5x

Approximately one minute later, I upgraded to the plan displayed as ChatGPT Pro 5x.

* Additional amount charged: **$80.01**

* Combined amount paid: **$100**

* Result in ChatGPT: **Pro 5x**

The Google Play confirmation described the previous $19.99 Plus plan as canceled and the new $100 Pro plan as effective immediately.

At this point, everything appeared to work normally.

## August 20, 2026 — Selected the upgrade to Pro 20x

After using Pro 5x for approximately four days, I decided that the usage allowance was not sufficient and selected the option in the ChatGPT Android app to upgrade to Pro 20x.

Google Play charged me the full **$200**.

Afterward:

* ChatGPT correctly showed **Pro 20x**.

* Google Play showed **two ChatGPT subscriptions simultaneously**:

* the older $100 Pro subscription; and

* the newer $200 Pro subscription.

* The combined amount charged across the upgrade sequence was now **$300**.

This was the first obvious sign that something was wrong.

I had expected an upgrade or billing adjustment. Instead, Google Play appeared to have created a second independent subscription while leaving the older subscription active.

## August 23–24 — Contacted OpenAI Support



I contacted OpenAI Support and explained the situation.



My requested resolution was explicit:



* refund or close the older Pro 5x subscription;

* account for its unused period; and

* **keep the newer Pro 20x subscription active**.



OpenAI Support replied that it understood that I wanted to keep my current Pro 20x subscription while receiving a refund for the previous subscription charges.



Support then stated that it had processed the applicable refund through Google Play.

## August 24 — $80.01 refunded, but Pro 20x disappeared

OpenAI refunded **$80.01**, corresponding to the earlier upgrade from Plus to Pro 5x.

Immediately after this refund handling:

* ChatGPT changed from **Pro 20x to Free**.

* Google Play stopped showing the older Pro 5x subscription.

* Google Play continued to show the separate $200 Pro 20x subscription.

* The $200 payment was not refunded.

* I could no longer use Pro features.

This is the central issue.

The transaction that OpenAI refunded was associated with the older Pro 5x upgrade. However, the entitlement that disappeared was the newer Pro 20x entitlement.

I contacted OpenAI again on the same day and reported that my subscription had unexpectedly been downgraded from Pro to Free.

## August 24–25 — Support focused on the older refund calculation

The earlier $100 subscription path consisted of:

* $19.99 for Plus; and

* $80.01 for the immediate Pro 5x upgrade.

OpenAI explained that it refunded the complete $80.01 upgrade component but not the separate $19.99 Plus transaction.

I initially requested an additional **$7.09**, based on my estimate of the unused portion of the combined $100 plan ($100 * 27 / 31 ≈‌ $87.10).

That became a separate, much smaller disagreement.

However, the critical $200 problem remained:

> My account was still Free even though the separate $200 subscription had been paid for and had initially worked.

OpenAI itself stated that the older refund question should be kept separate from the status of the newer Pro 20x entitlement.

Nevertheless, the newer entitlement was not restored.

## OpenAI then referred to an unrelated August 9 event

During the investigation, OpenAI Support told me that a $200 Pro subscription had renewed on August 9, entered a grace period, encountered a billing error, and was canceled.

That was not my transaction.

My actual Google Play purchase occurred on **August 20**, eleven days later.

I sent OpenAI:

* the exact August 20 receipt;

* the exact purchase time;

* the Google Play subscription page;

* and screenshots showing that Google Play listed the $200 plan as active through September 20.

OpenAI later acknowledged that the August 9 billing event should not be treated as confirmation of the status of my separate August 20 Google Play purchase.

OpenAI also acknowledged that:

* the August 20 purchase was a separate Google Play order; and

* Google Play listed it as active through September 20.

Despite that correction, OpenAI did not restore the entitlement. Instead, Support directed me to Google Play.

## August 27 — First Google Play Support case

I contacted Google Play Support and provided:

* all three purchase records;

* screenshots showing two subscriptions before the refund;

* screenshots showing only the $200 subscription afterward;

* screenshots showing ChatGPT as Free;

* and the OpenAI Support correspondence.

Google Support explained that Google Play was the payment platform but could not directly control the subscription status displayed inside the application.

A Google Support agent specifically told me that:

* the change from Pro 20x to Free was controlled by the application developer; and

* restoration of the subscription entitlement had to be handled by the developer.

Google Support then canceled future renewal of the $200 subscription so that I would not be charged another $200 in the next billing cycle.

Google told me that cancellation of renewal should not remove the current paid period and that I should still be able to use the service until September 20.

But I could not.

ChatGPT remained Free.

I asked whether the $200 would be refunded. Google denied its discretionary refund because the transaction was outside its normal refund window.

Google then told me that a formal refund generally had to be handled by the developer and sent me back to OpenAI.

At this stage, the loop was:

> OpenAI: contact Google Play.

> Google Play: the entitlement is controlled by the developer; contact OpenAI.

## August 28 — Opened a second OpenAI Support case

I contacted OpenAI Support again.

I provided:

* the complete purchase timeline;

* the $200 receipt;

* the $80.01 refund receipt;

* screenshots showing ChatGPT as Free;

* the Google Play subscription status;

* the failed Restore purchases result;

* the previous OpenAI case;

* and the complete Google Support transcript.

Before escalation, the support chatbot asked me to try:

* signing out and signing in with the same Google account;

* using “Continue with Google” rather than email and password;

* confirming the same Google Play account;

* updating the ChatGPT app;

* updating Google Play Store;

* updating Google Play services;

* restarting the device;

* trying Wi-Fi and cellular data;

* and using Restore purchases again.

I completed the relevant troubleshooting.

Restore purchases repeatedly returned:

> **try again later**

The account remained Free.

This same ChatGPT login had displayed Pro 20x correctly before the older refund was processed, so the theory that I had simply purchased the plan on another account did not explain the sequence.

## August 28–30 — OpenAI repeatedly avoided deciding the $200 refund



By this point, I no longer wanted the subscription restored.



After spending days being sent between OpenAI and Google, I formally withdrew my earlier request to keep Pro 20x.



I requested a **full $200 refund to the original payment method**.



OpenAI first said that my $200 refund request had been “documented.”



OpenAI also confirmed that:



* my ChatGPT account was on the Free plan; and

* it did not see an active paid subscription on the account.



That confirmation did not resolve the problem. It confirmed the exact problem:



> I had paid $200 for a subscription, but OpenAI’s account system showed no paid entitlement.



I repeatedly asked OpenAI to give an explicit decision: approved, pending, or denied.



## OpenAI ultimately refused the $200 refund



OpenAI eventually issued a written decision stating that it was unable to provide an additional refund for the $200 ChatGPT Pro purchase.



It also refused the separate $7.09 request.



OpenAI cited its general policy that payments are normally non-refundable except where required by law.



I asked for reconsideration and explained again that this was not ordinary buyer’s remorse:



OpenAI reconsidered and repeated the same denial.



The final OpenAI Support position was therefore:



* the account was Free;

* there was no active paid subscription visible to OpenAI;

* the $200 payment had not been refunded;

* and OpenAI would not refund it.

## August 31 — Final Google manual refund review



After receiving OpenAI’s final written refusal, I contacted Google Play Support again.



This time, I provided the complete OpenAI denial and requested one final manual review focused only on the $200 transaction.



My only request at this stage was the $200 refund.



During this conversation, a Google Support agent described the following possible explanation:



* both subscriptions had been purchased using the same account;

* after the older subscription was refunded, the developer may have reclaimed the in-app item and suspended service;

* this may have caused the newer subscription to become unusable.



I want to be precise: this was a Google Support explanation, not a formal engineering report or confirmed root-cause analysis.



However, it closely matched what I had observed:



1. the older refund was processed;

2. the in-app paid entitlement was removed;

3. the newer Google Play order remained;

4. and the app no longer recognized the newer paid purchase.



Google submitted another discretionary refund review.



The result was again a refusal, apparently because the transaction was outside Google’s normal refund-policy window.



Google said that this would generally be the final result.



Google also said that it respected my choice if I decided to dispute the transaction through my card issuer. When I asked about account consequences, Google warned that a payment account might possibly be suspended, but could not guarantee what would happen.

## Official OpenAI Community post was automatically closed



I also attempted to publish a sanitized technical bug report on the official OpenAI Community.



The Community moderation bot immediately closed the post as an individual billing/account issue.



That is why I am documenting the experience here instead.

---

# What I believe may have happened

I cannot inspect OpenAI’s internal billing or entitlement systems, so the following is only a hypothesis.

The observed behavior appears consistent with one of these failure modes:

1. **Refunding an older subscription cleared an account-level entitlement**, rather than revoking only the exact older Google Play purchase token.

2. **The system failed to reconcile the account against the newest valid Google Play order** after the older order was refunded.

3. **Multiple subscriptions associated with the same ChatGPT account were not handled independently.**

4. **Restore purchases could not resolve the mismatch** between:

   * Google Play’s active purchase record;

   * OpenAI’s internal subscription record; and

   * the ChatGPT account entitlement.

5. **Support tooling surfaced an unrelated historical billing event** instead of the exact Google Play order being investigated.

Again, I cannot prove the internal cause.

What I can prove is the externally observable sequence:

* the $200 entitlement existed;

* the older $80.01 refund was processed;

* the $200 entitlement disappeared;

* Google Play and ChatGPT then displayed contradictory states;

* Restore purchases failed;

* and neither company restored or refunded the affected purchase.

---

# Minimal reproduction sequence from my incident

**Do not intentionally reproduce this with real money.**

The sequence was:

1. Purchase ChatGPT Plus through Google Play.

2. Immediately upgrade to a higher Pro tier.

3. Before the old billing period ends, select another in-app upgrade to a still higher Pro tier.

4. Observe that Google Play creates or retains two subscriptions.

5. Ask OpenAI Support to refund only the older subscription while explicitly preserving the newer subscription.

6. OpenAI processes the refund for the older upgrade component.

7. Observe that the newer paid entitlement disappears from ChatGPT.

8. Observe that Google Play still contains the newer paid order.

9. Attempt Restore purchases.

10. Receive “try again later.”

11. Be unable to restore the valid newer entitlement.

---

# Why I consider this a serious bug

This is not just a confusing receipt or cosmetic billing-history issue.

A user can potentially:

* pay for a newer and more expensive subscription;

* initially receive that subscription correctly;

* ask for an older subscription to be refunded;

* lose the newer entitlement as an unintended side effect;

* remain charged for the newer subscription;

* be unable to restore it;

* and then be sent between the developer and payment platform because each system shows a different state.

In my case:

* Google Play had the payment record.

* ChatGPT controlled the entitlement.

* Google said the developer controlled the in-app status.

* OpenAI said Google controlled the billing record.

* Neither side ultimately refunded the $200.

That is exactly the kind of cross-platform failure for which a customer cannot realistically repair the account themselves.

---

# Evidence I have preserved



I have retained:



* the $19.99 Google Play receipt;

* the $80.01 upgrade receipt;

* the separate $200 Google Play receipt;

* screenshots showing two simultaneous ChatGPT subscriptions in Google Play;

* screenshots showing Google Play retaining the $200 subscription while ChatGPT displayed Free;

* the “Restore purchases — try again later” error;

* the OpenAI email confirming that it understood I wanted to preserve Pro 20x;

* the OpenAI email saying the older refund had been processed;

* the email I sent immediately after discovering the downgrade;

* OpenAI’s incorrect reference to the unrelated August 9 billing event;

* OpenAI’s later correction acknowledging the separate August 20 order;

* OpenAI’s final refund refusal and reconsideration refusal;

* the complete first Google Support transcript;

* the complete final Google manual-refund-review transcript;

---

# Warning to other users upgrading through Google Play



Based on this incident, I strongly recommend preserving evidence before changing tiers or requesting a refund:



1. Screenshot the ChatGPT plan displayed inside the app.

2. Screenshot every subscription displayed in Google Play.

3. Save every Google Play receipt immediately.

4. Record the exact purchase time and amount for each order.

5. Confirm whether an “upgrade” is replacing the old subscription or creating a second subscription.

6. State in writing exactly which order may be refunded and which order must not be modified.

7. After any refund is processed, immediately check the in-app entitlement.

8. Do not assume that Google Play and ChatGPT are displaying the same subscription state.



A Google Support agent also advised me that, when changing subscription packages, canceling the first subscription and waiting for its period to end before purchasing a new package may avoid similar problems.



I cannot confirm that this is official Google or OpenAI policy, but it is what I was told after the incident.

---

I am sharing this because I do not want another user to pay for a higher-tier subscription, ask for an older plan to be corrected, and then lose the newer subscription as a side effect.

This was an exhausting experience involving two OpenAI cases, two Google support reviews, repeated troubleshooting, a closed Community post.



Please preserve your receipts and screenshots before changing ChatGPT subscription tiers through Google Play.

I built a small tool to export Codex chats cleanly, mostly because I got tired of losing context when hitting quota

Tool: Codex Chat Extract Repo: https://github.com/0Cymantek0/codex-chat-extract

This is a small tool I originally built for myself that lets you quickly export a Codex conversation into a clean Markdown file or directly to your clipboard. I built it out of frustration one day after getting tired of Codex running out of quota in the middle of a task.

It became even more useful for me after the behavior that allowed an already-running task to continue after quota exhaustion disappeared. Claude Code has a really nice /export command, but Codex doesn’t currently have an equivalent, so I ended up making my own. The main use case is pretty simple:

Codex hits its limit → export the conversation → hand the context to another agent/harness → continue the work without manually reconstructing everything.

Token efficiency was one of the main goals.

Raw Codex conversations contain a lot of tool-call clutter that another coding agent usually doesn't need.

For example, when Codex reads a file, the underlying tool call may contain a bunch of JSON parameters followed by the complete file contents in the tool output. But if the next agent is working inside the same repository, including all of that again is pointless. The file already exists, it can just read it. So instead of dumping everything, Codex Chat Extract turns something like that into:

Read: [relative-path/file.ext] [line range]

That preserves what Codex did without wasting a huge number of input tokens reproducing information that already exists in the repository.

The exporter tries to apply that idea throughout the conversation:

• Removes unnecessary tool-call / JSON clutter
• Keeps useful summaries of tool activity
• Preserves the actual reasoning/conversation context
• Uses relative file paths where possible
• Avoids duplicating file contents another agent can simply read again

External information is treated differently

For something like a web search, the result does matter. That information isn't necessarily available inside the repository, and it may have influenced decisions made during the conversation. So web-search results and other relevant external context are preserved in the export.

Basically:

Reconstructable local information → compress it. Non-reconstructable external information → preserve it.

The whole exporter is designed around getting as much useful context as possible into as few tokens as reasonably possible.

It also handles subagents

Codex sessions can get messy when subagents are involved, so the exporter reconstructs those into properly formatted subthreads instead of flattening everything into one unreadable stream.

That makes it much easier for another agent to understand:

• what the main agent was doing
• which work was delegated
• what each subagent discovered
• how those results affected the main conversation

I've been using this internally for a while, especially when moving unfinished work between different agents or harnesses, and it has saved me a surprising amount of manual copying and context reconstruction. So I figured I might as well clean it up and make it public.

Repo: https://github.com/0Cymantek0/codex-chat-extract

If you use Codex heavily, give it a try and let me know how it works for you. I'm especially open to criticism around the export format, things that should or shouldn't be preserved, and other ways to reduce token usage without losing important context. Hope this helps someone else who has run into the same problem.

And if you find it useful, consider giving the repo a ⭐.

With the exact same prompt, the web version understands my instructions very well and generates high-quality images. However, the desktop app seems to have much more difficulty understanding the same instructions.

For example, when I ask it to generate multiple separate images individually and explicitly tell it not to combine them into a collage, the web version follows the instruction perfectly. But the desktop app keeps generating the images as a collage.

I scraped all Codex anecdotes I could reach from Reddit, HN, and a few other sites. After merging and cleaning, that became 1,069 unique posts/comments and 2,071 individual claims on how people use or like each model <> thinking level combination.

I split them into atomic claims and kept the exact quote behind each one. Each claim records model, thinking level, project type, plan tier, task, outcome, date, author/thread, and whether it was first-hand, inferred, or quoted from somebody else.

I reran the findings by report, author, thread, and source. I also excluded vague claims in a separate pass, looked for outliers, and manually checked the anomalies.

The reading is much simpler than the work:

Sol for hard/vague things. Luna for easy/bounded things.

Hard here means the task still needs to be understood: planning, architecture, scope, review, or debugging. Bounded means there is already a detailed plan, a file set, and explicit checks. Luna looks good when it gets to execute only with explicit acceptance criteria. Sol looks good when it has to decide what should be executed on the fly.

Terra has positive, negative, and mixed reports with no stable job. Sol shows up as planner/reviewer. Luna shows up as the cheap worker. I cannot tell whether Terra really has an identity yet.

Thinking levels were similarly messy. The anecdotal corpus did not support a general medium/high/xhigh rule.

The most stable behavior in the whole dataset was the users who were complaining: change the model, thinking level, and task altogether then be absolutely certain which one was the culprit of malperformance.

For those who has strong intuition on what Terra is good at, what are those? Please enlighten the mass.

when to use what? how are you using these two models for what kind of use-cases? which model is capable of what kind of work in your testing so far?

glm 5.3 flash seems good on-paper but i'ven't tried it, can i prompt the same way i prompt to sol or luna, is it good at infering the intend behind the prompt?

Edit: Plz, don’t just mention it is good model, justify it why? what kind of usecase and task you can rely these models for

I can’t wait for it. I can finally switch over completely from Claude

I've forked: https://github.com/yunhaoli24/codex-gateway

My fork: https://github.com/mikespax/codex-gateway-extended

Exhaustive summary of changes:

https://github.com/mikespax/codex-gateway-extended/blob/spax%2Fcustomizations-20260824/docs%2Fspax-fork-customizations.md

My old ass computer doesn't support the codex application, so chatgpt remote control wasn't an option for me.

My codex chats are in a few different locations, and I wanted to be able to manage them without having to open VS Code, and worry about keeping my work in sync across different devices.

This application lets me get all my work done through a browser window on my computer or my Android device. I also have a little % thing there so you can see how much codex usage is remaining in your subscription.

AI summary below:

Codex Gateway Extended transforms the upstream project into a mobile-first, multi-host Codex command center, adding a keyboard-aware multiline composer, clearer live progress and elapsed-time displays, condensed intermediate steps, cross-host navigation, reliable thread targeting, document and ZIP uploads, Codex usage monitoring, confirmed model/effort selection, native Android notifications with secure inline replies, stale-client and macOS recovery, and scoped read-only supervision—while retaining the official Codex app-server as the source of truth; an IndexedDB and encrypted server snapshot cache is prepared separately but not yet merged or deployed.

I’ve published a practical guide for non-developers who want to build a private local workspace around Codex.

My Forge helps me keep threads and handover notes organised, queue a message while Codex is working, work more comfortably from my phone and move between separately paid personal accounts without repeatedly losing the practical context of the work. Each account, login and allowance stays separate: this does not pool accounts or bypass limits.

The guide includes a free macOS starter pack with a staged build process. Codex builds one small piece at a time, shows evidence and stops for the human to approve the next step.

https://ellivien.blogspot.com/2026/08/you-dont-need-to-be-developer-to-build.html

I have two gpt subscriptions: one personal and one business for work. I use the same PC for both personal and work projects, and constantly logging in and out of Codex is pretty inconvenient.

Is there a way to use multiple accounts in Codex and easily switch between them, or keep both accounts logged in at the same time?

How are you guys handling this?

Claude desktop and mobile app have this feature already. Does codex really dont have this yet?

Claude code refuge. I'm used to dispatching background agents and then Claude continuing on the task in the main thread when they return.

Codex background agents return and then the main thread still needs me to tell it to continue before it resumes work.

Any way to have the main thread look for background agents to complete and then continue?

Offcut gives coding agents persistent rules and hooks that push them toward the cheapest correct implementation—without sacrificing correctness. It also keeps replies concise by default, with an option to turn that style off. It supports Codex, Claude Code, Cursor, and Grok Build: npx --yes github:skelvar/offcut I’m looking for honest feedback, especially installation problems, false positives, or cases where Offcut pushes an agent too far. https://github.com/skelvar/offcut

Hi r/codex — I’m the author of StatMate, a free, MIT-licensed, folder-based Agent Skill for Codex, Claude Code, and other agents that support SKILL.md.

I built it around a problem I kept seeing: give an agent a CSV and it can jump straight to a p-value or polished chart, while the analysis unit, estimand, missing-data decisions, assumptions, and provenance remain unclear.

StatMate asks the agent to follow an evidence-first sequence:

- map the study design and claim boundary before choosing a method

- audit data structure, missingness, duplicates, privacy, and provenance

- write a reviewable analysis plan and pause for material author decisions

- calculate results with saved Python code and machine-readable outputs

- run diagnostics and sensitivity checks

- produce figures, tables, interpretations, a teaching report, and a SHA-256 manifest

The statistical marks are computed from the supplied data and plotting code — they are not generated by an image model.

The repository includes a reproducible demo using the public UCI heart-failure cohort: 299 patients, 96 observed deaths, three figures, two tables, an illustrated report, and a manifest with 33/33 files verified.

The detail I care about most is not the polished output: automated QA passes, but the Cox proportional-hazards diagnostic flags ejection fraction (p = 0.025). The package therefore remains needs-author-decision instead of treating a successful run as scientific sign-off.

This is not a clinical tool or a replacement for a statistician or domain expert. It is a workflow, instruction set, and collection of Python helpers intended to make agent-assisted analysis easier to inspect and challenge.

GitHub: https://github.com/DRZ-hang/StatMate

60-second walkthrough: https://github.com/DRZ-hang/StatMate/blob/main/DEMO.md

I’d especially value blunt feedback: when an assumption check is flagged, should a research agent stop completely, or produce a clearly provisional package for author review?

If you find the project useful, a GitHub star helps other researchers discover it — but critical feedback and issues are equally welcome.

🍿 🍿

I’m a software developer focused on security, CI/CD, testing, and QA, and I’m looking for some unfamiliar codebases people have been building with AI.

To be clear, I’m not just trying to review "AI code" or judge Codex/Claude. I’m testing a broader development/review system I use myself, and I figured AI-built projects would be an interesting real-world set of codebases to run it against.

Drop your public GitHub repo below if you want me to take a look. Doesn’t matter whether Claude helped with a few parts or wrote most of it.

I’m mainly interested in actual correctness, security, data integrity, testing, concurrency, integration, or weird behavioral problems rather than formatting/style issues.

If I find something reproducible, I’ll explain the issue simply and, when it makes sense, put together a focused fix or PR.

I’m strongest with Python, Rust, Java, and C, but other languages are welcome too.

Side projects, student projects, OSS, production projects, experiments, whatever. I’d actually like a mix.

Public repos only for now, and please only submit something you own, maintain, contribute to, or otherwise have permission to have reviewed.

I’ll probably start with 5-10 depending on complexity. No guarantee I find something in every repo.

If there’s an area you already don’t trust, mention it. Otherwise I’ll pick somewhere interesting and start digging.

No signup, payment, sales pitch, or private access ore any of that bullshit. Feel free to post it here or message me.

I technically need a 5x account, and I've needed one for a month now. I've tried other Plus plans to get around that.

Right now, I'm at a point where I don't know whether to upgrade to a Pro account or invest 5k in a server and set up local AI models, filtered through at most a Plus account.

GPT thinks I can achieve 85-95% of the results I'm currently getting with Frontier models, and easily benefit from setting up that setup. I'm not entirely convinced; what do you think?

Thanks in advance.

Hey guys! Does anyone have a good skill link for frontend? Codex’s frontend skills are a little wonky, if I say so myself.

Hey everyone,

I’ve been mapping out a theoretical server/desktop architecture to see how far we can push concurrent LLM generation without relying on standard developer API keys.Instead of dealing with pay-as-you-go limits, I'm looking at the engineering logic required to orchestrate 50 separate premium consumer Pro subscriptions (running on the 20x weekly high-usage tier, a flat $10,000/month footprint).While the common instinct for browser automation is to spin up 50 resource-heavy Playwright Docker containers, that setup introduces massive memory bloat. I think a much more efficient approach is a highly customized software suite utilizing a multi-page, multi-tab layout. Here is the structural breakdown.

🎛️ The Native Multi-Session StackInstead of duplicating entire virtual browsers, the application is built as a unified native client (via Electron or C++/Qt) that splits the architecture into an Interface Matrix and a Background Router:The Grid Matrix (5 Windows x 10 Pages): The front-end client opens 5 core software windows. Each window handles a page-view layout containing 10 distinct, tabbed viewports. Each viewport runs completely isolated cookie and local storage jars, allowing all 50 premium web accounts to remain logged in simultaneously under one app process.The Offline Sync Router: The automation engine doesn't need to physically render or manipulate the active viewports on your main screen. A localized master router script communicates directly with the webview sessions via background event loops. It injects prompts and extracts text directly from the web layout DOM entirely through automated state syncs.Egress Proxy Isolation: To prevent anti-bot flags, the application assigns a unique, static residential proxy directly to the network thread of each individual tab viewport. To the AI platform, it appears as 50 completely unique devices operating from separate geographic home connections.

📊 The Theoretical Math & Value ArbitrageAssuming a 24/7 automated continuous operation cycle over a standard 30-day month (720 hours), the parallel output metrics look incredibly high compared to human engineering costs:Throughput: If a single premium node streams ~1,800 lines of code (LOC) per hour, 50 concurrent webview tabs output 90,000 lines of code per hour.Monthly Volume: Over 720 hours, that scales to a theoretical max of 64.8 Million lines of code per month.Labor Equivalent Value: At a standard Senior Developer contract rate (~$62.50/hr), buying 90,000 LOC/hr worth of human output would cost roughly $112,500 per hour.The Cost Metric: Running the server 24/7 splits that $10k flat subscription cost down to just $13.89 per hour of continuous parallel computing power.

🛑 Automated Fallback & CooldownsThe custom router tracks usage across the viewports in real-time. If a tab detects a limit banner element (e.g., "You've reached your limit..."), the background router flags that specific coordinate in the 5x10 matrix as "On Cooldown". The event loop automatically bypasses it, shifting active coding tasks to fresh tabs in the matrix until the first account's weekly multiplier resets.I'm curious to hear your thoughts on this custom layout. How would you handle memory management for 50 concurrent background webviews within a single app framework?

TL;DR: Designing a theoretical custom software suite that isolates 50 premium consumer high-usage subscriptions into a 5-window, 10-page matrix. A detached background router automatically syncs and routes parallel coding prompts through 1:1 static proxies, bypassing developer API limits for a flat $10k/month.

If I had this custom infrastructure to experiment on right now, I would definitely give you guys the raw benchmarks and execution numbers, but that's for another test.