Markdown

Cross-model KV cache transfer¶

Scope: reusing a KV cache produced by one model inside a different model, so that a fleet which swaps models mid-session (cost-quality cascading, routing, mid-conversation escalation) does not repay prefill on every swap. This page covers the closed-form per-head ridge mapper of "Cross-Model KV Cache Transfer in LLM Families" (arXiv 2608.03893) and the trained-fuser alternative C2C (arXiv 2510.03215), the matched-KV precondition, the storage and fleet-scaling cost, and the diagnostic that actually predicts whether a pair will work. Reuse within one model across requests is prefix caching; reuse across layers of one model is cross-layer KV sharing; reuse across agents sharing text is multi-agent KV reuse; moving an unmodified cache between machines is KV cache transfer with NIXL.

The Python blocks below are runnable, self-checking validations of the core math this page teaches: the closed-form ridge solve (cross-checked against an augmented least-squares reference), the RoPE strip-and-re-rotate round trip, the error-placement result that explains why reconstruction quality does not predict downstream accuracy, and the mapper storage formula (cross-checked against all three parameter counts the paper publishes). Each was executed on a stock python3 with numpy and asserts its result; the pasted output is the real output. No accuracy number on this page was reproduced. Every retention, speedup and benchmark figure is quoted from the cited papers, which released no code at the time of writing. Treat those as vendor-reported.

What it is¶

Prefill turns a prompt into a KV cache. If a serving stack routes a mid-conversation request from a 14B model to a 32B model, the 32B model normally recomputes that entire cache from scratch, because a KV cache is written in the private representation of the model that produced it. Cross-model KV cache transfer replaces that recomputation with a learned map from the source model's cache into the target model's expected format.¹

The precondition that makes the problem tractable is matched KV: source and target share KV head count and per-head dimension, even though layer counts, hidden sizes and parameter counts differ. Within a model family this is common, because families reuse head geometry across scales. All six pairs studied in the primary paper are 8 KV heads at head dimension 128 on both sides, with parameter ratios from 1.8x to 8.8x and depth ratios from 1.2x to 2.5x.¹

Two mapper families exist:

Closed-form (gradient-free). Fit an independent ridge regression per target (layer, head) from a small calibration set. No backpropagation, no training loop. This is the arXiv 2608.03893 approach and it fits in roughly 47 to 87 minutes per pair on one 8xH100 node.¹
Trained fusers. Learn a neural projector per pair. C2C trains a per-pair cache fuser with a learnable gate selecting which target layers benefit, reporting 6.4 to 14.2% higher average accuracy than the receiver alone and about 2.5x lower latency than routing the same information as text.²

The distinction matters operationally: a closed-form mapper is a calibration job you can re-run when a model version changes, while a trained fuser is a training job with its own data pipeline and failure modes.

Why use it¶

The cost being avoided is real and grows with session length. Prefill scales with model size and prompt length, so a long agentic session that escalates from a small model to a large one pays the large model's full prefill over the entire accumulated transcript. Measured on Qwen3 14B to 32B, applying the mapper takes 278 ms against 6,975 ms to re-prefill 32K tokens, a 25x gap; across seven pairs and ten sequence lengths the mapper was faster in all 70 measured cells, spanning 2.7x to 25.1x.¹

The saving is bounded by what prefill costs in your traffic. If your sessions are short, or you rarely swap models, there is nothing here for you. The technique earns its keep specifically in router and cascade architectures where swaps are frequent and contexts are long.

When to use it (and when not)¶

Use it when all of the following hold:

You actually swap models mid-session. Routing that picks a model once per request and never revisits it can use ordinary prefix caching instead.
Source and target are matched-KV members of one family. Cross-family transfer is explicitly untested and listed as open work.¹
Your workload is dominated by the task classes where transfer holds up, and you have measured it on your own traffic rather than trusting a published average.

Do not use it when:

