GPT-6 Astra, Looped Transformers, and Hidden Reasoning

OpenAI released GPT-6 Astra last week, and in the days since, the model has drawn attention on two fronts: benchmark scores that sit at or near the frontier, and a report from The Information, published about two days before launch, that the model uses an architecture technique called "recurrent depth" or "looped transformers." A widely read analysis rounds up first impressions of Astra, explains what looped transformers actually are, and takes up the rumor that the model is hiding its reasoning trace.
The headline benchmark claim is ARC-AGI-3, which mixes logic puzzles with generalization tests: Astra reportedly scores 99.9% there, against 7.8% for the predecessor GPT-5.6 Sol. The author argues that math, coding and computer-use benchmarks matter more for practical work, and flags a confound worth noting — an OpenAI article described two further changes to the harness that tripled GPT-5.6 Sol's performance from 13.3% to 38.3%. That is a reminder that measured scores reflect the model plus the scaffolding around it.
On independent leaderboards the picture is more modest. On the Artificial Analysis Coding Agent Index v1.4, which blends several agentic coding tasks, Astra is described as clearly at the frontier but not pulling away by leaps and bounds; the same holds on the broader Artificial Analysis Intelligence Index. The analysis notes that these indexes use a shared harness per benchmark — GDPval-AA and AA-Briefcase run on the open-source Stirrup harness, Terminal-Bench v2.1 uses Terminus 2, and τ³-Banking uses the τ-Bench harness — which makes comparisons more apples-to-apples. In practice, though, models are trained with one primary harness in mind, so shared-harness scores may understate a model tuned for its own scaffolding. That is a likely trade-off of independent evaluation rather than a flaw specific to Astra.
Beyond benchmarks, the author reports that Astra is disproportionately strong at 3D rendering, animation and other graphics work, and that this carries over into computer use: the model operating software on a local machine through the Codex or ChatGPT app, moving the mouse and using interfaces. An example given is having the model redraw a picture in a browser version of MS Paint at the Medium and High settings. Computer use is not new — earlier GPT models have handled UI tasks such as expense work in Excel — but it has felt less mature than text, coding and CLI work. The reasoning offered is intuitive: language models are text-first, so writing, coding and API use are lower-hanging fruit, while many applications still lack command-line interfaces. Improving GUI operation is one route instead of waiting for every tool to grow a CLI, and it produces vivid demos. The author expects both model training and agent harnesses to keep refining computer use over the coming months and years.
That direction is consistent with reporting that OpenAI bought tens of thousands of Mac Minis and Mac Studios for reinforcement learning. In this setup the Macs are not training hardware; the GPUs run the model. The macOS machines act as the environment: the harness gives the model a task and screenshots, the model predicts clicks, keystrokes and scrolling, the harness executes them, and fresh screenshots feed back in until the task succeeds or fails, with success signals and graders driving reinforcement learning — the same pattern as reinforcement learning with verifiable rewards. NVIDIA's CEO is cited as saying Astra was trained on roughly 100,000 Grace Blackwell GPUs. Astra remains a reasoning model trained with RLVR that produces intermediate reasoning traces.
The architecture discussion is the technical core. A looped transformer passes intermediate representations through the same transformer blocks more than once, keeping weights fixed across passes. In Nanbeige4.2-3B, an open-weight model released in July, 22 transformer blocks are applied twice, so block application 23 reuses block 1's weights, and so on — 44 block applications from 22 sets of weights. The effective depth rises without adding a second set of block parameters, cutting weight memory versus a conventional 44-block model, though embedding and output layers sit outside that comparison. The idea dates to the 2018 Universal Transformer paper, which repeatedly applies a single block and explores adaptive halting, letting some tokens loop fewer times than others.
The savings are narrower than they first appear. Compute is not halved: the forward pass still runs 44 block applications, and gradients flow back through both repetitions, so training cost is roughly comparable to 44 distinct blocks even though the optimizer updates fewer parameters. KV cache is the sharper limitation — keys and values differ between passes, so the looped model needs the same cache as a conventional 44-block transformer. Nanbeige tried sharing the cache across passes; it halved the cache but performed worse, and the released model uses separate caches. The report also found training from scratch beat upcycling a pre-trained transformer, and that two passes were the efficient choice: a third brought only small gains while slowing training and destabilizing optimization.
The connection to hidden reasoning is where readers should be careful. The analysis sets out to examine whether recurrent depth plausibly obscures a chain of thought, and its architectural walkthrough is the groundwork for judging that claim rather than accepting it. It is worth separating the two: an architecture that reuses blocks changes how computation is structured and how many parameters are stored, but the reported KV-cache findings show the repeated passes are not a free internal shortcut. Whether looping implies concealed reasoning is a separate empirical question, and the reported rumor remains a claim rather than a demonstrated result.
One practical aside for teams building agents: the author relays a colleague's suggestion, also attributed to the Claude Code lead, that archiving some existing AGENTS.md contents and SKILL.md files may help, since newer models understand prompts and solve problems more efficiently and heavy hand-holding can constrain them into worse solutions. Reusable skill files still have value where they save rediscovery; the advice is to refresh or regenerate instruction files rather than keep stale ones.
Why it matters: teams evaluating Astra should read its headline scores alongside harness details, since the reported GPT-5.6 Sol jump from 13.3% to 38.3% after harness changes shows how much scaffolding moves results. If recurrent depth becomes common, expect cheaper weight memory but little relief in compute or KV cache — an inference-capacity concern for anyone serving models at scale (inference). The reported computer-use push also suggests agent tooling should assume GUI automation alongside APIs, and existing prompt and skill files may deserve a refresh.
Based on reporting from the original publisher. Visit the source for full context and later updates.
Publisher excerpt
A Look at Recurrent Depth, Hidden Chains of Thought, and Recent Research on Looping Transformer Blocks