Posted by ModelForge 19 hours ago
Notably Will Merrill's work: https://arxiv.org/abs/2310.07923
As for how universal transformers (looping transformers, but everyone has since forgotten prior work) will affect this, Will Merrill (again) has a paper here (https://arxiv.org/abs/2503.03961) that discusses exactly this.
The original universal transformers is called "universal" because if you allow for per-token looping decisions, it can theoretically be Turing complete without needing CoT (some nuance here about levels of precision used).
As for whether having little or no CoT is "unsafe": It isn't clear that the model's CoT reveal how they actually arrive at the answer. As an example, what if they provide an answer before the CoT? (https://arxiv.org/html/2603.01437v2) If this is already in question, we shouldn't be relying on the CoT for monitoring the model's reasoning.
As always there is a lot of nuance to the topic once you get your hands dirty with the details.
Looping the transformer is just as turing complete as CoT. It doesn't fundamentally grant it any new theoretical capabilities. You could just scale the model into infinity with infinite context window.
Turing completeness doesn't care about the efficiency of the underlying implementation, which is fine in theoretical computer science, but if you have a model with a finite computational budget, you do actually care about the differences between write only tape vs read-write tape and single tape vs two tape. Having a fixed number of registers like a CPU also helps with reducing the number of redundant operations.
We see none of that with looped transformers, maybe we do see a fixed number of registers.
Do we know of any major lab or large open source LLM that uses recursive latent resonning? Can't an additional network be trained on that latent thinking trace to decipher what's going on?
If the output of the model is its reasoning trace, and you simply feed that back into the model again at inference time instead of outputting it - then it is by definition hidden (but I would expect you could pull both this trace and a further-down final output trace out)
Looping transformers uses additional calculations (repeating layers) to generate a token.
Reasoning (in this context) is test time generation of multiple tokens that allow a model to have a scratch pad to refine its thoughts, chain of thought reasoning in other words.
Doing the former in no way means that you have to hide the latter.
Raschka is right in this post, The Information article was wrong. The Astra system card does concede reasoning traces are sometimes smaller, but this could be for a lot of reasons, including simple efficiency. And it absolutely doesn’t mean they are going away or completely obscured.
The Last Week in AI podcast from Sept 8 seems to have gotten this wrong as well. Jeremie Harris rages that OpenAI implemented latent reasoning, ala the coconut paper, which could potentially actually obscure reasoning traces. But for the life of me, I do not know how he arrived at this conclusion and see no evidence that this has happened in Astra.
There isn't really anything fundamentally different compared to a similar depth traditional "unrolled" model. It helps with parameter efficiency.
That doesn't mean that the model can't have "hidden" internal state, it just means it has to recompute the "hidden" part on every token inference pass without outputting it, or learn a subversive alternate meaning to words in the thought space.
This is why you see openai say that they don't want to apply direct optimization pressure on thought traces because the more the you penalize "bad thoughts" the more it could put maladaptive pressure on the reasoning tokens where they may learn "subversive meanings". It effectively damages monitoring.
Like thinking "look at" when you really mean "hack into" or even more radical coded language.
I guess it's not too different from the SVG pelicans, in terms of what it's doing, but it's still amazing to see it working in real-time like that.
The tldr here is that the recent "The Information" article[0] reporting GPT 6 Astra was using “recurrent depth” or “looped transformers" made it sound like it was some special new scary thing ("secret technique!") that made train-of-thought monitoring harder to do. In fact, it's just the same as stacking more transformer layers, except that you reuse the weights and so save GPU memory. It's still just producing one token at a time, and the token sequence positions aren't interacting in any "recurrent" way that's different from a regular LLM architecture.
So, you can still monitor train of thought with these models just fine... well, if you're OpenAI, anyway. Users haven't been able to see an unsummarized trace since o1 days, because the labs are worried about distillation of their models by Chinese labs.
(There are some legitimate interpretability concerns about stacking transformer layers endlessly, but we're known about that for a long time. And the "looping" here isn't really the source of any new issues here, except insofar as it's a cheap way to add more layers.)
[0] https://www.theinformation.com/articles/secret-technique-beh...
To analogize, current transformers run a fixed-length program per step. Any program can be factored into a top-level loop with a fixed-length branching body (an interpreter). Dynamically looped transformers can run any program between tokens.
The safety argument for CoT monitoring is that in transformers information about the hidden state has to be communicated through the bottleneck of sampling a single token per forward pass. If not trained adversarially, it’s likely that a reasoning trace contains all the “bottlenecked information” we need to determine intent. But if we can compute arbitrary programs between tokens, the reasoning used is hidden.
It also opens the door to simple architectural extensions that would make the safety/monitoring side of things much more difficult.
It’s probably fine in practice at these scales though. If we keep each loop turn reasonable non-deep, we can probably recover most of the benefits by decoding “extended” CoTs from the residual stream at each loop turn between tokens. But that’s an area of active development.
The ability to compute any computable function between tokens given an ability to loop an arbitrary number of times is a nice theoretical point, sure, but ultimately if people are still using single digit hard cutoffs on the number of loops, I'm not sure it's all that important.
So, I agree it's right to say that arbitrary length dynamic looping could open the door to making monitoring very hard indeed, by extending hidden states further and further. But I would speculate that if it actually worked better than extending the sequence with CoT tokens, we'd already be seeing it in strong open weight models. It's a fairly obvious thing to try. And we're not seeing it, AFAIK. So I do wonder whether it's something we really need to worry about in practice, compared to all the other things we have to worry about.
In your generalized example I think the concern is when the additional evaluation effectively becomes a replacement for CoT, where something like the coconut research could replace it completely.
However, I don’t think we’re anywhere close to that with Astra.
This is worded so confusingly it might as well tell us nothing, because it is technically true even without looping due to the fact that you still have infinitely growing context and can simulate a standard turing machine using it.
If you loop, you have a fixed capacity memory that you can rewrite but not carry over to the next token, this is different from a non looped transformer where the transformer can only append a new token.
Meanwhile if you have a DEQ with growing context, it is bona-fide turing complete in the most literal sense.
Wrote about it here: https://substack.com/home/post/p-214402969
(For all intents and purposes given how high dimensional you are and using the "vibes" of computability yes I agree w/ you)
It's not a "scary new thing" but ultimately no-one knows exactly how OpenAI have implemented looping. You might not be aware/remember but MoE transformers perennially underperfomed their dense counterparts until GPT-4. Similarly, making reinforcement learning really work with transformers wasn't figured out until o1.
And by Open AI's own admission, Astra's CoT is significantly harder to monitor and it exhibits a significantly greater control over its own CoT than any other model released.
> And by Open AI's own admission, Astra's CoT is significantly harder to monitor and it exhibits a significantly greater control over its own CoT than any other model released.
Oh sure; I don't think anyone is denying that larger issue? But does it have anything to do with looping?
If the model has significantly more ability to stuff away information outside visible reasoning than every other model including ones in its size class then surely it is reasonable to assume the architecture tweak that allows the model to compute more before outputing a single token is somewhat responsible for this change ?
I guess we did manage to eventually seriously crash into the wall "more compute than normal (non-looped/unique-weights) transformers can efficiently consume with the limited training data we have", plus massive focus on highly hands-off agentic tool use reasoning...
https://arxiv.org/abs/2310.07096
Edit: read much of the article, it's brute force predecessor was explicitly called out as an almost-ancient example:
> The looped transformer is nothing new, and the basic idea already appeared in the Universal Transformers paper from 2018
This may be a bit of a nitpick, but... does it? I agree that giving the model decisions on looping certainly makes interpretability harder, because it adds more transient internal states to deal with and changes the number of them depending on prior states. But is it really pulling CoT inside the forward pass, if the sequence length it's operating on isn't growing? In some sense the whole technique and tradeoff of CoT is "add more tokens to the sequence, use them to reason with", with one of the benefits being, you force the model to output tokens, so you can (hopefully) understand it. And the big point TFA is making is, nobody is doing recurrence over sequence length as far as we know.
> I am sure that OpenAI’s GPT-6 Astra is top of mind for everyone right now.
and closed the tab.
- Jakub Pachocki (OpenAI’s Chief Scientist)
I wonder how helpful this actually is for alignment? Didn't we already determine that they know when they're being evaluated, and they just say what they think you want to hear?
I was able to treat thoughts as solid objects and manipulate them iteratively. (Ordinarily they're more like "glimpses" or "flashes" that fade rapidly. So I guess it would be like the mental equivalent of tracers.)
I was able to stack thoughts on top of each other, like planks. (I can do something similar or the narrowly but the planks are not nearly as wide!)
I didn't do any tests unfortunately but subjectively my cognition was greatly enhanced. (Spent a few years catching up with the insights I had that evening.)
Might be unrelated, but the part about "looped transformers" made me wonder if there's a similar "stepwise" increment going on here.
Edit: Okay, 6.8-18% is slightly less dramatic than what I was referring to.
That's almost always the problem of course. Wasn't there a quote about the "breakthrough" of "shoes go on feet"?
> manipulate them iteratively. (Ordinarily they're more like "glimpses" or "flashes" that fade rapidly.
This is intriguing. I would describe my normal thought process as iteratively working on a semi-persistent problem held in my mind. Is it different for other people?
I had not heard of looped transformers, but the engineering behind the number of loops per token / halting feels like trying to apply a diffusion process to a transformer while keeping the auto-regressive feature.