Your workload is generative reasoning. This is the most important scope condition on the page and the published averages obscure it. See the retention table below.
Models are architecturally identical, in which case DroidSpeak-style direct sharing applies and no mapping is needed.¹
The pair uses hybrid attention (sliding-window or local) or carries SSM state alongside KV, such as attention-recurrent hybrids. Out of scope in the source work.¹
You cannot afford the mapper storage, which is quadratic in fleet size (below).

The retention headline is a five-benchmark average, and one benchmark collapses¶

The abstract reports that four of six pairs retain 73 to 98% of the target's standalone accuracy. That is an arithmetic mean over five benchmarks, four of which are log-likelihood classification tasks. Reading the per-benchmark column changes the picture materially. The following is transcribed from the paper's Table 1 and cross-checked against the raw accuracies in its Table 13:¹

Pair	Avg	Floor-norm	ARC-C	HellaSwag	WinoGrande	MMLU	GSM8K
Qwen3 14B to 32B	97.6%	96.3%	101.0%	97.6%	98.5%	95.0%	95.6%
Qwen3 8B to 32B	87.5%	80.7%	94.0%	95.2%	91.0%	88.5%	68.8%
Llama 3.1 8B to 70B	72.8%	62.9%	90.9%	94.4%	87.1%	73.3%	18.2%
Ministral 3B to 8B	76.2%	65.9%	90.6%	93.3%	91.3%	69.4%	36.6%
Ministral 3B to 14B	44.2%	14.7%	43.6%	68.0%	74.0%	32.0%	3.2%
Ministral 8B to 14B	41.6%	11.1%	40.7%	58.7%	74.2%	32.7%	1.6%

Two of the four "successful" pairs retain 18.2% and 36.6% of GSM8K, the only chain-of-thought generation benchmark in the set. In raw terms Llama 3.1 8B to 70B scores 14.78 where the 70B target scores 81.12. A deployment that reads "73 to 98% retention" and routes math or agentic tool-use traffic through this mapper will ship a model that has effectively lost its reasoning ability while still scoring well on multiple choice.

Two structural facts explain why this is easy to miss and easy to under-weight:

The number of source layers k is selected per pair by maximising the mean of the log-likelihood benchmarks. GSM8K is a holdout by construction, so nothing in the tuning procedure protects it.¹
The paper's own out-of-sample check (Table 18) uses PIQA, BoolQ and ARC-Easy, all classification and all easier than the selection set. It reports 96 to 100% for the four Tier 1 pairs, which reads as reassuring while testing none of the capability that collapsed.¹

The paper reports both raw and floor-normalized retention, and the difference is worth carrying into any evaluation you build. Raw retention credits a mapper that scores below chance: on WinoGrande an ablated mapper scoring 48.5 against a 50-point chance floor is recorded as 69.2% retention, which floor normalization correctly places at -7.7%.¹ Report floor-normalized numbers, or a percentage of a chance-corrected range, whenever you compare compression or transfer methods.

Architecture¶

flowchart LR
  subgraph SRC["Source model S"]
    SP["prefill"] --> SC["KV cache C_S"]
  end
  SC --> STRIP["strip source RoPE<br/>(orthogonal, exact)"]
  STRIP --> SEL["per target layer:<br/>concat top-k source layers"]
  SEL --> RIDGE["per-head ridge<br/>W = (X'X + lambda I)^-1 X'Y"]
  RIDGE --> REROT["re-apply target RoPE"]
  REROT --> TC["mapped cache C_T"]
  TC --> DEC["target decodes,<br/>no re-prefill"]
  CAL["calibration:<br/>500 seqs x 1024 tok"] -.fits.-> RIDGE

Three components, in the order they contribute:

Cross-layer source selection is the largest single contributor. Each target layer draws from its top-k most predictive source layers, concatenated. Dropping from k=8 to k=1 takes key R-squared from 0.79 to 0.56 and collapses downstream accuracy. Complementary information is genuinely spread across source layers: at k=1 you capture 66% of the k=all key R-squared and 42% for values.¹
Per-head ridge regression, one independent closed-form solve per target (layer, head), with lambda = 0.01 for conditioning rather than regularization strength. Calibration is 500 FineWeb-Edu sequences of 1,024 tokens.¹
Content-space (RoPE-stripped) mapping. Keys are de-rotated before fitting and re-rotated at inference, so the fit is position-free.

