acceptodds
Under review as a conference paper at ICLR 2027

Read Once, Reuse Across LLM Families: KV Cache Sharing with CachePort

34 views

Abstract

Multi-model LLM applications repeatedly process the same document or conversation when passing context between models. Reusing key–value (KV) caches could avoid this work, but differences in tokenization, layer and head structure, and learned representations prevent direct reuse across model families. We introduce **CachePort**, a framework for cross-family cache reuse that avoids constructing a complete native receiver cache. CachePort aligns states at shared text boundaries, translates them through measured layer correspondences and full-width affine maps, and combines a lightweight receiver adapter with limited native recomputation. Both models' pretrained weights remain frozen; only the translators and the adapter are trained. Experiments spanning Llama, Qwen, and Mistral demonstrate useful context transfer for language modeling, question answering, and summarization, with quality depending on the transfer direction and recomputation budget. A receiver adapter also supports a source excluded from its training when paired with newly fitted translators. For Llama-3.1-8B to Mistral-7B transfer, an optimized receiver-computation path achieves speedups over full prefill across tested context lengths, excluding serving-system overhead. Separately, a vLLM integration reduces receiver handoff latency from 123.9 to 75.8 ms at an 8k-token context with a perplexity increase of 0.30 relative to full prefill. These results establish a practical quality–latency trade-off for cross-family context reuse.

Primary area:
foundation or frontier models, including LLMs
Keywords:
KV Cache, Cross-model KV-cache reuse, Efficient LLM inference

Reviews

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

In this paper, a framework CachePort is proposed for reusing KV caches across independently pretrained LLM families without requiring a full prefill by the receiver model. CachePort tackles three challenges: tokenizer mismatches are handled by character-boundary alignment; representation differences are addressed through CKA-guided layer routing and affine KV translation; and residual errors are mitigated by receiver adaptation and selective recomputation. Experiments across Llama, Qwen, and Mistral demonstrate lower perplexity than prior transfer methods, improved downstream task performance, and serving efficiency gains for sufficiently long contexts.

Critical strengths
  1. This paper targets an important and challenging systems problem: cross-family KV cache replacement without a full receiver prefill and without modifying pretrained model weights. Its combination of content-anchored token alignment, representation translation, and receiver-side adaptation offers a practical and reasonably complete solution.
  2. The experiments cover multiple model families and show consistent perplexity gains over the evaluated transfer baselines. The component ablations provide useful evidence for the key design choices, and the vLLM integration demonstrates practical latency benefits for sufficiently long contexts.
Critical weaknesses
  1. As acknowledged in Appendix E, several baselines are simplified reimplementations rather than faithful reproductions. Some comparisons also rely on different execution paths, and the results do not include multiple training seeds or comparable training-cost accounting. As a result, the claimed superiority over existing methods is not yet fully established under a comprehensive and reproducible protocol.
  2. Query-selected refresh improves multi-hop QA performance but is evaluated only offline, without accounting for its probing and scheduling overhead. In addition, substantial quality gaps remain relative to full prefill in certain directions (e.g., HotpotQA F1 of 0.360 versus 0.500 for full prefill on Q7 to L8). The deployed latency gains are also context-length dependent, so the practical benefits for latency-sensitive or high-quality-demanding workloads remain insufficiently demonstrated.
Questions for authors

For cross-family pairs with non-monotonic layer correspondences, such as L8 to Q7, how much does CKA-guided routing improve over proportional-depth routing at equal refresh budgets?

2 comments

We thank the reviewer for the insightful feedback, particularly the suggestion to test CKA routing on non-monotonic pairs. Below, we present this multi-pair routing ablation alongside controlled baseline comparisons, multi-seed variance and cost accounting (W1), and end-to-end vLLM latency and throughput measurements for both refresh modes (W2). We denote Llama3.1-8B, Qwen2.5-3B, Qwen2.5-7B and Mistral-7B-v0.3 as L8, Q3, Q7 and MI, respectively

Q1. How much does routing matter across model pairs?

CKA-guided routing recovered a larger fraction of the floor-to-native PPL gap at zero refresh (B=0B=0) than both proportional-depth and terminal-alignment (C2C-style) heuristics on all three tested pairs:

