Designing, implementing, and comparing interpretable architectures requires a formal language to represent them. The most common representations fall short in one of two ways. Symbolic equations give no global view of an architecture at a glance. Probabilistic graphical models and flowcharts do not describe actual tensor manipulations, thus hiding key insights and limiting reproducibility. To close this gap, we introduce a graphical notation for designing interpretable AI architectures, adapted from Penrose tensor notation. This graphical notation gives a global view of an architecture and maps one to one onto PyTorch einsum code. We first use this notation to describe architectures that are interpretable by construction, including concept bottlenecks, sparse probes, prototype networks, neural additive models, and mixtures of linear models. We then diagram the key architectural components of Steerling-8B, a frontier interpretable language model. The diagram yields global insights into the architecture (e.g., showing that Steerling is a residual model), a geometric interpretation of each individual operation, and a direct translation into 33 lines of PyTorch code.
Figures & tables
Figure 1
Name / op
Diagram
Array shape
Algebraic
Scalar s = torch . randn (1)
[⋅]
s∈R
Vector v = torch . randn ( n )
[⋅⋅⋅]
v∈Rn
Matrix A = torch . randn ( m , n )
[⋅⋅⋅⋅⋅⋅]
A∈Rm×n
3-Tensor T = torch . randn ( a , b , c )
–
T∈Ra×b×c
Table 2
Name / op
Diagram
Array shape
Algebraic
Scalar multiplication h = torch . einsum (’,->’, v , w )
⋅×⋅=⋅
h=ab
Element-wise product h = einsum (’ i , i -> i ’, a , b )
[⋅⋅⋅]⊙[⋅⋅⋅]=[⋅⋅⋅]
hi=aibi
Dot product h = einsum (’ i , i ->’, a , b )
[⋅⋅⋅][⋅⋅⋅]=⋅
h=∑iaibi
Squared norm h = einsum (’ i , i ->’, a , a )
[⋅⋅⋅][⋅⋅⋅]=⋅
h=∑iaiai=∥a∥2
Normalize asqn = einsum (’ i , i ->’, a , a ) an = a / asqn **0.5
n([⋅⋅⋅])=[⋅⋅⋅]
a^i=ai/∑jaj2
Convex combination h = einsum (’ i , i ->’, a , bn )
[⋅⋅⋅]n([⋅⋅⋅])=⋅
h=∑iaib^i
Table 3
Table 4
MLP z1 = sigma ( einsum (’ bj , ij -> bi ’, X , W0 )) z2 = sigma ( einsum (’ bj , ij -> bi ’, z1 , W1 )) ⋯ y = sigma ( einsum (’ bj , ij -> bi ’, zL , WL ))
While transformers achieve strong performance, their internal decision-making processes remain opaque. We investigate whether architectural constraints can enforce interpretability by design through architectural stream independence: maintaining a token stream (carrying symbolic structure) and contextual semantics in separated streams that remain independently observable throughout processing, with integration delayed until output. We validate this principle through the Late Fusion Architecture (LFA), which demonstrates interpretable symbolic heads through all the final layers, while standard transformers show dissolution by the third of six layers; we quantify this effect by introducing the Token-Position Dependence Score (PDS), with PDSmax = 0.276 and 0.058, respectively. Crucially, intervention experiments demonstrate functional modularity: suppressing LFA's recency heads causes minimal semantic damage (Cohen's d = -0.158) versus catastrophic entanglement in baselines (d = -0.672). LFA demonstrates that architectural constraints improve underlying learning mechanisms, averaging 42% stability versus 19% and 11% for baseline comparisons, with extremes from 50% on LFA's best pairs (6 of 12 heads position-invariant) down to 0% complete collapse in over-constrained cases. By preventing premature entanglement, architectural independence steers models toward semantic understanding over positional heuristics, establishing interpretability as an architectural design criterion enforceable through structural constraints rather than post-hoc analysis.
Mechanistic interpretability assumes that circuit analysis becomes harder as models scale. We challenge this assumption by showing that the attention architecture matters more than parameter count. Studying three circuit types across Pythia and Qwen2.5, we find that grouped query attention produces circuits that are far more concentrated and mechanistically stable than standard multi-head attention at comparable scales. The same concentration pattern holds across indirect object identification, induction heads, and factual recall. Within a single architecture family (Qwen2.5), factual recall circuits undergo a discrete phase transition above a critical scale, collapsing to a single bottleneck rather than degrading gradually. These findings suggest that some architectural choices make large models more tractable to study and that interpretability difficulty is not a fixed consequence of model size.
Interpretability is often treated as a tax on capability: language models are trained as opaque systems, then explained after the fact, with methods whose reliability is difficult to establish. In this work, we challenge this premise. Rather than reverse-engineering a model, we make interpretability a constraint of the training pipeline, optimized alongside the language modeling objective. Across three orders of magnitude of compute, on both autoregressive and diffusion language models, interpretability scales with capability rather than against it. Surprisingly, model representations become more disentangled and aligned with human-understandable concepts with scale. We instantiate the training-time recipe with Steerling-8B, a diffusion language model with a causal attention mask. For any group of generated tokens, Steerling-8B attributes the output to relevant input tokens, human-understandable concepts, and training data. This enables closed-loop intervention: diagnose an output through its concept or feature attribution, retrieve similar training data, and correct the behavior through concept steering without retraining. Steerling-8B remains competitive with open peer models trained on substantially 2-16x more compute, suggesting a different scaling paradigm: interpretability can be designed into training, and it improves with scale.
Guide Labs Team, Andreas Madsen, Aya Abdelsalam Ismail +7