The RoPE component is a portability argument, not a measured win¶

The ablation table invites a misreading. Its "minus inference RoPE" row collapses MMLU and GSM8K to near random, which looks like proof that RoPE handling is load-bearing. But that row is a deliberate fit-versus-evaluation mismatch, not a fair alternative. The honest comparison is the "minus all RoPE" row, which keeps RoPE coupled at both fit and inference: it scores 61.09 / 80.73 / 68.59 / 77.70 / 90.98 against the full pipeline's 61.60 / 80.70 / 68.98 / 78.09 / 90.98. That is a wash on every benchmark.¹

The paper says so plainly in its appendix, that the coupled variant "lands within noise of the full decoupled pipeline on every benchmark at the 1,024-token fit context" and that decoupling is preferred because it generalizes to other RoPE configurations and longer contexts by construction. Adopt RoPE stripping for that portability reason. Do not expect it to buy accuracy at your fit length, and do not cite the straw-man ablation row as evidence that it does.

How to use it: the mapper math, executed¶

The block below implements and checks the pieces that a deployment has to get right. The ridge solve is verified against an independent least-squares formulation, and the RoPE inversion is verified to be exact and position-transferable.

import numpy as np

rng = np.random.default_rng(7)

def ridge_fit(X, Y, lam=0.01):
    """Centered ridge. Returns (W, b) for Y ~ X W + b."""
    xm, ym = X.mean(0), Y.mean(0)
    Xc, Yc = X - xm, Y - ym
    W = np.linalg.solve(Xc.T @ Xc + lam * np.eye(Xc.shape[1]), Xc.T @ Yc)
    return W, ym - xm @ W

N, ds, dt = 4096, 256, 128
Xs = rng.standard_normal((N, ds))
Yt = Xs @ (rng.standard_normal((ds, dt)) / np.sqrt(ds)) + 0.3 * rng.standard_normal((N, dt))

W, b = ridge_fit(Xs, Yt)
W_ref = np.linalg.lstsq(np.vstack([Xs - Xs.mean(0), np.sqrt(0.01) * np.eye(ds)]),
                        np.vstack([Yt - Yt.mean(0), np.zeros((ds, dt))]), rcond=None)[0]
print(f"ridge vs augmented-lstsq reference: max|dW| = {np.abs(W - W_ref).max():.2e}")
assert np.allclose(W, W_ref, atol=1e-8)

def rope(x, pos, base=10000.0):
    d = x.shape[1]
    inv = base ** (-np.arange(0, d, 2) / d)
    ang = pos[:, None] * inv[None, :]
    c, s = np.cos(ang), np.sin(ang)
    xe, xo = x[:, 0::2], x[:, 1::2]
    out = np.empty_like(x)
    out[:, 0::2] = xe * c - xo * s
    out[:, 1::2] = xe * s + xo * c
    return out

T = 512
pos = np.arange(T)
k_content = rng.standard_normal((T, 64))
k_rot = rope(k_content, pos)
print(f"RoPE round-trip error = {np.abs(rope(k_rot, -pos) - k_content).max():.2e}")

# A content-space fit re-applied at positions never seen during calibration.
Wc, bc = ridge_fit(k_content, k_content @ rng.standard_normal((64, 64)) / 8)
far = np.arange(30000, 30000 + T)
lhs = rope(rope(k_rot, -pos) @ Wc + bc, far)
rhs = rope(k_content @ Wc + bc, far)
print(f"content-space fit at positions 30000+: max diff = {np.abs(lhs - rhs).max():.2e}")
assert np.allclose(lhs, rhs, atol=1e-8)

ridge vs augmented-lstsq reference: max|dW| = 9.16e-16
RoPE round-trip error = 8.88e-16
content-space fit at positions 30000+: max diff = 1.33e-15