Model Pair (Source → Receiver Layers)CKA RoutingProportional-DepthTerminal Alignment
L8 →\rightarrow Q7 (32 →\rightarrow 28)79.8%68.5%61.3%
L8 →\rightarrow Q3 (32 →\rightarrow 36)81.2%65.2%69.6%
MI →\rightarrow L8 (32 →\rightarrow 32)72.8%67.7%—

The margin was 11.3 percentage points on the L8 →\rightarrow Q7 pair in your question and 16.0 points on L8 →\rightarrow Q3. Even on MI →\rightarrow L8 (equal 32 layers, where proportional routing is the identity map), CKA still improved recovery by 5.1 points. For each comparison, we fitted the maps for the chosen routing rule and held the training documents, distillation budget, evaluation examples, and refresh budget fixed.

W1. Baseline fairness, seeds, and training cost

  • Matched baseline adaptation: Equipping Heo et al.[1] with the exact same character-boundary alignment, native 16-token sink, and rank-64 receiver adapter recipe improved their baseline by 0.31–0.34 PPL, yet CachePort still retained a statistically significant 0.24–0.34 PPL lead at B=0B=0 and 0.11–0.17 PPL at B=128B=128.
DirectionPPL Heo et al. (Aligned, No Adapter)PPL Heo et al. (+ Matched Adapter)PPL CachePort B=0
Q3 →\rightarrow Q77.977.6567.321
L8 →\rightarrow Q77.647.2957.057
  • Seeds and execution paths: Across three random seeds, adapter PPL standard deviation was at most 0.016 PPL, and training from scratch in a single 4-epoch stage was within 0.04 PPL of the submitted warm-start result. On shared arms, our offline harness and vLLM engine agreed within 0.000–0.014 PPL.
  • Training cost: Closed-form maps fit in minutes on CPU, and receiver adapter training took 1.5–2.5 minutes per stage on one B200 (3.3 minutes single-stage from scratch). We will distinguish closed-form fitting from trained components in the cost table and document the execution stack and cross-tokenizer modifications for each baseline.

W2. When is query-selected refresh useful, and how does the deployed path scale with length?

Query-selected refresh is useful for information-sensitive tasks where the output depends on a few exact mid-context tokens (e.g., extractive multi-hop QA), since contiguous tail refresh only updates the end of the prompt and never touches those decisive spans. On the short Q7 → L8 HotpotQA setting you identified, selecting query-attended windows raised F1 from 0.300 to 0.370 relative to tail refresh (and from 0.391 to 0.451 on L8 → Q7), though probing and sequential recomputation made native prefill faster at 1.4K. At longer prefixes 32K–64K, the same mechanism absorbs probing and scheduling overheads while still outperforming native prefill: in vLLM, it achieves 1.5–2.8× higher concurrent throughput across 16K–64K and 1.16–2.2× lower single-request latency at 32K–64K, while improving RULER QA accuracy over tail refresh.

Thank you again for your review and suggestion. We hope these results and clarifications fully address your concerns and allow you to view the paper more favorably.

Reference [1] Heo, Taekyung, et al. "Cross-model KV cache transfer in LLM families: A closed-form linear mapping for prefill reuse." arXiv preprint arXiv:2608.03893 (2026).

I only used AI tools to translate and polish my reviews. Therefore, the content of my reviews remains unchanged.

Thank you for your responses and additional experiments. I keep my score.

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

The paper presents CachePort, a framework for reusing KV caches across independently pretrained LLM families without constructing a complete native receiver cache. It aligns source and receiver positions through shared character endpoints, removes and reapplies rotary position encodings around affine translation, and selects source layers using representation similarity. Source-specific translators are jointly trained with a receiver-side LoRA adapter, while native attention-sink states and budgeted selective recomputation help recover quality. Evaluation covers language modeling, question answering, summarization, and vLLM serving across Llama, Qwen, and Mistral. The results demonstrate useful context transfer and latency benefits for sufficiently long contexts, with quality and efficiency depending on the transfer direction and recomputation budget.

