GPT-6 Astra Deep Dive: Looped Transformers, Computer Use & the Hidden Reasoning Debate

GPT-6 Astra: First Impressions

Benchmark Performance

Sebastian Raschka reports that GPT-6 Astra is the strongest model he has used to date, showing disproportionate gains in 3D rendering and animation tasks. On benchmarks, Astra scores 99.9% on ARC-AGI-3 (vs. 7.8% for GPT-5.6 Sol) and leads on coding agent and intelligence indices from Artificial Analysis, though the margin over competitors is not dramatic. Raschka notes that agent benchmarks often use unified frameworks (e.g., Stirrup, Terminus) which may underestimate a model's performance in its native framework.

Computer Use Capabilities

Astra excels at computer use — operating local software via the Codex/ChatGPT app by controlling mouse and keyboard. Examples include redrawing a photo in browser-based MS Paint and driving Blender for 3D modeling. Raschka compares this to humanoid robots: not the most efficient for specialized tasks, but uniquely general. He predicts the next months to years will see heavy investment in computer-use capabilities across LLM and agent frameworks.

Training Computer Use via Mac Environments

Reports that OpenAI purchased tens of thousands of Mac Minis/Studios align with using macOS as a reinforcement-learning environment, not for model training compute. The training loop:

Prompt the model with a task (e.g., "open xyz app and do abc").

Provide a screenshot of the macOS UI (handled by the framework).

Model predicts mouse/keyboard actions (click, type, scroll).

Execute actions on the Mac (framework).

Feed the updated screenshot back to the model.

Repeat steps 2–5 until success or failure.

Use success/failure signals and a verifier as reward for RLVR-style post-training.

The model itself runs on NVIDIA GPUs (≈100k Grace Blackwell GPUs per Jensen Huang), communicating with the Macs via API.

Astra Remains a Reasoning Model

Despite the computer-use focus, Astra is still a reasoning model trained with verifiable-reward RL (RLVR) that emits intermediate reasoning traces (chain-of-thought). The hidden-CoT discussion is deferred.

Looped Transformers Explained

Reusing Transformer Blocks

A looped transformer passes intermediate representations through the same stack of transformer blocks multiple times, sharing weights across passes. Nanbeige4.2-3B (July 2024) applies a 22-block stack twice, yielding 44 block applications with only 22 unique blocks' parameters. The unfolded computation equals 44 layers, but parameter memory is roughly halved (embedding/output layers excluded).

The Cost of Recurrence

Forward pass computes all 44 block applications; backward pass backprops through both passes, so compute matches a 44-independent-block model. KV cache cannot be shared across passes because hidden states differ; Nanbeige tried sharing KV cache but performance dropped. Two design takeaways from Nanbeige: (1) training looped from scratch beats upcycling a pretrained transformer; (2) two passes is the sweet spot — more passes add compute without proportional gains.

Universal Transformer and Adaptive Halting

The 2018 Universal Transformer loops a single block (not a whole stack) and introduces adaptive halting : a learned halting function emits a stop probability per token per step; cumulative probability exceeding a threshold halts that token's loop, up to a max step limit. This allocates compute per token dynamically.

Routing Recursion Depth with Mixture-of-Recursions

Mixture-of-Recursions (MoR) (2025) uses a learned router to decide per-token recursion depth. A shared recursion block (several transformer layers) sits between fixed first/last layers. Two routing variants: expert-choice routing (each recursion step selects which tokens continue) and token-choice routing (router assigns a fixed depth upfront). Both reuse weights across steps. MoR outperforms vanilla and fixed-recursion transformers at larger scales and lower compute budgets, and processes more tokens per budget by skipping computation.

Empirical Results

MoR validation loss curves (Fig. 11) show vanilla wins at tiny scale (135M), but MoR catches up and often leads at larger scales and tighter compute budgets. At the highest budget, curves converge. This underscores the need for large-scale experiments to evaluate architectural ideas.

Digression: Recurrent Neural Networks vs. Looped Transformers

RNNs reuse weights across time steps (token-to-token), while looped transformers reuse weights across depth (multiple passes for the same token). Attention still handles inter-token communication in looped transformers.

Did GPT-6 Astra Use Looped Transformers?