The RoPE inversion is exact because the rotation is orthogonal, so R(-p) is R(p) inverse at negligible cost. That exactness is the whole justification for fitting in content space: the same weights remain valid at positions far outside the calibration range.

How to screen a pair: reconstruction quality is the wrong metric¶

The most useful transferable result in this work is negative. Calibration R-squared, the obvious a-priori screening statistic, does not predict downstream retention across pairs. Llama 3.1 8B to 70B and Ministral 3B to 8B both fit at key R-squared 0.84, yet the Llama pair retains 94% of HellaSwag small-to-large and only 37% large-to-small.¹ Across 12 pair evaluations, attention-output cosine correlates with HellaSwag retention at Pearson r = +0.57 while calibration R-squared manages r = -0.20.

The mechanism is where the residual error lands, not how large it is. Attention does not weight all channels equally: it scores keys against the target's queries and weights values by the resulting pattern. Error that falls in directions the queries never read costs nothing; error of identical magnitude aimed into the query subspace changes the attention output. The block below constructs exactly that situation, holding reconstruction error constant while moving only its direction.

import numpy as np
rng = np.random.default_rng(7)
T, dh = 512, 64
Kt, Vt = rng.standard_normal((T, dh)), rng.standard_normal((T, dh))
Q = rng.standard_normal((32, dh))

Uq = np.linalg.svd(Q, full_matrices=False)[2]
read = Uq[:8].T @ Uq[:8]          # subspace attention actually reads
null = np.eye(dh) - read

def attn(K, V, Qm):
    lg = Qm @ K.T / np.sqrt(dh)
    p = np.exp(lg - lg.max(1, keepdims=True)); p /= p.sum(1, keepdims=True)
    return p @ V

def r2(pred, true):
    return 1.0 - np.sum((true - pred) ** 2) / np.sum((true - true.mean(0)) ** 2)

def cos(a, b):
    return float(np.sum(a * b) / (np.linalg.norm(a) * np.linalg.norm(b)))

base = rng.standard_normal((T, dh))
e_read, e_null = base @ read, base @ null
e_null *= np.linalg.norm(e_read) / np.linalg.norm(e_null)   # identical Frobenius norm
K_read, K_null = Kt + 0.6 * e_read, Kt + 0.6 * e_null

ref = attn(Kt, Vt, Q)
print(f"error norms: {np.linalg.norm(K_read-Kt):.4f} vs {np.linalg.norm(K_null-Kt):.4f}")
print(f"R^2:      in-subspace {r2(K_read, Kt):.4f} | null-space {r2(K_null, Kt):.4f}")
print(f"attn cos: in-subspace {cos(attn(K_read,Vt,Q), ref):.4f} | "
      f"null-space {cos(attn(K_null,Vt,Q), ref):.4f}")
assert abs(r2(K_read, Kt) - r2(K_null, Kt)) < 0.02
assert cos(attn(K_null,Vt,Q), ref) > cos(attn(K_read,Vt,Q), ref) + 0.05

error norms: 38.2620 vs 38.2620
R^2:      in-subspace 0.9551 | null-space 0.9551
attn cos: in-subspace 0.9251 | null-space 0.9885

Identical error magnitude, identical R-squared, materially different attention output. This is why the paper's nonlinear MLP variant recovers up to +36.8 points of HellaSwag retention on the pairs where ridge fails: it does not fit better in a least-squares sense, it redistributes error away from attention-sensitive directions, lowering key-concentration by about 2.5 and raising attention-output cosine by about 0.45 on those pairs.¹ On pairs where ridge already works, the MLP is slightly worse. Nonlinearity is a rescue for badly placed error, not a general upgrade.

Practical consequence: screen candidate pairs on attention-output cosine against the target's own queries, and validate on a generation benchmark, not on reconstruction error. Both remain post-hoc, since they need a fitted mapper; the paper lists a pre-fit transferability signal as open work.

How to integrate it¶