Critical strengths
  • Validation includes actual serving measurements and clearly exposes trade-offs.The vLLM integration strengthens the practical case beyond isolated translation benchmarks. For L8→MI at an 8k context, a 1,024-token refresh reduces median handoff-to-first-token latency from 123.9 to 75.8 ms, with perplexity increasing from 4.660 to 4.961. The paper also reports unfavorable regimes, including short contexts and cases where aggregate throughput improves while receiver throughput decreases.

  • A useful extension to cross-family context reuse.CachePort addresses tokenizer mismatch and representation incompatibility while avoiding a complete receiver prefill. The combination of character-based alignment, receiver adaptation, and limited native recomputation produces useful transfer across multiple model families. This is a practically relevant contribution for workflows in which several models process the same context.

Critical weaknesses
  1. The incremental gains over prior KV-transfer methods are insufficiently isolated. Heo et al. already permit cross-head mixing, but the comparison uses a reduced reimplementation while CachePort additionally trains receiver adapters. Existing ablations do not fully separate the benefits of the proposed routing and translation choices from implementation and adaptation differences, weakening the evidence for the method’s incremental contribution.

  2. The downstream quality–latency trade-off remains insufficiently established. The strongest HotpotQA results use offline query-selected refresh, whereas serving uses tail refresh. Even with query-selected refresh, Q7→L8 achieves F1 0.360 versus 0.500 for full prefill. Without matched QA accuracy and serving latency, it remains unclear whether the practical speedups justify the task-quality loss.

Questions for authors
  1. Matched serving evidence: Could you report QA F1 and full handoff-to-first-token latency together for CachePort and native prefill on the same examples, using the deployed tail-refresh path?

  2. Baseline clarification and controlled evidence: What was changed in the Heo et al. reimplementation? Does CachePort’s advantage persist with the same alignment and comparable receiver-adaptation training, keeping both methods at B=0?

1 comment

We thank the reviewer for the constructive comments on baseline fairness and matched serving evaluation. Below, we clarify our baseline modifications and report controlled experiments adaptation pipeline and measuring paired QA accuracy and TTFT. We denote Llama3.1-8B, Llama-3.2-3B, Qwen2.5-3B, Qwen2.5-7B and Mistral-7B-v0.3 as L8, L32, Q3, Q7 and MI, respectively.

Q1. What quality and latency does the deployed tail-refresh policy deliver?

Evaluating QA quality and end-to-end TTFT latency together on the exact same examples using the deployed tail-refresh path, the trade-off scales directly with context length. At the paper's short 1.4K HotpotQA setting, CachePort is near latency parity with native prefill with a 0.03–0.20 F1 gap. However, CachePort is 1.5–5.2$\times$ faster than native prefill while retaining 84%–96% of native accuracy within-family L8→L32 and 69%–73% cross-family L8→MI from 16K to 32K on RULER HotpotQA haystacks .

Both tables below report paired QA scores and median TTFT on the exact same evaluation instances for native prefill and CachePort's deployed tail-refresh path:

DirectionPrefixAcc.<br> Native → CachePortTTFT (ms)<br> Native → CachePort
L8$\rightarrow$L3216K0.51 → 0.49160 → 70
L8$\rightarrow$L3232K0.50 → 0.42401 → 104
L8$\rightarrow$MI16K0.48 → 0.33306 → 90
L8$\rightarrow$MI32K0.52 → 0.38631 → 122

(b) for the paper’s original 100 HotpotQA examples:

DirectionF1<br> Native → CachePortTTFT (ms)<br> Native → CachePort
L8→Q70.471 → 0.35266 → 53
Q7→L80.504 → 0.32269 → 57
L8→L320.403 → 0.36242 → 52
Q3→Q70.471 → 0.28746 → 44

Q2. Does the advantage over Heo et al. survive a matched comparison?

What was changed in the Heo et al. reimplementation? To make Heo et al.[1] compatible with cross-tokenizer transfer and match CachePort's training setup, we added:

  • Alignment & Sink: CachePort's character-boundary alignment and native 16-token sink (since Heo et al. assume 1-to-1 paired token positions).
  • Matched Receiver Adapter: The exact same rank-64 receiver adapter trained with the identical data, objective, epochs, and learning rate, while keeping Heo et al.’s closed-form projection map fixed.

Does CachePort’s advantage persist at B=0B=0? Yes. Even after boosting Heo et al. with the same alignment, sink, and receiver adapter, CachePort achieves lower PPL:

DirectionPPL<br> Heo et al. (Aligned, No Adapter)PPL<br> Heo et al. (+ Matched Adapter)PPL<br> CachePort B=0
Q3 →\rightarrow Q77.977.6567.321
L8 →\rightarrow Q77.647.2957.057

