💻 computer science

Hidden APIs in Language Models: Discovering Reusable Causal Interfaces from Forked Futures

This paper introduces "forked futures," a method for identifying reusable causal interfaces in language models by comparing hidden states based on their induced future response distributions, demonstrating that a "Shared" interface provides the most economical and robust representation across multiple model architectures.

Original authors: SiYuan Ma, Yiqin Luo, Zhangji, Canran Xiao, Albert Gao, Wei-Hsing Huang, Wei Wang, Qiwei Wu, Xinran Li, Jinfeng Wei, Qixin Zhang

Published 2026-07-31

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: SiYuan Ma, Yiqin Luo, Zhangji, Canran Xiao, Albert Gao, Wei-Hsing Huang, Wei Wang, Qiwei Wu, Xinran Li, Jinfeng Wei, Qixin Zhang

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to understand how a giant, super-smart robot thinks. You can see what it says in response to a question, but you can't see the gears turning inside its brain. For a long time, scientists have tried to peek inside by looking at the robot's "hidden states"—the internal electrical patterns that exist just before it types an answer. The big question is: does the robot use one special, reusable "control panel" to handle all its thinking, or does it scramble to build a brand-new, one-time-only tool for every single task? This is like asking if a chef uses one master knife for everything, or if they grab a different, specialized gadget for chopping onions, slicing bread, and filleting fish every single time. Understanding this matters because if the robot has a reusable control panel, we might be able to talk to it, fix its mistakes, or understand its secrets much more easily. If it's just a chaotic mess of one-off tools, figuring out how it works becomes a nightmare.

This paper introduces a clever new way to solve this mystery, called "forked futures." Instead of just asking the robot a question and seeing what it says, the researchers set up a time-travel experiment. They let the robot form an internal thought (a hidden state) based on a story so far, but before they tell it what to do next. Then, they "fork" the future: they ask the robot to do many different things with that same thought, like comparing facts, verifying a rule, or composing a new sentence. By watching how the robot's brain reacts to these different future tasks, they can see if the internal thought was actually a versatile, reusable tool or just a dead-end.