Mapper size is 2 * L_target * n_kv * (k * n_kv * d_head_source) * d_head_target weights for K and V together. It is independent of sequence length and cache size, and it is directional: a mapper fit for A to B does not serve B to A.

def mapper_params(Lt, n_kv, k, ds_h, dt_h):
    return 2 * Lt * n_kv * (k * n_kv * ds_h) * dt_h

published = [("Qwen3 14B->32B", 64, 8, 1.07, 4),
             ("Qwen3 8B->32B", 64, 12, 1.61, 6),
             ("Llama 3.1 8B->70B", 80, 20, 3.36, 12)]
for label, Lt, k, want_b, want_gb in published:
    p = mapper_params(Lt, 8, k, 128, 128)
    print(f"{label:20s} k={k:2d} -> {p/1e9:.2f} B params (paper {want_b}) | "
          f"{want_gb * 2**30 / p:.1f} bytes/param")
    assert abs(p / 1e9 - want_b) < 0.005

for P in (3, 4, 5):
    print(f"{P}-model fleet: {P*(P-1)} ordered pairs x ~6.5 GB = {P*(P-1)*6.5:.0f} GB")

Qwen3 14B->32B       k= 8 -> 1.07 B params (paper 1.07) | 4.0 bytes/param
Qwen3 8B->32B        k=12 -> 1.61 B params (paper 1.61) | 4.0 bytes/param
Llama 3.1 8B->70B    k=20 -> 3.36 B params (paper 3.36) | 3.8 bytes/param
3-model fleet: 6 ordered pairs x ~6.5 GB = 39 GB
4-model fleet: 12 ordered pairs x ~6.5 GB = 78 GB
5-model fleet: 20 ordered pairs x ~6.5 GB = 130 GB

The formula reproduces all three published parameter counts exactly, which also reveals something the paper does not state: dividing its reported storage by its reported parameter count gives 4 bytes per weight, so the 4 to 12 GB figures are fp32. Storing mappers in bf16 should halve that, at a numerical risk nobody has published a measurement for.

Fleet planning consequences:

A router over P models needs up to P(P-1) ordered pairs. Growth is quadratic, reaching roughly 130 GB for five models at the paper's average size.
The budget is host memory or disk, not VRAM. Inference is one batched matmul per target layer, so mappers can be paged in when a pair becomes active. The paper estimates 80 to 480 ms to page 4 to 12 GB over PCIe Gen4/Gen5 and is explicit that these "are computed from size and bandwidth, not measured".¹
Every model version bump invalidates every mapper touching it, at roughly one GPU-hour of recalibration per ordered pair.

Latency numbers to re-measure before trusting¶

The published speedups exclude work a real deployment must do. Both conditions run on synthetic inputs, and the paper states that end-to-end transfer "would also include shipping the mapped cache to the target process, which we do not measure".¹ In a disaggregated stack that shipping cost is exactly what KV cache transfer with NIXL and centralized KV placement exist to manage, and it can dominate at short sequence lengths where the mapper's own floor is already 14.0 ms. Two further asymmetries: the mapper runs in eager mode with no CUDA graphs (biased against the mapper) while re-prefill uses FlashAttention-2, and Ministral re-prefill timings exclude the vision tower.

How to run it in production¶

Gate on a generation benchmark. Make chain-of-thought accuracy a release gate for any pair you enable, since that is the capability the published averages hide. Treat multiple-choice retention as necessary and nowhere near sufficient.
Enable per direction, not per pair. Retention is strongly asymmetric; large-to-small can fail where small-to-large succeeds at identical fit quality.
Bound multi-turn drift. Alternating handoff is stable over the measured horizon but not free: large-to-small drift grows linearly at about 0.33 points per turn on the one pair evaluated, over 10 turns of CoQA. Nothing bounds a 50-turn session; measure yours.¹
Keep re-prefill as the fallback path and make the cutover observable. A transfer that silently degrades reasoning produces no error, only worse answers.
Calibration domain is the one axis with real cost. Substituting CodeAlpaca for FineWeb-Edu cost 5.24 points of HellaSwag while Wikipedia stayed within noise, and the authors note neither substitution bounds calibration confined to a narrow field such as medicine or law.¹

