u/Character_Novel_2592

[removed]

https://preview.redd.it/gokr5vdg9dnh1.jpg?width=1200&format=pjpg&auto=webp&s=fa88a8665324a4a3bf45f6bfb0d45f64f51c305c

Artificial Analysis has Astra at 61, exactly the same as Sol. Muse Spark 1.3 is at 62.

Even in coding, Astra is only around 67 vs 65 for Sol. Meanwhile the API price per token is 2.5x higher.

The real improvements seem to be automation, tool use, long-running tasks and token efficiency. Those are useful, but that’s very different from a massive jump in raw intelligence or coding ability.

If you remove the GPT-6 name and the launch hype, the independent numbers look a lot less revolutionary.

At this point, calling Astra a generational intelligence leap looks more like marketing than benchmark reality.

https://preview.redd.it/7uatdei6tzmh1.png?width=584&format=png&auto=webp&s=2146a391adcd0b34814fb2443448aad1f2463c66

Astra should be coming pretty soon, possibly this week 👀

Only this.

1. One short Codex turn (ChatGPT account).
2. DevTools → Network → filter codex.
3. The large request: POST https://chatgpt.com/backend-api/codex/responses
4. Compare:
   • outbound (model in the body): what you asked for
   • inbound (model / model_slug / resolved_model in the SSE): what ran

If they differ (e.g. you sent gpt-5.6-sol, it came back gpt-5-5-mini) and there is no limit banner, it was routed...

Results: people on the OpenAI forum are reporting the same thing. Here are some screenshots.::

https://preview.redd.it/7rplk5urozmh1.png?width=800&format=png&auto=webp&s=1d6f46d72e88784193e7a7ba4bcd36b1fa8f7b02

https://preview.redd.it/ljttl5urozmh1.png?width=745&format=png&auto=webp&s=5f6ff65879b7420a1f9e2cacdb3c7d6f485f4b04

https://preview.redd.it/br4dcgjt1zmh1.jpg?width=1320&format=pjpg&auto=webp&s=2a4c0b65c27d3b0106478d9f41b834c5d0563b59

https://preview.redd.it/tn50f6fyrxmh1.png?width=923&format=png&auto=webp&s=ebf872e6d9cc3bc3654a7b09beb8e0160ece6a8b

If Codex feels noticeably worse today, it might be worth avoiding critical tasks for a few hours. Some users are reporting lower-quality responses and possible routing to smaller models, even when manually selecting a different model.

It may not be affecting everyone, but if you notice clear degradation, I’d avoid burning quota or trusting it with important changes until things stabilize.

https://reddit.com/link/1w2axr3/video/kvxm9q4btgmh1/player

Seems the old examples were too easy for Asttra. And come ppl even thought Opus5 could do them.

Prompt: Build a gorgeous sci‑fi spaceship with explorable internal structures.Just One-shot,ASTRA will be a glimpse of AGI.

Caught what looks like a pretty serious bug in Codex CLI 0.151.0.

While Codex was waiting on the same long-running process, it kept calling write_stdin, going back through the model with a huge context, then deciding to wait another 30 seconds.

UTC	Cumulative input	Last model call	Weekly usage
04:22:47	224,402,675	326,342	82%
04:24:01	225,717,943	332,924	82%
04:25:10	226,391,971	338,315	82%
04:28:43	229,543,938	357,668	83%

That's around 5.14M additional input tokens in under 6 minutes.

I also confirmed 3 consecutive write_stdin waits on the same process:

332,924 + 335,713 + 338,315 = 1,006,952 input tokens

All 3 were above the 272K threshold, so the documented 2x usage rate may have applied.

But the 2x isn't the bug.

The bug is Codex making a massive 330K+ model call just to decide “wait another 30 seconds”, then doing the same thing again on the same process.

still running → 330K+ model call → wait 30s → still running → another 330K+ call → repeat

I also found later followup_task / subagent continuations around 356K–358K, so this might not be limited to write_stdin.

I have the full JSONL with timestamps, token counts and tool calls. Support is already looking into it and checking whether the >272K multiplier was applied.

If your Codex usage has been disappearing way faster than usual, especially while it's sitting there “waiting” on tests or builds, I'd check your logs. Also worth running codex doctor and making sure your connections/runtime look normal.

Curious if anyone else can find the same wait / write_stdin pattern. This definitely wasn't happening to me like this before.

https://reddit.com/link/1w1rqk2/video/yzga9p1yfcmh1/player

Rumored highlights:

• Much stronger agentic coding
• Better long-horizon reasoning
• Improved planning and verification
• More autonomous multi-step work
• Stronger cybersecurity capabilities
• Better one-shot generation for apps, games, and complex projects

https://reddit.com/link/1w1rk3f/video/yzga9p1yfcmh1/player

Rumored highlights:

• Much stronger agentic coding
• Better long-horizon reasoning
• Improved planning and verification
• More autonomous multi-step work
• Stronger cybersecurity capabilities
• Better one-shot generation for apps, games, and complex projects

Hey everyone,

I was recently reviewing the latest AA-Omniscience Hallucination Rate metrics, and the data on some of the most popular models is genuinely concerning. We are seeing major models hitting 80-90%+ failure rates when it comes to simply admitting "I don't know." Instead, they confidently invent incorrect answers.

https://preview.redd.it/eqbsxrtl5tjh1.png?width=1256&format=png&auto=webp&s=df4802bd83ff39a2a07a86be9d1f4e8b48364251

In software development, this specific type of hallucination is far more dangerous than a standard syntax error. A compiler or linter will catch bad syntax immediately. However, if a model confidently hallucinates a non-existent React hook, invents a library method, or fabricates a flawed PostgreSQL query, it introduces silent logic bugs that can compromise an entire system's architecture and security.

Add to this the fact that we now have 1M token context windows active. While I can't even imagine everything we could achieve with that much capacity, it really makes me wonder: will it actually be quality code at that scale? Or will half of it just be fabricated code meant to "fill in" the gaps when it loses track of the instructions?

To mitigate all of this, I’ve been adopting a few strict strategies:

• Context Narrowing: Forcing the model to work strictly within the provided context rather than relying on its training data.
• Documentation Forcing: Prompting the model to explicitly summarize the official documentation (e.g., Next.js or Node.js docs) before it is allowed to generate the actual code.
• Modular Prompting: Breaking down complex architectural requests into single-function outputs to prevent the model from filling in the gaps with fabricated logic.

How is everyone else handling this? Are you relying entirely on manual code review, or have you found prompt engineering techniques that successfully force these models to admit ignorance?