Skip to content

Back to the catalog

Causal Chain of Thought: Mitigating Attention Leakage via Context Isolation
arxiv.orgpaper

Causal Chain of Thought: Mitigating Attention Leakage via Context Isolation

CausalCoT is an inference framework that splits a problem into a directed acyclic graph of atomic sub-questions and evaluates each node in an isolated context holding only its direct causal parents. This removes attention paths to non-parent content, so intermediate steps drive the answer rather than leaking from global context. It keeps benchmark accuracy competitive and raises causal sensitivity of reasoning steps by 12 points on average, up to 21, over the strongest baseline. The graph also allows test-time corrections that propagate downstream.

TL;DR Proposes CausalCoT, which evaluates DAG sub-questions in isolated parent-only contexts to make chain-of-thought steps causally faithful.
Document

What it claims

CausalCoT is an inference-only procedure from authors at Università della Svizzera Italiana, ETH Zurich and Oxford (arXiv, October 2026). It replaces a single chain-of-thought stream with a planned graph of sub-questions, each answered in a separate prompt. The authors also propose a new faithfulness metric, Predictable Change. It asks whether downstream predictions shift in the way an injected error logically implies, rather than counting raw answer flips. The paper uses "causal" to mean strict procedural dependence on prior steps, not formal causal inference or structural causal models (Appendix D).

How it works

The method rests on one claim about leakage: it is transitive. A token's hidden state has already absorbed earlier context, so attending to any prior step carries the whole history forward. Shared-context decomposition methods are therefore not enough, so isolation has to happen at the prompt level.

  1. Graph generation. The same LLM acts only as a planner. It writes atomic sub-questions and directed edges marking which answers each question needs. It executes nothing at this stage.
  2. Isolated evaluation. Nodes run in topological order, each in a fresh context. Root nodes see the original input X plus their sub-question. Every other node sees only its sub-question and its direct parents' answers. It does not see X, siblings or parallel branches.
flowchart TD
    X[Original input X] --> P[Planner: build DAG]
    X --> R1[Root node 1]
    X --> R2[Root node 2]
    P --> R1
    P --> R2
    R1 --> I[Internal node: parent answers only]
    R2 --> I
    I --> Y[Final answer]
    X -. blocked .-> I

After an edit, only descendants of the edited node are recomputed. Experts can edit the plan before execution by adding or removing sub-questions, changing edges or changing context. They can also overwrite a node's answer and propagate it. The authors frame this as equivalent to Pearl's do-operator, valid under the same fixed graph.

Evidence

The fetched text ends before the results section. It carries only the abstract's figures: competitive accuracy, described as on par with standard CoT or "only marginal drops", and causal sensitivity up 12 points on average and up to 21 over the strongest baseline. Faithfulness is measured by intermediate-step perturbation (modifying, truncating or corrupting steps), following Lanham et al. (2023).

Limits

The fetched text does not name the benchmarks, the "multiple frontier models" tested, per-benchmark accuracy deltas, or the number of LLM calls per question. The method needs one call for planning plus one per node, but the page states no cost figure. Because non-root nodes never see X, any input detail the planner omits from root sub-questions is lost downstream. The authors state that the method constrains the inference procedure and does not expose the model's internal computation. Its counterfactual guarantees hold only for the generated graph. No code or install instructions appear in the fetched text.

Organisations named here

  • arXiv

Technologies named here

  • CausalCoT
  • LLM
  • Transformer

Techniques named here

  • CausalCoT
  • Chain-of-Thought Prompting