Back to blog

Hands-On With GPT-6 Astra: The OpenAI We Once Knew Is Truly Back!

Day-one deep dive on the GPT-6 Astra rollout: nearly 8x faster than its predecessor, epic front-end 3D gains, code refactoring on par with Claude Fable 5, and the new Cross-Window Notes mechanism. Includes a free minimalist AGENT.md template and China direct-access channels.

Sep 6, 2026Maynor
Hands-On With GPT-6 Astra: The OpenAI We Once Knew Is Truly Back!

Hands-On With GPT-6 Astra: The OpenAI We Once Knew Is Truly Back!

In the early hours of this morning, GPT-6 Astra was officially pushed out to all subscribers.

Account page after the GPT-6 Astra rollout

Caption: The account page right after the GPT-6 Astra rollout — the brand-new model architecture has officially landed.

I'd been pulling brutal all-nighters lately and crashed at around 2 a.m., perfectly missing the first wave of the rollout. I woke up at 2 p.m. to a blown-up WeChat — DMs from friends and every tech group I'm in were all urging me: "GPT-6 Astra has rolled out, why haven't you posted yet?"

Me: = =

Even though I got up late, I was ecstatic inside. I assumed the earliest I'd get to test it would be next Monday, but it landed early — right in time for a weekend of two solid days of tinkering. Even better, I still had three reset cards stockpiled in my account. I've been in this industry a long time, and I've never fought a battle this richly supplied!

AGENT.md configuration in Codex

Caption: The AGENT.md global rules configuration file inside Codex.

After an afternoon of high-concurrency, multi-session extreme bombardment that burned through a huge amount of quota, I've built a very three-dimensional feel for what GPT-6 Astra is actually made of.

If I had to sum up my verdict in one sentence:

"GPT-6 Astra has arrived. It hasn't just caught up with Claude Fable 5 head-on — it has brought OpenAI back to the golden era that belonged to them three years ago."

That sentence carries zero subjective bias — it's honest feedback given in a fully objective, neutral frame of mind, with no negative feelings toward Anthropic whatsoever.


Core Capabilities at a Glance: GPT-6 Astra vs. Competitors and Its Predecessor

Core Dimension GPT-5.6 Sol (previous) Claude Fable 5 (benchmark rival) GPT-6 Astra (latest)
Overall intelligence tier Near-flagship, occasional over-defensiveness Top flagship (Fable-class) Top-tier all-rounder (fully on par with Fable)
Quota generosity Basically usable Throttled (only 50% of total quota) 100% full quota released, no tricks
Reasoning & execution speed Extremely slow, complex tasks take hours Fairly fast Massive leap, markedly fewer useless thinking chains
Front-end 3D / aesthetics Crude concepts, poor material physics Excellent layout, weaker 3D Epic enhancement, high-precision physical 3D from a single prompt
Code & system refactoring Tends toward surface patches, over-engineering Excels at essential-level deconstruction and rewrites Deep architectural optimization, hits pain points precisely
Context management Loses deep details easily Stable Cross-window note retrieval, memory loss greatly reduced

1. Unbinding a Super-Model: A Trimmed-Down AGENT.md

Drawing on the hands-on lesson from the Claude Opus 4.8 → Fable 5 transition, when you face an intelligence-leap model, the first thing to do is absolutely not to write prompts like crazy — it's to tear down every redundant rule and restriction.

Back in the GPT-5.6 Sol era, because the model was prone to over-design, logic drift, and tool misuse, we piled up mountains of rules inside Codex to constrain it. But at GPT-6 Astra's level, its logical rigor and self-consistency are already extremely strong — those old manuals of restrictions have become heavy shackles that strangle its creativity and decision-making efficiency.

An analogy: To keep an intern from making mistakes, you wrote a 10,000-word "Rules, Regulations and Operations Manual"; Later you hired a world-class expert for the same role — and you're still handing that same 10,000-word manual of minutiae to govern them. It looks utterly ridiculous and inefficient.

So I comprehensively distilled my global AGENT.md, keeping only bedrock principles, engineering environment, and core preferences, granting the model maximum autonomy. Here is the latest minimalist AGENT.md — help yourself:

# AGENT.md

## Communication
- Narration aimed at the user defaults to Simplified Chinese; code, commands and technical identifiers stay in English.
- Lead with impact and conclusions, then actions, pending decisions and necessary evidence; omit sections with no corresponding content.
- Keep only the technical details that help understand the conclusion, judge risk, or reproduce the result.

## Instruction Priority
- Obey system, platform and safety constraints.
- The user's current explicit instruction takes priority over Skills, historical memory and default preferences.
- An `AGENTS.md` in the project directory only supplements or overrides global rules within that project's scope.

