The telephone game, skipped.
Two models talk without saying anything. On the cord, a sentence loses glyphs. On the bus, a cache crosses whole.
Every message between two models is a compression step.
A model holds a high-dimensional picture of the context. To tell another model, it flattens that picture into a string. The receiver reads the string and rebuilds a picture of its own. The loss lives in that round trip, and a standard message format does nothing about it.
Coder holds
Writer produces
Nothing has crossed yet. The Writer has the document and no instruction.
This is a schematic and not a model run. The example follows the paper's Figure 2, and we invented the two documents. The stopwatch plays the paper's measured seconds for this pair, 1.52 s for text-to-text and 0.40 s for cache-to-cache.
Flattening a cache to a string and rebuilding it on the far side is where the loss happens, and no message format can touch it.
Keep the receiver's own cache and add to it. Overwriting it throws away more than it contributes.
C2C trains a small module per layer. The module concatenates the receiver's cache with the sharer's, projects the pair, reweights the result per input, and passes it through a learnable gate that decides whether that layer takes the sharer's context at all. Both base models stay frozen. Only the fuser learns.
Projection alone averages 20.70. It dumps the receiver's own reading of the question and replaces it.
Project only 20.70 · +Fuse 44.88 · +Gate 47.95 average. Per benchmark, MMLU-Redux 20.01 / 43.36 / 42.92, ARC-C 19.57 / 51.65 / 54.52, OpenBookQA 21.80 / 47.60 / 52.60, C-Eval 21.41 / 36.91 / 41.77.
Under the same training budget the heterogeneous pair wins with the fewest parameters. C2C at 478M beats Identical at 529M and Single at 596M on every benchmark, which is the evidence that the gain is a second reading of the context and not extra capacity.
Keep the receiver's own cache. Overwriting it costs 24 points.
A 0.6B receiver gains about ten points from any of three sharers and beats the text channel every time.
The receiver stays Qwen3-0.6B. The sharers are Qwen2.5-0.5B, Llama3.2-1B, and a Qwen3-4B base model that never got instruction tuning. The authors compare each pairing against each model alone, against routing between them, and against a text hand-off where the sharer writes an analysis and the receiver reads it in front of the question.
All numbers from Table 3
| Sharer · benchmark | Receiver | Sharer | Routing | T2T | C2C |
|---|
Accuracy in percent. Times are seconds per query on one A100. Averaged over the four benchmarks, C2C gains 11.00, 9.64 and 11.88 points over the receiver alone and 5.36, 4.15 and 3.06 over text-to-text. The speedups against the text channel are 3.46×, 1.51× and 14.41×.
The 14× speedup is the sharer rambling. The 1.5× is the honest number.
Two models with the same score solve different questions.
When the authors map a 4B model's cache into a 0.6B model's space, the result sits inside the target's space and covers only part of it. The larger model's understanding doesn't contain the smaller one's. The sets of questions each model gets right overlap only partly, even where the aggregate scores match. A leaderboard column can't see that.
Schematic after the paper's t-SNE and correct-set analysis. The mapped cache occupies a smaller subset of the target's space even though the source is larger.
| Receiver · sharer | Rcv | Shr | T2T | C2C |
|---|---|---|---|---|
| Qwen3-0.6B · Gemma3-1B | 39.20 | 31.75 | 41.35 | 45.90 |
| Qwen3-0.6B · Qwen2.5-Math-1.5B | 39.20 | 39.86 | 43.71 | 46.13 |
| Qwen3-0.6B · Qwen2.5-Coder-0.5B | 39.20 | 25.09 | 39.74 | 46.89 |
| Qwen2.5-0.5B · Qwen3-0.6B, swapped | 38.42 | 39.20 | 32.12 | 43.47 |
| Qwen3-0.6B · Qwen2.5-0.5B | 39.20 | 38.42 | 41.03 | 46.50 |
Accuracy as printed in the paper's Table 6, which doesn't name the benchmark for these five pairs. Across them C2C beats text-to-text by 8.59 points on average. When the roles swap, C2C adds 5.05 points while text-to-text costs 6.3. The math sharer's text hand-off took 6.60 seconds and its cache hand-off took 0.27.
Swap the roles and text-to-text loses six points while cache-to-cache gains five. The two models answer different questions.
The limits the headline leaves out.
- The receivers are 0.6B-class models and the largest sharer is 14B. There's no frontier-scale result, and larger receivers gain less because their baselines are stronger.
- The authors train a fuser per sharer-and-receiver pair, and building it needs both models' weights. That rules out the API-to-API case most agent systems live in.
- The benchmarks are multiple-choice with a 64-token generation cap, timed on one A100 at batch size 1. The paper doesn't test open-ended generation or production serving.
- The MCP and A2A critique concerns representation loss between models. Text protocols for tool calls send a schema as their payload, and the paper says nothing against them.
The receiver learned more from a cache it couldn't read than from a message it could.
Averaged over four benchmarks, the gap between the cache channel and the text channel was three to five points for every sharer the authors tried. The agent frameworks we've built assume that models hand each other sentences. This paper measures a way to pass the part a model can't say.