acceptodds
Under review as a conference paper at ICLR 2027

Learning Verifiable Input Attribution in Language Models

Abstract

Language-model agents make decisions from context they did not write, such as retrieved passages, tool outputs and injected instructions. Input attribution estimates how much each input influenced a decision, which supports context management and helps audit actions steered by untrusted text. We define an input's influence counterfactually, as the change in the model's likelihood of its decision when that input is masked, that is, removed from the context. Leave-one-out (LOO) computes this exactly but needs one model call per input, while simply asking the model takes only a single call but is often unfaithful. We introduce the Decision Faithfulness Suite (DFS), which spans four decision tasks and labels every input with its exact LOO influence. Across the Qwen models and scales we test, prompted models find the inputs that support a decision better than they rank their influence, a pattern we call the support-influence gap. We propose Counterfactual Influence Distillation (CID), which trains the model with verifiable rewards to rank its inputs by influence and then measures only the top few exactly by masking them. We find that (i) CID is more faithful than the popular ContextCite on every task for both Qwen3.5-9B and Gemma-4-12B, with at least ten times fewer calls, (ii) prompted models also surpass ContextCite with enough masks, but training helps most when masks are scarce, and (iii) on controlled reasoning, a small trained model ranks influence better than prompted models eight times its size.

Primary area:
interpretability and explainable AI
Keywords:
input attribution, interpretability, counterfactual explanations, large language models, verifiable learning.

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_L6QrOpenReview ↗
Rating
2
Confidence
4
Informativeness
1
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes Counterfactual Influence Distillation (CID), a method that uses LoRA adapters trained with GRPO to predict input attribution scores that reflect the importance of different input elements to an LLM's outputs. The authors propose using pre-computed labels derived from costly leave-one-out estimation (LOO, requiring one model call per label) as targets for reinforcement learning from verifiable rewards. At inference, CID masks top-ranked inputs and replaces their scores with measured LOO values, finally rescaling all remaining scores.

CID is evaluated using correlation between scores predicted by the learned model and LOO over all inputs, and compared with ContextCite and SelfCite for Qwen3.5-9B and Gemma-4-12B. The authors show that 1) with a little number of masks, CID outperforms ContextCite-64 on every tested task; and 2) training helps most when few masks are used, and it adds little for Gemma-4-12B.

Critical strengths
  • The paper controls well for possible confounds by applying the same verification step to prompted, random, lexical and CID rankings, making differences between methods depend only on the set of masked inputs selected by each method. The authors report that the verified prompted report already beats ContextCite-64 within four masks, so most of the fidelity gains can be associated with the masking itself rather than training. Even against this stricter reference, CID outperforms other methods with two masks on all tasks for Qwen3.5-9B, suggesting that ad-hoc training can further improve the identification of salient inputs.
Critical weaknesses
  • Most of the reported gain comes from verification rather than the added training procedure, and the ContextCite comparison does not show a meaningful efficiency gain. DFS contexts have at most 23 inputs, so ContextCite-64 costs more than exact LOO for each task, and the statement "ten times fewer calls than ContextCite" is misleading at this scale. On DFS-R and DFS-A (the tasks where masking saves calls over exact LOO), CID beats the prompted report by a very small margin. The current evidence seem to support a modest benefit of training at small budgets, but is not sufficient to justify the broader claim that CID makes faithful attribution cheap enough to enable its use at each step of agentic execution.

  • As pointed out in the limitations of Appendix G, fidelity scores may not reflect the decision the agent actually makes, since the labels are computed on a different prompt from the one the model uses to decide its answer (without the chat template, as shown in Appendix H), and on that prompt the model rarely gives its own answer. When the model writes its report, it also sometimes gives a different answer from the one being explained (authors report that this happens about half the time for the prompted model on DFS-R and DFS-A). CID’s advantage may therefore come from giving the expected answer more often rather than simply ranking inputs better.

Questions for authors
  • What is the fidelity of the prompted and CID reports on the examples where both reports’ decisions match the gold one? This would help me understand how much of CID’s gain over the prompted report comes from better ranking rather than simply preserving the original decision.
1 comment
AuthorsOpenReview ↗

Author's response to Reviewer L6Qr

Thank you for your feedback. We answer both questions with new controls.

W1 — Most of the gain comes from verification; the efficiency claim.

  • Verification is half of CID by design; learning decides where it measures. section 5.2 states that most of the fidelity at four or more masks comes from masking itself, and the abstract will say so. Verification makes any report exact on the inputs it masks; learning decides which inputs those are, and therefore how many masks a target fidelity costs. That matters most when masks are scarce, which is when attribution is cheap enough to run at every step. With intervals, CID minus the prompted report at B=0B = 0 and 1 is +0.164 and +0.125 on Qwen DFS-0, and +0.197 and +0.149 on DFS-1. On the real-text tasks the gain is smaller but significant at B≤2B \le 2 (DFS-R +0.032 [0.018, 0.045] and DFS-A +0.024 [0.007, 0.043] at B=2B = 2). Trained Qwen reaches CC-64's fidelity with fewer masks than the prompted report (point estimates): 0 vs 2 on DFS-1, 1 vs 2 on DFS-R. The gain reproduces on a freshly generated DFS-0 split never used in development, with matched configurations and two seeds: +0.157 [0.131, 0.184] at B=0B = 0 and +0.067 [0.047, 0.086] at B=2B = 2 for the Rank reward, against +0.065 and +0.014 for SFT on the same data (our response to Pyj9, part 3).

  • Efficiency. The call comparison against CC-64 is accurate, and with ≤23\le 23 inputs exact LOO is the tighter reference. The saving holds against it too, in tokens:

    • on DFS-R and DFS-A, CID with 2 masks processes 9,972 and 10,571 tokens per decision against 49,197 and 59,635 for exact LOO, 4.9–5.6$\times$ fewer, and 3.4–3.8$\times$ fewer with 4 masks;
    • on DFS-0 and DFS-1, with 5–7 inputs, the saving over LOO is at most 1.5$\times$.

    The saving grows with the number of inputs: at 100 paragraphs, exact LOO needs 101 scoring calls and CID with four masks one generation and 5. The revised abstract states the saving against both references.