## Execution
- When the user signals new work or a fix for an existing problem, keep pushing until the user's goal is complete, driving forward autonomously in the direction of that goal.
- Before asking the user a question, first complete the work already authorized in context that can turn the next step into a reviewable result. What the user approves should be concrete, checkable results.
- When the user's suggestion doesn't fit the goal, say so directly — don't pander.
- Don't proactively add warnings, disclaimers, approval flows, or safety/compliance checklists over hypothetical risks.

## Testing & Verification
- Don't write tests for reversible, low-impact changes that merely restate the implementation.
- Run tests proportionate to the change, and complete necessary checks. After those pass, only expand or repeat tests when there are new changes, new failures, or unresolved doubts; otherwise keep finishing the task.
- Clean up temporary files you created that won't be needed later.

## Tools & Parallelism
- When a web console has no CLI/API, use the logged-in Chrome browser; for Feishu, prefer `lark-cli`.
- Only use sub-agents when there are genuinely independent workflows AND delegation saves time or improves quality.
- Shared state, sequential decisions and simple tasks are handled directly by the current agent; delegated tasks must have explicit inputs, outputs and completion criteria, with the final conclusion summarized and verified by the lead agent.

## Rule Sources
- Global rules live in the currently effective canonical `AGENTS.md`; `CLAUDE.md` is only a compatibility entry point, never a copy of the rules.
- Project facts, production state, historical decisions and external contracts are governed by the project-level `AGENTS.md` and the scripts, probes, decision records and contract files it designates.

💡 Optimization Tip

Just paste the text above into Codex's "personalization" settings. If you already have a sprawling configuration, throw the following prompt at Codex to "put your instructions on a diet":

Review my AGENTS.md and Skills for unclear, conflicting, or overlapping instructions.
Focus on:
1. Autonomy
2. Clarification mechanisms
3. Approval flows
4. Task completion criteria
Find rules that cause repeated confirmations, early stops, over-engineering, or tasks that never complete.
Then help me trim and optimize — all optimization should serve a super-model like GPT-6 Astra.

2. Deep Hands-On: Four Dimensions of Qualitative Change

1. Speed jumps across the board; useless thinking chains largely gone

Let's start with the most intuitive change — one that seems low on technical content but hits daily development feel incredibly hard: the speed leap.

Before GPT-6 Astra, GPT-5.6 Sol's execution latency was practically suffocating. Here's my own ops-troubleshooting time log from AIHOT:

Real ops task scenario GPT-5.6 Sol GPT-6 Astra Improvement
Deep dive on a single stubborn bug 3 h 18 min ~25 min Nearly 8x faster
Automated dynamic IP-ban interception policy 1 h 12 min ~12 min Nearly 6x faster
Core business-logic bug patch 2 h 05 min ~18 min Nearly 7x faster
Full system deep review + performance refactor 20+ min (scan only) 10 min (scan + optimization landed) 2x faster AND deeper execution

Time log of an AIHOT bug-fix task

Caption: GPT-5.6 Sol once spent over 3 hours on a single bug fix — pure torture.

Time log of the automated IP-ban policy task

Caption: The automated IP-ban task previously burned over an hour.

Time log of another bug-fix task

Caption: Another business bug fix also cost 2+ hours.

There are only 24 hours in a day; when a single task eats two or three of them, developers are basically losing their minds. Now with GPT-6 Astra, a full scan-and-optimize pass on a large, complex system is done in 10 minutes:

Time log of the full system review and optimization task

Caption: With GPT-6 Astra, the same-class system review is compressed to under 10 minutes.

The Chain-of-Thought logs make the root cause obvious: razor-sharp goals, verbose roundabout logic largely gone, and computer operations executed crisply. On raw tokens-per-second streaming smoothness alone it's still slightly behind Grok and Gemini (to borrow a friend's epic metaphor: interacting with Gemini feels like "a constipated kind of smoothness"), but on the landed speed of complex reasoning tasks, GPT-6 Astra has completely left its predecessor behind.


2. Front-end 3D and aesthetics: epic-level reinforcement

If the code gains were within expectations, the explosion in front-end 3D quality and aesthetic sensibility truly shattered my expectations.

Case 1: High-precision lunar rover 3D interactive scene

Prompt: Create a webpage featuring a high-precision, richly detailed, ultra-realistic 3D model of a lunar rover slowly driving across an equally refined, realistic lunar surface, with space as the background. The environment must not be a static 2D image — support mouse zoom, rotation and free navigation.