The Information reported (unconfirmed) that Astra uses "recurrent depth" / "looped transformers." OpenAI Chief Scientist Jakub Pachocki later stated frontier models' compute-graph depth is within 2× of GPT-4, which is consistent with either looped blocks or simply 2× more regular blocks. Raschka believes Astra's strength comes mainly from better training recipes and data; looped transformers may help but their contribution is likely overstated by the leak.

The Hidden Chain-of-Thought Debate

How Reasoning Models Work

Reasoning models generate intermediate text tokens (reasoning traces / CoT) before the final answer, enabling backtracking (e.g., trying 5+5=10 but product 25, then trying 3+7). These traces act as scratchpad, increasing compute before the answer. OpenAI has hidden most traces from users since o1.

Token Usage and Shorter Chains

Astra does not uniformly use fewer tokens than GPT-5.6 Sol across effort levels, but at matched accuracy it uses fewer tokens. Raschka argues this reflects higher capability — fewer errors, less backtracking — not architectural obscuration. He cites GPT-5.6 family: Luna uses 80% more tokens than Sol for similar performance, yet no one claims Sol is less interpretable. The more plausible explanation: stronger models solve problems more efficiently (fewer tokens).

Astra's system card acknowledges a decline in trace monitorability (shorter, less informative traces) relative to Sol, but this does not prove looped transformers are the cause; it may simply be a side effect of shorter traces, as with Luna vs. Sol. Raschka sees no evidence that looped transformers induce deceptive traces.

Jakub Pachocki clarified: "I want to avoid a race to the unmonitorable sparked by confused reporting. Compute-graph depth of our frontier models (including Astra) is within 2× of GPT-4. We've worked to preserve and leverage CoT monitoring since the earliest reasoning models… I do think it's fragile and unfortunately trending in the wrong direction, for reasons unrelated to architecture changes… but we have ways to strengthen it."

Pachocki explicitly decouples architecture changes from CoT monitoring trends.

Recent Research on Looped Transformers

Latent Reasoning with Recurrent Depth

Scaling up Test-Time Compute with Latent Reasoning: A Recurrent Depth Approach (2025) trains a 3.5B model on 800B tokens with a 4-block shared stack sandwiched between 2 initial and 2 final blocks. Each loop concatenates the previous hidden state with the initial block outputs, projected linearly. Training samples random loop counts; inference uses a fixed budget (8, 32, 64 loops) or adaptive halting via KL divergence between successive next-token distributions. Gains vary by task: HellaSwag plateaus ~8 loops; GSM8K and HumanEval benefit from more loops. The model can still emit text CoT; loops add pre-token compute.

Knowledge Retrieval vs. Reasoning

Beyond Parameters: Exploring Virtual Logic Depth for Scaling Laws (June 2025) separates memory capacity from reasoning. With fixed parameters, recurrence barely changes memory retrieval performance, but boosts multi-step math reasoning. Conclusion: recurrence adds compute, not storage; larger models improve both but also increase parameters.

Compute-Matched Scaling Laws (SMELT)

SMELT: Scaling Laws for Compute-Matched MoE Looped Transformers (Sept 2026) compares looped vs. vanilla transformers under matched per-token compute, non-embedding params, and KV cache. Using MoE, they loop the middle half of blocks twice (similar to Nanbeige with Latent-Reasoning sandwich), narrow hidden dims to offset compute, then add experts to recover params and adjust attention heads to match KV cache. Up to 54B non-embedding params, SMELT reaches target validation loss with 6.8–18% less training compute. Looped transformers are compute-efficient.

Full-Bandwidth Transformer

Full-bandwidth transformer (Aug 2026) introduces cross-token recurrence: a learned gate combines the previous token's final hidden state with the new token's embedding to form the next forward-pass input. On a 1B base model, this shortens CoT on MATH500 while maintaining or improving accuracy, but the effect disappears after instruction tuning. The study did not test whether simply adding more regular layers would produce similar shortening.

Conclusion

GPT-6 Astra is a major leap, especially in computer use, which will become a central focus for open and closed frameworks. Astra likely employs a looped transformer variant, which improves modeling quality per compute budget. Shorter reasoning traces accompany stronger models (fewer errors, less backtracking, more internal compute) — a trend visible within model families (Luna vs. Sol) and not unique to looped architectures. The CoT monitoring challenge is real but driven by factors other than recurrence. Open-source auditing of computer-use frameworks is crucial before granting full system access.