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.

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.

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!

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 |

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

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

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:

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:

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:

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.

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.

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:

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:

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

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.

Caption: Word choice and delicate expression in plain-description writing.
And it renders suspense and atmosphere very well, with obvious rhythm control now:

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:

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

Caption: A discussion comparing GPT-5.6 and GPT-6 Astra writing quality.
The chasm still uncrossed: "restraint and measure" in the Chinese language

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:
- 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.
- 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!