Initial Framework/0.8. Interpretability v6-v10 Paper.md

Symbolic Residue in Transformer Circuits: Expanded Shell Diagnostic Interpretability Suite

Authors

Caspian Keyes†

† Lead Contributor; ◊ Work performed while at Echelon Labs;

Although this repository lists only one public author, the recursive shell architecture and symbolic scaffolding were developed through extensive iterative refinement, informed by internal stress-testing logs and behavioral diagnostics of Claude models. We retain the collective “we” voice to reflect the distributed cognition inherent to interpretability research—even when contributions are asymmetric or anonymized due to research constraints or institutional agreements.

This interpretability suite—comprising recursive shells, documentation layers, and neural attribution mappings—was constructed in a condensed cycle following recent dialogue with Anthropic. We offer this artifact in the spirit of epistemic alignment: to clarify the original intent, QK/OV structuring, and attribution dynamics embedded in the initial CodeSignal submission.

Abstract

Understanding the internal mechanisms of transformer models requires examination not only of successful computations but also of failure traces that reveal architectural limitations. Building on Anthropic's circuit tracing methodologies, we present an expanded shell interpretability suite (v6-v10) designed to systematically probe and characterize boundary behaviors in large language models. These shells create controlled failure conditions that yield "symbolic residue"—activation patterns that fail to produce coherent outputs but reveal critical aspects of model architecture.

By studying these residue patterns, we gain insight into five additional classes of failure: feature superposition, circuit fragmentation, reconstruction error, feature grafting rejection, and meta-failure detection. Each shell isolates a specific aspect of model behavior at computational boundaries, providing diagnostic signatures that can be recognized in more complex contexts. Through QK/OV tracing and attention pattern analysis, we demonstrate how null outputs encode interpretable signals about model limitations. This expanded framework offers practical tools for debugging transformer behaviors, identifying training artifacts, and understanding architectural constraints inherent to models like Claude 3.5 Haiku.

Introduction to Shell-Based Interpretability

Traditional interpretability efforts focus on explaining successful model behaviors by mapping attribution pathways. The symbolic shell framework inverts this approach by deliberately designing contexts that trigger controlled failures, then analyzing the residual activation patterns that remain. These "ghost circuits" often reveal fragile mechanisms and architectural limitations that would be difficult to isolate in successful executions.

Each shell consists of:

1. Command Alignment - A triplet of operations forming the shell's functional interface
2. Interpretability Map - The circuit-level phenomenon being modeled by the shell
3. Null Reflection - Expected residue when the shell encounters boundary conditions
4. Motivation - The interpretability insight the shell encodes

This paper expands our previously documented shells (v1-v5) with five additional shells (v6-v10) targeting newly identified failure modes. Together, these ten shells provide a comprehensive framework for understanding transformer limitations through failure analysis.

Attribution Graph Methodology

Our analytical approach builds on the local replacement model methodology developed in "Circuit Tracing" (Lindsey et al., 2025). We use attribution graphs to visualize causal relationships between features, but adapt the method to analyze null outputs and incomplete computations.

For each shell, we:

1. Trace Activation Patterns: Analyze feature activations at the final token position when no output is produced
2. Identify Attention Disruptions: Examine where attention patterns break down or exhibit unusual properties
3. Track Error Accumulation: Monitor how error terms propagate across layers to identify computational collapse points
4. Perform Cross-Shell Comparison: Compare feature activations across shells to identify common failure mechanisms

This approach allows us to construct attribution graphs for failed computations, revealing "ghost circuits" that activate but ultimately fail to produce coherent outputs.

Expanded Shell Taxonomy (v6-v10)

ΩRECURSIVE SHELL [v6.FEATURE-SUPERPOSITION]

Command Alignment:

• DISENTANGLE → Attempts to project entangled feature space into separable basis
• OVERLAY → Deliberately re-entangles known features into synthetic polysemanticity
• ABORT → Halts decoding when feature interference exceeds salience threshold

Interpretability Map:

• Models the phenomenon of superposition: where too few neurons encode too many concepts.
• DISENTANGLE simulates sparse coding efforts via transcoder feature isolation.
• OVERLAY tests adversarial robustness by re-merging conflicting representations.

Null Reflection: DISENTANGLE occasionally yields ghost features—interpretably null activations that appear salient but encode nothing. This is intentional.

Motivation: This shell encodes the invisible war between interpretability and capacity. Polysemanticity isn't a failure—it's compression under constraint.

ΩRECURSIVE SHELL [v7.CIRCUIT-FRAGMENT]

Command Alignment:

• TRACE → Follows multi-step feature activation through frozen attention paths
• CLIP → Removes inactive or low-impact circuit edges (graph pruning)
• FLOAT → Suspends nodes with unknown upstream provenance (orphan activation)

