cd /news/large-language-models/looped-reasoning-means-the-ai-s-visi… · home topics large-language-models article
[ARTICLE · art-126382] src=dev.to ↗ pub= topic=large-language-models verified=true sentiment=· neutral

Looped reasoning means the AI's visible trace isn't the reasoning

A developer argues that looped transformer architectures, such as the described GPT-6 Astra which runs the same blocks through roughly 44 recurrent passes while reusing weights, decouple a model's visible chain of thought from its actual computation. Because the written reasoning is generated after the fact as narration rather than a recording of the underlying passes, the author contends that agent evaluations and code reviews relying on visible traces are judging a story rather than the model's thinking. The recommended response is to instrument checkable artifacts instead — the tool loop, touched files, final diff, and observable behavior — and to note which harness variant was measured, since forcing reasoning out changes how the model allocates passes.

by read2 min views2 publishedSep 11, 2026

GPT-6 Astra ships looped transformers: the same blocks run ~44 passes, reusing weights, so effective depth doubles without new parameters. The KV cache and the intermediate states differ per pass, but the tokens you actually see are only one layer of that surface.

Here's the part that matters for anyone evaluating agents or reviewing AI-generated code: when the reasoning is hidden inside those loops, the transcript you ask the model to produce is a summary written after the fact, not the trace of what it computed. The text is real, but it's narration. It's the model telling you a plausible story about how it got from input to output, because the actual computation happened across a bunch of recurrent passes you can't inspect.

That quietly breaks a habit most review and benchmark setups lean on. A huge amount of agent evaluation rides on the idea that the chain of thought is evidence. You hand the reviewer a diff, and you judge both the answer and the surrounding reasoning: did it consider this edge case, did it notice that the change touches a shared enum, did it follow the repo's style rules before it touched the code. If the trace is decoupled from the compute, then judging the trace is judging a story, not the thinking.

It doesn't make the model dishonest. Narration and computation agreeing is the common case, probably. The problem is you can't tell when they diverge, and the divergence is exactly where a bad review or a subtle bug hides.

For eval design, the practical response is to stop treating the visible reasoning as the ground truth and start instrumenting the things you can actually pin: the tool loop, the files the agent touched, the final diff, the observable behavior. Those are checkable. A written chain of thought from a looped model is a report, not a recording. The interesting trade is that forcing the reasoning out, which some setups do as a transparency measure, is itself an intervention on how the model allocates its passes. Transparent models and hidden-trace models aren't the same system, so a number measured on a forced-transparent variant doesn't cleanly transfer to the shipping default. That's a harness difference before you even get to reasoning quality. Pin which one you measured.

── more in #large-language-models 4 stories · sorted by recency
── more on @gpt-6 astra 3 stories trending now
sponsored brought to you by zahid.host 4,200+ EU-deployed projects
reading about agents? ship yours in a single git push.

Run your AI side-project on zahid.host

EU-based hosting, git-push deploys, automatic HTTPS, no cold starts. Free tier with a custom domain — perfect for shipping the agent you just read about.

$git push zahid main
Live at https://your-agent.zahid.host
Get free account → Pricing
from €0/mo · no card required
LIVE [news/looped-reasoning-mea…] indexed:0 read:2min 2026-09-11 ·