We will include these matched baseline and paired serving tables in the revision and make our baseline descriptions and target operating regime explicit in the text. We hope this clarifies our evaluation setup and addresses all of your questions.

Reference [1] Heo, Taekyung, et al. "Cross-model KV cache transfer in LLM families: A closed-form linear mapping for prefill reuse." arXiv preprint arXiv:2608.03893 (2026).

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

This paper presents CachePort, a framework for reusing KV caches across independently pretrained LLM families without requiring the receiver to perform a full prefill over the shared context. CachePort aligns source and receiver states using shared character-end boundaries, removes and reapplies model-specific RoPE, selects source layers using CKA, and translates KV states through full-width affine maps. A receiver-side LoRA adapter and a limited amount of native recomputation are used to mitigate residual translation errors. Experiments across Llama, Qwen, and Mistral show that the transferred caches retain useful contextual information and can reduce receiver-side prefill latency for sufficiently long contexts. However, the method introduces a non-negligible quality gap, and its practical benefits are demonstrated only up to 8K context lengths in a favorable colocated-GPU setting.

Critical strengths
  1. The paper addresses redundant prefill computation across heterogeneous models. Replacing the receiver’s prefill across different tokenizers and independently pretrained model families is substantially more challenging than cache reuse between identical or closely related models.

  2. Technically coherent design. Character-boundary alignment, explicit RoPE removal/reapplication, CKA-based layer routing, and full-width KV translation address distinct sources of incompatibility. Receiver-side adaptation and selective recomputation are also well motivated.

Critical weaknesses
  1. The most relevant long-context regime is not adequately evaluated. Experiments stop at 8K tokens, with only 12 documents in the 8K quality evaluation. There are no 16K–64K experiments or standard long-context retrieval benchmarks. This is a major omission because long contexts are precisely where avoiding receiver prefill should be most valuable.

  2. The quality–latency trade-off is not yet convincing. At 8K, the strongest live result reduces median TTFT from 123.9 ms to 75.8 ms, but increases PPL from 4.660 to 4.961. Downstream degradation can be substantially larger: for Q7→L8 on HotpotQA, F1 decreases from 0.500 with full prefill to 0.360 with query-selected refresh. Moreover, the best query-selected policy is only evaluated offline and its probing overhead is not included.

  3. The generality and guarantees are limited. CachePort provides no formal bound on attention error, output-distribution divergence, or downstream quality. It relies on token-indexed KV states, dot-product attention, and removable RoPE, so its applicability to linear attention, recurrent-state models, SSMs, or substantially different positional mechanisms is unclear. In addition, stronger source models only reduce translation loss and never improve over the receiver’s own full prefill, so the method does not currently demonstrate capability transfer.

Questions for authors
  1. Can the authors evaluate CachePort at 16K, 32K, and 64K on standard long-context retrieval benchmarks, reporting task accuracy, PPL, median/p95 TTFT, transferred KV volume, and peak memory?

  2. What speedup remains when quality degradation is restricted in advance, for example to at most one absolute accuracy point or a small prespecified PPL increase?

  3. What are the end-to-end latency and throughput of query-selected refresh after including the probing pass, window selection, cache assembly, and scheduling overhead?

  4. Does CachePort remain beneficial when source and receiver are placed on different GPUs or nodes using NVLink, PCIe, or RDMA? How much KV data must be transferred at 8K, 32K, and 64K?

  5. What exact architectural assumptions are required by CachePort, and can the authors provide any formal relationship between KV translation error, attention-output error, and output-distribution divergence?

2 comments

We thank the reviewer for the careful review. We answer the five questions. For the weaknesses, W1 is answered by Q1 and Q4; W2 by Q2 and Q3; W3 by Q5. We denote Llama3.1-8B, Llama-3.2-3B, and Mistral-7B-v0.3 as L8, L32, and MI, respectively

Q1. How does CachePort perform at longer contexts?

CachePort’s quality–latency trade-off improves substantially as context scales: across 16K–64K, median TTFT speedup grows to 2.2–6.7$\times$ for L32 and 4.0–6.3$\times$ for MI, while PPL and downstream accuracy degradation remain stable rather than compounding with context length.