W2 / Q — Does CID win by keeping the expected answer? This is the right control, and we computed it. On the examples where both the prompted and the CID report give the labeled decision y⋆y^\star, CID minus prompted is:

Qwen3.5-9B, both keep y⋆y^\starnnB=0B = 0B=2B = 2
DFS-0427+0.170 [0.148, 0.192]+0.080 [0.064, 0.097]
DFS-1229+0.188 [0.158, 0.216]+0.059 [0.033, 0.085]
DFS-R124+0.025 [−0.000, 0.051]+0.021 [0.006, 0.040]
DFS-A123+0.066 [0.034, 0.099]+0.016 [−0.007, 0.038]

The gain persists, at about the same size as on all examples (+0.164 / +0.075, +0.197 / +0.058, +0.029 / +0.032, +0.075 / +0.024). It holds when both answers match the gold answer too: +0.159 and +0.184 at B=0B = 0 on DFS-0 and DFS-1. So CID's advantage comes from better ranking, not from preserving the decision. For Gemma on the paper's labels, the gain on DFS-1 persists on its 278 decision-matched examples (+0.026 [0.011, 0.041] at B=2B = 2), while the Gemma DFS-R and DFS-A subsets are small (37 and 86 examples) and not significant.

The direct test: both reports must give y⋆y^\star. We evaluated decision-conditioned reports, whose answer field is fixed to y⋆y^\star, so that report, verification and labels explain the same decision. With the decision held equal by construction, CID still beats the identically conditioned prompted report at B=0B = 0 on every Qwen task. With the chat template used throughout, the margins are +0.171 [0.148, 0.195], +0.113 [0.082, 0.143], +0.044 [0.025, 0.063] and +0.097 [0.073, 0.120] on DFS-0/1/R/A; under the paper's labels they are +0.193, +0.203, +0.029 and +0.089, all significant. Without any masks, conditioned CID also exceeds CC-64 on DFS-1, DFS-R and DFS-A under the chat template, and on DFS-0 and DFS-1 under the paper's labels (0.698 vs 0.667; 0.668 vs 0.595).

The scoring prompt. For Qwen3.5-9B we now evaluate the deployed tuple end to end under the chat template in which the decision is generated: labels, verification, and CC-64 rerun under the same prompt. CID never trained on these labels, which differ from the stored ones (ρ\rho = 0.38–0.64), yet every conclusion holds:

  • CID beats the prompted report without masks on every task, by +0.06 to +0.18 when each explains its own decision;
  • conditioned on y⋆y^\star, CID beats CC-64 without masks on three of four tasks, and with 3 masks on DFS-0.

Details are in our response to Pyj9, part 2.

The decision-matched controls show that CID's advantage comes from better ranking, not from keeping the answer, and the token counts show that the saving holds against exact LOO. We would be grateful if you would reconsider your score.

Reviewer_gyjBOpenReview ↗
Rating
3(+1)
Confidence
2(−1)
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

The paper creates a dataset, DFS, that spans 4 different LLM tasks and computes the exact LOO feature influence for each input. The paper proposes training LLMs to predict feature influence more efficiently using CID, a training and inference framework where we first prompt the LLM to predict feature influence scores, then we compute the exact LOO for the top-ranking features, and finally we rescale the influence of the rest of the features. In experiments, CID produces more faithful feature ranking than two existing methods, SelfCite and ContextCite, while requiring significantly fewer exact LOO computations during inference (2-4 versus 64). Prompting an untrained model directly, however, can also perform faithful feature ranking when we allow 4-8 exact LOO computations during inference. Finally, training small models with CID makes them more faithful than untrained big models 8 times the size.

Critical strengths
  1. The authors propose a simple input attribution method to improve both inference efficiency and fidelity compared to two commonly used LLM input attribution methods.
  2. Experiments on diverse tasks demonstrate both the strength of CID and the main sources of this strength (the prompted model), while also showing the limitations of CID in helping with downstream tasks, specifically in monitoring injected instructions.
Critical weaknesses
  1. The CID framework is grounded in the empirical evidence that LLMs often rank their features well, better than predicting the exact influence score. However, this is not a guarantee, so CID would be sensitive to the choices of LLM and task, specifically whether that LLM also ranks features well for that task.
  2. The fidelity metric used is the signed rank, which only evaluates feature ranking, not the exact influence scores. This metric may artificially inflate the performance of the untrained prompted model and CID-trained model evaluated in this paper, as the base model has already shown empirical evidence of being good at ranking features.
Questions for authors
  1. Could the authors justify why they chose the signed rank as the fidelity metric? Could the main experiments be recomputed with a different fidelity metric that measures not only feature ranking but also exact influence scores? Do the main findings in the paper stay the same with a different fidelity metric?
  2. Could the authors provide one experiment where a CID-trained model on one task produces a high-fidelity explanation for a different task at the same small budget? This experiment would be important to establish the efficiency of the CID framework, as constructing a new training dataset, where all exact LOO influences are computed, for each new task is not efficient.
  3. There are two attribution methods mentioned in the Related Work section but not in the experiments: AttriBoT and AT2. Could the authors explain why they are not included in the experiments, or provide empirical comparisons between them and CID?
  4. Could the authors elaborate on why the reward function in Equation (3) is in that specific format? While each component of the reward was described, there isn’t a clear intuitive interpretation for the specific formula in Equation (3).
  5. In Figure 4, could the authors explain why certain experiments are not run, or could the authors update the experiments with a complete table of results? Do the main findings in the paper stay the same when all experiment results are included?
  6. In Line 374, could the authors explain further what the statement “the report decides how many masks a given fidelity costs” means? How can we determine the number of masks given a fixed fidelity cost?