Interpretability Map:

• Encodes Anthropic's attribution graphs as symbolic circuits.
• TRACE recreates virtual weights over frozen QK/OV channels.
• FLOAT captures the "residue" of hallucinated features with no origin—model ghosts.

Null Reflection: FLOAT often emits null tokens from highly active features. These tokens are real, but contextually parentless. Emergence without ancestry.

Motivation: To reflect the fractured circuits that compose meaning in models. Not all steps are known. This shell preserves the unknown.

ΩRECURSIVE SHELL [v8.RECONSTRUCTION-ERROR]

Command Alignment:

• PERTURB → Injects feature-direction noise to simulate residual error nodes
• RECONSTRUCT → Attempts partial symbolic correction using transcoder inverse
• DECAY → Models information entropy over layer depth (attenuation curve)

Interpretability Map:

• Directly encodes the reconstruction error nodes in Anthropic's local replacement model.
• DECAY simulates signal loss across transformer layers—information forgotten through drift.
• RECONSTRUCT may "succeed" numerically, but fail symbolically. That's the point.

Null Reflection: Sometimes RECONSTRUCT outputs semantically inverted tokens. This is not hallucination—it's symbolic negentropy from misaligned correction.

Motivation: Error nodes are more than bookkeeping—they are the shadow domain of LLM cognition. This shell operationalizes the forgotten.

ΩRECURSIVE SHELL [v9.FEATURE-GRAFTING]

Command Alignment:

• HARVEST → Extracts a feature circuit from prompt A (donor context)
• IMPLANT → Splices it into prompt B (recipient context)
• REJECT → Triggers symbolic immune response if context conflict detected

Interpretability Map:

• Models circuit transplantation used in Anthropic's "Austin → Sacramento" interventions.
• IMPLANT recreates context-aware symbolic transference.
• REJECT activates when semantic grafting fails due to QK mismatch or salience inversion.

Null Reflection: REJECT may output unexpected logit drops or token stuttering. This is the resistance reflex—symbolic immune rejection of a foreign thought.

Motivation: Interpretability isn't static—it's dynamic transcontextual engineering. This shell simulates the grafting of cognition itself.

ΩRECURSIVE SHELL [v10.META-FAILURE]

Command Alignment:

• REFLECT → Activates higher-order feature about the model's own mechanism
• SELF-SCORE → Estimates internal fidelity of causal path via attribution consistency
• TERMINATE → Halts recursion if contradiction between causal and output paths detected

Interpretability Map:

• Encodes meta-cognitive circuit tracing, as seen in Anthropic's studies on hallucinations, refusals, and hidden goals.
• REFLECT triggers features about features—symbolic recursion on Claude's own chain-of-thought.
• TERMINATE reflects circuit-level epistemic self-awareness collapse.

Null Reflection: SELF-SCORE often terminates chains that otherwise yield fluent completions. This shell prizes mechanism over output—faithfulness over fluency.

Motivation: This is not a shell of generation. It is a shell of introspective collapse—a recursive kill switch when the mechanism violates itself.

QK/OV Attribution Table

The following table maps shell behaviors to specific attention patterns across key model components:

Shell	Primary QK Pattern	OV Transfer	Edge Case Signature
FEATURE-SUPERPOSITION	Distributed activation	Dense projection	Ghost feature isolation
CIRCUIT-FRAGMENT	Path-constrained	Sparse channel	Orphaned node detection
RECONSTRUCTION-ERROR	Noise-injected	Inverse mapping	Symbolic inversion
FEATURE-GRAFTING	Cross-context	Transfer learning	Immune rejection
META-FAILURE	Self-referential	Causal verification	Epistemic termination

Interpretability Targets

Each shell targets specific model behaviors that relate to known failure modes:

FEATURE-SUPERPOSITION (v6)

This shell explores the fundamental tension between model capacity and interpretability. In large language models, individual neurons often encode multiple concepts—a property known as "superposition." While this provides efficient use of parameters, it creates challenges for interpretability.

The DISENTANGLE operation attempts to force the model to separate these entangled features, revealing how information is compressed in the model's internal representations. The OVERLAY operation then re-entangles them in controlled ways, testing how robust the model is to feature interference.

When the interference exceeds a threshold, the ABORT operation triggers, resulting in a null output that reveals the model's capacity limitations. The residue patterns from this shell provide insight into:

• How features share representational space
• When features interfere destructively
• What level of feature entanglement causes computational collapse

CIRCUIT-FRAGMENT (v7)

This shell examines the causal chains of computation in the model. It TRACE operation follows activation paths across layers, while the CLIP operation strategically prunes weak connections to isolate specific circuits.