The tables below summarize the 16K–64K results for long-context retrieval benchmarks with PPL, accuracy and efficiency (refresh token=1024):

Receiver from L8PrefixPG-19 PPL, native → CachePortMedian TTFT, msp95 TTFT, msMoved KV volume, GBPeak memory, GiB
L3216K10.01 → 10.39143 → 66 (2.2$\times$)147 → 77 (1.9$\times$)2.198
L3232K9.37 → 9.85377 → 100 (3.8$\times$)381 → 105 (3.6$\times$)4.398
L3264K9.84 → 10.581,120 → 167 (6.7$\times$)1,129 → 171 (6.6$\times$)8.699
MI16K7.12 → 7.78275 → 69 (4.0$\times$)281 → 88 (3.2$\times$)1.993
MI32K6.93 → 7.66633 → 101 (6.3$\times$)641 → 108 (5.9$\times$)3.692

RULER QA, HotpotQA-derived

Receiver from L8PrefixAcc. Native → CachePortTTFT p50 (ms) Native → CachePort
L3216K0.51 → 0.49 (96%)160 → 70 (2.3$\times$)
L3232K0.50 → 0.42 (84%)401 → 104 (3.9$\times$)
MI16K0.48 → 0.33 (69%)306 → 90 (3.4$\times$)
MI32K0.52 → 0.38 (73%)631 → 122 (5.2$\times$)

LongBench GovReport

Receiver from L8PrefixROUGE-L F1 Native → CachePortTTFT p50 (ms) Native → CachePort
L328K0.215 → 0.208 (97%)67 → 49 (1.4$\times$)
L3216K0.197 → 0.193 (98%)154 → 68 (2.3$\times$)
MI8K0.222 → 0.189 (85%)134 → 54 (2.5$\times$)
MI16K0.217 → 0.191 (88%)288 → 68 (4.2$\times$)

These results support the reviewer's intuition that avoiding receiver prefill becomes more valuable at longer contexts: with the refresh budget fixed, CachePort reuses a larger portion of the prefix, and its latency grows more slowly than native prefill. From 16K to 64K, L32's native TTFT increases 7.8×, whereas CachePort’s increases only 2.5×. The benefit also extends to downstream tasks: on GovReport at 16K, L32 achieves a 2.3× speedup while retaining 98% of native ROUGE‑L. Q2 further examines speedups under explicit quality constraints.

Q2. What speedup remains under a quality constraint?

CachePort controls quality degradation by adjusting the tail-refresh budget BB. Under a absolute bound of ΔPPL<0.9\Delta\text{PPL} < 0.9, CachePort achieves 2.2–6.5$\times$ TTFT speed-ups across 16K–64K (and 2.2–4.7$\times$ at ΔPPL≤0.6\Delta\text{PPL} \le 0.6). Even when restricted to a strict ΔPPL≤0.3\Delta\text{PPL} \le 0.3 bound, it retains 1.1–2.5$\times$ speed-ups across 16K–32K.

The table below reports the selected refresh budget BB and retained TTFT speed-up for each pre-specified degradation bound:

Degradation BudgetDirection & PrefixB-refreshspeed-up
ΔPPL ≤ 0.3L8→MI 16K / 32K81921.1× / 2.0×
L8→L32 16K / 32K2048 / 40961.9× / 2.5×
ΔPPL ≤ 0.6L8→MI 16K / 32K20482.9× / 4.7×
L8→L32 16K / 32K / 64K1024 / 1024 / 40962.2× / 3.8× / 4.3×
ΔPPL ≤ 0.9L8→MI 16K / 32K10243.8× / 6.1×
L8→L32 16K / 32K / 64K10242.2× / 3.8× / 6.5×

Even when strict bounds ΔPPL≤0.3\Delta\text{PPL} \le 0.3 require larger refresh budgets B=2048–8192B = 2048 \text{--} 8192, CachePort still bypasses the majority of attention computation at 16K–64K, maintaining consistent speed-ups that grow with context length.

Q3. What does query-selected refresh cost end to end?

Including the probing pass, window selection, cache assembly, and engine scheduling overhead inside vLLM, query-selected refresh achieves 1.5–2.8$\times$ higher throughput than native prefill across all evaluated lengths from 16K to 64K. For single-request end-to-end latency, it crosses native prefill between 16K and 32K, moving from 0.56–0.94$\times$ at 16K to 1.16–2.2$\times$ faster than native prefill at 32K–64K.