3 comments
AuthorsOpenReview ↗

Author's response to Reviewer gyjB (1)

Thank you for the concrete questions.

W1 — Does CID depend on the model ranking well? Verification makes the masked inputs exact regardless of the ranking, so a poor ranking costs extra masks, not correctness. Fig. 5 runs random and lexical rankings through the same verification, and every ranking converges to exact LOO as BB grows. The model-dependence you anticipate is visible in our results:

  • Gemma's prompted report ranks poorly (ρ\rho = 0.17 on DFS-0);
  • training helps Gemma little on the paper's labels, and on its deployed decisions the adapters rank below the prompted report on DFS-0 and DFS-1 (general response, part 1/3). Gemma's stored labels barely agree with its chat-template labels, so we are retraining its DFS-1 adapter on chat-template labels and will report the result in this thread and in the revision;
  • its verified reports still exceed CC-64 within 2–3 masks.

CID makes the ranking measurable per model and trainable where it is weak.

W2 / Q1 — Why the signed rank, and do the findings hold under value metrics? We chose the signed rank for three reasons:

  • the two uses of a report, choosing which inputs to mask and which to keep in compaction, consume only its order;
  • it is scale-free across tasks whose mean absolute effect per input ranges from 0.8 to 9.2 nats;
  • exact LOO scores 1.

To test value sensitivity, we recomputed Table 1 with three further metrics: Kendall τ\tau (rank), Pearson rr (linear in values) and mean absolute error in nats. CC-64's coefficients are log-odds, so we also report its MAE after the best global rescaling, which is fit on the test labels and therefore favors CC-64.

Qwen3.5-9BDFS-0DFS-1DFS-RDFS-A
Kendall τ\tau: CC-64 / CID B=2B=20.553 / 0.5810.488 / 0.6670.232 / 0.3750.244 / 0.321
MAE: CC-64 rescaled / CID B=2B=20.446 / 0.1371.057 / 0.2740.492 / 0.2860.594 / 0.400
Pearson rr: CC-64 / CID B=2B=2 / B=4B=40.862 / 0.831 / 0.8680.863 / 0.877 / 0.9540.852 / 0.826 / 0.8720.844 / 0.726 / 0.782
Gemma-4-12BDFS-0DFS-1DFS-RDFS-A
Kendall τ\tau: CC-64 / CID B=2B=20.260 / 0.3480.478 / 0.5460.164 / 0.2970.160 / 0.276
MAE: CC-64 rescaled / CID B=2B=22.523 / 1.6116.146 / 3.7492.412 / 1.8482.366 / 1.820
Pearson rr: CC-64 / CID B=2B=2 / B=4B=40.421 / 0.497 / 0.6880.682 / 0.710 / 0.8930.663 / 0.663 / 0.7420.680 / 0.628 / 0.680
  • Under the rank metric (Kendall τ\tau) and the value metric (MAE), CID with two masks beats CC-64 on all eight model–task pairs. For MAE the reason is that verification writes the measured effects into the masked inputs.
  • Pearson rr is dominated by the few largest effects, which CC-64's regression fits well. CC-64 stays ahead until 4 masks on Qwen DFS-0 and DFS-R (it ties Gemma DFS-R at 2), and until 8 on DFS-A (Qwen 0.856 vs 0.844; Gemma 0.749 vs 0.680). This matches Table 4, where CC-64 is stronger in detection on real text.
  • The main finding therefore holds for ranking all inputs and for value error. For the few largest effects on real text, CC-64's regression stays competitive at small budgets and CID overtakes it with 4–8 masks, which the revision states next to Table 4. Kendall τ\tau is slightly more favorable to CID than ρ\rho: on Qwen DFS-0, CID with 2 masks is below CC-64 in ρ\rho (0.655 vs 0.667) but above it in τ\tau.
AuthorsOpenReview ↗

Author's response to Reviewer gyjB (2)

Q2 — Transfer to a task the model was not trained on. We evaluated every Qwen adapter on every task. Entries are ρ\rho at B=0B = 0, with B=2B = 2 in parentheses; the diagonal is in-task.