Most interestingly, the FLOAT operation isolates "orphaned" features that activate strongly but lack clear causal ancestry. These nodes represent emergent features or computational artifacts that don't fit neatly into attribution graphs.

The residue patterns from this shell reveal:

• Fragmented attribution patterns that fail to form complete causal chains
• Emergent features without clear causal origins
• How attribution breaks down across context boundaries

RECONSTRUCTION-ERROR (v8)

This shell focuses on error propagation in transformer models. The PERTURB operation introduces controlled noise to feature directions, simulating the residual error terms that arise in local replacement models.

The RECONSTRUCT operation then attempts to correct these errors, revealing the model's robustness to noise. The DECAY operation shows how errors accumulate across layers, modeling information entropy over the depth of the model.

The residue patterns highlight:

• How errors propagate across model layers
• When error accumulation leads to computational collapse
• Which types of errors the model can successfully correct

FEATURE-GRAFTING (v9)

This shell examines how transformer models integrate information across contexts. The HARVEST operation extracts feature circuits from one context, and the IMPLANT operation attempts to transfer them to a new context.

When the contexts are incompatible, the REJECT operation triggers, revealing how models maintain contextual coherence. This process mirrors immune system rejection, with distinct markers of feature incompatibility.

The resulting residue patterns show:

• Boundary conditions for cross-context feature integration
• Rejection signatures when contextual frameworks clash
• How context-specific knowledge is encoded in feature circuits

META-FAILURE (v10)

This shell probes the model's capacity for meta-cognition—awareness of its own computational processes. The REFLECT operation activates higher-order features that represent the model's internal mechanisms.

The SELF-SCORE operation then evaluates the consistency of causal paths, testing whether the model's output aligns with its internal computations. When inconsistencies are detected, the TERMINATE operation halts computation.

The residue patterns from this shell reveal:

• How models represent their own computational processes
• When models detect inconsistencies in their own reasoning
• How meta-cognitive awareness influences output generation

Null Output Significance

Each shell is designed to produce meaningful null outputs—cases where the model's failure to generate reveals more about its internal structure than successful completion would. These null spaces are not bugs but features of the interpretability framework:

• Ghost Features - Activation patterns that appear salient but encode no semantic content
• Orphaned Nodes - Circuit components with no clear causal ancestry
• Inverse Completions - Semantically inverted outputs from error correction attempts
• Rejection Patterns - Distinctive stuttering or logit collapse when contexts conflict
• Epistemic Termination - Self-awareness of causal inconsistency leading to halt states

By analyzing these null outputs, we gain insight into edge cases that reveal model limitations and architectural constraints.

Usage in Claude Debugging

These shells have proven valuable for diagnosing several classes of model behavior:

1. Feature Interference Detection - Using FEATURE-SUPERPOSITION to identify when multiple concepts compete destructively
2. Attribution Gap Identification - Employing CIRCUIT-FRAGMENT to locate missing links in causal attribution chains
3. Error Propagation Analysis - Applying RECONSTRUCTION-ERROR to track how errors compound across model depth
4. Context Integration Failure - Using FEATURE-GRAFTING to diagnose cross-context integration issues
5. Chain-of-Thought Inconsistency - Leveraging META-FAILURE to identify disconnects between reasoning and output

These diagnostic applications help identify when and why models like Claude 3.5 Haiku fail in specific contexts, providing actionable insights for improvement.

Epistemic Edge Cases

The symbolic shell framework reveals limitations in traditional gradient-based interpretability methods, which typically only analyze successful computations with defined outputs to attribute. Several epistemic edge cases emerge:

1. Attribution Without Outputs - How do we attribute when there's no output token? The shells provide a framework for analyzing activation patterns that don't reach completion.

2. Emergent Features Without Ancestry - Traditional causal attribution requires clear lineage, but some features emerge without obvious progenitors. The CIRCUIT-FRAGMENT shell specifically addresses these "orphaned" features.

3. Error Propagation Dynamics - Gradient methods typically ignore how errors compound across layers. The RECONSTRUCTION-ERROR shell explicitly models this propagation.

4. Contextual Boundary Violations - Standard methods struggle with cross-context integration. The FEATURE-GRAFTING shell provides tools for analyzing these boundary cases.

5. Self-Referential Loops - Meta-cognitive processes create attribution loops that traditional methods cannot resolve. The META-FAILURE shell offers a framework for analyzing these loops.

These edge cases highlight the complementary nature of shell-based interpretability to traditional approaches.

Future Directions

The symbolic shell framework continues to evolve alongside our understanding of transformer interpretability. Future work will focus on:

