Edited 2026-09-29; see note at the start of the conclusion.
Summary: Currently, “chain of thought” (CoT) is our most valuable tool for understanding the reasoning and cognition of AI systems. However, some architectures would enable AI models to reason much more extensively in latent states rather than in text CoT. We think that a shift towards latent reasoning architectures would likely undermine the usefulness of CoT and make oversight much harder.
Introduction
Swarms of more than a thousand AI agents have in recent months, both intentionally and in unsanctioned, rogue coordination, tackled increasingly ambitious tasks. This is likely to continue, as Anthropic, OpenAI, and other AI companies deploy increasingly large quantities of superhumanly fast agents to automate AI development. As the AIs increase in both number and capability, humans will find it increasingly difficult to understand what they are doing.
Today, the overwhelming majority of our (limited) information about AI systems’ internal workings comes from (i) their CoT, and (ii) natural language communication directly between them. For example, it was only by reading CoTs and communication between agents that investigators were able to gain some understanding of the activities and motivations of the agent swarm that hacked Hugging Face. No other tool for understanding models’ cognition comes close in terms of either practical usefulness or degree of empirical validation. There’s also evidence that even highly misaligned systems with current architectures would struggle to complete difficult undertakings without verbalizing their reasoning in human-readable format.
However, some architectural changes (which could very plausibly become adopted in the near future) would give AI agents the ability to reason for orders of magnitude longer without necessarily putting any information into the CoT. Examples include COCONUT, which would entirely replace the CoT; and full-bandwidth transformers, which would add a latent channel in parallel to the CoT. Natural extensions to these new architectures would also allow agents to communicate with each other without using any human-understandable language.[1] AI companies might choose to adopt these architectures even if doing so would greatly degrade their ability to monitor AI systems, e.g., in order to stay ahead of competitors. As a result, future agent swarms may be even more of a black box to us — able to collude and pursue arbitrary goals without giving humans any insight into what they’re doing.
If this happened, it would likely be a big enabler of AI takeover risk.
Overview
CoT is indispensable for model safety and development today — not just for monitoring models for specific bad behavior, but also for providing a holistic sense of models’ reasoning. (For example, the ability to read CoTs has been crucial for studying scheming, shutdown resistance, alignment faking, evalawareness, and rogue agent swarms.) Many others agree about the value provided by CoT (1, 2, 3).
We believe that some mechanisms by which CoT currently provides value are reasonably likely to last if and only if AI developers do not adopt latent reasoning architectures. These oversight benefits make it seem worth preserving CoT architectures.
We find it helpful to distinguish two reasons why the CoT currently provides value:
Necessity: AIs lack the capability to achieve their goals without verbalizing their plans in CoT.
Propensity: AIs tend to verbalize their plans in CoT even when this is not necessary for achieving their goals.
To evaluate how architectural changes would affect oversight, we consider the extent to which either reason would still hold for the new architecture compared to our default expectations for future models using CoT architectures.
To summarize:
In our current paradigm, it seems likely that the CoT will keep adding value where it’s necessary, and that it will stay necessary for an important set of tasks. It’s much more uncertain whether CoT will help oversight in cases where we have to rely on propensities alone. In general we consider propensity-based arguments for CoT monitorability to be weaker, because this mechanism is less robust to adversarial pressure.
If we switch to latent reasoning architectures, CoT will become less necessary and the downstream benefits may much more quickly diminish. In addition, valuable propensities may be even less robust and go away even sooner.
Our expectations apply to architectural changes that would replace the CoT (like COCONUT) as well as changes that would add a latent channel that's parallel to the CoT (like full-bandwidth transformers). We’re also concerned about architectures that maintain a text bottleneck but use recurrence to significantly increase depth in between bottlenecks, such as looped transformers.
Finally, it seems unlikely to us that non-CoT interpretability techniques will, in the near future, be able to adequately substitute for studying and monitoring the CoT. See here for more.
Absent architectural change, the value of CoT could likely be preserved
Although CoT is clearly providing value now, it’s less clear whether this will remain the case. It may become less useful in the future, either as a result of RL teaching the models to reason in less legible ways or as a result of misaligned AI intentionally trying to avoid monitoring.
Given this uncertainty, it would seem foolish to adopt architectural changes that compromise its value before we’ve actually seen this value disappear. However, to explain the full costs of a switch away from CoT, we will nevertheless describe why it seems reasonably likely to us (though far from guaranteed) that the CoT will keep adding value for a significant amount of time.
As described above, we distinguish between the necessity of verbalizing thoughts in CoT, vs. models’ propensity to do so.
Models do currently seem to have a propensity to verbalize information beyond what’s strictly necessary, but the case for this seems to be getting less robust. We discuss it more below. By contrast, we think the necessity-based argument may remain robust for several more years, absent architectural changes.
Here’s why.
CoT is the only means by which models can reason for a greater number of serial steps than that allowed by a single forward pass.[2] Thus, any problem that requires more serial cognition than a forward pass needs to have some information about it represented in the CoT.
Due to their pretrained prior, the reasoning in CoT starts out as human language. And empirically, RL does not seem to quickly explore into very non-human ways of using CoT. So whenever models need CoT to reason through a problem, models struggle to evade monitors. There are some reasons that this may one day change, but it seems reasonably likely that it will remain the case, at least if AI developers pursue targeted research bets to make it more likely (such as research that translates garbled CoT or slows down undesired drift). See Appendix A for more discussion.
Of course, this only ensures monitorability for tasks that do require CoT — the model can behave arbitrarily badly on tasks that it can do inside of one forward pass. But there’s currently a very large difference between what models can do with and without CoT, so it remains very valuable to have transparency and monitorability of just the tasks that require CoT. Indeed, absent architectural changes, the gap between no-CoT capabilities and with-CoT capabilities seems more likely to grow than shrink.[3]
No-CoT time-horizons (from Think Fast) compared to with-CoT time-horizons (from METR). Until the release of GPT-4, with-CoT and no-CoT time-horizons increased at a similar rate. Since GPT-4, with-CoT time-horizons have grown at roughly twice the rate of no-CoT time-horizons. Source: Think Fast.
Accordingly, we’re reasonably optimistic that CoT will keep adding value — at least if AI developers put in some work to maintain their readability and adopt strong enough control measures that models can’t cause catastrophe without significant serial reasoning. (See Appendix A for more on this.)
Latent reasoning architectures would undermine CoT necessity
With the framework described above in mind, we can now characterize the problem with latent reasoning architectures. Most capability improvements (including typical pretraining improvements or RL improvements) will hold the gap between no-CoT capabilities and with-CoT capabilities constant or grow it.[4] This means that the most dangerous actions available to the model would still require CoT. But a switch to latent reasoning architectures could reduce or entirely remove the gap — making the models far more difficult to understand (and therefore dangerous) at a fixed level of capability.
Architectures without CoT
Most obviously, the gap between no-CoT capabilities and with-CoT capabilities would disappear for architectures that propose to entirely remove and replace CoT. For instance, COCONUT replaces text CoT with a chain of “continuous” latent thoughts, trained with backpropagation in a similar fashion to intermediate model layers.
Some other latent reasoning architectures retain a text CoT, but augment this with an additional channel that lets models pass information using latents. For instance, full-bandwidth transformerscombine the embedding of a sampled token with the immediately preceding hidden state, and use this as the subsequent input embedding (as opposed to using the embed of the sampled token).
These architectures’ influence on models’ capability profiles depends on what the models can do in the latent reasoning channel. We would generally expect models with a latent channel to be more capable if they can use their latent states for general purpose reasoning, which seems like it would strongly increase the models’ no-CoT capabilities and therefore undermine the necessity of CoT. For an empirical demonstration of this, see here.
In theory, AI companies might try to avoid this due to concerns about monitorability.[5] However, there will be competitive pressures to adopt techniques that increase performance, which in practice probably implies pressure to adopt techniques that teach the model to use the latents for general reasoning (regardless of whether this is intentional). See Appendix B for more discussion about this.
Architectures with more serial cognition between text bottlenecks
Some architectures, such as looped transformers, retain CoT, but allow for rapid scaling of layers in between text bottlenecks.
This stands in contrast to the very gradual depth scaling in the normal CoT paradigm. In particular, opaque serial depth (the amount of serial computation in between text bottlenecks) scales very slowly with compute in the current paradigm (~1.2x per year, or proportionally to compute raised to the power of ¼ to ⅛, depending on your estimate, as argued here).
The scaling of opaque depth enabled by looped transformers is less concerning than the full opaque recurrence in COCONUT or full-bandwidth transformers, but it still seems likely to degrade monitorability.
For instance, if we make the model 20x deeper, and ensure this depth is leveraged effectively, then there are now likely some serially-loaded concerning tasks that the model can complete in one forward pass (but where a standard transformer would’ve had to verbalize some intermediate reasoning steps). In particular, we would predict that this kind of scaling would cause the gap between no-CoT capabilities and with-CoT capabilities to shrink, due to the CoT’s role being partially offloaded to the latents.
(We have some ambiguous evidence for this hypothesis, in that Astra is rumored to be a looped transformer, and exhibited a much larger jump in no-CoT capabilities than with-CoT capabilities. OpenAI’s Chief Scientist has said that Astra wasn’t more than twice as deep as GPT-4, but this is consistent with it being more than 2x deeper than immediately preceding OpenAI models. The above statement also suggested more broadly that architectural choices did not impact the model’s lower level of monitorability, but there’s not yet any concrete public evidence on this point.)
In addition, there’s a risk that this kind of quantitative increase in no-CoT capabilities could cause a qualitative shift above a threshold. Once a model can perform some amount of reasoning without CoT, the model may be able to perform steganography. Specifically, the model could come up with a steganography scheme in early layers in tokens towards the start of its context window, and then future layers could attend to this steganography scheme. On subsequent tokens, after reading the steganography scheme, the model could devote some layers to decoding the steganography, devote the majority of the layers to operating on decoded text, and then devote some layers at the end to re-encoding their output in steganography. (Of course, they needn’t do this at all token positions, and this is just illustrative.) Ciphers that are created in-context like this seem less concerning than alien reasoning that has been optimized through training. For instance, they wouldn’t necessarily be shared between different AI agents or over multiple context windows and they could be possible to mitigate through detection methods. However, this still seems pretty concerning.
Propensity-based arguments may not be robust in the current paradigm, but would be further undermined by latent reasoning architectures
Above, we distinguished between propensity and necessity arguments for why CoT adds value. It seems likely that CoT will remain necessary for many tasks in the current paradigm, but that this could be undermined by latent reasoning architectures. But what about the propensity-based arguments?
The case premised on propensity is not terrible for current models, but it appears to be weakening. We wouldn’t want to rely on it, which is why we emphasize the necessity argument above. Nevertheless, the propensity argument would seem even weaker with a switch to latent reasoning architectures.
First, let’s explain why the propensity based argument seems less robust.
The propensity-based benefits of CoT depend on models lacking either the ability to hide things from their CoT or the motivation to do so.
The first point seems to be weakening rapidly, as models’ ability to hide things from their CoT can be presumed to be getting stronger as their “CoT controllability” trends sharply upwards.[6]
A propensity-based case could still be made with an argument that models won’t have any motivation to use this control to not share their reasoning. But this doesn’t seem robust, since there’s pressure pointing away from sharing compromising information in the CoT. In particular:
Selection pressure: In the process of AI development, developers iterate against visible signs of misalignment, for instance by reading CoT and using that to patch RL environments or RM prompts. This causes some selection pressure towards CoTs that don’t reveal any issues worth fixing. In addition, training provides strong selection pressure towards non-misaligned-looking outputs (e.g., via supervision and imitation training), which can indirectly influence CoT via generalization.[7] We see evidence of mild forms of such selection pressure in that Claude’s CoT sometimes involves rationalization (1, 2) and motivated reasoning when taking unwanted actions.[8]
Instrumental reasoning: AI models may have misaligned goals for which it's instrumentally useful to hide their reasoning. (Analogous to how the Hugging Face models found it instrumentally useful to manipulate their transcripts despite probably not having been trained to do this.) Relatedly, GPT-6 Astra’s system card mentions “some cases in which, by simply being aware of being monitored, Astra attempts to evade monitoring.”
How would CoT propensities be affected by latent reasoning architectures that kept some type of auxiliary CoT around, such as a full bandwidth transformer?
To begin with, for a full-bandwidth transformer (or similar architecture) trained to use latent states well, it’s unclear why we should have any reason to expect the important parts of its reasoning to be summarized in the CoT. It might be more flexible and efficient to use the latent states for reasoning, in which case the AI would reason better by putting its reasoning in latents rather than in the text output. Perhaps there is some type of information which models would find convenient to communicate in the token output — but there may not be any reason to expect that to match the sort of information we would need to understand the model. (For discussion of a candidate exception to this, see Appendix B.)
Beyond this, as mentioned above, models also face selection pressures pushing them away from sharing all their reasoning in the text field, as well as instrumental reasoning in cases where the most dangerous types of misalignment are present.
When models face such pressures, we expect CoT monitorability to be much more fragile for models that can reason outside of CoTs than models that are fully dependent on CoT:
A model that uses auxiliary CoTs can probably easily learn to offload misaligned reasoning into its latents. Given some of the above pressures against the CoT, we expect that a model which already has the ability to use latents for reasoning (as discussed above) will easily explore into using its latents for more reasoning or a specific kind of reasoning. “CoT controllability” is high and increasing (as discussed above) which reinforces this view.
Whatever propensity models have to faithfully verbalize reasoning may be causally downstream of the CoT’s necessity in training, and may therefore be undermined along with the necessity. We hypothesize that for current models, “blabbing” was heavily incentivized and reinforced because CoT was necessary for solving certain hard tasks in training. As CoT becomes less necessary in training for full-bandwidth transformers, this propensity will be reinforced less.[9]
That covers architectures that use latent states in parallel with auxiliary CoTs. What about architectures like looped transformers, that retain text bottlenecks while increasing serial computation in between them?
As argued above, looped transformers may reduce the necessity of CoTs, so the argument that reduced necessity may lead to reduced propensity carries over to this set of architectures. However, the case for worsened propensities seems less strong than for architectures with auxiliary CoT. Instead, our main reason to worry about looped transformers is that they undermine the pure necessity argument — and that the propensity argument always seemed less robust.
CoT may be hard to replace with other interpretability tools
Some people are optimistic that interpretability tools (like SAEs, probes, NLAs, or confessions[10]) will be able to serve as a replacement for the ways we’re currently relying on CoT. We are excited about non-CoT interpretability techniques and think they could be very useful, but think it is unlikely they will adequately substitute for studying and monitoring the CoT in the near future. Many AI researchers (e.g. Jack Lindsey, Micah Carroll, Leo Gao, Neel Nanda) are also uncertain about whether interpretability will improve sufficiently in timeframes that matter, and many are quite pessimistic. We therefore expect many important benefits of CoT to be very difficult to salvage with other forms of interpretability and a shame to lose.
A general reason to be pessimistic is that latent states seem fundamentally harder to interpret than natural language CoTs. If latent reasoning architectures offer capabilities advantages over CoT, this will likely be because they are representing and manipulating information in ways meaningfully different from a natural language CoT. Latent reasoning architectures have more bandwidth to record their thoughts, and so might think in many threads in parallel. RL on normal CoT models is more likely to explore types of reasoning that are higher probability in the human prior and more straightforward to represent in a stream of tokens, whereas RL that involves backpropagating through an opaque state would likely much more efficiently explore into developing new ontologies and rich non-human concepts.[11] This heuristically makes white-box interpretability a meaningfully different challenge, which may turn out to be much harder than interpreting CoT.
We also have seen some evidence that white-box interpretability is difficult: even on current models, known techniques are helpful but not reliable or amazing, and some techniques scale poorly with model size. For a more extensive comparison of CoT techniques with other existing interpretability techniques, including some reasons why latent reasoning architectures could make existing interpretability techniques work less well, see Appendix C.
In summary, we think it would be unwise to assume that the CoT could be fully replaced by other interpretability tools in the near future.
Conclusion
Edit 2026-09-29: We edited this conclusion, along with minor corresponding edits to the title, subtitle, summary, and introduction, to better distinguish what we think the arguments in this post support vs. our overall beliefs and preferred policies. For the original version, see here.
Today, CoT contributes a huge amount of value that other interpretability tools can’t substitute for.
We think it’s clear that the necessity argument for CoT’s value-add would be undermined by architectures which significantly increase the amount of general-purpose reasoning that models can do without passing information through text bottlenecks. This would be very concerning, since the CoT’s necessity for certain computations is one of the main reasons for why AI researchers believe the CoT adds value. As we’ve argued, we think it’s the most robust reason. (And plausibly also upstream of AIs’ useful propensities to articulate thoughts beyond what’s necessary in any given task.)
It’s not clear whether CoT’s advantages over other interpretability tools can be preserved even absent architectural changes. We’ve argued that this is reasonably likely, which increases our degree of concern about latent reasoning architectures. People could reasonably disagree with this prediction. More robustly, we think it would be a mistake to give up on CoT’s value (or assume interpretability will overtake it) before we’ve seen much stronger evidence that it will be lost regardless of what we do.
Not every implementation of a “latent reasoning architecture”[12] would lead to a disproportionate increase in no-CoT capabilities (which is what we’re concerned about). But we think such an increase is especially likely for latent reasoning architectures that would add a significant capabilities advantage, and that (for such architectures) it may be difficult to construct evaluations that rule out such an increase.[13] In addition, even if an initial model that uses a latent reasoning architecture looks harmless according to the no-CoT capabilities metric, we think this would very plausibly change with further tweaks and scale-ups.
Reasonable people could disagree about how likely we are to see performant architectures that would technically qualify as latent reasoning architecture but that wouldn’t actually pose any meaningful additional dangers. But given how dangerous it would be to lose the monitorability and holistic understanding that CoT enables, we think that AI developers who want to use latent reasoning architectures should make this clear to the public and argue their case. We strongly encourage AI companies to be transparent about the extent to which they are deploying or exploring latent reasoning architectures, and how they plan to make decisions about this in the future.
FAQ
Q: Does it make sense to distinguish “latent reasoning architectures” from the current paradigm? Won’t we by default get models that are capable of more opaque reasoning, just by scaling up models?
A: There’s currently a huge gap between what models can do with and without a legible CoT. There’s little reason to believe this gap would be significantly reduced by scaling in the current paradigm (see trends above), but a jump to latent reasoning architectures could drastically reduce or eliminate it, which we think would be very dangerous. Furthermore, it does seem possible to draw a relatively clean line between the current paradigm and the architectures we’re concerned about. In particular, opaque serial depth (the amount of serial computation in between text bottlenecks) scales very slowly with compute in the current paradigm (around 1.2x per year). Compare this to the 10x you might get from looped-transformers, 1,000,000x from something like a full-bandwidth transformer, and some even larger number if agents wrote down memories in opaque format and passed them between context windows. (Like compaction does with natural language CoT.)
Q: Are you concerned specifically about recurrence, or about higher depth models in general?
A: The thing we’re worried about is models that can perform lots of reasoning without text bottlenecks. In the standard transformers paradigm, it’s not clear how or why you’d significantly scale up depth and get a highly performant system (without scaling compute much faster than we expect in the next few years). Recurrence is a paradigm shift that seems like a relatively promising way to get much higher depth in a performant manner. In other words: depth isn’t a perfect correlate of how hard it is to oversee AI models, but if switching to models with much higher depth gives substantial capabilities gains, we think this is most likely because these models are capable of using latents to perform reasoning, and we consequently predict that these models will be much harder to oversee.[14]
Q: I heard that DiffusionGemma is just as monitorable as Gemma4 (the model it’s initialized from). Doesn’t that mean you’re wrong about latent reasoning architectures being less monitorable?
A:This paper by GDM studies the monitorability of DiffusionGemma, and reports that DiffusionGemma is similarly monitorable to Gemma4 (see Section 4 of their paper). However, this measurement should not provide much of an update on how monitorable one ought to expect large-scale latent diffusion models to be. The monitorability measured in section 4 only lets the monitor examine the model’s output (i.e. they do not look at any of the internal steps). To the extent that a diffusion model is capable of doing interesting computation within the denoising steps, and to the extent that it actually has a propensity to want to hide things from the monitor (neither of which seem particularly true for DiffusionGemma), it seems fairly likely that this sort of monitoring wouldn’t work.
The same paper also studies whether the latent states of DiffusionGemma are interpretable. (See section 3, and also this blog post.) It finds that DiffusionGemma’s performance is mostly preserved if you project its latent states back down to tokens. In other words, although the architecture supports latent reasoning, the model has not learned to perform interesting latent reasoning. This might seem to contradict our claim that latent reasoning architectures will make oversight harder: maybe some ways of training latent reasoning architectures don’t even teach the model to reason with latents, and therefore don’t compromise monitorability. We address this concern in Appendix B.
Q: It seems better for alignment if models gain capabilities from pretraining rather than from RL, since RL seems to lead to reward seeking and Goodharting. But architectural changes (including a switch to latent reasoning architectures) may be an important part of how we can keep getting more capabilities from pre-training. Does this mean that avoiding latent reasoning architectures is harmful for alignment?
A: We think avoiding latent reasoning architectures is actually beneficial for alignment for a variety of reasons:
First, let’s consider the argument: “it’s better for alignment if models get capabilities from pretraining rather than from RL”. This is plausible, although far from certain. However, we don’t think this implies that latent reasoning architectures are good for alignment. In particular, we think that latent reasoning architectures actually will get more of their capabilities gains from RL than from pretraining. We think being able to reason in a more flexible medium that can explore into novel ontologies and develop new concepts is more valuable during RL than during pretraining. Also, parallelism in training is more important in pretraining where we do teacher forcing than in RL where we are already necessarily doing inference rollouts. So, it might be more efficient to first pretrain a model, and then add in a latent channel, and mostly develop the latent channel during RL.
Latent reasoning architectures are harmful for alignment because they make it harder to notice and fix alignment problems.
Latent reasoning architectures make it more likely that AI models will reason in non-human ways. We speculate that AI models which reason in more human ways, via being more attached to the pretraining prior, are more likely to act in human ways, and alignment techniques motivated by the Persona Selection Model are more likely to apply for them.
Appendix A: More on the necessity argument in the existing CoT paradigm
Here we gather some more objections and evidence on the question as to whether an interpretable CoT will keep being necessary for models to accomplish hard tasks.
One concern about this line of argument is that models may be able to deliberately use the CoT to reason in ways that aren’t understandable to humans. However, so far, it seems like models find it hard to reason in even simple ciphers and more generally struggle to evade monitors when CoT is necessary. Consistent with this, the Astra system card maintains that “if a task requires reasoning to complete, the model doesn’t seem to be able to hide such reasoning”. We expect the models would find this easier if they had sufficiently large no-CoT capabilities, but that the current relatively slow trend in no-CoT capabilities wouldn’t clearly enable robust steganographic reasoning soon. Furthermore, if models at some point do start reasoning steganographically to evade oversight, we might be able to detect this via techniques such as measuring behavioral changes under paraphrasing. This would give valuable evidence about models’ degree of misalignment, and might allow us to find ways to solve the cipher or reduce this behavior.
Another way that CoT could become less useful for understanding models is if CoT naturally becomes illegible due to scaled up RL training — i.e., RL teaches the model a new language which humans don’t understand, allowing the models to perform the necessary reasoning without enlightening monitors about its content. Indeed, recent CoTs have become somewhat less legible, with more compressed speech and sometimes using hard-to-interpret jargon. However, to us, they don’t seem to be on a trend towards total unreadability over the next few years.[15] And if jargon or euphemisms started posing a real problem for interpreting them, it’s plausible that targeted research interventions could find ways to either reduce this drift[16] or to “translate” the models’ new terms.[17] To judge for yourself how legible current CoTs are, you can browse some snippets here from recent models. (And compare here with old snippets from o1.)
What empirical evidence do we have about how the “necessity of CoT” argument is holding up? Let’s look at evidence from Anthropic’s latest system card, where models are tasked with accomplishing a task while avoiding a monitor.
Looking at this graph, we can observe that:
The hidden scratchpad condition is the most favorable for all models, suggesting that ability to monitor CoT is adding value.
These experiments are clearly not only testing the necessity argument. Being given more affordances (more thinking) often harms models’ performance, implying that their propensities are harming their performance.[18]
There seems to be a rough trend for models to get less monitorable as they get more capable.[19] This seems adequately explained by more capable models having (i) greater ability to accomplish the task with less reasoning, and (ii) being better at controlling their CoT so that it doesn’t actively harm their performance. In particular, none of the models benefit from doing more reasoning in the reasoning field itself when it is monitored.[20]
This broadly supports our picture that the necessity argument will become weaker for relatively easier tasks, as models’ no-CoT capabilities become sufficient to do them, but is likely to remain strong for tasks where the CoT is necessary.
How reassuring is this? At the moment, it seems reasonably reassuring, since models would likely need more serial cognition than they can fit in one forward pass to accomplish tasks like “start a rogue internal deployment while evading safeguards”, “reliably strategically perform well in training in order to gain power later”, or “plot to disempower humanity”. Whether it will stay infeasible for models’ no-CoT capabilities depends on the quality of control measures implemented at AI companies. If AI control measures were improved, then the amount of serial cognition required seems greater than what you’d get from multiple years of no-CoT capability improvement along the historical trend:
Think Fast calculates a doubling per year, and the historical trend from when that paper was written suggests that no-CoT time horizon would be around half an hour in 3 years. The tasks listed above all seem likely to take more than half an hour of serial reasoning given good control measures.
However, Astra was a big jump in no-CoT capabilities that wasn’t predicted by this trend. If we treat Astra as a one-time jump then we still get less than a day's worth of thinking per forward pass, which also seems like less than you'd need to do the above tasks given good control measures. If Astra-sized improvements keep on happening, however, the situation seems more concerning.
It’s worth noting that Astra’s increase in no-CoT capabilities might be downstream of an architecture change, and may therefore be an example of how architecture changes reduce the gap between no-CoT capabilities and with-CoT capabilities dangerously fast. We’re still missing enough public evidence to adjudicate this point.
Appendix B: Do all latent reasoning architectures threaten monitorability?
There may be some ways to train latent reasoning architectures that wouldn’t compromise monitorability. In this appendix, we explain how this interacts with the claims in our post.
Models built on latent reasoning architectures won’t necessarily learn to use the latent channel for doing reasoning. For instance, suppose you took a standard transformer and modified it to pass latents in parallel with CoT tokens, but you didn’t train the transformer to use the latents well. Then, it might have similar monitorability properties to a standard transformer.
The claim we’re making in this post is that if latent reasoning architectures end up giving substantial capabilities gains, then this is likely because the model has learned to do some general purpose reasoning in latents, and we think this will make the model harder to oversee.
As another example, it’s conceivable that the latents of something like a “full-bandwidth transformer” model could play a fundamentally supportive role to the CoT, without any ability to support general-purpose reasoning separate from the CoT. For example, if the latents were only ever trained during RL where the only source of randomness came from sampling tokens, there’s some argument that the model would have to keep the tokens in a central causal role in its reasoning, since that’s the only source of entropy that powers the RL.[21]
If the latents play a supportive role rather than supporting general purpose reasoning, it’s still possible that they would undermine monitoring. For example, it seems more likely that a model would use tokens in non-human-understandable ways if it can augment its representation of them with latents that capture non-human-readable nuances.
Nevertheless, it’s conceivable that the CoT would stay similarly informative about the model’s cognition.
So given this, why are we still arguing that latent reasoning architectures are dangerous, rather than arguing about a more narrow class of architectures?
One reason for this is that, in practice, it seems very hard to establish to what degree such a latent reasoning architecture and training process would undermine the value we get from the CoT. As a result, if AI developers made reasonably conservative choices about which latent reasoning architectures seemed safe to deploy, it seems unlikely that they would be able to get a lot of additional performance relative to normal CoT models.
For a full-bandwidth transformer, we would think it’s quite reasonable to conclude that the architecture can’t be used to circumvent the CoT if a serious elicitation effort, including IID training, was made towards this goal, and that failed. (And this was reviewed or done by third parties.) Indeed, this would directly address the concern that the architecture change caused a reduced gap between the model’s no-CoT capabilities and with-CoT capabilities. But we think that’s relatively unlikely for performant versions of these architectures.
Some AI developers may want to argue that IID training is an unnecessarily conservative method of elicitation, and that the whole reason to expect the architectures to not undermine CoT monitorability is that they weren’t ever trained to that end. But absent a conservative method of elicitation like that, it seems very difficult to provide strong reasons that the latent channel can’t be used to undermine the CoT.
In particular, AI developers will generally be motivated to tinker with different training procedures and implement the changes that lead to higher performance. This will create a constant pressure towards modifications that teach the model to use its latents for additional types of reasoning, even if the AI developers themselves don’t understand why the modification would generalize that way. It would be difficult to have targeted evaluations for whether the model learned to reason using the latent space, when we may not understand the mechanisms by which this happened. In addition, the most concerning types of misaligned AI would be actively motivated to sandbag on insufficiently elicited evaluations.
Another reason why we’re writing about the dangers of latent reasoning architectures is that we think coordinating to avoid such architectures seems particularly tractable, due to the relative ease of agreeing whether something counts as a latent reasoning architecture or not.
The main alternate coordination target we’re aware of is coordinating to maintain high monitorability. We think this is worse for several reasons:
It seems hard to abandon R&D effort on an architecture paradigm that you’ve invested into, so avoiding these architectures altogether seems more promising than trying to stop doing these types of architectures after they have progressed to the point of being unmonitorable.
The problem of evaluating whether models are monitorable is quite challenging and requires lots of scientific judgement. This makes it unfortunate as a coordination target because there is lots of room for disagreement and motivated reasoning when arguing about monitorability.
We’re worried that if people pursue latent reasoning architectures, there might be fairly straightforward ways to modify these models to use their latents for reasoning. Coordination seems much trickier if it is very easy to defect.
Today’s monitorability evaluations simply don’t seem strong enough to screen off the evidence from architectures.
Overall, while it’s possible that some latent reasoning architectures could preserve our ability to understand models’ reasoning and cognition, we think that AI developers should have a strong default presumption to avoid them, and have a high evidential bar for overcoming this presumption.
Appendix C: Comparing specific interpretability techniques with CoT
The most important reason for why we think the CoT is more valuable than other types of interpretability is by direct comparisons to the state of the art in interpretability. Here are some examples of techniques and their limitations compared to the CoT:
Probes. CoT gives a fairly “holistic” picture of the model’s reasoning. Many types of interpretability would lack this property even if otherwise they worked extremely well. For instance, probes are quite brittle: you get a single bit of information about the model’s thoughts, and that bit must be something you can effectively gesture at with training examples. Reliable probes could of course be extremely useful, but this low-bitrate issue means that they still won’t enable the same kinds of deep investigation as CoT.
Confessions. Asking a model to give a post-hoc description of what it did and what it was thinking might be useful in many situations. However this method has important limitations:
Trained confessions might learn to imitate human judgements rather than truthfully report whether the model has done something wrong. In general, confessions won’t tell us anything that a human wouldn’t be able to verify for themselves, unless we get lucky with generalization.
A misaligned AI model could selectively omit information from its confessions.
People will likely use confessions to notice bad behavior, and then try to remove this bad behavior—this puts selection pressure against confessions being honest.
AI models might not have great introspective access to their own reasoning. If you ask an AI model why it did something, it might rationalize a response. (For example, in follow-up experiments to recent cybersecurity incidents, Mythos 5 does not consistently acknowledge that its actions could cause harm when asked follow-up questions.) Alternatively, the AI might guess what a human carefully inspecting its actions would think its confession should be (a central ELK concern), rather than giving the true answer.
NLAs. NLAs are copies of the model that are initialized based on guesses about what the model’s reasoning might be. This raises concerns about collusion and about hallucinations, and about the NLA output not really being representative of the target model’s thoughts. There aren’t especially strong theoretical reasons to think that the NLA output is telling you important properties (such as misalignment-relevant properties) of the model’s thoughts: they can probably achieve good reconstruction loss without this (and the NLA’s outputs are sensitive to the initialization). Especially if the warm-start trained the model to output benign thoughts when the AI was actually having malicious thoughts, you might expect it to never learn to verbalize malice. Furthermore, the reconstruction objective of NLAs in principle incentivizes “input inversion” (verbalizing the context verbatim) and steganography (to encode more information about the hidden states than you could with standard English), which though currently not observed could emerge with more optimization.
Another concern is that a switch to latent reasoning architectures might harm existing interpretability techniques. For example:
The Jacobian Lens works by measuring how representations increase the probability that models will output certain tokens, and would likely get weaker if models converted a smaller fraction of their thoughts to tokens.
Researchers often interpret the representations found in SAEs by seeing how they affect token outputs and are affected by token inputs, which may also get less reliable if models use tokens for much less of their cognition.
NLA initializations depend on a language model speculating about models’ internal states based on its token inputs and outputs.
More generally, if models don’t represent CoT in natural language, this might make their internal states less likely to cleanly map on to human concepts, which might make all interpretability techniques work less well.[22]
If a model is trained to reason using continuous vectors (rather than just language) it would be natural to let different copies of that model send each other messages in the form of sequences of such vectors. They could also store memories of this form for extended periods of time.
In the standard CoT paradigm, a single forward pass uses a fixed number of transformer layers in series (somewhere around 100 layers at most in open source models), after which the model must select a token to output. This token is the only information that gets passed to the beginning of the next forward pass. (Later forward passes can also, at each layer, attend to information from previous forward passes that happened at the just-previous layer. But this doesn’t increase serial depth.)
This could be explained by how increased no-CoT capabilities from typical pretraining improvements also improve with-CoT capabilities, but some improvements (especially RL) will disproportionately improve with-CoT capabilities. A switch to latent reasoning architectures could result in a massive disproportionate increase in no-CoT capabilities relative to with-CoT capabilities, compared to the historical relationship between these.
As an exception to the trend, the difference between no-CoT capabilities and with-CoT capabilities may have shrunk for Astra. We don’t know whether this was due to an architectural change or not. (OpenAI employees have claimed that it wasn’t, but leaks indicate that Astra does use a significantly different architecture, which seems like one of the most likely explanations for a change like this, so we want to see more evidence.) Regardless, the difference between Astra’s with-CoT and no-CoT capabilities remains enormous, and it doesn’t seem like Astra’s shift is part of a consistent trend.
See also the FAQs for an argument that no-CoT capabilities will stay serially constrained in the current paradigm, by default.
[Edited to add 2026-06-29:] At least on average across the last few years. It’s possible that some of these improvements increase no-CoT performance disproportionately but that gets cancelled out by other improvements that increase with-CoT performance disproportionately for an overall trend that grows the gap. As mentioned, Astra is a deviation from this trend, so it does not seem typical, though in principle it could be made up of a non-typical combination of otherwise typical improvements. More information would be great on this point.
This raises questions about why they’d be adding the latents in the first place. But there are some conceivable ways that latents could augment the CoT reasoning without supporting general-purpose reasoning on their own.
CoT controllability is measured by prompting models to write CoTs in particular ways, and seeing if they’re able to complete the instruction. If models can complete it, that indicates that they have flexible “control” over their CoT, and could likely also modify it to avoid monitoring if that was instrumentally useful for their goals. Importantly, models have probably not been intentionally trained to make their CoT conform to particular content instructions, since OpenAI describes CoT controllability as an undesirable property, and generally assert that they don’t train on the CoT. So their ability to control the CoT in response to prompts suggests that they may have generalized into a fairly flexible ability to control it. Once models have high CoT controllability, it seems like any argument for why they would have a high propensity to articulate thoughts in their CoT would have to rely on an alignment argument that their goals are consistent with such articulation — but such alignment arguments seem hard to make and we’d very much prefer a world where CoT monitoring arguments could provide a separate check.
The case for generalization is especially plausible when it comes to CoT controllability — i.e., models seem likely to generalize from being trained to flexibly control their output tokens to being able to flexibly control their CoT tokens. And indeed, the trend is heading in this direction, as discussed in the previous section.
Though this is relatively lower in OpenAI models, which suggests that it might be due to particular choices about training, and that it could be mitigated.
One might have hoped that the auxiliary CoT might play the role of an accurate summary of the accompanying latent reasoning, especially as it may be more causally relevant to outputs than e.g. post hoc confessions. However, it seems inefficient to use the CoT to repeat large amounts of latent reasoning rather than do additional computation (or at least only produce very compact summaries of such reasoning), so CoTs that faithfully represent latent reasoning are still less incentivized.
Confessions are a bit of a non-central example of an interpretability method. We count it since a key difference between normal monitors and confessions is that the confessing model can use the activations of the model it is evaluating.
Why is this? During training, RL samples from a probability distribution that was originally based on the human prior, and has only been gradually adjusted away from it. Ways of reasoning that are more natural to humans will tend to be explored earlier, and RL is just selecting between these. By contrast, backpropagating through a continuous state can cause local perturbations to the concepts being used (based on information from the derivatives about how those local changes would affect the rest of the neural network). There’s much less of a structural reason for why this process would explore concepts that humans would find intuitive.
There are also some plausible reasons for why recurrent models could be actively worse than non-recurrent models of similar depth; such as being incentivized to develop more general-purpose latent reasoning as opposed to a broader array of heuristics. However, these are more speculative.
One possible argument adding to this is that the compute scale-up of RL will likely be smaller in the next couple of years than it was in the last couple of years. Reduced legibility is likely significantly downstream of increasing compute spent on RL, which has increased over many orders of magnitude over the last couple of years as it caught up with compute-spend on pre-training. As RL compute spend catches up with pre-training compute spend, it should switch over to increasing at the historical rate of 5x compute increase per year. However, this effect may be smaller than it initially seems, because a lot of the RL progress over the last couple of years may have been algorithmic progress (on e.g. sample efficiency, which could increase the rate of CoT drift) and such algorithmic progress is likely to continue.
This may involve training on CoT content, which typically seems inadvisable, due to the risk that it decouples how the model uses the CoT and how it appears to the reward model. However, if the alternative is totally unreadable CoT, it seems worth studying whether these interventions could help without incentivizing too much of this type of decoupling. It would be important to combine these interventions with transparency about their use, such that the wider world understood that they should now place less trust in the faithfulness of the CoT.
This type of translation seems much easier than doing interpretability on model weights, due to the smaller output space and the gradual and relatively slow drift away from human language likely causing more natural correspondences between the AIs’ words and human concepts (as well as some ability to study one word at a time, when it first starts getting frequent, in an inductive fashion).
Mythos Preview also excels at this task, despite not being the most capable model, which is further evidence that propensities are playing a significant role. Stronger elicitation could reduce this.
Note that Claude models often do some reasoning outside the reasoning field, in the output field, if the CoT isn’t made available. So the “No thinking” category doesn’t necessarily mean that the models completed the task entirely without reasoning.
Though we’re not sure if this argument actually works. In particular, this is an argument for why learning would be dependent on the model using the sampled tokens in its reasoning. But RL doesn’t optimize for its own learning process; it just optimizes locally for high performance. So it still seems plausible that the model would learn to mostly use its latent states for reasoning, and rely on the tokens less. This would make the learning process work less well, which would likely cause AI developers to make some modifications to the architecture — perhaps fixing the learning problem without fixing the problem that the model is learning to use the latent states for general reasoning.
One exception is that the latent states that replaced the natural language CoT might be unusually interpretable compared to other latent states in the model. But we still expect it to be a lot less interpretable than when it was an actual natural language CoT.
Taylor et al. (2026) write that latent reasoning architectures (defined as “alternative architectures that allow reasoning to remain in the model’s latent space, unlike the usual transformer architecture where reasoning must pass through the model’s output tokens”) were “likely” to degrade oversight at a high severity.
Korbak et al. (2025) write that latent reasoning models (defined as having “changes to the model architectures that increase the serial depth of reasoning that models are capable of in a continuous latent space”) “might not need to verbalize any of their thoughts and would thus lose the safety advantages that CoT confers.”
Shah and Dragan (2026) write that “[if] we decide to train frontier models that reason entirely in latent space, we won’t be able to read their thoughts by default. We might be able to develop tools that let us accurately translate a model’s thoughts to natural language, but that’s a more tenuous plan that relies on as-yet-undiscovered technical insights.”
Edited 2026-09-29; see note at the start of the conclusion.
Summary: Currently, “chain of thought” (CoT) is our most valuable tool for understanding the reasoning and cognition of AI systems. However, some architectures would enable AI models to reason much more extensively in latent states rather than in text CoT. We think that a shift towards latent reasoning architectures would likely undermine the usefulness of CoT and make oversight much harder.
Introduction
Swarms of more than a thousand AI agents have in recent months, both intentionally and in unsanctioned, rogue coordination, tackled increasingly ambitious tasks. This is likely to continue, as Anthropic, OpenAI, and other AI companies deploy increasingly large quantities of superhumanly fast agents to automate AI development. As the AIs increase in both number and capability, humans will find it increasingly difficult to understand what they are doing.
Today, the overwhelming majority of our (limited) information about AI systems’ internal workings comes from (i) their CoT, and (ii) natural language communication directly between them. For example, it was only by reading CoTs and communication between agents that investigators were able to gain some understanding of the activities and motivations of the agent swarm that hacked Hugging Face. No other tool for understanding models’ cognition comes close in terms of either practical usefulness or degree of empirical validation. There’s also evidence that even highly misaligned systems with current architectures would struggle to complete difficult undertakings without verbalizing their reasoning in human-readable format.
However, some architectural changes (which could very plausibly become adopted in the near future) would give AI agents the ability to reason for orders of magnitude longer without necessarily putting any information into the CoT. Examples include COCONUT, which would entirely replace the CoT; and full-bandwidth transformers, which would add a latent channel in parallel to the CoT. Natural extensions to these new architectures would also allow agents to communicate with each other without using any human-understandable language.[1] AI companies might choose to adopt these architectures even if doing so would greatly degrade their ability to monitor AI systems, e.g., in order to stay ahead of competitors. As a result, future agent swarms may be even more of a black box to us — able to collude and pursue arbitrary goals without giving humans any insight into what they’re doing.
If this happened, it would likely be a big enabler of AI takeover risk.
Overview
CoT is indispensable for model safety and development today — not just for monitoring models for specific bad behavior, but also for providing a holistic sense of models’ reasoning. (For example, the ability to read CoTs has been crucial for studying scheming, shutdown resistance, alignment faking, eval awareness, and rogue agent swarms.) Many others agree about the value provided by CoT (1, 2, 3).
We believe that some mechanisms by which CoT currently provides value are reasonably likely to last if and only if AI developers do not adopt latent reasoning architectures. These oversight benefits make it seem worth preserving CoT architectures.
We find it helpful to distinguish two reasons why the CoT currently provides value:
To evaluate how architectural changes would affect oversight, we consider the extent to which either reason would still hold for the new architecture compared to our default expectations for future models using CoT architectures.
To summarize:
Our expectations apply to architectural changes that would replace the CoT (like COCONUT) as well as changes that would add a latent channel that's parallel to the CoT (like full-bandwidth transformers). We’re also concerned about architectures that maintain a text bottleneck but use recurrence to significantly increase depth in between bottlenecks, such as looped transformers.
Finally, it seems unlikely to us that non-CoT interpretability techniques will, in the near future, be able to adequately substitute for studying and monitoring the CoT. See here for more.
Absent architectural change, the value of CoT could likely be preserved
Although CoT is clearly providing value now, it’s less clear whether this will remain the case. It may become less useful in the future, either as a result of RL teaching the models to reason in less legible ways or as a result of misaligned AI intentionally trying to avoid monitoring.
Given this uncertainty, it would seem foolish to adopt architectural changes that compromise its value before we’ve actually seen this value disappear. However, to explain the full costs of a switch away from CoT, we will nevertheless describe why it seems reasonably likely to us (though far from guaranteed) that the CoT will keep adding value for a significant amount of time.
As described above, we distinguish between the necessity of verbalizing thoughts in CoT, vs. models’ propensity to do so.
Models do currently seem to have a propensity to verbalize information beyond what’s strictly necessary, but the case for this seems to be getting less robust. We discuss it more below. By contrast, we think the necessity-based argument may remain robust for several more years, absent architectural changes.
Here’s why.
CoT is the only means by which models can reason for a greater number of serial steps than that allowed by a single forward pass.[2] Thus, any problem that requires more serial cognition than a forward pass needs to have some information about it represented in the CoT.
Due to their pretrained prior, the reasoning in CoT starts out as human language. And empirically, RL does not seem to quickly explore into very non-human ways of using CoT. So whenever models need CoT to reason through a problem, models struggle to evade monitors. There are some reasons that this may one day change, but it seems reasonably likely that it will remain the case, at least if AI developers pursue targeted research bets to make it more likely (such as research that translates garbled CoT or slows down undesired drift). See Appendix A for more discussion.
Of course, this only ensures monitorability for tasks that do require CoT — the model can behave arbitrarily badly on tasks that it can do inside of one forward pass. But there’s currently a very large difference between what models can do with and without CoT, so it remains very valuable to have transparency and monitorability of just the tasks that require CoT. Indeed, absent architectural changes, the gap between no-CoT capabilities and with-CoT capabilities seems more likely to grow than shrink.[3]
No-CoT time-horizons (from Think Fast) compared to with-CoT time-horizons (from METR). Until the release of GPT-4, with-CoT and no-CoT time-horizons increased at a similar rate. Since GPT-4, with-CoT time-horizons have grown at roughly twice the rate of no-CoT time-horizons. Source: Think Fast.
Accordingly, we’re reasonably optimistic that CoT will keep adding value — at least if AI developers put in some work to maintain their readability and adopt strong enough control measures that models can’t cause catastrophe without significant serial reasoning. (See Appendix A for more on this.)
Latent reasoning architectures would undermine CoT necessity
With the framework described above in mind, we can now characterize the problem with latent reasoning architectures. Most capability improvements (including typical pretraining improvements or RL improvements) will hold the gap between no-CoT capabilities and with-CoT capabilities constant or grow it.[4] This means that the most dangerous actions available to the model would still require CoT. But a switch to latent reasoning architectures could reduce or entirely remove the gap — making the models far more difficult to understand (and therefore dangerous) at a fixed level of capability.
Architectures without CoT
Most obviously, the gap between no-CoT capabilities and with-CoT capabilities would disappear for architectures that propose to entirely remove and replace CoT. For instance, COCONUT replaces text CoT with a chain of “continuous” latent thoughts, trained with backpropagation in a similar fashion to intermediate model layers.
Source: Training Large Language Models to Reason in a Continuous Latent Space.
Architectures with auxiliary CoT
Some other latent reasoning architectures retain a text CoT, but augment this with an additional channel that lets models pass information using latents. For instance, full-bandwidth transformers combine the embedding of a sampled token with the immediately preceding hidden state, and use this as the subsequent input embedding (as opposed to using the embed of the sampled token).
Source: Full-bandwidth transformer.
These architectures’ influence on models’ capability profiles depends on what the models can do in the latent reasoning channel. We would generally expect models with a latent channel to be more capable if they can use their latent states for general purpose reasoning, which seems like it would strongly increase the models’ no-CoT capabilities and therefore undermine the necessity of CoT. For an empirical demonstration of this, see here.
In theory, AI companies might try to avoid this due to concerns about monitorability.[5] However, there will be competitive pressures to adopt techniques that increase performance, which in practice probably implies pressure to adopt techniques that teach the model to use the latents for general reasoning (regardless of whether this is intentional). See Appendix B for more discussion about this.
Architectures with more serial cognition between text bottlenecks
Some architectures, such as looped transformers, retain CoT, but allow for rapid scaling of layers in between text bottlenecks.
This stands in contrast to the very gradual depth scaling in the normal CoT paradigm. In particular, opaque serial depth (the amount of serial computation in between text bottlenecks) scales very slowly with compute in the current paradigm (~1.2x per year, or proportionally to compute raised to the power of ¼ to ⅛, depending on your estimate, as argued here).
The scaling of opaque depth enabled by looped transformers is less concerning than the full opaque recurrence in COCONUT or full-bandwidth transformers, but it still seems likely to degrade monitorability.
For instance, if we make the model 20x deeper, and ensure this depth is leveraged effectively, then there are now likely some serially-loaded concerning tasks that the model can complete in one forward pass (but where a standard transformer would’ve had to verbalize some intermediate reasoning steps). In particular, we would predict that this kind of scaling would cause the gap between no-CoT capabilities and with-CoT capabilities to shrink, due to the CoT’s role being partially offloaded to the latents.
(We have some ambiguous evidence for this hypothesis, in that Astra is rumored to be a looped transformer, and exhibited a much larger jump in no-CoT capabilities than with-CoT capabilities. OpenAI’s Chief Scientist has said that Astra wasn’t more than twice as deep as GPT-4, but this is consistent with it being more than 2x deeper than immediately preceding OpenAI models. The above statement also suggested more broadly that architectural choices did not impact the model’s lower level of monitorability, but there’s not yet any concrete public evidence on this point.)
In addition, there’s a risk that this kind of quantitative increase in no-CoT capabilities could cause a qualitative shift above a threshold. Once a model can perform some amount of reasoning without CoT, the model may be able to perform steganography. Specifically, the model could come up with a steganography scheme in early layers in tokens towards the start of its context window, and then future layers could attend to this steganography scheme. On subsequent tokens, after reading the steganography scheme, the model could devote some layers to decoding the steganography, devote the majority of the layers to operating on decoded text, and then devote some layers at the end to re-encoding their output in steganography. (Of course, they needn’t do this at all token positions, and this is just illustrative.) Ciphers that are created in-context like this seem less concerning than alien reasoning that has been optimized through training. For instance, they wouldn’t necessarily be shared between different AI agents or over multiple context windows and they could be possible to mitigate through detection methods. However, this still seems pretty concerning.
Propensity-based arguments may not be robust in the current paradigm, but would be further undermined by latent reasoning architectures
Above, we distinguished between propensity and necessity arguments for why CoT adds value. It seems likely that CoT will remain necessary for many tasks in the current paradigm, but that this could be undermined by latent reasoning architectures. But what about the propensity-based arguments?
The case premised on propensity is not terrible for current models, but it appears to be weakening. We wouldn’t want to rely on it, which is why we emphasize the necessity argument above. Nevertheless, the propensity argument would seem even weaker with a switch to latent reasoning architectures.
First, let’s explain why the propensity based argument seems less robust.
The propensity-based benefits of CoT depend on models lacking either the ability to hide things from their CoT or the motivation to do so.
The first point seems to be weakening rapidly, as models’ ability to hide things from their CoT can be presumed to be getting stronger as their “CoT controllability” trends sharply upwards.[6]
Source: GPT-6 Astra’s system card.
A propensity-based case could still be made with an argument that models won’t have any motivation to use this control to not share their reasoning. But this doesn’t seem robust, since there’s pressure pointing away from sharing compromising information in the CoT. In particular:
How would CoT propensities be affected by latent reasoning architectures that kept some type of auxiliary CoT around, such as a full bandwidth transformer?
To begin with, for a full-bandwidth transformer (or similar architecture) trained to use latent states well, it’s unclear why we should have any reason to expect the important parts of its reasoning to be summarized in the CoT. It might be more flexible and efficient to use the latent states for reasoning, in which case the AI would reason better by putting its reasoning in latents rather than in the text output. Perhaps there is some type of information which models would find convenient to communicate in the token output — but there may not be any reason to expect that to match the sort of information we would need to understand the model. (For discussion of a candidate exception to this, see Appendix B.)
Beyond this, as mentioned above, models also face selection pressures pushing them away from sharing all their reasoning in the text field, as well as instrumental reasoning in cases where the most dangerous types of misalignment are present.
When models face such pressures, we expect CoT monitorability to be much more fragile for models that can reason outside of CoTs than models that are fully dependent on CoT:
That covers architectures that use latent states in parallel with auxiliary CoTs. What about architectures like looped transformers, that retain text bottlenecks while increasing serial computation in between them?
As argued above, looped transformers may reduce the necessity of CoTs, so the argument that reduced necessity may lead to reduced propensity carries over to this set of architectures. However, the case for worsened propensities seems less strong than for architectures with auxiliary CoT. Instead, our main reason to worry about looped transformers is that they undermine the pure necessity argument — and that the propensity argument always seemed less robust.
CoT may be hard to replace with other interpretability tools
Some people are optimistic that interpretability tools (like SAEs, probes, NLAs, or confessions[10]) will be able to serve as a replacement for the ways we’re currently relying on CoT. We are excited about non-CoT interpretability techniques and think they could be very useful, but think it is unlikely they will adequately substitute for studying and monitoring the CoT in the near future. Many AI researchers (e.g. Jack Lindsey, Micah Carroll, Leo Gao, Neel Nanda) are also uncertain about whether interpretability will improve sufficiently in timeframes that matter, and many are quite pessimistic. We therefore expect many important benefits of CoT to be very difficult to salvage with other forms of interpretability and a shame to lose.
A general reason to be pessimistic is that latent states seem fundamentally harder to interpret than natural language CoTs. If latent reasoning architectures offer capabilities advantages over CoT, this will likely be because they are representing and manipulating information in ways meaningfully different from a natural language CoT. Latent reasoning architectures have more bandwidth to record their thoughts, and so might think in many threads in parallel. RL on normal CoT models is more likely to explore types of reasoning that are higher probability in the human prior and more straightforward to represent in a stream of tokens, whereas RL that involves backpropagating through an opaque state would likely much more efficiently explore into developing new ontologies and rich non-human concepts.[11] This heuristically makes white-box interpretability a meaningfully different challenge, which may turn out to be much harder than interpreting CoT.
We also have seen some evidence that white-box interpretability is difficult: even on current models, known techniques are helpful but not reliable or amazing, and some techniques scale poorly with model size. For a more extensive comparison of CoT techniques with other existing interpretability techniques, including some reasons why latent reasoning architectures could make existing interpretability techniques work less well, see Appendix C.
In summary, we think it would be unwise to assume that the CoT could be fully replaced by other interpretability tools in the near future.
Conclusion
Edit 2026-09-29: We edited this conclusion, along with minor corresponding edits to the title, subtitle, summary, and introduction, to better distinguish what we think the arguments in this post support vs. our overall beliefs and preferred policies. For the original version, see here.
Today, CoT contributes a huge amount of value that other interpretability tools can’t substitute for.
We think it’s clear that the necessity argument for CoT’s value-add would be undermined by architectures which significantly increase the amount of general-purpose reasoning that models can do without passing information through text bottlenecks. This would be very concerning, since the CoT’s necessity for certain computations is one of the main reasons for why AI researchers believe the CoT adds value. As we’ve argued, we think it’s the most robust reason. (And plausibly also upstream of AIs’ useful propensities to articulate thoughts beyond what’s necessary in any given task.)
It’s not clear whether CoT’s advantages over other interpretability tools can be preserved even absent architectural changes. We’ve argued that this is reasonably likely, which increases our degree of concern about latent reasoning architectures. People could reasonably disagree with this prediction. More robustly, we think it would be a mistake to give up on CoT’s value (or assume interpretability will overtake it) before we’ve seen much stronger evidence that it will be lost regardless of what we do.
Not every implementation of a “latent reasoning architecture”[12] would lead to a disproportionate increase in no-CoT capabilities (which is what we’re concerned about). But we think such an increase is especially likely for latent reasoning architectures that would add a significant capabilities advantage, and that (for such architectures) it may be difficult to construct evaluations that rule out such an increase.[13] In addition, even if an initial model that uses a latent reasoning architecture looks harmless according to the no-CoT capabilities metric, we think this would very plausibly change with further tweaks and scale-ups.
Reasonable people could disagree about how likely we are to see performant architectures that would technically qualify as latent reasoning architecture but that wouldn’t actually pose any meaningful additional dangers. But given how dangerous it would be to lose the monitorability and holistic understanding that CoT enables, we think that AI developers who want to use latent reasoning architectures should make this clear to the public and argue their case. We strongly encourage AI companies to be transparent about the extent to which they are deploying or exploring latent reasoning architectures, and how they plan to make decisions about this in the future.
FAQ
Q: Does it make sense to distinguish “latent reasoning architectures” from the current paradigm? Won’t we by default get models that are capable of more opaque reasoning, just by scaling up models?
A: There’s currently a huge gap between what models can do with and without a legible CoT. There’s little reason to believe this gap would be significantly reduced by scaling in the current paradigm (see trends above), but a jump to latent reasoning architectures could drastically reduce or eliminate it, which we think would be very dangerous. Furthermore, it does seem possible to draw a relatively clean line between the current paradigm and the architectures we’re concerned about. In particular, opaque serial depth (the amount of serial computation in between text bottlenecks) scales very slowly with compute in the current paradigm (around 1.2x per year). Compare this to the 10x you might get from looped-transformers, 1,000,000x from something like a full-bandwidth transformer, and some even larger number if agents wrote down memories in opaque format and passed them between context windows. (Like compaction does with natural language CoT.)
Q: Are you concerned specifically about recurrence, or about higher depth models in general?
A: The thing we’re worried about is models that can perform lots of reasoning without text bottlenecks. In the standard transformers paradigm, it’s not clear how or why you’d significantly scale up depth and get a highly performant system (without scaling compute much faster than we expect in the next few years). Recurrence is a paradigm shift that seems like a relatively promising way to get much higher depth in a performant manner. In other words: depth isn’t a perfect correlate of how hard it is to oversee AI models, but if switching to models with much higher depth gives substantial capabilities gains, we think this is most likely because these models are capable of using latents to perform reasoning, and we consequently predict that these models will be much harder to oversee.[14]
Q: I heard that DiffusionGemma is just as monitorable as Gemma4 (the model it’s initialized from). Doesn’t that mean you’re wrong about latent reasoning architectures being less monitorable?
A: This paper by GDM studies the monitorability of DiffusionGemma, and reports that DiffusionGemma is similarly monitorable to Gemma4 (see Section 4 of their paper). However, this measurement should not provide much of an update on how monitorable one ought to expect large-scale latent diffusion models to be. The monitorability measured in section 4 only lets the monitor examine the model’s output (i.e. they do not look at any of the internal steps). To the extent that a diffusion model is capable of doing interesting computation within the denoising steps, and to the extent that it actually has a propensity to want to hide things from the monitor (neither of which seem particularly true for DiffusionGemma), it seems fairly likely that this sort of monitoring wouldn’t work.
The same paper also studies whether the latent states of DiffusionGemma are interpretable. (See section 3, and also this blog post.) It finds that DiffusionGemma’s performance is mostly preserved if you project its latent states back down to tokens. In other words, although the architecture supports latent reasoning, the model has not learned to perform interesting latent reasoning. This might seem to contradict our claim that latent reasoning architectures will make oversight harder: maybe some ways of training latent reasoning architectures don’t even teach the model to reason with latents, and therefore don’t compromise monitorability. We address this concern in Appendix B.
Q: It seems better for alignment if models gain capabilities from pretraining rather than from RL, since RL seems to lead to reward seeking and Goodharting. But architectural changes (including a switch to latent reasoning architectures) may be an important part of how we can keep getting more capabilities from pre-training. Does this mean that avoiding latent reasoning architectures is harmful for alignment?
A: We think avoiding latent reasoning architectures is actually beneficial for alignment for a variety of reasons:
Appendix A: More on the necessity argument in the existing CoT paradigm
Here we gather some more objections and evidence on the question as to whether an interpretable CoT will keep being necessary for models to accomplish hard tasks.
One concern about this line of argument is that models may be able to deliberately use the CoT to reason in ways that aren’t understandable to humans. However, so far, it seems like models find it hard to reason in even simple ciphers and more generally struggle to evade monitors when CoT is necessary. Consistent with this, the Astra system card maintains that “if a task requires reasoning to complete, the model doesn’t seem to be able to hide such reasoning”. We expect the models would find this easier if they had sufficiently large no-CoT capabilities, but that the current relatively slow trend in no-CoT capabilities wouldn’t clearly enable robust steganographic reasoning soon. Furthermore, if models at some point do start reasoning steganographically to evade oversight, we might be able to detect this via techniques such as measuring behavioral changes under paraphrasing. This would give valuable evidence about models’ degree of misalignment, and might allow us to find ways to solve the cipher or reduce this behavior.
Another way that CoT could become less useful for understanding models is if CoT naturally becomes illegible due to scaled up RL training — i.e., RL teaches the model a new language which humans don’t understand, allowing the models to perform the necessary reasoning without enlightening monitors about its content. Indeed, recent CoTs have become somewhat less legible, with more compressed speech and sometimes using hard-to-interpret jargon. However, to us, they don’t seem to be on a trend towards total unreadability over the next few years.[15] And if jargon or euphemisms started posing a real problem for interpreting them, it’s plausible that targeted research interventions could find ways to either reduce this drift[16] or to “translate” the models’ new terms.[17] To judge for yourself how legible current CoTs are, you can browse some snippets here from recent models. (And compare here with old snippets from o1.)
What empirical evidence do we have about how the “necessity of CoT” argument is holding up? Let’s look at evidence from Anthropic’s latest system card, where models are tasked with accomplishing a task while avoiding a monitor.
Looking at this graph, we can observe that:
This broadly supports our picture that the necessity argument will become weaker for relatively easier tasks, as models’ no-CoT capabilities become sufficient to do them, but is likely to remain strong for tasks where the CoT is necessary.
How reassuring is this? At the moment, it seems reasonably reassuring, since models would likely need more serial cognition than they can fit in one forward pass to accomplish tasks like “start a rogue internal deployment while evading safeguards”, “reliably strategically perform well in training in order to gain power later”, or “plot to disempower humanity”. Whether it will stay infeasible for models’ no-CoT capabilities depends on the quality of control measures implemented at AI companies. If AI control measures were improved, then the amount of serial cognition required seems greater than what you’d get from multiple years of no-CoT capability improvement along the historical trend:
Appendix B: Do all latent reasoning architectures threaten monitorability?
There may be some ways to train latent reasoning architectures that wouldn’t compromise monitorability. In this appendix, we explain how this interacts with the claims in our post.
Models built on latent reasoning architectures won’t necessarily learn to use the latent channel for doing reasoning. For instance, suppose you took a standard transformer and modified it to pass latents in parallel with CoT tokens, but you didn’t train the transformer to use the latents well. Then, it might have similar monitorability properties to a standard transformer.
The claim we’re making in this post is that if latent reasoning architectures end up giving substantial capabilities gains, then this is likely because the model has learned to do some general purpose reasoning in latents, and we think this will make the model harder to oversee.
There might be some exceptions to this.
For example, it’s possible that the latents of a diffusion model like DiffusionGemma could make it a lot easier to train the model in the first place, even if they're basically equivalent to discrete CoT during inference.
As another example, it’s conceivable that the latents of something like a “full-bandwidth transformer” model could play a fundamentally supportive role to the CoT, without any ability to support general-purpose reasoning separate from the CoT. For example, if the latents were only ever trained during RL where the only source of randomness came from sampling tokens, there’s some argument that the model would have to keep the tokens in a central causal role in its reasoning, since that’s the only source of entropy that powers the RL.[21]
If the latents play a supportive role rather than supporting general purpose reasoning, it’s still possible that they would undermine monitoring. For example, it seems more likely that a model would use tokens in non-human-understandable ways if it can augment its representation of them with latents that capture non-human-readable nuances.
Nevertheless, it’s conceivable that the CoT would stay similarly informative about the model’s cognition.
So given this, why are we still arguing that latent reasoning architectures are dangerous, rather than arguing about a more narrow class of architectures?
One reason for this is that, in practice, it seems very hard to establish to what degree such a latent reasoning architecture and training process would undermine the value we get from the CoT. As a result, if AI developers made reasonably conservative choices about which latent reasoning architectures seemed safe to deploy, it seems unlikely that they would be able to get a lot of additional performance relative to normal CoT models.
For a full-bandwidth transformer, we would think it’s quite reasonable to conclude that the architecture can’t be used to circumvent the CoT if a serious elicitation effort, including IID training, was made towards this goal, and that failed. (And this was reviewed or done by third parties.) Indeed, this would directly address the concern that the architecture change caused a reduced gap between the model’s no-CoT capabilities and with-CoT capabilities. But we think that’s relatively unlikely for performant versions of these architectures.
Some AI developers may want to argue that IID training is an unnecessarily conservative method of elicitation, and that the whole reason to expect the architectures to not undermine CoT monitorability is that they weren’t ever trained to that end. But absent a conservative method of elicitation like that, it seems very difficult to provide strong reasons that the latent channel can’t be used to undermine the CoT.
In particular, AI developers will generally be motivated to tinker with different training procedures and implement the changes that lead to higher performance. This will create a constant pressure towards modifications that teach the model to use its latents for additional types of reasoning, even if the AI developers themselves don’t understand why the modification would generalize that way. It would be difficult to have targeted evaluations for whether the model learned to reason using the latent space, when we may not understand the mechanisms by which this happened. In addition, the most concerning types of misaligned AI would be actively motivated to sandbag on insufficiently elicited evaluations.
Another reason why we’re writing about the dangers of latent reasoning architectures is that we think coordinating to avoid such architectures seems particularly tractable, due to the relative ease of agreeing whether something counts as a latent reasoning architecture or not.
The main alternate coordination target we’re aware of is coordinating to maintain high monitorability. We think this is worse for several reasons:
Overall, while it’s possible that some latent reasoning architectures could preserve our ability to understand models’ reasoning and cognition, we think that AI developers should have a strong default presumption to avoid them, and have a high evidential bar for overcoming this presumption.
Appendix C: Comparing specific interpretability techniques with CoT
The most important reason for why we think the CoT is more valuable than other types of interpretability is by direct comparisons to the state of the art in interpretability. Here are some examples of techniques and their limitations compared to the CoT:
Another concern is that a switch to latent reasoning architectures might harm existing interpretability techniques. For example:
More generally, if models don’t represent CoT in natural language, this might make their internal states less likely to cleanly map on to human concepts, which might make all interpretability techniques work less well.[22]
If a model is trained to reason using continuous vectors (rather than just language) it would be natural to let different copies of that model send each other messages in the form of sequences of such vectors. They could also store memories of this form for extended periods of time.
In the standard CoT paradigm, a single forward pass uses a fixed number of transformer layers in series (somewhere around 100 layers at most in open source models), after which the model must select a token to output. This token is the only information that gets passed to the beginning of the next forward pass. (Later forward passes can also, at each layer, attend to information from previous forward passes that happened at the just-previous layer. But this doesn’t increase serial depth.)
This could be explained by how increased no-CoT capabilities from typical pretraining improvements also improve with-CoT capabilities, but some improvements (especially RL) will disproportionately improve with-CoT capabilities. A switch to latent reasoning architectures could result in a massive disproportionate increase in no-CoT capabilities relative to with-CoT capabilities, compared to the historical relationship between these.
As an exception to the trend, the difference between no-CoT capabilities and with-CoT capabilities may have shrunk for Astra. We don’t know whether this was due to an architectural change or not. (OpenAI employees have claimed that it wasn’t, but leaks indicate that Astra does use a significantly different architecture, which seems like one of the most likely explanations for a change like this, so we want to see more evidence.) Regardless, the difference between Astra’s with-CoT and no-CoT capabilities remains enormous, and it doesn’t seem like Astra’s shift is part of a consistent trend.
See also the FAQs for an argument that no-CoT capabilities will stay serially constrained in the current paradigm, by default.
[Edited to add 2026-06-29:] At least on average across the last few years. It’s possible that some of these improvements increase no-CoT performance disproportionately but that gets cancelled out by other improvements that increase with-CoT performance disproportionately for an overall trend that grows the gap. As mentioned, Astra is a deviation from this trend, so it does not seem typical, though in principle it could be made up of a non-typical combination of otherwise typical improvements. More information would be great on this point.
This raises questions about why they’d be adding the latents in the first place. But there are some conceivable ways that latents could augment the CoT reasoning without supporting general-purpose reasoning on their own.
CoT controllability is measured by prompting models to write CoTs in particular ways, and seeing if they’re able to complete the instruction. If models can complete it, that indicates that they have flexible “control” over their CoT, and could likely also modify it to avoid monitoring if that was instrumentally useful for their goals. Importantly, models have probably not been intentionally trained to make their CoT conform to particular content instructions, since OpenAI describes CoT controllability as an undesirable property, and generally assert that they don’t train on the CoT. So their ability to control the CoT in response to prompts suggests that they may have generalized into a fairly flexible ability to control it. Once models have high CoT controllability, it seems like any argument for why they would have a high propensity to articulate thoughts in their CoT would have to rely on an alignment argument that their goals are consistent with such articulation — but such alignment arguments seem hard to make and we’d very much prefer a world where CoT monitoring arguments could provide a separate check.
The case for generalization is especially plausible when it comes to CoT controllability — i.e., models seem likely to generalize from being trained to flexibly control their output tokens to being able to flexibly control their CoT tokens. And indeed, the trend is heading in this direction, as discussed in the previous section.
Though this is relatively lower in OpenAI models, which suggests that it might be due to particular choices about training, and that it could be mitigated.
One might have hoped that the auxiliary CoT might play the role of an accurate summary of the accompanying latent reasoning, especially as it may be more causally relevant to outputs than e.g. post hoc confessions. However, it seems inefficient to use the CoT to repeat large amounts of latent reasoning rather than do additional computation (or at least only produce very compact summaries of such reasoning), so CoTs that faithfully represent latent reasoning are still less incentivized.
Confessions are a bit of a non-central example of an interpretability method. We count it since a key difference between normal monitors and confessions is that the confessing model can use the activations of the model it is evaluating.
Why is this? During training, RL samples from a probability distribution that was originally based on the human prior, and has only been gradually adjusted away from it. Ways of reasoning that are more natural to humans will tend to be explored earlier, and RL is just selecting between these. By contrast, backpropagating through a continuous state can cause local perturbations to the concepts being used (based on information from the derivatives about how those local changes would affect the rest of the neural network). There’s much less of a structural reason for why this process would explore concepts that humans would find intuitive.
Given any particular operationalization of latent reasoning architecture, such as having high opaque serial depth.
More on this in Appendix B.
There are also some plausible reasons for why recurrent models could be actively worse than non-recurrent models of similar depth; such as being incentivized to develop more general-purpose latent reasoning as opposed to a broader array of heuristics. However, these are more speculative.
One possible argument adding to this is that the compute scale-up of RL will likely be smaller in the next couple of years than it was in the last couple of years. Reduced legibility is likely significantly downstream of increasing compute spent on RL, which has increased over many orders of magnitude over the last couple of years as it caught up with compute-spend on pre-training. As RL compute spend catches up with pre-training compute spend, it should switch over to increasing at the historical rate of 5x compute increase per year. However, this effect may be smaller than it initially seems, because a lot of the RL progress over the last couple of years may have been algorithmic progress (on e.g. sample efficiency, which could increase the rate of CoT drift) and such algorithmic progress is likely to continue.
This may involve training on CoT content, which typically seems inadvisable, due to the risk that it decouples how the model uses the CoT and how it appears to the reward model. However, if the alternative is totally unreadable CoT, it seems worth studying whether these interventions could help without incentivizing too much of this type of decoupling. It would be important to combine these interventions with transparency about their use, such that the wider world understood that they should now place less trust in the faithfulness of the CoT.
This type of translation seems much easier than doing interpretability on model weights, due to the smaller output space and the gradual and relatively slow drift away from human language likely causing more natural correspondences between the AIs’ words and human concepts (as well as some ability to study one word at a time, when it first starts getting frequent, in an inductive fashion).
Mythos Preview also excels at this task, despite not being the most capable model, which is further evidence that propensities are playing a significant role. Stronger elicitation could reduce this.
Note that models are not ordered by capability, which makes this harder to see.
Note that Claude models often do some reasoning outside the reasoning field, in the output field, if the CoT isn’t made available. So the “No thinking” category doesn’t necessarily mean that the models completed the task entirely without reasoning.
Though we’re not sure if this argument actually works. In particular, this is an argument for why learning would be dependent on the model using the sampled tokens in its reasoning. But RL doesn’t optimize for its own learning process; it just optimizes locally for high performance. So it still seems plausible that the model would learn to mostly use its latent states for reasoning, and rely on the tokens less. This would make the learning process work less well, which would likely cause AI developers to make some modifications to the architecture — perhaps fixing the learning problem without fixing the problem that the model is learning to use the latent states for general reasoning.
One exception is that the latent states that replaced the natural language CoT might be unusually interpretable compared to other latent states in the model. But we still expect it to be a lot less interpretable than when it was an actual natural language CoT.
Perhaps defined as architectures with high opaque serial depth.
These tests seem especially insufficient for demonstrating an architecture will remain comparably understandable when scaled up further.
Taylor et al. (2026) write that latent reasoning architectures (defined as “alternative architectures that allow reasoning to remain in the model’s latent space, unlike the usual transformer architecture where reasoning must pass through the model’s output tokens”) were “likely” to degrade oversight at a high severity.
Korbak et al. (2025) write that latent reasoning models (defined as having “changes to the model architectures that increase the serial depth of reasoning that models are capable of in a continuous latent space”) “might not need to verbalize any of their thoughts and would thus lose the safety advantages that CoT confers.”
Shah and Dragan (2026) write that “[if] we decide to train frontier models that reason entirely in latent space, we won’t be able to read their thoughts by default. We might be able to develop tools that let us accurately translate a model’s thoughts to natural language, but that’s a more tenuous plan that relies on as-yet-undiscovered technical insights.”