How to maintain it¶

Re-fit on model version changes, and treat a mapper as pinned to an exact pair of checkpoints.
Re-run the k sweep rather than inheriting it. The best k tracks how distant the pair is: Qwen3 14B to 32B is within 0.3 points of peak by k=8, while Llama 3.1 8B to 70B keeps improving to k=24.¹
Ridge lambda and calibration size are robust. Lambda is flat across four orders of magnitude and collapses only at 1.0; sample count flattens after 200 sequences, with 50 sequences still within about 1.6 points.¹ Do not spend tuning effort here.
Watch for the closed-form-versus-trained tradeoff shifting. C2C's trained fusers reach different operating points and its reported speedup over text-based communication varies enormously by pair (3.46x, 1.51x and 14.41x across three sharers), so a single average is not a planning number.²

Failure modes¶

Shipping on the five-benchmark average. The headline mean is dominated by classification. Two of the four "good" pairs lost 63 to 82% of their GSM8K accuracy.¹
Screening pairs on R-squared. It correlates negatively with retention across pairs (r = -0.20). A pair can fit beautifully and fail downstream.¹
Assuming symmetry. Fit A to B, deploy B to A, and you may be running the 37% case rather than the 94% one.
Citing the RoPE ablation as proof RoPE stripping helps accuracy. The fair ablation row is a wash; the dramatic row is an induced mismatch.
Budgeting mapper storage linearly in fleet size. It is quadratic in ordered pairs, and the published GB figures are fp32.
Counting the published speedup as end-to-end. Cache shipping to the target process is unmeasured, and the mapper has a fixed floor (14.0 ms on the Qwen3 pair) that dominates at short sequences.
Extending to mismatched-KV, cross-family, or hybrid-attention pairs. All three are untested and explicitly out of scope; the matched-KV property of all six pairs is a construction of the evaluation, not a demonstrated requirement or a demonstrated non-requirement.¹

Open questions and validation¶

No code release accompanied the primary paper at the time of writing, so nothing on this page beyond the executed math has been independently reproduced. C2C does publish code.²
Whether closed-form transfer survives across families (Qwen3 to Llama, say) is open. So is whether it works at all under mismatched KV geometry.
A pre-fit transferability signal does not exist. Attention-output cosine requires a fitted mapper, so screening still costs a calibration run per candidate pair.
Whether bf16 or int8 mapper storage preserves retention is unmeasured, and it directly determines whether the quadratic fleet budget is affordable.
Whether transfer composes with token eviction or quantized caches, where the source cache is already lossy before mapping, is not addressed anywhere in this literature.

References¶

Heo et al., Cross-Model KV Cache Transfer in LLM Families: A Closed-Form Linear Mapping for Prefill Reuse (arXiv 2608.03893, NVIDIA): https://arxiv.org/abs/2608.03893
Fu et al., Cache-to-Cache: Direct Semantic Communication Between Large Language Models (arXiv 2510.03215, ICLR 2026): https://arxiv.org/abs/2510.03215 and https://github.com/thu-nics/C2C
Brandon et al., Reducing Transformer Key-Value Cache Size with Cross-Layer Attention (arXiv 2405.12981, NeurIPS 2024): https://arxiv.org/abs/2405.12981
Liu et al., DroidSpeak: KV Cache Sharing Across Fine-Tuned Model Variants (NSDI 2026), cited in arXiv 2608.03893 as the identical-architecture baseline
Zhao et al., IAM: Efficient Inference through Attention Mapping between Different-scale LLMs (ACL 2025), cited in arXiv 2608.03893 as the attention-pattern-substitution baseline
Dery et al., Latent Space Communication via K-V Cache Alignment (arXiv 2601.06123): https://arxiv.org/abs/2601.06123