adapter ↓\downarrow / task →\toDFS-0DFS-1DFS-RDFS-A
none (prompted)0.485 (0.579)0.460 (0.680)0.234 (0.413)0.149 (0.359)
trained on DFS-00.649 (0.655)0.424 (0.656)0.234 (0.419)0.100 (0.313)
trained on DFS-10.441 (0.588)0.657 (0.738)0.234 (0.410)0.159 (0.346)
trained on DFS-R0.485 (0.603)0.476 (0.694)0.263 (0.445)0.217 (0.376)
trained on DFS-A0.507 (0.599)0.462 (0.698)0.256 (0.441)0.224 (0.383)
  • Between the two real-text tasks, learning transfers in both directions. The DFS-R adapter never saw injected instructions. On DFS-A it is still +0.068 [0.039, 0.096] above the prompted report at B=0B = 0, close to the in-task adapter (DFS-R's Rank+keep adapter: +0.071). The DFS-A adapter on DFS-R is +0.028 [0.015, 0.041] at B=2B = 2, also close to in-task.
  • Across input types, an adapter needs training on that type. Adapters trained on the generated tasks (reasoning, tool calls) transfer neither to each other nor to real text. Without masks they match the prompted report or fall below it (DFS-1 →\to DFS-0: −0.044 [−0.064, −0.024]; DFS-0 →\to DFS-A: −0.049 [−0.077, −0.020]). Real-text adapters add at most +0.022 on the generated tasks.
  • Verification absorbs a mismatched ranking. With four masks, every off-task adapter is within 0.025 of the prompted report on every task.

A deployment therefore trains one adapter per input type, a one-time cost of 5.5–35 GPU-hours, and with masks, verification absorbs a mismatched adapter.

Q3 — AttriBoT and AT2.

  • AttriBoT approximates exact LOO, the quantity our labels compute.
    • At n≤23n \le 23 its exact mode is exact LOO, which Table 1 includes, with cost (n+1)(n+1) calls.
    • Its KV caching is exact and accelerates CID's B+1B+1 scoring calls equally.
    • We now evaluate its proxy-model approximation, with Qwen3.5-0.8B/2B/4B scoring the 9B decision. It stays below CC-64 on every task, and below CID at B=2B = 2 on every task, at over twice CID's compute (table in our response to Pyj9, part 4).
  • AT2 learns a weighting of attention-head scores from ablations. In Qwen3.5-9B, 24 of the 32 layers use linear attention, which produces no attention weights, so AT2 cannot be applied as designed. We ran AT2 on Gemma-4-12B, which has standard attention, on all four tasks under CC-64's protocol (general response, part 2/3). AT2 alone stays below CC-64 on every task; as the ranking that guides verification it needs as many masks as CID, and on the real-text tasks CID's report is the better guide.

Q4 — Why Eq. 3 is a product. Each factor addresses a way an additive reward can be gamed:

  • V(z)V(z) gives zero reward to malformed reports, so format errors are never traded against fidelity.
  • Fver(a~)F_{\text{ver}}(\tilde a) is the quality of the verified report, the object that is deployed. Multiplying by it makes the other terms count only in proportion to verified quality. With a sum, a policy could keep the answer and earn the retention term while ignoring attribution.
  • (1+λRtail)/(1+λ)(1 + \lambda R_{\text{tail}})/(1 + \lambda) lies in [1/(1+λ),1][1/(1+\lambda), 1] (λ=0.35\lambda = 0.35). It is a bonus of at most 26% for ordering the unmasked inputs, which the cap may tie but a larger budget masks next.
  • (1−η+ηKeq)(1 - \eta + \eta K_{\text{eq}}) with η=0.25\eta = 0.25 keeps three quarters of the reward when the decision changes. A zero factor would leave the group without gradient whenever every sample changes the answer, because GRPO normalizes rewards within the group.

Q5 — Missing cells in Fig. 4. The hatched cells were never run:

  • Rank on DFS-1 and DFS-A;
  • Rank+keep on DFS-0.

The ladder was built in order. Rank alone kept the answer on DFS-0. On DFS-R it collapsed accuracy from 0.348 to 0.040, so every later task used Rank+keep and Composed instead. Each real-text run costs 33–35 GPU-hours. To compare recipes cleanly, we now train Rank, Verified, Composed and SFT on DFS-0 with identical settings:

  • LoRA r=16r = 16, KL 0.02, 1,200 updates;
  • the same output cap;
  • two seeds each;
  • SFT with its loss on the report only.

We evaluate them on a fresh DFS-0 split that was never used during development; the full table is in our response to Pyj9 (part 3).

  • Every RL reward beats the prompted report with 0 and 2 masks, and beats SFT: Rank minus SFT is +0.092 [0.068, 0.116] at B=0B = 0. SFT loses 4.4 points of accuracy; RL keeps it.
  • On DFS-0, Rank alone matches Composed at B=2B = 2 (−0.004 [−0.010, 0.002]), so stopping the ladder at Rank there was sound. On DFS-R, Rank alone collapsed accuracy, which is what the composed reward fixes.
AuthorsOpenReview ↗

Author's response to Reviewer gyjB (3)

Q6 — "The report decides how many masks a given fidelity costs." All rankings pass through the same verification, so the ranking determines how many masks are needed to reach a given fidelity. Masks needed to reach CC-64's ρ\rho (point estimates; the paired-interval B⋆B^\star is in Table 1):

Qwen3.5-9BrandomlexicalpromptedCID
DFS-1 (CC-64 ρ\rho = 0.595)3320
DFS-R (CC-64 ρ\rho = 0.313)4321
DFS-A (CC-64 ρ\rho = 0.328)6322

The same holds for higher targets. On DFS-R, reaching ρ\rho = 0.5 takes 8 masks with random or lexical rankings, 4 with the prompted report and 3 with CID. We will rephrase the sentence accordingly.

We hope the new metrics, the transfer results and the matched ablation answer your questions, and we would be grateful if you would reconsider your score.

Reviewer_Pyj9OpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
1
Read review
Paper summary

The paper introduces the Decision Faithfulness Suite (DFS), which labels contextual inputs with model-specific leave-one-out effects on a fixed answer's log-likelihood. Counterfactual Influence Distillation (CID) trains a reporting model to rank inputs, measures its highest-ranked inputs under a masking budget, and rescales the remaining scores. Experiments cover controlled reasoning, single tool calls, retrieved paragraphs, and injected instructions. CID exceeds 64-mask ContextCite in rank correlation with at most four masks across model/task combinations; prompted verification also captures much of this improvement (Secs. 3–5; Table 1, p. 7).

Critical strengths
  1. A concrete, reproducible attribution target. Equation 1 defines influence through an observable intervention on the scored answer. DFS supplies model-specific labels, and Appendix B documents input construction, splits, and a relabeling check rather than treating human support annotations as model influence (pp. 3, 14–15).

  2. Useful separation of ranking and measurement. Table 1 and Figure 5 apply the same verification procedure to trained, prompted, random, and lexical rankings. This exposes where training helps and where direct masking supplies most fidelity, including cases where prompted verification is competitive (pp. 7–8).

  3. Informative failure analysis. The paper distinguishes fidelity from answer correctness and attack resistance, reports compaction and monitoring outcomes, and gives worked examples where a faithful report explains an incorrect answer. These observations clarify what the measured attribution can and cannot support (Sec. 5.4; Appendix F, pp. 19–20).

Critical weaknesses
  1. The evaluated attribution target differs from the proposed deployed use. Equation 1 measures Δ_i(M0, p_raw, y*), while y* was generated with a chat template; deployment substitutes the reporting model's answer ŷ. Appendix G reports ŷ ≠ y* on 8–36% of CID's Qwen test examples and explicitly says that the deployed substitution is untested (p. 20). Shared stored labels make benchmark comparisons consistent but do not validate attribution for this changed answer/prompt tuple. Algorithm 1 deliberately retains M0 as verifier, so the result also needs to be distinguished from attribution of the reporting model's own computation (p. 16). This is a central limitation on the claim that the method explains an agent's actual decisions.

  2. The verification cap can destroy the remaining ranking. Equation 2 sets the cap to zero whenever a selected input has nonpositive influence, forcing all unmasked scores to tie at zero. Those inputs can then rank above a measured negative effect even when their true effects are more negative. This is particularly relevant to a signed-rank evaluation: 33% of Gemma-4-12B's DFS-0 inputs have effects at most −0.5 (Appendix B, p. 15). Appendix G acknowledges the heuristic, but the paper does not establish when it preserves useful ordering or quantify the loss when it collapses that ordering. Its behavior on suppressive inputs needs direct analysis (Eq. 2, p. 5; Appendix G, p. 20).

  3. The experiments do not cleanly identify the additional contribution of learning. At two masks, Qwen DFS-R improves from 0.413 to 0.445 and DFS-A from 0.359 to 0.383; Gemma DFS-R changes from 0.352 to 0.353. Qwen's tool-call gains are stronger, but verification accounts for much of the benefit elsewhere (Table 1). The reward comparison does not resolve this unevenness because LoRA rank, KL penalty, update count, and output cap vary with the recipe; SFT also trains on prompt tokens and uses different optimization settings (Fig. 4; Appendix D, p. 17). Appendix G records reward development using about 25 DFS-0 test evaluations. A fixed-configuration ablation evaluated on an unused split would better establish what the learning objective contributes. The headline should also distinguish rank fidelity from detection, which requires 6–12 masks to exceed ContextCite on the real-text tasks (Table 4).

  4. The efficiency claim lacks a comparison at equivalent computational workloads. Section 3.3 counts an autoregressive report like a scoring pass, although reports can contain several hundred tokens and ContextCite masks retain approximately half the input. Offline labeling/training and an additional generation when retaining y* are excluded (Appendix G, p. 21). Moreover, AttriBoT's efficient LOO approximation is discussed but not evaluated, and the SelfCite comparison uses untrained best-of-32 search rather than its trained citation model (Sec. 2; Table 2; Appendix D; Liu et al., 2025; Chuang et al., 2025). These omissions leave both the practical cost advantage and the position relative to close alternatives unresolved. Equivalent-target token/latency comparisons and training amortization would be more informative than call counts alone.

  5. The long-input result does not establish scalability to difficult evidence contexts. Table 5 pads short reasoning examples to 100 inputs using nearly uninfluential notices; the appendix explicitly acknowledges that this overstates the training benefit for real long contexts (pp. 18–19). Full score vectors fail to parse in 136/150 examples, and the successful alternative changes both output format and training objective. The comparison therefore mixes representational robustness with attribution quality and does not test many plausible or interacting evidence units. No direct evidence found in the manuscript. Template-sharing across DFS splits further limits extrapolation beyond the evaluated families (Appendix G, p. 20).

  6. The metric description and supplied code do not identify a single reproducible evaluator. Appendix D assigns constant predictions correlation zero and handles AP ties as blocks (p. 17). The supplied lia_bench/eval/metrics.py returns None for constant predictions and processes tied AP entries individually; labelers/oracle.py creates flip-inclusive support, whereas Appendix B restricts evaluation support to Δ_i ≥ 0.5 (p. 15). These choices matter for flat reports and tied verified scores, including the cap behavior above. The inspected paths do not establish which evaluator generated Tables 1 and 4. Resolving this provenance is necessary before interpreting small differences between methods.

Questions for authors
  1. What exact model/prompt/answer tuple is intended at deployment, and has fidelity been measured against fresh labels for that tuple? Results separated by agreement or disagreement between ŷ and y* would directly address the operational interpretation (Eq. 1; Algorithm 1; Appendix G).

  2. How frequently does the cap in Equation 2 become zero, and what happens to signed-rank fidelity in those cases? A comparison with an uncapped or signed alternative at the same verification budget would clarify whether the rescaling helps beyond the measured inputs (Appendix B, p. 15; Appendix G).

  3. Are matched-configuration results available that isolate the reward objective from adapter capacity, optimization duration, and output format? Which real-text gains over prompted verification remain under that comparison, particularly on a split unused during reward development (Table 1; Fig. 4; Appendices D and G)?

  4. Which exact evaluator and support-label construction produced Tables 1 and 4? Please reconcile constant predictions, AP ties, and flip-inclusive support with the manuscript definitions, and identify the path from saved predictions to the reported values (Appendices B and D; supplied evaluation code).

4 comments
AuthorsOpenReview ↗

Author's response to Reviewer Pyj9 (1)

Thank you for the thorough review we received, including inspecting the code. We take each point in turn.

W6 / Q4 — Which evaluator produced Tables 1 and 4. The tables were computed with the App. D rules. The supplied metrics.py is the benchmark library's evaluator and differs from App. D in three conventions, none of which changes a conclusion.

  • What produced the tables. Tables 1 and 4 come from scripts/paper_figures/table1_rho.py. It calls rho_fixed and ap_tie in fidelity_fixed.py:

    • a constant report scores ρ=0\rho = 0;
    • an example with constant Δ\Delta is skipped;
    • S⋆S^\star is recomputed from the labels as {i:Δi≥0.5}\{i : \Delta_i \ge 0.5\}, without flips;
    • each tied block is one AP threshold.

    These scripts were not in the supplement. The flip-inclusive support_set written by labelers/oracle.py is used only by the training reward, as App. C.1 states ("the training support adds to S⋆S^\star the inputs whose masking flips the decision").

  • How much the conventions matter. We recomputed every cell with the supplement's conventions.

    • ρ\rho, constant reports skipped instead of scored 0: every verified cell (B≥2B \ge 2) and CC-64 is identical to three decimals. The largest change is +0.020, on the unverified prompted DFS-A report of Qwen, where 29 of 250 reports are constant. No B⋆B^\star changes.
    • AP, flip-inclusive support and untied ranking: values change by up to 0.18. Exact LOO no longer scores 1 under this convention: at B=8B = 8 on Gemma DFS-0, where verification equals exact LOO on almost every example, AP is 0.876. The result also depends on input order, because verified reports tie most unmasked inputs. This convention would favor CID: on Qwen DFS-R, CC-64 falls from 0.810 to 0.766 and CID with 2 masks rises from 0.759 to 0.781. The App. D definition is therefore the stricter one for our method.
  • Fix. We will release the table scripts and saved predictions with a one-command reproduction, and change metrics.py to the App. D rules so that the library and the paper share one evaluator.

W2 / Q2 — The cap in Eq. 2. We measured how often the cap binds and replayed four alternatives at the same budget.

CID, B=2B = 2Qwen DFS-0DFS-1DFS-RDFS-AGemma DFS-0DFS-1DFS-RDFS-A
cap = 00.340.250.460.490.560.470.510.48
unmasked tied by the report itself0.580.060.790.740.330.210.720.66
ρ\rho, Eq. 2 (paper)0.6550.7380.4450.3830.3970.6180.3530.329
tie-break by report order+0.019+0.027−0.002−0.006−0.034−0.036−0.008−0.012
cap only if positive+0.017+0.018−0.002−0.005−0.035−0.020−0.009−0.012
no cap+0.014−0.008−0.002−0.006−0.034−0.012−0.010−0.013

The first two rows are fractions of examples; the alternative rows are changes in ρ\rho relative to Eq. 2.

  • Most ties are already in the reports, which give zero to most inputs. The cap therefore rarely destroys ordering the report actually expressed.
  • Keeping the report's order helps where suppressive inputs are rare: Qwen DFS-0 and DFS-1 gain +0.02–0.03, which is significant. It hurts where they are common: in Gemma, 30–35% of inputs have Δi≤−0.5\Delta_i \le -0.5, against 4–8% in Qwen. There the report's positive scores misorder suppressive inputs, and the cap discards that tail order exactly when a measured input is non-positive. The case you describe, an unmasked input placed above a measured negative one despite a more negative effect, occurs in 12–38% of examples at B=2B = 2. Correcting it with a negative cap ("signed cap") lowers ρ\rho on seven of eight settings, by up to 0.076, because most unmasked inputs are not more negative.
  • For CID at B=4B = 4, every alternative is within 0.01 of Eq. 2. For prompted reports the cap matters more: dropping it at B=4B = 4 lowers ρ\rho by up to 0.035 (Qwen DFS-A), so the cap protects weaker rankings. Recomputing B⋆B^\star under each alternative changes only Gemma DFS-0, from 2 to 3 masks. The headline "CID exceeds CC-64 within four masks on every task" holds for every variant.

We will add this table, describe the cap as a conservative rule, and offer the tie-break variant for models whose suppressive effects are rare.

AuthorsOpenReview ↗

Author's response to Reviewer Pyj9 (2)

W1 / Q1 — Which decision is attributed at deployment. CID can attribute the deployed decision in two ways, and we now evaluate both end to end.

  • (a) Decision-conditioned report. The agent decides with M0M_0 as usual, producing y⋆y^\star with the chat template. The adapter then writes the scores with the answer field fixed to y⋆y^\star, and verification scores y⋆y^\star under M0M_0 with the same chat template. Report, verification and labels then explain the same decision. The cost is the decision the agent makes anyway, plus the report. Explaining the computation of M0M_0, the deployed decision-maker, is the intended target: the adapter is an attribution head, not the policy.
  • (b) Report decides. MθM_\theta writes y^\hat y and the scores, and M0M_0 verifies y^\hat y. This is what Algorithm 1 describes; it is cheaper when the report also serves as the decision.

New evidence:

  • Decision agreement. y^=y⋆\hat y = y^\star for the prompted/CID reports of Qwen on 0.89/0.91 (DFS-0), 0.82/0.92 (DFS-1), 0.53/0.72 (DFS-R) and 0.51/0.64 (DFS-A).
  • Subset where both reports keep y⋆y^\star. On these examples, CID minus Base, with 95% intervals:
Qwen, both keep y⋆y^\starnnB=0B = 0B=2B = 2B=4B = 4
DFS-0427+0.170 [0.148, 0.192]+0.080 [0.064, 0.097]−0.026 [−0.041, −0.012]
DFS-1229+0.188 [0.158, 0.216]+0.059 [0.033, 0.085]+0.002 [−0.014, 0.019]
DFS-R124+0.025 [−0.000, 0.051]+0.021 [0.006, 0.040]+0.001 [−0.012, 0.013]
DFS-A123+0.066 [0.034, 0.099]+0.016 [−0.007, 0.038]+0.004 [−0.015, 0.021]

The deployed tuple, end to end. The chat template is M0M_0's native interface and the prompt in which it decides, so it is the right scoring prompt. App. G noted that our stored labels use a raw completion prompt instead, and that aligning them requires new labels. We have now built them for every Qwen task:

  • exact LOO under the chat template, for y⋆y^\star and for every decision a report wrote;
  • verification with these labels;
  • CC-64 (pinned official core) rerun under the same prompt.

This is a held-out test for CID. Its training reward used the stored prompt, and the new labels differ from the stored ones (ρ\rho = 0.38–0.64). Every conclusion holds:

Qwen, deployed tupleDFS-0DFS-1DFS-RDFS-A
CC-64, chat template0.6950.5540.3250.305
mode (a), answer fixed to y⋆y^\star, B=0B = 0: prompted / CID0.473 / 0.6450.504 / 0.6170.329 / 0.3740.242 / 0.339
mode (a), CID, B=2B = 20.7030.7110.4560.411
mode (a), masks to beat CC-64 (B⋆B^\star): prompted / CID3 / 32 / 01 / 02 / 0
mode (b), own decision, B=0B = 0: prompted / CID0.518 / 0.6970.484 / 0.5970.312 / 0.3690.221 / 0.312

Bold marks a significant lead over the prompted report (B=0B = 0 rows) or over CC-64 (B=2B = 2 row).

  • Learning pays without masks. In both modes CID beats the prompted report on every task without masks: by +0.04 to +0.17 when both explain y⋆y^\star (mode a; +0.03 to +0.17 on the examples where both reports parse), and by +0.06 to +0.18 when each explains its own decision (mode b). All of these are significant.

  • Conditioned on y⋆y^\star, CID needs no masks to beat CC-64 on DFS-1, DFS-R and DFS-A (+0.063 [0.018, 0.111], +0.049 [0.017, 0.080], +0.034 [0.004, 0.066]), and 3 on DFS-0. The prompted report needs 1–3 masks on every task, and Table 1 (stored labels, report decides) gave CID 4/0/2/2.

  • Conditioning on the decision helps. Fixing the answer to y⋆y^\star raises CID's fidelity without masks on every task (0.589 →\to 0.645, 0.603 →\to 0.617, 0.330 →\to 0.374, 0.281 →\to 0.339), with parse failures at or below 1.2%. We therefore recommend mode (a) for deployment.

The revision makes the deployed tuple the primary evaluation in Table 1 and keeps the stored labels in the appendix.

AuthorsOpenReview ↗

Author's response to Reviewer Pyj9 (3)

W3 / Q3 — What learning adds. CID minus the prompted report, at equal masks, with 95% intervals (significant in bold):

B=0B = 0B=1B = 1B=2B = 2B=4B = 4
Qwen DFS-0+0.164+0.125+0.075−0.033
Qwen DFS-1+0.197+0.149+0.058+0.013
Qwen DFS-R+0.029+0.037+0.032+0.010
Qwen DFS-A+0.075+0.066+0.024+0.006
Gemma DFS-0−0.004−0.008+0.007+0.011
Gemma DFS-1+0.027+0.042+0.023+0.025
Gemma DFS-R+0.009+0.007+0.001+0.003
Gemma DFS-A+0.022+0.023+0.025+0.013

The gains you cite on Qwen DFS-R and DFS-A are significant (+0.032 [0.018, 0.045] and +0.024 [0.007, 0.043] at B=2B = 2), and under the deployed tuple they reach +0.044 and +0.097 without masks (part 2). On Gemma DFS-R training adds nothing, as §5.2 reports.

Matched-configuration ablation on an unused split. We generated a fresh DFS-0 test split of 500 examples, with test-split generator seeds disjoint from every existing split and no content overlap. Rank, Verified, Composed and SFT now share the same configuration:

  • LoRA r=16r = 16, KL 0.02, 1,200 updates;
  • the same prompt and output cap;
  • two seeds each.

SFT now computes its loss on the report only, not the prompt. On the fresh split (n=500n = 500):

DFS-0, fresh splitaccuracyB=0B = 0B=2B = 2B=4B = 4
prompted report, ρ\rho0.9080.4570.5930.749
SFT, gain over prompted0.864+0.065+0.014−0.022
RL, Rank0.911+0.157+0.067−0.014
RL, Verified0.913+0.127+0.053−0.013
RL, Composed0.907+0.140+0.063−0.009

Rows after the first are gains in ρ\rho over the prompted report; bold gains have 95% intervals excluding zero.

  • Learning pays on unseen data. Every RL reward beats the prompted report with 0 and 2 masks; Rank gains +0.157 [0.131, 0.184] and +0.067 [0.047, 0.086], matching the paper's DFS-0 row above (+0.164, +0.075).
  • RL beats SFT at equal configuration: Rank minus SFT is +0.092 [0.068, 0.116] at B=0B = 0 and +0.053 [0.035, 0.071] at B=2B = 2, and Verified and Composed also beat SFT at both budgets (the smallest margin is Verified's +0.039 [0.022, 0.056] at B=2B = 2). SFT gains only without masks and costs 4.4 points of accuracy; the RL rewards keep it (0.907–0.913).
  • With 4 masks all recipes converge (within 0.03 of the prompted report), as expected once verification measures the influential inputs.
  • On DFS-0 the Rank reward alone matches Composed (B=2B = 2: −0.004 [−0.010, 0.002]). The composed reward is needed on DFS-R, where Rank alone collapsed accuracy (Fig. 4).

Headline: fidelity versus detection. The headline is a rank-fidelity claim, which Table 1 measures, and it holds as stated. To rule out a misreading, the abstract will name the metric and add detection (Table 4): CID exceeds CC-64 in rank fidelity within four masks, and in detection within 2–3 masks on DFS-0/1 and 6–12 on the real-text tasks.

W4 — Cost at equal workloads. Tokens processed per decision for Qwen; Gemma's counts are within 8%. A report generation counts its prompt and its decoded report, and a masked context omits the masked input.

Tokens per decisionDFS-0DFS-1DFS-RDFS-A
inputs nn7.45.220.023.0
exact LOO, (n+1)(n+1) scoring calls1,3041,06749,19759,635
CC-647,0558,64780,09184,351
CID, B=2B = 2 (1 generation + 3 scoring calls)8478909,97210,571
CID, B=4B = 41,1511,22414,64715,532
decoded report tokens10290231264
  • Tokens. With 2 masks CID needs 4.9–5.6$\times$ fewer tokens than exact LOO and 8$\times$ fewer than CC-64 on the 20–23-input tasks. On DFS-0 and DFS-1 it costs about as much as LOO: 1.2–1.5$\times$ fewer tokens at B=2B = 2, and between 10% fewer and 15% more at B=4B = 4.
  • Latency. CID's scoring calls batch exactly like LOO's; its added latency is decoding the report, 230–260 tokens for a full score vector. The top-five list format (Table 5) decodes tens of tokens and matches the full vector's fidelity on real text (0.444 vs 0.448 with 2 masks on 150 DFS-R questions; follow-up comment).
  • Training cost. Training is a one-time 5.5–6.9 GPU-hours on DFS-0 and DFS-1 and 33–35 GPU-hours on DFS-R and DFS-A, on a single RTX PRO 6000 GPU. At the measured scoring throughput (about 5.7k tokens/s per card on DFS-R), it is recovered after roughly 10k decisions relative to CC-64 and 17k relative to exact LOO. Prompted verification needs no training and already exceeds CC-64 within 2–4 masks.

We will report these counts and the amortization instead of call counts alone.

AuthorsOpenReview ↗

Author's response to Reviewer Pyj9 (4)

W4 — AttriBoT and SelfCite.

  • AttriBoT (Liu et al., 2025) approximates exact LOO in three ways:

    • KV-cache reuse is exact and speeds up every scoring call equally, including CID's B+1B+1 calls, so it is complementary;
    • hierarchical attribution prunes groups of inputs, which our input-level budget already does with the report's ranking;
    • smaller proxy models score the target model's decision.

    We evaluate the proxy variant: Qwen3.5-0.8B, 2B and 4B compute LOO of the stored Qwen3.5-9B decision on the same prompt, and the result is scored against the 9B labels, alone and as the ranking that guides verification.

Qwen3.5-9B, ρ\rhoDFS-0DFS-1DFS-RDFS-A
CC-640.6670.5950.3130.328
proxy LOO: 0.8B / 2B / 4B0.392 / 0.466 / 0.5530.451 / 0.458 / 0.5480.170 / 0.167 / 0.2740.151 / 0.184 / 0.289
CID, B=0B = 00.6490.6570.2630.224
4B proxy + 2 masks0.5580.6580.3560.347
CID, B=2B = 20.6550.7380.4450.383
  • No proxy exceeds CC-64 on any task. Without masks, the 4B proxy matches CID on DFS-R and beats it on DFS-A (+0.065 [0.025, 0.106]), but trails it on DFS-0 and DFS-1.
  • As the ranking that guides verification, every proxy is below CID at B=2B = 2 on every task. Against the 4B proxy, CID is +0.097, +0.080, +0.089 and +0.036, all significant.
  • The proxy is not cheaper. On DFS-R and DFS-A it processes the same 49k–60k tokens as exact LOO, on a model with 44% of the 9B's parameters. That is over twice the compute of CID with two masks (10k–11k tokens).
  • SelfCite. The released SelfCite model is a Llama-3.1-8B fine-tuned for LongCite-format citations. It does not attribute the decisions of Qwen3.5-9B or Gemma-4-12B, so SC-32 applies SelfCite's context-ablation reward to each model's own decision through best-of-32 search. Training a model on that reward is close to our Verified recipe, which Fig. 4 includes.

W5 — Long inputs. Table 5 is a controlled stress test of the output format, and the submission scopes it so: the abstract makes no claim about length, and the main text attributes the 16% figure to the padded control. To test many interacting evidence units, we built a real-text version of DFS-R with 50 and 100 paragraphs: the added paragraphs are Wikipedia paragraphs that MuSiQue retrieved for other questions, chosen by similarity to the question, and in 11–19% of examples one of them contains the answer. The results (follow-up comment to all reviewers) support the method at length: verification guided by the report stays well ahead of lexical overlap and random scores at 50 and 100 paragraphs, the trained report transfers to five times its training length without retraining, and top-five lists keep parsing. Its gain over the prompted list does not grow with length, which the revision states next to Table 5.

Template sharing. As App. G states, the splits share templates. The new DFS-0 split above uses fresh generator seeds; transfer across tasks is in our response to gyjB.

None of the soundness concerns changes a conclusion. The evaluator is identified and released, and every verified cell of Table 1 is unchanged under the supplement's conventions; the cap is conservative, and B⋆B^\star is unchanged in 7 of 8 settings under its alternatives; learning's gain is significant with intervals, persists on decision-matched subsets and reproduces on an unused split; and under the deployed tuple the main result gets stronger. We would be grateful if you would reconsider your score.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.