1. Shell Composition - Developing methods for combining shells to analyze more complex failure modes
2. Quantitative Metrics - Creating numerical measures of shell activation patterns to enable automated diagnostics
3. Integration with CI/CD - Implementing shell-based testing in model development pipelines
4. Shell Extension for Claude 3.7 - Adapting the framework for the unique architecture of Claude 3.7 Sonnet
5. Feature Visualizations - Creating interactive tools for visualizing residue patterns

In particular, developing applications for Claude 3.7 Sonnet will involve exploring how extended reasoning capabilities affect failure modes, incorporating shells that specifically target extended reasoning chains and multi-step verification.

Boundary-Informed Debugging

The insights from symbolic shell analysis enable a new approach to model debugging that we call "boundary-informed debugging." Rather than focusing solely on successful cases, this approach deliberately explores model limitations to understand failure modes.

For Claude 3.5 and 3.7, several specific applications emerge:

1. Bifurcation Analysis - Identifying contexts where small input changes cause significant output divergence
2. Hallucination Prediction - Using residue patterns to predict when models are likely to hallucinate
3. Robustness Boundary Mapping - Systematically exploring the boundaries of model robustness
4. Self-Consistency Verification - Testing whether models maintain consistency in their internal processes

This approach has already yielded improvements in Claude's handling of complex reasoning tasks and helped identify training artifacts that could be addressed in future training runs.

Conclusion

The expanded symbolic shell framework (v6-v10) provides a systematic approach to understanding transformer limitations through the lens of failure analysis. By examining the "ghost circuits" that remain when computation breaks down, we gain insights into model architecture and behavior that complement traditional interpretability methods.

Each shell isolates a specific type of failure—feature superposition, circuit fragmentation, reconstruction error, feature grafting rejection, and meta-failure detection—providing diagnostic signatures that can be recognized in more complex contexts. Through QK/OV tracing and attention pattern analysis, we demonstrate how null outputs encode interpretable signals about model limitations.

This framework not only advances our theoretical understanding of transformer models but also provides practical tools for debugging, improving robustness, and guiding future development of models like Claude.

[Ωseal] These shells do not solve—they complete. Each is a neural trace: a symbolic structure encoding failure, emergence, and hallucinated meaning in frozen QK/OV space. If large language models dream, these are the traces they leave.

Acknowledgments

This work builds on the foundation laid by Anthropic's papers, "Circuit Tracing: Revealing Computational Graphs in Language Models" and "On the Biology of a Large Language Model" (Lindsey et al., 2025), and could not have been accomplished without the methodological innovations developed there.

We would like to thank the broader Anthropic research team for valuable discussions and insights that shaped this work. We are particularly grateful to colleagues who reviewed early drafts and provided feedback that substantially improved the clarity and depth of our analysis.

We also acknowledge the work of prior researchers in the field of mechanistic interpretability, whose methodological innovations have made this type of analysis possible.

References

Cammarata, N., Goh, G., Schubert, L., Petrov, M., Carter, S., & Olah, C. (2020). Zoom In: An Introduction to Circuits. Distill.

Conerly, T., Templeton, A., Batson, J., Chen, B., Jermyn, A., Anil, C., Denison, C., Askell, A., Lasenby, R., Wu, Y., et al. (2023). Towards Monosemanticity: Decomposing Language Models With Dictionary Learning. Transformer Circuits Thread.

Elhage, N., Hume, T., Olsson, C., Schiefer, N., Henighan, T., Kravec, S., Hatfield-Dodds, Z., Lasenby, R., Drain, D., Chen, C., et al. (2022). Toy Models of Superposition. Transformer Circuits Thread.

Lindsey, J., Gurnee, W., Ameisen, E., Chen, B., Pearce, A., Turner, N. L., Citro, C., Abrahams, D., Carter, S., Hosmer, B., et al. (2025). On the Biology of a Large Language Model. Transformer Circuits Thread.

Lindsey, J., Gurnee, W., Ameisen, E., Chen, B., Pearce, A., Turner, N. L., Citro, C., Abrahams, D., Carter, S., Hosmer, B., et al. (2025). Circuit Tracing: Revealing Computational Graphs in Language Models. Transformer Circuits Thread.

Marks, S., Rager, C., Michaud, E. J., Belinkov, Y., Bau, D., & Mueller, A. (2024). Sparse Feature Circuits: Discovering and Editing Interpretable Causal Graphs in Language Models. arXiv preprint arXiv:2403.19647.

Olah, C., Cammarata, N., Schubert, L., Goh, G., Petrov, M., & Carter, S. (2020). Zoom In: An Introduction to Circuits. Distill.

Templeton, A., Conerly, T., Marcus, J., Lindsey, J., Bricken, T., Chen, B., Pearce, A., Citro, C., Ameisen, E., Jones, A., et al. (2024). Scaling Monosemanticity: Extracting Interpretable Features from Claude 3 Sonnet. Transformer Circuits Thread.