The table below reports the end-to-end single-request TTFT and concurrent throughput against native prefill (at concurrency K∈{6,3,2}K \in \{6, 3, 2\} for 16K / 32K / 64K):

Receiver from L8PrefixTTFT (ms) native → query-selectedKThroughput (req/s) Native → query-selected
L3216K159 → 286 (0.56$\times$)64.68 → 7.13 (1.5$\times$)
L3232K406 → 351 (1.16$\times$)32.04 → 4.27 (2.1$\times$)
L3264K1,162 → 526 (2.2$\times$)20.79 → 2.11 (2.7$\times$)
MI16K306 → 327 (0.94$\times$)62.44 → 5.54 (2.3$\times$)
MI32K632 → 402 (1.6$\times$)31.24 → 3.44 (2.8$\times$)

Q4. Does the benefit survive cross-GPU transfer?

Yes. Placing the source and receiver on separate GPUs has minimal impact on CachePort's speedup: across two NVLink-connected B200 GPUs, CachePort retains a 1.8–6.1$\times$ TTFT speedup over native prefill.

The table below compares single-GPU and dual-GPU (NVLink) TTFT at B=1024B=1024 (with PPL matching within 0.002):

Receiver from L8PTTFT (ms) NativeTTFT (ms) CachePort single GPU → two GPUsspeed-up (two GPUs)
MI16K27569 → 823.4×
MI32K633101 → 1115.7×
L3216K14466 → 791.8×
L3232K377100 → 1133.3×
L32641120167 → 1856.1×

Cross-GPU overhead is small because handoff latency is dominated by on-GPU row gathering and translation rather than link transfer. Transferring 8.6 GB at 64K takes only ∼12 ms\sim 12\text{ ms} at our measured 731 GB/s731\text{ GB/s} NVLink bandwidth.

Q5. What assumptions and error bounds apply?

CachePort requires token-indexed per-layer K/V caches, shared input text, dot-product attention (MHA or GQA, where source and receiver head counts and widths may differ), and invertible position-only key encodings (e.g., RoPE). Recurrent, state-space, linear-attention, and uncompressed latent-cache models fall outside this formulation.

For a fixed receiver query qq, suppose each translated key and value has Euclidean error at most εK\varepsilon_K and εV\varepsilon_V. Let dd be the key dimension and Vmax⁡=max⁡i∥vi∥2V_{\max} = \max_i \lVert v_i \rVert_2. Since each attention logit shifts by at most δ=∥q∥2εK/d\delta = \lVert q \rVert_2 \varepsilon_K / \sqrt{d}, the attention-output error satisfies

∥o−o^∥2≤Vmax⁡(e2∥q∥2εK/d−1)+εV.\lVert o-\hat{o}\rVert_2 \le V_{\max}\left(e^{2\lVert q\rVert_2\varepsilon_K/\sqrt{d}}-1\right)+\varepsilon_V.

The first term captures how key error perturbs attention routing, and the second captures error in the retrieved values. These explain why key error is costlier than value error, and why refreshing high-attention sink and tail states removes the dominant error source. If the resulting perturbations induce a final-layer logit shift Δ\Delta, the output-distribution divergence satisfies KL(π ∥ π^)≤2∥Δ∥∞\mathrm{KL}(\pi \,\Vert\, \hat{\pi}) \le 2\lVert\Delta\rVert_\infty, though bounding ∥Δ∥∞\lVert\Delta\rVert_\infty end-to-end requires controlling how hidden states and queries propagate across layers. Because our objective is to avoid redundant receiver prefill rather than claim capability transfer, native receiver prefill serves as the quality ceiling.

We have incorporated the long-context benchmarks, calibrated budget policy, dual-GPU measurements, and formal error analysis into the revision, and made our architectural assumptions and quality-ceiling framing explicit throughout the text. We hope these additions resolve your concerns and provide the empirical evidence needed to support a more positive assessment of our work.

Comments on the paper

1 comment

Dear Reviewers, thank you for your time and effort in reviewing this submission. As the discussion period is ongoing, I would appreciate it if you could join the discussion and engage with the authors' rebuttal at your earliest convenience.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.