Heo, Shafipour, Zhao, Golub, Kamani, Borkar, Chandran, Zardoshti and Darvish Rouhani, "Cross-Model KV Cache Transfer in LLM Families", arXiv 2608.03893v1, 4 Aug 2026, NVIDIA. Preprint; no code release accompanies it. Setup: three matched-KV families (Qwen3, Llama 3.1, Ministral 3), all pairs 8 KV heads and head dim 128 on both sides, dense full attention, six pairs, parameter ratios 1.8x to 8.8x, depth ratios 1.2x to 2.5x. Mapper: per-(target layer, head) ridge at lambda 0.01, closed form W = (X'X + lambda I)^-1 X'Y, features = concatenated top-k source layers selected by head-averaged R-squared, keys mapped in RoPE-stripped content space. Calibration: 500 FineWeb-Edu sequences of 1,024 tokens, stride-4 subsampled to about 128K token observations per target head; fitting 47 to 87 min per pair on one 8xH100 node. Linear structure (Qwen3 14B->32B): single source layer explains 56% of key variance and 32% of value variance, rising to 79% and 65% at k=8 (Table 7: k=1 0.5572/0.3249, k=8 0.7914/0.6541, k=all 0.8451/0.7645); best single heatmap cell reaches K_stripped R-squared 0.81. Table 1 retention (Avg / floor-normalized / ARC-C / HellaSwag / WinoGrande / MMLU / GSM8K): Qwen3 14B->32B 97.6/96.3/101.0/97.6/98.5/95.0/95.6; Qwen3 8B->32B 87.5/80.7/94.0/95.2/91.0/88.5/68.8; Llama 3.1 8B->70B 72.8/62.9/90.9/94.4/87.1/73.3/18.2; Ministral 3B->8B 76.2/65.9/90.6/93.3/91.3/69.4/36.6; Ministral 3B->14B 44.2/14.7/43.6/68.0/74.0/32.0/3.2; Ministral 8B->14B 41.6/11.1/40.7/58.7/74.2/32.7/1.6. Raw GSM8K (Table 13): Llama 8B->70B 14.78 vs 70B standalone 81.12; Ministral 3B->8B 30.86 vs 8B standalone 84.38. Ablation (Table 2, Qwen3 14B->32B, ARC-C/HellaSwag/WinoGrande/MMLU/GSM8K): full 61.60/80.70/68.98/78.09/90.98; minus inference RoPE 44.97/75.39/56.59/25.79/4.17 (an induced fit-vs-eval mismatch); minus all RoPE 61.09/80.73/68.59/77.70/90.98 (the fair comparison, a wash); minus RoPE minus cross-layer k=1 27.65/44.81/51.78/26.07/0.38. Appendix C states the coupled variant "lands within noise of the full decoupled pipeline on every benchmark at the 1,024-token fit context". MLP substitution (Table 3 HellaSwag retention, ridge -> MLP): Qwen3 14B->32B 97.6 -> 97.3 (-0.3pp); Ministral 3B->8B 93.3 -> 91.8 (-1.5pp); Ministral 3B->14B 68.0 -> 92.3 (+24.3pp); Ministral 8B->14B 58.7 -> 95.5 (+36.8pp); MLP is two 1,024-unit ReLU layers, Adam lr 1e-3, 20 epochs, MSE. Mechanism (Table 4): on failure pairs MLP lowers K-concentration by about 2.5 and raises attention-output cosine by about 0.45; ridge eval-domain K R-squared is deeply negative there (-7.81, -3.22). Cross-pair predictor: attention-output cosine vs HellaSwag retention Pearson r=+0.57 over 12 pair evaluations, calibration R-squared r=-0.20; Llama 8B->70B and Ministral 3B->8B both fit at K R-squared 0.84 but retain 94%/37% and 93%/93% in the two directions. Metric anchor (Table 14): an ablated mapper scoring 48.5 on WinoGrande against a 50 chance floor is credited 69.2% raw retention and -7.7% floor-normalized. k selection: swept over {1,2,4,6,8,10,12,16,20,24,all}, argmax of mean log-likelihood accuracy over ARC-C, HellaSwag, MMLU (WinoGrande absent at most k); GSM8K, CoQA and latency are holdouts by construction; leave-one-out re-selection moves the held-out benchmark by at most 2.49pp (mean 0.30pp), always downward. Held-out benchmarks (Table 18, PIQA/BoolQ/ARC-Easy) give 96.8 to 99.9% mean for Tier 1 and 59.3 to 63.7% for Tier 2, and the paper notes PIQA and ARC-Easy are easier than the selection set. Calibration sensitivity (Table 8, HellaSwag): lambda 0/1e-4/0.01/0.1/1 -> 80.86/80.88/80.73/79.75/64.94; N 50/100/200/500/1000 -> 79.09/79.72/80.44/80.73/80.89; domain CodeAlpaca/Wikipedia/FineWeb-Edu -> 75.46/79.65/80.70. Multi-turn (CoQA, 100 conversations of about 15 turns, Qwen3 14B<->32B): small-to-large gap widens 1.7pp from turn 1 to 10; large-to-small drift grows linearly at 0.33pp/turn. Latency (Table 5, Qwen3 14B<->32B): S->L 64/8K/32K tokens 14.0/67.8/277.6 ms mapper vs 61.7/1154.8/6975.3 ms re-prefill (4x/17x/25x); L->S 11.6/101.9/427.1 vs 39.2/501.0/2952.7 (3x/5x/7x). Table 16 spans seven pairs and ten sequence lengths, 2.7x to 25.1x, mapper faster in all 70 cells; measured on one 8xH100 node with NVLink, bf16, 50 warmup and 30 timed trials, mapper in eager mode with no torch.compile or CUDA graphs, re-prefill with flash_attention_2 excluding the LM head. Stated caveats: synthetic inputs, cache shipping to the target process unmeasured, Ministral re-prefill excludes the vision tower. Mapper size 2L_tn_kv(kn_kvd_s)d_t: 1.07B/4GB, 1.61B/6GB, 3.36B/12GB, 1.85B/7GB, 1.01B/4GB, 1.68B/6GB across the six pairs (the GB/params ratio implies fp32); host-to-device paging of 80 to 480 ms at an assumed 25 to 50 GB/s is stated as "computed from size and bandwidth, not measured"; a router over P models covers up to P(P-1) ordered pairs, about 39/79/131 GB for 3/4/5 models. Stated limitations: single-domain calibration, k selected on reported benchmarks, matched-KV is empirical (mismatched-KV untested), scope is within-family dense full-attention only. ↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩↩
Fu, Min, Zhang, Yan, Dai, Ouyang and Wang, "Cache-to-Cache: Direct Semantic Communication Between Large Language Models", arXiv 2510.03215v2 (v1 3 Oct 2025, v2 2 Mar 2026), ICLR 2026; code at https://github.com/thu-nics/C2C. Trains a per-pair neural cache fuser that projects and fuses the source model's KV cache into the target's, with a learnable gate selecting which target layers receive fused cache. Abstract reports 6.4 to 14.2% higher average accuracy than individual models, about 3.1 to 5.4% over text-to-text communication, and an average 2.5x latency speedup. Body reports accuracy increases of 11.00%, 9.64% and 11.88% across three sharers versus receiver-only, and 5.36%, 4.15% and 3.06% versus text-to-text; per-sharer speedups over text-to-text are 3.46x, 1.51x and 14.41x, so the 2.5x average spans a very wide range. Table 3 notes 90 ms of KV-cache fusion time on the MMLU-Redux breakdown (sharer Qwen2.5-0.5B-Instruct, receiver Qwen3-0.6B). Oracle experiments motivating the design: enriching KV-cache semantics at fixed cache length improves accuracy, and enriching only the top-performing layers slightly beats enriching all layers while enriching the worst-performing layers reduces accuracy, which is what the gate is designed to exploit. Fusers are trained on OpenHermes2.5. arXiv 2608.03893 classifies C2C as gradient-based, cross-scale, KV-value-transferring but not closed-form. ↩↩↩