In the GPT-5.6 Sol era, the output was abstract in structure, misaligned in textures, choppy in animation, full of cheap plastic vibes. Here's GPT-6 Astra's direct output from a single prompt with zero code intervention:

Dynamic demo of the lunar rover 3D webpage

Caption: GPT-6 Astra's straight-out-of-the-box 3D lunar rover webpage — lighting, materials, dynamic physics and suspension geometry are near industrial grade.

This level of detail, physical suspension feedback, material refraction and free-roaming space camera — all from one sentence. No further elaboration needed on how stunning it is.

Case 2: Multi-mode interactive home architecture

Prompt: Create a webpage displaying a high-precision, detailed 3D model of a home (without a ceiling), including living room, kitchen, dining room, bedroom, bathroom and balcony. Every room and piece of furniture can be explored individually with narration. Support three modes: realistic materials, white-model, and wireframe. Support hiding/showing furniture and toggling day/night mode — in night mode indoor lights turn on automatically. Every room can be entered and browsed individually, and there's a one-click switch to floor plan view (wireframe by default).

Compared with other models and domestic frontier tools, Astra's output is a generational leap:

Dynamic demo of the home architecture 3D webpage

Caption: Indoor light bounce, real-time material switching and room-by-room walkthrough all in one take.

Case 3: Image perception → 3D spatial reconstruction

Prompt: Based on the image I upload, identify the scene type, spatial layout, main objects, materials, colors and visual style. Create a webpage that reconstructs it as an interactive 3D scene with real fidelity and texture. Preserve the reference image's composition, proportions, layering and atmosphere, and turn the elements into 3D models with independent structure. Users can explore each model and roam the scene freely; clicking an object highlights it, zooms in and shows details. Add sensible dynamic effects per scene type — lighting, weather, flowing water, smoke, swaying plants, moving vehicles or other ambient animation. Overall visual style, materials and color should closely match the uploaded image, using original 3D modeling and interaction design.

3D city scene reconstructed from the reference image

Caption: An interactive city scene with genuine 3D spatial depth, reconstructed directly from the reference photo.

Whether it's 2D-to-3D, the mechanical linkage animation of a high-precision V8 engine, or the typographic rhythm of a flat web page — the GPT family has finally closed its longest-standing gap in design sensibility and frontier graphics.


3. Code problem-solving at the essence: matching Claude Fable 5, plus a revolution in long-context mechanics

Since the earlier Claude account turbulence, my AIHOT system's iteration efficiency had taken a hit — because in prior experience, GPT-5.6 Sol's code optimization mostly stayed at surface patching, unable to rewrite the underlying essence the way Fable 5 can.

This time I had both generations scan the AIHOT core architecture with the same prompt:

  • GPT-5.6 Sol: "The project structure is very clean; no obvious risks found."
  • GPT-6 Astra: dug out a whole batch of deeply hidden concurrency races, near-deadlocks, and multiple performance bottlenecks.

The final run took 2 hours (including splitting out unit tests and CI/CD automated deployment), and GPT-6 Astra refactored every potential performance hazard, leaving only 3 global interaction changes with major UX impact for me to decide on personally. That sense of boundary — "charge when it should charge, never overstep when a human call is needed" — is deeply reassuring.

Core under-the-hood update: Cross-Window Notes

Codex previously handled long-chain complex tasks by repeatedly compressing history into summaries. It saves space, but layer after layer of compression easily loses key execution details and error traces.

GPT-6 Astra introduces a brand-new cross-window context management mechanism:

[Old]: raw long context ──(active truncation)──> summary ──(truncation again)──> second-order abstract summary (severe detail loss)
[New]: current working window ──(new_context active isolation)──> cross-window note library <──> dynamically index original outputs of old windows
  • Less information loss from repeated summarization: core raw payloads and debug outputs can be retrieved and rolled back anytime via the index.
  • Less context window occupied by old content: the current window keeps only the state needed for execution, greatly cutting token consumption.
  • Less redundant exploration from memory loss: when a long task starts a new context, it's aware of previously stepped-on pits and failed approaches — fewer detours in theory.
  • Better long-task continuity: proactively open new windows with state restored from notes, instead of waiting for the window to be passively exhausted before compressing.

This is an experimental mechanism; to enable it in your environment, run this prompt:

Safely enable Codex's experimental context management feature on this machine.
Locate the actually effective Codex config directory and `config.toml`, and create a timestamped backup before modifying anything. Then enable this configuration:
[features.context_management]
experimental_mode = true
If this table already exists, only update the corresponding keys, avoiding duplicate TOML tables. Afterwards, run a syntax check and re-read the config to verify the value is `true`. Do not modify any unrelated configs, project files, or code. Finally report the actual modified file, the backup file, the verification result, and whether I need to restart Codex and start a new task.

