An operationalization of opaque serial depth

Currently, chain-of-thought (CoT) is a valuable tool for overseeing AI models. However, some architectural shifts could significantly reduce CoT monitorability. We have recently proposed that AI companies should transparently share ​​information about the degree to which their architectures may allow for latent reasoning and communication. To assist with this proposal, this document operationalizes a measure that serves as a proxy for the amount of unverbalized serial cognition a model can perform. Our measure is a specific instantiation of the notion of “opaque serial depth”, originally defined in a recent paper from GDM (Brown-Cohen et al, 2026). To measure the opaque serial depth of a computation, Brown-Cohen et al. propose measuring the longest path in the computational graph which doesn’t pass through some form of “interpretable bottleneck”. Centrally, if one considers CoT tokens as “interpretable” but transformer hidden states as “non-interpretable”, then the opaque serial depth of a standard transformer is proportional to the number of layers.[1] Our main contribution in this document is a particular standard for what counts as an “interpretable bottleneck”. Roughly speaking, we want to consider nodes to be “interpretable bottlenecks” if they output text (as opposed to latent states), and were initialized from a pre-training prior. To make this notion more precise, we define the concept of natural-language-rooted nodes (NL-rooted nodes) in a computation graph.[2] In order for a set of nodes in a model’s computational graph to count as NL-rooted, we require: Natural-language initialization: The model has been initialized from a pre-training prior to produce “natural-language” outputs at those nodes. (We have a very permissive notion of natural-language, which includes objects like “code”, “jsons” and “image patches”, and allows for distillation from models with garbled CoTs.) No expansion of the output space: The only outputs of those nodes are tokens whose meanings were directly initialized from that pre-training prior. (Ruling out, for example, abstract CoT, COCONUT, full-bandwidth transformers, and token superpositions.) No modifying the model to interpret the tokens as a different type of data: The model should not be directly modified to use these tokens in ways radically disconnected from the pre-training prior. (This clause should not preclude natural training methods. It is primarily intended to rule out technical loopholes in the above bullet point, such as turning a latent reasoning model into a model that superficially reasons in natural language via encoding and decoding its activations as natural language tokens.)[3] We elaborate on these criteria below. Importantly, all normal forms of post-training can be used without preventing nodes from being NL-rooted, including prompting, distillation, and RL. (Even with aggressive length penalties or CoT supervision, and even if these forms of post-training make the CoT illegible in practice.) Given this definition of NL-rooted nodes, we call our corresponding notion of opaque serial depth “Natural-Language-rooted node”-Separated depth (NLS depth). Beyond defining this term, we also argue that it tracks concerning architectural changes, discuss how to apply NLS depth to a number of example architectures (in Appendix A), and discuss some alternative operationalizations of opaque serial depth (in Appendix B). Tracking the NLS depth of AI systems is not a replacement for tracking monitorability or no-CoT capabilities; it is an important complement. NLS depth has some advantages not shared by these other measurements. In particular: NLS depth is a relatively crisp and easy-to-quantify notion,[4] whereas it’s unclear how to quantify or measure monitorability (e.g., what tasks should this be measured on, what elicitation strategies should be used). NLS depth can be adjudicated before training begins, just given the architecture, training recipe, and intended deployment-time configuration of an AI system. This makes it easier to use in decisions about what models to train. To achieve these properties, NLS depth is insensitive to some post-training choices that could in fact lead models to have significantly more or less interpretable CoT. However, we think NLS depth is a good (albeit imperfect) proxy[5] for the amount of opaque serial cognition that models can perform, which we think is highly relevant for monitorability. NLS depth does a good job of separating architectures in the current natural language CoT paradigm (even with heavy scaling) from especially concerning architectures like scaled-up versions of full-bandwidth transformers (which can recur on opaque state throughout a full context window). Overall, we think it would be highly valuable to track the NLS depth of AI systems. Definition of natural-language-rooted nodes Before defining NLS depth we must define what “natural-language-rooted” (NL-rooted) nodes in a computational graph are—