The researchers tested this idea on two famous language models, Qwen2.5-1.5B and Llama-3-8B, pitting four different theories against each other: a "Shared" theory (one master control panel), a "Local" theory (a unique tool for every job), a "Mixture" theory (some tools are shared, some aren't), and a "Distributed" theory (the work is spread out everywhere with no central hub). They measured which theory explained the robot's behavior most efficiently. The results suggest that the "Shared" theory is the winner. The robot seems to use a compact, reusable "API" (a kind of internal interface) that saves it effort. Specifically, the Shared model required a description length of 1.292 nats on the Qwen model and 1.187 nats on the Llama model, beating the next best option by a margin of 0.216 and 0.294 nats respectively. This means the robot is using a "shortcut" to reuse its internal states rather than reinventing the wheel every time.

However, the paper is very careful not to overhype this. It explicitly rules out the idea that this is a perfect, universal "global workspace" that handles everything in the robot's brain. The evidence shows that this reusable interface works best within specific families of tasks (like logic puzzles or code) but gets weaker when you try to mix and match completely different types of tasks. In fact, when they tested their method on fake, simple robot brains where they knew the answer, they found that their method made a mistake 8.3% of the time (1 out of 12 non-shared brains was wrongly labeled as shared). This means the discovery is real but limited; it's a powerful tool for understanding specific parts of the robot's thinking, not a magic key to unlock its entire mind. The paper concludes that while these models do have a compact, reusable causal interface, it is a specific, conditional feature, not a magical, all-powerful brain center.

Technical Summary: Hidden APIs in Language Models

1. Problem Statement

Current methods for analyzing language model (LM) internal states often rely on "probing" hidden states to predict the current output token. However, identical current answers can arise from hidden states that support fundamentally different future computations. Consequently, a decodable direction for a single answer does not establish a reusable internal interface. The central question addressed is counterfactual: which distinctions between hidden states remain necessary across possible future computations? The paper seeks to determine whether LMs expose a compact, shared state that multiple downstream computations can reuse, distinct from operation-specific (Local), gated (Mixture), or distributed alternatives.

2. Methodology

2.1 Forked Futures and Causal Signatures

The core innovation is the definition of forked futures. For a given prefix state $h$ , an operation bank $\mathcal{K}$ generates valid continuations after the state has formed. The model's response distributions to these operations define a future causal signature, $\Sigma_{\mathcal{K}}(h)$ .

Causal Equivalence: Two states are empirically future-equivalent if their signatures are close under Jensen-Shannon divergence (Future Signature Distortion, FSD).
Controls: The methodology employs semantic-collision controls (same current answer, different future transitions) and lexical anti-collision controls (different surface forms, same future signature) to prevent the interface from memorizing current answers or prompt templates.

2.2 Architecture Competition via Prequential Causal MDL

The paper frames interface discovery as a falsifiable architecture-selection problem. Four competing architectures are evaluated:

Shared: One operation-agnostic encoder $E(h)$ and a single bottleneck code $c$ .
Local: Independent encoder-reconstructor pairs $(E_k, R_k)$ for each operation.
Mixture: An operation-conditioned gate interpolating between shared and local components.
Distributed: Information retained across multiple components without a privileged bottleneck.

Selection is based on Prequential Causal Minimum Description Length (MDL). The model is trained sequentially on blocks of data; the MDL measures the code length required to predict future signatures on held-out blocks given only the preceding data. The Sharedness Gain (SG) is defined as the MDL advantage of the Shared architecture over the best non-Shared alternative, subject to strict fidelity constraints (mean, worst-family, and tail FSD).

2.3 Mechanistic Validation

A selected interface must pass rigorous intervention tests to prove it functions as a causal API, not just a statistical correlate:

Transplantation: Donor interface codes are inserted into matched producer roles in base episodes. Success is measured by Target Correctness (realizing donor relations), Locality (preserving non-target base state), and Copy Preservation (avoiding leakage of donor-specific surface content).
Mediation: Blocking "API-aligned" paths between producers and consumers must significantly reduce the target effect compared to matched null paths.
Model Organisms: The pipeline is tested on synthetic transformers with known ground-truth routing (Shared, Local, Mixture, Distributed) to measure false-positive rates and recovery accuracy.

3. Key Results

3.1 Architecture Competition

In evaluations on Qwen2.5-1.5B and Llama-3-8B:

Shared achieved the lowest held-out prequential MDL compared to Local, Mixture, and Distributed.
Sharedness Gain (SG):
- Qwen2.5-1.5B: $SG = 0.216$ nats (95% CI: [0.161, 0.278]).
- Llama-3-8B: $SG = 0.294$ nats (95% CI: [0.208, 0.391]).
Fidelity: The Shared architecture maintained comparable or slightly better FSD (Mean, Worst-Family, and Tail) than alternatives, indicating the gain is due to coding efficiency (reuse) rather than predictive superiority.
Robustness: A five-backbone sweep (including Qwen2.5-7B, Mistral-7B, Gemma-2-9B, Phi-3-3.8B) preserved the positive direction of Sharedness Gain.

3.2 Mechanistic Evidence

Transplantation: The Shared interface achieved the highest composite score (0.87) on target correctness, locality, and copy preservation, significantly outperforming Local (0.70), Mixture (0.64), and Distributed (0.46).
Mediation: API-aligned paths mediated 0.749 of the target effect, compared to 0.150 for matched null paths.
Selectivity: The causal graph was sparse (sparsity $\approx 0.79$ ) with high cross-seed stability (Jaccard overlap 0.83). Only 7 of 64 dimensions survived BH-FDR correction, indicating selective necessity.

3.3 Model Organism Falsification

In a blind test on 16 synthetic organisms (4 per architecture class):

Recovery: 14/16 architectures were correctly identified.
False-Positive Rate: Among 12 non-Shared organisms, 1 was misclassified as Shared (8.3% false-Shared rate). This prevents claims of perfect identifiability but supports the method's ability to reject the "always Shared" hypothesis.

4. Claims and Significance

The paper claims to demonstrate an economical reusable causal interface within the tested operation banks for the evaluated models.

Nature of the Claim: The claim is explicitly comparative and conditional. It asserts that, for a preregistered family of future operations, the model exposes a compact state that multiple downstream computations can reuse more efficiently than operation-specific or distributed alternatives.
Scope Limitations: The authors explicitly state that this does not identify a unique global workspace for all LM computation. The results are conditional on the candidate architectures, interventions, and held-out futures. The interface is shown to be reusable within aligned causal families but exhibits weaker transfer across distinct task families (e.g., relation-world to program-state).
Mechanistic Insight: The results support the hypothesis that LMs utilize a "Shared" bottleneck for specific causal roles, evidenced by shorter description lengths, successful transplantation with high locality, and mediation through sparse, stable paths.

The paper concludes that the "Shared" architecture is the best tested abstraction under the declared alternatives, providing a falsifiable framework for discovering hidden APIs without relying on researcher-specified latent labels.