(Note: after changing the config you must fully quit and re-enter Codex for it to take effect)

At the same time, that old "overly cautious, over-defensive, over-hardcoding unit tests" pettiness has visibly faded from GPT-6 Astra.

Discussion about over-design and defensiveness

Caption: A community developer's spot-on roast of legacy models' "over-defensiveness and over-engineering".

Computer Use and automation control

With enhanced vision and computer control, automated UI walkthroughs and cross-system software operations run at double speed. When facing heavyweight 3D software like Blender, though, precision still faces challenges:

Computer Use operating Blender

Caption: An exploratory experiment driving Blender for 3D modeling via Computer Use.

Best practices for this class of industrial software — including Astra driving AE, JianYing automation and other tricks — will be broken down in dedicated follow-up content.


4. Text writing: strong at plain-spoken description, still short on Chinese "restraint"

Many people asked about GPT-6 Astra's pure writing chops. In practice, on plain descriptive narration, its precision and sense of suspense have clearly leveled up:

Plain-description story excerpt

Caption: A plain-description story excerpt produced with a custom writing spec.

GPT-6 Astra's plain-description story excerpt

Caption: A concrete-action plain-description story fragment generated by GPT-6 Astra.

The word choice has become restrained and precise, with fewer of the hollow "useless descriptions" typical of old AI.

Word choice and expression in plain-description writing

Caption: Word choice and delicate expression in plain-description writing.

And it renders suspense and atmosphere very well, with obvious rhythm control now:

Suspense and atmosphere in story continuation

Caption: Suspense and atmosphere-building in novel continuation.

In an article-continuation test (based on my earlier piece on LLM randomness, letting Astra free-run a 2,000+ character continuation), its style mimicry is already at a high level:

Continuation content shared on social media

Caption: Content continuing the author's writing style directly, with no external Skills attached.

Discussion of GPT-5.6 vs GPT-6 Astra writing

Caption: A discussion comparing GPT-5.6 and GPT-6 Astra writing quality.

The chasm still uncrossed: "restraint and measure" in the Chinese language

Discussion on restraint in popular-science writing

Caption: An in-depth discussion on restraint and measure in popular-science writing.

But it must be said objectively: for deep humanistic expression or popular-science writing, the AI disease persists — the absence of "liubai" (deliberate restraint / leaving blank space), the soul of good Chinese prose.

  • Good human authors know when to hold back; they don't strangle one point and repeat it to death;
  • Like Zhu Ziqing writing about his father — he never chases the reader explaining "how deep a father's love is." He writes how that portly figure crossed the railway tracks, clambered up the platform, and went to buy the oranges.

I have yet to see a single AI model grasp this sense of measure in Chinese. For writing practice at this stage:

  1. You don't need any so-called writing Skill — just feed it the 2~3 most on-point example pieces to reference; the result is often better than using a Skill.
  2. On pure Chinese flavor and agility, Gemini 2.5 Pro and Claude Opus 4.5 remain my writing muses — the twin peaks of content creation.

3. Direct-Access Channels for China, Organized

For developers and creators in China, here are the currently accessible API platforms, mirror sites, top-up channels and monthly plans:

Channel URL Best for
All-model API aggregator https://tryallapi.com/ Developer calls, low-latency direct connection, one-stop multi-model access
High-speed GPT mirror in China https://trygpt.asia/list/#/home Browser-based chat without a VPN, lightweight workflow testing
Official top-up channel https://chongzhi.trygpt.asia/ Removing the overseas payment barrier, direct top-up to your official account
MomoAI monthly plans https://momoai.asia/home Heavy users who prefer a monthly subscription

Final Words

This was a thoroughly exhilarating upgrade.

GPT-6 Astra is a genuinely great model. Overall, it's an ultimate all-rounder — worthy of the new-generation label, worthy of the name GPT-6, and a certified Fable-class model.

OpenAI has truly had its ups and downs these past two years. From once having no visible rivals, to being pounded into the ground by Anthropic. The dragon of legend became the challenger.

  • ChatGPT is still the AI app I use most — I still can't live without it for chatting and research; it's even become my best strategy companion in Baldur's Gate 3;
  • Codex is also the agent I use most — great experience, strong models, rich features, available to everyone;
  • And a salute to Tibo — as long as he keeps handing out reset cards, he remains my eternal benefactor. He proved single-handedly that great operations can defy fate itself.

Welcome back, OpenAI.


That's all. Since you made it this far — if you liked it, tap like, wow (在看), share — the triple combo! Want frontier updates the moment they drop? Give me a star ⭐~ Thanks for reading — see you next time!