- Rating
- 2
- Confidence
- 3
- Informativeness
- 3
- Presentation
- 2
- Soundness
- 2
Read review
Paper summary
LogitTree addresses a mismatch between generation and training when an agent evicts or compresses its memory. Naive replay can remove evidence from earlier targets or restore evicted text to later ones. LogitTree replays each response under the live prefix available at generation time and uses disjoint loss masks so that every target contributes once. SDCC provides a cheaper alternative: a compressed-context pass is trained with forward KL toward the same model's detached live-prefix prediction. The student branch still receives gradients from this loss. Across three white-box and two black-box harnesses, the authors report better accuracy than naive compressed-context training, with SDCC recovering much of LogitTree's gain at lower cost.
Critical strengths
S1. The paper states a concrete conditioning requirement: each target should see exactly what it saw when it was generated, and should contribute to the loss once. Framed this way, the requirement excludes two easy mistakes in replay, namely stripping evidence from earlier targets and restoring evicted text to later ones.
S2. SDCC recovers most of LogitTree's reported accuracy gain at a much lower cost. On MemexRL, macro EM goes from 28.9 for Naive-Compressed to 45.9 with LogitTree and 43.1 with SDCC, at relative costs of 1.00, 4.20 and 1.55.
Critical weaknesses
W1. The single-copy graph is not generally equivalent to independent branch replay. A retained token can carry information from evicted text in its intermediate states and pass it to later targets. Matching direct visibility and token positions does not remove that indirect path. The appendix describes a viable block-diagonal implementation with branch replication and summed branch costs, but the main figure and exactness argument need to describe that executed computation consistently.
W2. Checkpoint selection uses the test suite. A disjoint development set produces a shortlist, but the reported checkpoint is whichever performs best on the full test suite. This makes the test results part of model selection. The black-box averages also differ: the text gives SDCC/LogitTree values of 37.5/35.9 and 36.9/35.0, while the main table gives 42.6/42.4 and 43.9/42.9.
Questions for authors
Q1. Which computation graph does the exactness statement describe? Please compare losses and gradients with independent per-branch replay on one batch containing an eviction. The main illustration and cost statement should then be aligned with the executed graph and its summed branch lengths.
Q2. Can you report results with checkpoints selected only on the development set and then evaluated on a locked test suite? For the two black-box harnesses, which runs and checkpoints produced each set of conflicting averages?
6 comments
Rebuttal for W1&Q1 Part (2/2)
(2) A historical same-model, same-trajectory comparison supports numerical agreement in the FP32 reference configuration.
We recovered the results of the historical experiment e01-20natural-r16; we did not rerun this experiment for the rebuttal. It fixes the same complete 36-layer Qwen3-4B model and compares the two executions using TP=8 and FP32 math SDPA on 20 trajectories containing natural AgentFold memory evictions. Each trajectory contains three branches, forming one packed group.
| Execution | Computation |
|---|---|
| Independent branch replay | Evaluate each branch separately and aggregate losses and gradients using the same target assignments, weights, and normalization |
| Branch-replicated LogitMask | Pack the same branches, isolate them with block-diagonal causal attention, and use the same target assignments and loss rules |
The experiment covers 60 branches and 134,145 target tokens.
| Check | Historical result |
|---|---|
| Maximum absolute difference in target log-probabilities | |
| Mean absolute difference in target log-probabilities | |
| Maximum across trajectories of the absolute difference in normalized NLL loss | |
| Maximum across trajectories of the absolute difference in normalized controlled PPO loss | |
| Maximum across trajectories of the relative L2 error in NLL gradients | |
| Maximum across trajectories of the relative L2 error in controlled PPO gradients | |
| Trajectories passing the historical script's prespecified FP32 thresholds | 20/20 |
The mean log-probability difference is weighted over all target tokens. Gradient errors follow the historical script's aggregation across TP shards, including replicated parameters. The PPO results concern a controlled objective test. We will specify the thresholds and metric definitions in the revision.
These results provide a same-model, same-trajectory loss and gradient comparison with natural evictions, supporting numerical agreement for branch-replicated execution in the tested FP32 reference configuration. The layer-by-layer correspondence establishes mathematical equivalence, while this experiment quantifies numerical differences in that specific execution configuration.
(3) Cost is reported using actual branch lengths, including replicated context.
Let be the input length of branch . The actual non-padding input size is
This quantity includes copies of shared context appearing in different branches. For the 20 trajectories above:
| Input quantity | Total | Mean per trajectory |
|---|---|---|
| Number of branches | 60 | 3 |
| Branch input tokens, including copies and excluding padding | 189,368 | 9,468.4 |
| Packed input positions, including padding | 198,656 | 9,932.8 |
| Independent-replay input positions, including padding | 214,016 | 10,700.8 |
The padded position counts were reconstructed from the historical configuration.
One packed forward/backward describes how execution is organized; it does not eliminate computation for the branches or their context copies. If the attention backend skips cross-branch blocks, the quadratic attention term scales with . If it computes the full dense matrix before applying the mask, that term instead scales with .
We will align Figure 3(c), Table 6, and the associated cost derivations with this execution graph, using the sum of actual branch lengths to report input size.
Rebuttal for W2&Q2 Part (1/3)
W2 / Q2: Were checkpoints selected using only the development set? How do the Table 1 metrics correspond, and which runs produced the two sets of black-box results?
We confirm that the reported models were selected by validation performance; test scores were not used for checkpoint selection. The statement in Section 5.1 describing selection of the best test-performing checkpoint among fully evaluated checkpoints does not reflect the procedure actually followed. The reviewer's concern follows directly from this incorrect description. We will correct it and apologize for the confusion.
(1) The actual protocol selects checkpoints on validation data and reports their performance on a fixed test suite.
We compare candidate checkpoints on a fixed validation set disjoint from the test examples, select the checkpoint with the highest validation score, and report that model's performance on the fixed test suite. Valid Avg. EM is the equally weighted mean over the validation portions of the seven benchmarks.
To make the selection evidence concrete, the following table reports recovered validation records for 12 method/harness configurations. For each configuration, it lists up to five higher-scoring candidates among the recovered records, ordered by checkpoint number. The selected checkpoint is shown in bold.
| Method | Harness | Candidate checkpoint → Valid Avg. EM |
|---|---|---|
| Naive-Full | AgentFold | 132 → 27.56; 184 → 22.99; 205 → 14.61; 219 → 14.31; 223 → 14.91 |
| Naive-Compressed | TC-RAG | 39 → 35.29; 45 → 35.86; 49 → 36.23; 53 → 37.64; 55 → 39.24 |
| Naive-Compressed | AgentFold | 214 → 45.81; 218 → 46.63; 220 → 45.84; 228 → 45.80; 232 → 46.53 |
| Naive-Compressed | MemexRL | 67 → 25.10; 69 → 23.63; 71 → 25.84; 73 → 27.86; 75 → 29.64 |
| LogitMask / 4D-Mask | TC-RAG | 147 → 38.43; 159 → 38.09; 161 → 41.13; 163 → 40.09; 165 → 39.90 |
| LogitMask / 4D-Mask | AgentFold | 63 → 34.99; 65 → 33.61; 67 → 34.94; 69 → 33.94; 71 → 35.53 |
| LogitMask / 4D-Mask | MemexRL | 73 → 31.94; 80 → 31.56; 81 → 31.60; 131 → 31.61; 133 → 34.43 |
| LogitTree | TC-RAG | 184 → 40.81; 186 → 41.00; 192 → 39.43; 194 → 39.91; 196 → 38.97 |
| LogitTree | AgentFold | 96 → 34.43; 104 → 37.57; 112 → 39.77; 120 → 38.36; 128 → 39.66 |
| SDCC | TC-RAG | 168 → 44.83; 184 → 45.37; 192 → 46.44; 197 → 45.43; 199 → 47.36 |
| SDCC | AgentFold | 159 → 40.74; 166 → 44.06; 167 → 42.33; 169 → 43.07; 175 → 35.06 |
| SDCC | MemexRL | 134 → 44.33; 135 → 43.14; 138 → 44.34; 191 → 42.40; 199 → 41.76 |
These records document checkpoint selection; the different checkpoints within a configuration are model snapshots from different training steps.
Rebuttal for W1&Q1 Part (1/2)
We thank the reviewer for recognizing our formulation of generation-time conditioning consistency and the value of SDCC's accuracy–cost trade-off.
Your comments identify two aspects that need to be made explicit: the exactness argument must consistently describe the computation actually executed, and the evaluation protocol and black-box results must have clear provenance. We address these concerns below.
Our exactness claim concerns the branch-replicated, block-diagonal attention construction implemented in Appendix H. This implementation computes hidden states separately for each branch and restricts attention within that branch at every layer, excluding the indirect cross-branch information path raised by the reviewer. We will align the main figure, proofs, and cost descriptions with this execution graph.
(1) Each branch performs the same computation as independent replay.
Each branch has its own copies of the input tokens, and its hidden states are computed from that branch's inputs. When the same token appears in different branches, its hidden states are computed separately under the respective contexts. A branch does not reuse hidden states from another branch that has attended to content evicted from its own context.
Block-diagonal causal attention prevents cross-branch access at every layer, so this isolation holds throughout the computation. Packed LogitMask and independent LogitTree replay use:
The loss mask assigns each original generated target to exactly one branch reproducing its generation-time context, so each target contributes to the task loss once. Replicated context tokens remain part of their respective branch computations.
Under the stated architectural assumptions, with no additional cross-branch coupling and with stochastic operations disabled or correspondingly matched, the hidden states of the two executions agree layer by layer. Let Tb denote the targets assigned to branch b. Then :
Lpacked(θ)=Z1∑b∑twtℓt(θ);t∈Tb
Z1∑b∑twtℓt(θ)=Llogitmask(θ);t∈Tb
The target sets are disjoint and jointly cover all original training targets. Consequently, the two executions have identical target logits, scalar losses, and parameter gradients in exact arithmetic.
Figure 3(c) did not explicitly depict the branch copies and their independently computed hidden states, making it possible to interpret the diagram as a single-copy execution sharing hidden states across branches. We will redraw the figure and align Section 3, Proposition 3, Theorem 1, and Appendix H so that the exactness argument explicitly applies to the implemented branch-replicated computation graph.