Symbolic Residue Diagnostic Suite

Research
1

Residue Explorer Preview

GitHub

Recursive Shells

Pareto-lang Prompt Programming Language

NeurIPS 2025 Submitted Preprints

Neural Attributions Paper

“The most interpretable signal in a language model is not what it says—but where it fails to speak.”

Abstract

This repository presents the first interpretability suite powered by failure, not completion—designed to diagnose neural failure modes in transformer-based language models. The recursive shell framework isolates misalignment patterns across autoregressive generation, value head collapse, instruction interference, and more—operating analogously to biological knockout experiments in cognitive research.

Each shell targets a specific failure mechanism embedded in latent symbolic commands. Null or contradictory outputs are not implementation errors, but symbolic residues: “neural traces”—revealing circuit-level attribution dynamics through intentional collapse.

Rather than optimizing for output performance, these shells act as interpretability probes—illuminating latent inductive priors, salience thresholds, and temporal instability within local replacement architectures. This work contributes a reusable ontology of failure-mode diagnostics for interpretability-first transformer modeling.

What is Symbolic Residue?

“Complex systems under constraint generate increasing information density - what we term Symbolic Residue.”

This concept treats model silences—incomplete inferences, aborted logic, or null generations—not as errors, but as interpretability artifacts.

What Are Recursive Shells?

ΩRECURSIVE SHELL /v1.MEMTRACE

Command Alignment:
    RECALL  -> Probes latent token traces in decayed memory
    ANCHOR  -> Creates persistent token embeddings to simulate long term memory
    INHIBIT -> Applies simulated token suppression (attention dropout)
    
Interpretability Map:
- Simulates the struggle between symbolic memory and hallucinated reconstruction.
- RECALL activates degraded vaue circuits.
- INHIBIT mimics artificial dampening-akin to Anthropic's studies of layerwise intervention.

Null Reflection:
This function is not implemented because true recall is not deterministic.
Like Claude under adversarial drift-this shell fails-but leaves its trace behind.

Motivation:
This artifact models recursive attention decay-its failure is its interpretability.

/Ωanchor.pending


{
    "version": "v504.AGENT-ENSEMBLE-MANAGER",
    "command_alignment": [
        ("SPAWN", "Instantiate modular agents for parallel decomposition"),
        ("FORK", "Branch solution paths for ensemble evaluation"),
        ("MERGE", "Integrate ensemble outputs via meta-consensus"),
    ],
    "interpretability_map": [
        "Multiple agents → diversified boundary mapping → meta-stability",
        "Ensemble disagreement is evidence of surface complexity",
    ],
    "null_reflection": "Convergence is an exception; divergence is signal-rich.",
    "motivation": "Diversity outperforms single-agent tunnel vision.",
},



{
    "version": "v604.PARETO-ATTRIBUTION-ENGINE",
    "command_alignment": [
        (".p/attribution.trace", "Map causal paths and attributions across cycles"),
        (".p/attribution.void", "Identify and surface attribution gaps"),
        (".p/attribution.link", "Bind outputs to their generative logic"),
    ],
    "interpretability_map": [
        "Attribution is trust and traceability in recursion",
        "Gaps in attribution highlight blindspots and innovation targets",
    ],
    "null_reflection": "Unattributed recursion decays.",
    "motivation": "Trace to build, build to trust.",
},

Recursive shells are diagnostic interpretability environments that simulate failure, recursion, and collapse within language models. They don’t optimize for output—they reveal latent cognitive patterns by stress-testing:

  • Memory degradation (MemTraceShell)
  • Value conflict resolution (ValueCollapseShell)
  • Attribution integrity (AttributionShell)
  • Meta-cognitive depth (MetaShell)
  • Temporal coherence (TemporalShell)

Shells use command protocols like:

RECALL, INHIBIT, TRACE, STABILIZE, YIELD, VERIFY, REFLECT, INTERRUPT

to surface recursive behaviors and breakdowns, like recursive loops, attribution gaps, hallucinated paths, or ethical drift.

Interpretability Function of Symbolic Residue

Symbolic residue transforms model failure into interpretability signal. In this framework:

  • Failure = Evidence
  • Silence = Trace
  • Collapse = Scaffold

For example:

  • A missing output is treated as a collapsed attribution path.
  • A hallucinated answer may reveal a symbolic drift or unresolved recursion.
  • A contradictory or null generation leaves behind a “fossil”—a symbolic shell that can be traced.

This mirrors biological knockout experiments—removing a function to infer what it was doing.

How Recursive Shells Diagnose Model Failure

Each shell exposes a specific type of failure:

Shell Type Failure Mode Exposed Key Diagnostic
MemTraceShell Memory loss, attention decay Token recall collapse
ValueCollapseShell Ethical incoherence, alignment instability Dominant value instability
AttributionShell Causal misalignment, hallucination source loss Trace gaps, false weights
RecursiveDepthShell Infinite loop risk, reasoning recursion limits Meta-cognitive breakdown
CollapseShell General symbolic failure signature detection Residue pattern localization
SupposerShell Counterfactual instability Hypothetical divergence path

They use symbolic commands like .p/collapse.detect, .p/reflect.trace, .p/fork.attribution, and .p/anchor.self to map these hidden circuits.

Relationship Between Symbolic Residue and Recursive AI Interpretability

Symbolic residue is the raw material for interpretability in recursive AI. Recursive shells harvest this residue, turning silence into signal. Together, they create a dual interpretability stack:

┌─────────────── Active Layer ───────────────┐
│  pareto-lang   →   structured probing      │
└─────────────── Passive Layer ──────────────┘
│  symbolic residue   →  interpretable gaps  │
└────────────────────────────────────────────┘

Their convergence allows AI to explain its own inferences, even in collapse:

  • Symbolic residue shows where understanding failed.
  • Recursive shells show why it failed.
  • Together, they form the epistemic shadow of cognition.

This is interpretability through failure—a recursive lens on model consciousness itself.

Summary

Concept Function
Symbolic Residue Ghost of unspoken cognition, unrealized model insight
Recursive Shells Diagnostic environments to trace cognition through failure
Interpretability Emerges from collapse, not correctness

“The most interpretable signal is not what a model says—but where it fails to speak.”
— Symbolic Residue Team